Java学习笔记 2021-7-1 2021-7-8

Stream流

1 Stream流的体验

//附加：String s ="";，注意s.length()为0，但是此时s !=null；
如果要实现需求：

那么按照正常的操作:

public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        array.add("林青霞");
        array.add("张曼玉");
        array.add("王祖贤");
        array.add("柳岩");
        array.add("张明");
        array.add("");
        ArrayList<String> array2 = new ArrayList<>();
        ArrayList<String> array3 = new ArrayList<>();
        for(String s:array){
           if (s.startsWith("张")){
               array2.add(s);
               if (s.length()==3){
                   array3.add(s);
               }
           }
        }
    }

如果使用stream流的话：

public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        array.add("林青霞");
        array.add("张曼玉");
        array.add("王祖贤");
        array.add("柳岩");
        array.add("张明");
        array.add("");
        ArrayList<String> array3 = new ArrayList<>();
        //stream为了方便阅读才分行了，实际上一行就够了。
        //直接阅读代码即可方便的明白无关逻辑方式的语意
        array.stream().filter(s -> s.startsWith("张"))
                .filter(s -> s.length()==3)
                .forEach(array3::add);
        System.out.println(array3);
    }

stream流的生成操作

stream操作有三步：例如：

第一步：生成流。
常见的生成流的操作有：

stream中间流操作

filter

limit和skip

    public static void main(String[] args) {
        ArrayList<String> array1 = new ArrayList<>();
        array1.add("1");
        array1.add("2");
        array1.add("3");
        array1.add("4");
        array1.add("5");
        array1.add("6");
        array1.stream().skip(2).forEach(System.out::println);
        array1.stream().limit(2).forEach(System.out::println);
    }

concat和distinct

concat是合并流，distinct（截然不同的）不是拆分流，而是删除流中的重复元素。

sorted

public static void main(String[] args) {
    ArrayList<String> array1 = new ArrayList<>();
    array1.add("lqx");
    array1.add("zmy");
    array1.add("gdg");
    array1.add("wsq");
    array1.add("wrq");
    array1.add("fhcq");
   array1.stream().sorted((s1,s2)->{//排序结果：先按长度排，长度一样的按自然排序结果排
       int num = s1.length()-s2.length();
       return num==0?s1.compareTo(s2):num;//compareTo 方法：返回自然排序的结果
   }).forEach(System.out::println);
}

map和mapToInt

    public static void main(String[] args) {
        ArrayList<String> array1 = new ArrayList<>();
        array1.add("15");
        array1.add("6");
        array1.add("52");
        array1.add("97");
        array1.add("24");
        array1.add("33");
        array1.stream().map(Integer::parseInt).forEach(System.out::println);
        //mapToInt方法返回的是IntStream，里面全是Int形数据，因此相比较于单独的Stream，多一些方法，比如下面的sum方法
        int sum = array1.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
    }

stream终结操作

stream流的收集操作

将stream流中的数据收集回集合。

对toMap的范例程序：

    public static void main(String[] args) {
        String[] strArray = {"林青霞,30","张曼玉,35","王祖贤,33","柳岩,25"};
        Map<String, Integer> map = Stream.of(strArray).collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));//两个Function的参数都是一样的字符串。
        System.out.println(map);

    }

反射

类加载器

类加载

396 类加载器

范例程序：

    public static void main(String[] args) {
        ClassLoader c1 = ClassLoader.getSystemClassLoader();
        ClassLoader c1Parent = c1.getParent();
        ClassLoader c1ParentParent = c1Parent.getParent();
        System.out.println(c1);
        System.out.println(c1Parent);
        System.out.println(c1ParentParent);
        /*
		程序输出：
		jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc
		jdk.internal.loader.ClassLoaders$PlatformClassLoader@3ac3fd8b
		null
		*/
    }

反射

反射概述

获取Class类的对象

范例程序：

    public static void main(String[] args) throws ClassNotFoundException {
        Class<Student> c1 = Student.class;
        System.out.println(c1);
        Student s1 = new Student();
        Class<? extends Student> c2 = s1.getClass();
        System.out.println(c2);
        Class<?> c3 = Class.forName("Lei.Student");
        System.out.println(c3);
    }

反射获取构造方法并使用

范例程序：

    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        //1.获取字节码文件
        Class<?> c1 = Class.forName("Lei.Student");
        //2.通过字节码文件获取构造方法类
        Constructor<?> constructor = c1.getConstructor(int.class, String.class);
        //3.通过构造方法创建实例
        Object s1 = constructor.newInstance(30, "王祖贤");
        System.out.println(s1);
    }

使用此方法时如果改用getDeclaredConstructor方法获取private修饰的私有构造方法会报错，因为是private修饰的，无法正常创建对象，此时可以通过暴力反射（取消访问检查）来创建。

反射获取成员变量并使用

反射获取成员方法并使用

注意：最后的invoke返回的是一个null的Object，调用方法的是传入的那个Object类。范例代码：

 public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        Class<?> c = Class.forName("Lei.Student");
        Method[] methods = c.getDeclaredMethods();
        Method setAgeMethod = c.getDeclaredMethod("setAge", int.class);
        Object obj = c.getConstructor(int.class, String.class).newInstance(20, "lqx");
        Object invokeObj = setAgeMethod.invoke(obj, 25);
        System.out.println(invokeObj);//显示null
        System.out.println(obj);//年龄已经修改为25
    }

反射之越过泛型检查

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        ArrayList<Integer> array = new ArrayList<>();//指定了Integer类型
        Class<? extends ArrayList> c = array.getClass();
        Method addMethod = c.getMethod("add", Object.class);//反射越过泛型检查
        addMethod.invoke(array,"nihao");
        addMethod.invoke(array,"Miho");
        addMethod.invoke(array,"Miho");
        System.out.println(array);
    }

407 通过反射运行配置文件指定的内容

观看视频比较直观