每日要点

正则表达式

例子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();
        // StackOverflowError
        // 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;
    }
}