欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Java学习笔记 - 第026天

程序员文章站 2022-07-15 08:13:41
...

每日要点

正则表达式

例子1:零宽正向先行断言、零宽负向先行断言、零宽正向后行断言、零宽负向后行断言

class Test01 {

    public static void main(String[] args) {
        // 零宽正向先行断言
        String str1 = "a regular expression";
        // 匹配后面是gular的re
        Pattern pattern1 = Pattern.compile("re(?=gular)\\S+");
        Matcher matcher1 = pattern1.matcher(str1);
        while (matcher1.find()) {
            System.out.println(matcher1.group());
        }
        
        matcher1.reset();
        // 零宽负向先行断言
        // 匹配后面不是gular的re
        matcher1.usePattern(Pattern.compile("re(?!gular)\\S+"));
        while (matcher1.find()) {
            System.out.println(matcher1.start() + "-" + matcher1.end());
            System.out.println(matcher1.group());
        }
        
        // 零宽正向后行断言
        String str2 = "regex represents regular expression";
        // 找re前面有其他字符(re不在最开头)的re
        Pattern pattern2 = Pattern.compile("(?<=\\w)re\\S+");
        Matcher matcher2 = pattern2.matcher(str2);
        while (matcher2.find()) {
            System.out.println(matcher2.start() + "-" + matcher2.end());
            System.out.println(matcher2.group());
        }
        
        matcher2.reset();
        // 零宽负向后行断言
        // 找re前面没有其他字符的re
        matcher2.usePattern(Pattern.compile("(?<!\\w)re\\S+"));
        while (matcher2.find()) {
            System.out.println(matcher2.start() + "-" + matcher2.end());
            System.out.println(matcher2.group());
        }
    }
}

异常

自定义异常

例子1:以前计算器例子
自定义异常

/**
 * 分数操作异常
 * @author Kygo
 *
 */
@SuppressWarnings("serial")
public class FractionException extends RuntimeException {
    
    /**
     * 构造器
     * @param message 异常相关信息
     */
    public FractionException(String message) {
        super(message);
    }
}

计算器类部分:

    /**
     * 构造器 : 指定分子和分母创建分数对象
     * @param num 分子
     * @param den 分母
     * @throws RuntimeException 如果分母为0就会引发异常
     */
    public Fraction(int num, int den) {
        if (den == 0) {
            throw new FractionException("分母不能为0");
        }
        this.num = num;
        this.den = den;
        this.normalize();
        this.simplify();
    }
其他异常和错误

例子2:

class Test02 {

    public static int sum(int n) {
        if (n == 1) return 1;
        return n + sum(n - 1);
    }
    
    public static void main(String[] args) {
        String str = "a123";
        // NumberFormatException
        int b = Integer.parseInt(str);
        System.out.println(b);
        
        Scanner scanner = new Scanner(System.in);
        System.out.print("a = ");
        // InputMismatchException
        int a = scanner.nextInt();
        System.out.println(a);
        scanner.close();
        // *Error
        // System.out.println(sum(100000));
        // OutOfMemoryError
        // List<String> list = new ArrayList<>();
        // while (true) {
            // list.add("hello");
        // }
    }
}
关机钩子

例子3::

@SuppressWarnings("serial")
class Annoyance extends Exception {}

@SuppressWarnings("serial")
class Sneeze extends Annoyance {}

class Test03 {

    public static void main(String[] args) {
        // 获得JVM
        Runtime rt = Runtime.getRuntime();
        // -Xms32M -Xmx32M
        System.out.println(rt.freeMemory());
        System.out.println(rt.totalMemory());
        // 注册一个关机钩子(在关闭JVM时要执行的方法)
        rt.addShutdownHook(new Thread(() -> {
            System.out.println("Fuck the world.");
        }));
        
        try {
            try {
                throw new Sneeze();
            } catch (Annoyance a) {
                System.out.println("Caught Annoyance");
                throw a;
            }
        }
        catch (Sneeze e) {
            System.out.println("Caught Sneeze");
        //  return ;
            System.exit(0);
        }
        finally {
            System.out.println("hello");
        }
    }
}
异常接口和继承相关例子

构造器不会被继承 子类只能调用父类构造器 如果父类构造器声明了异常
子类构造器必须声明能够处理该异常的异常的类型

例子4:

@SuppressWarnings("serial")
class Ex1 extends Exception { }
@SuppressWarnings("serial")
class Ex2 extends Ex1 { }
@SuppressWarnings("serial")
class Ex3 extends Exception { }

interface C {
    public void foo() throws Ex1;
}

abstract class A {
    public A() throws Ex2 { }
    public abstract void foo() throws Ex3;
}

class B extends A implements C {
    // 构造器不会被继承 子类只能调用父类构造器 如果父类构造器声明了异常
    // 子类构造器必须声明能够处理该异常的异常的类型
    public B() throws Ex1 { }
    
    // foo()方法有双重来源 可以声明的异常是Ex1和Ex3的交集
    // 由于Ex1和Ex3两种异常没有交集 所以此处不能声明任何受检异常
    @Override
    public void foo() {
    }
}

class Test04 {
    
    public static void bar(A a) {
        try {
            a.foo();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try {
            bar(new B());
        }
        catch (Exception e) {   // 异常捕获遵循里氏替换原则
            e.printStackTrace();
        }
    }
错使用误异常try-catch的例子

例子5:

class Test05 {

    public static void main(String[] args) {
        int[] array = { 12, 34, 6, 99, 27 };
        int index = 0;
        // 龌龊做法: 用异常处理正常业务逻辑
        try {
            while (true) {
                System.out.println(array[index]);
                index += 1;
            } 
        }
        catch (ArrayIndexOutOfBoundsException e) {
        }
    }
}

龌龊做法: 用异常处理正常业务逻辑

垃圾回收

例子6:

class Shit {
    // 当垃圾回收器回收Shit对象时可能会调用该方法
    @Override
    protected void finalize() throws Throwable {
        System.out.println("*没了!!!");
    }
}

class Test06 {

    public static void main(String[] args) {
        // 强引用
        Shit shit = new Shit();
        System.out.println(shit);
        // 软引用、弱引用和幻引用
        // 请查阅资料明天进行讲解
//      SoftReference<Shit> sf;
//      WeakReference<Shit> wf;
        shit = null;
        System.gc();
        // Runtime.getRuntime().gc();
    }
}

对容器数据的相关操作

大数据处理常用操作:
过滤(filter) -> 映射(map) -> 归约(reduce)
过滤 - 把无用信息排除掉
映射 - 把数据转换成系统需要的格式
归约 - 把多项数据合并成一项数据得出结论性的东西
例子7:

class Test07 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("pitaya");
        list.add("orange");
        list.add("grape");
        list.add("watermelon");
        // Java 8 - Lambda表达式
        list.forEach(elem -> {
            System.out.println(elem);
        });
        // Java 8 - 方法引用(高阶函数)
        list.forEach(System.out::println);
        // 大数据处理常用操作:
        // 过滤(filter) -> 映射(map) -> 归约(reduce)
        // 过滤 - 把无用信息排除掉
        // 映射 - 把数据转换成系统需要的格式
        // 归约 - 把多项数据合并成一项数据得出结论性的东西
        // Java 8 集合的流式操作
        // - stream() / - parallelStream()
        list.stream()
        .filter(x -> { return x.length() > 5; })
        .map(x -> { return x.toUpperCase(); })
        .forEach(x -> { System.out.println(x); });
        
        String result = list.parallelStream()
        .filter(x -> { return x.length() > 5; })
        .map(x -> { return x.toUpperCase(); })
        .reduce("", (s1, s2) -> { return s1 + s2; });
        System.out.println(result);
    }
}

网络编程

例子8:使用百度身份证识别接口,百度APIStore的身份证查询服务

// 百度APIStore的身份证查询服务
// 通过HTTP协议请求服务器提供的JSON格式的数据
class Test08 {
    public static void main(String[] args) {
        String string = request("http://apis.baidu.com/apistore/idservice/id", "id=511623199505201158");
        System.out.println(string);
    }

    public static String request(String httpUrl, String httpArg) {
        String result = "";
        StringBuffer sb = new StringBuffer();

        HttpURLConnection connection = null;
        try {
            // 将URL和请求参数拼接到一起组成完整的URL
            URL url = new URL(httpUrl + "?" + httpArg);
            // 通过URL获得HTTPURLConnection对象(代表对服务器的连接)
            connection = (HttpURLConnection) url.openConnection();
            // 设置请求方法为GET方法
            connection.setRequestMethod("GET");
            // 填入apikey到HTTP请求头中
            connection.setRequestProperty("apikey", "2fa58657897cc7c76740406af043b75d");
            // 通过连接对象连到服务器
            connection.connect();
            // 建立输入流从服务器获取数据
            try (InputStream is = connection.getInputStream()) {
                BufferedReader reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                String str = null;
                while ((str = reader.readLine()) != null) {
                    sb.append(str);
                    sb.append("\r\n");
                }
                result = sb.toString();
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 断开连接
            if (connection != null) {
                connection.disconnect();
            }
        }
        return result;
    }
}