Java学习记录六（方法引用、函数式接口、Stream流、反射和模块化）

Java

28.方法引用

28.1体验方法引用

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案:拿参数做操作
那么考虑一种情况:如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢?答案肯定是没有必要
那我们又是如何使用已经存在的方案的呢?
这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案

示例:

s = "abaccdeff"
返回 "b"

s = "" 
返回 " "

//hashmap.get(Object key, V defaultValue)   返回 key 相映射的的 value，如果给定的 key 在映射关系中找不到，则返回指定的默认值。
class Solution {
   public char firstUniqChar(String s) {
       HashMap<Character,Integer> hm= new HashMap<>();
       for(int i=0;i<s.length();i++){
           char c = s.charAt(i);
           hm.put(c,hm.getOrDefault(c,0)+1);
       }
       for(int i=0;i<s.length();i++){
           char c = s.charAt(i);
           if(hm.get(c) == 1){
               return c;
           }
       }
       return ' ';
   }
}
/*
两次遍历这个字符串，第一遍用HashMap Key为每个char Value为s.getOrDefault(ch,0)+1存起来，如果第一次出现Value为1，第二次为2;
第二次遍历用HashMap的get方法返回Integer 若Integer为1说明是第一个出现一次的字符
*/

接口中静态方法的定义格式:

• 格式: public static返回值类型方法名(参数列表){}
• 范例: public static void show() { }

接口中静态方法的注意事项:

• 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
• public可以省略，static不能省略

package Firmness001;

public interface Printable {
    void printString(String s);
}

package Firmness001;

public class PrintableDemo {
    public static void main(String[] args) {
        //在主方法中调用usePrintable方法
//        usePrintable((String s) -> {
//            System.out.println(s);
//        });

        usePrintable(s -> System.out.println(s));//接口中有一个方法的形参类型是String

//        System.out.println("爱生活爱Java");

        //方法引用符:
        usePrintable(System.out::println);

        //可推导的就是可省略的


    }
    private static void usePrintable(Printable p){
        p.printString("爱生活爱Java");
    }
}

28.2方法引用符

方法引用符

• 该符号为引用运算符，而它所在的表达式被称为方法引用

回顾一下我们在体验方法引用中的代码

• Lambda表达式: usePrintable(s -> System.out.printIn(s));
  分析:拿到参数s 之后通过Lambda表达式，传递给System.out.println方法去处理
• 方法引用: usePrintable(System.out:printIn);
  分析:直接使用System.but中的println方法来取代Lambda，代码更加的简洁

推导与省略

• 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
• 如果使用方法引用，也是同样可以根据上下文进行推导
• 方法引用是Lambda的孪生兄弟

package Firmness002;

public interface Printable {
    void printInt(int i);
}
package Firmness002;

public class PrintableDemo {
    public static void main(String[] args) {
        //在主方法中调用usePrintable方法
        usePrintable(i -> System.out.println(i));

        //方法引用
        usePrintable(System.out::println);
    }
    public static void usePrintable(Printable p){
        p.printInt(666);
    }
}

28.3Lambda表达式支持的方法引用

常见的引用方式:

• 引用类方法
• 引用对象的实例方法
• 引用类的实例方法
• 引用构造器

28.3.1引用类方法

引用类方法，其实就是引用类的静态方法

• 格式:类名:静态方法
• 范例: Integer:parselnt
  Integer类的方法: public static int parseInt(String s)将此String转换为int类型数据

练习:

• 定义一个接口(Converter)，里面定义一个抽象方法

  ​ int convert(String s);

• 定义一个测试类(ConverterDemo)，在测试类中提供两个方法
  一个方法是: useConverter(Converter c)
  —个方法是主方法，在主方法中调用useConverter方法

package Firmness003;

public interface Converter {
    int convert(String s);
}
package Firmness003;

public class ConverterDemo {
    public static void main(String[] args) {
        //在主方法中调用useConverter方法

//        useConverter((String s) -> {
//            return Integer.parseInt(s);
//        });
        useConverter(s -> Integer.parseInt(s));

        //引用类方法
        useConverter(Integer::parseInt);

        //Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数(多个参数)


    }

    private static void useConverter(Converter c){
        int number = c.convert("666");
        System.out.println(number);
    }
}

28.3.2引用对象的实例方法

引用对象的实例方法，其实就引用类中的成员方法

• 格式:对象::成员方法
• 范例: “HelloWorld”:toUpperCase
  String类中的方法: public String toUpperCase()将此String所有字符转换为大写

练习

• 定义一个类(PrintString)，里面定义一个方法
  public void printUpper(String s):把字符串参数变成大写的数据，然后在控制台输出

• 定义一个接口(Printer)，里面定义一个抽象方法
  void printUpperCase(String s)

• 定义一个测试类(PrinterDemo)，在测试类中提供两个方法

  一个方法是: usePrinter(Printer p)
  一个方法是主方法，在主方法中调用usePrinter方法

package Firmness004;

public interface Printer {
    void printUpperCase(String s);
}
package Firmness004;

import java.util.Locale;

public class PrinterDemo {
    public static void main(String[] args) {
        //在主方法中调用usePrinter方法
//        usePrinter((String s) -> {
//            String result = s.toUpperCase();
//            System.out.println(result);
//            System.out.println(s.toUpperCase());
//        });

        usePrinter(s -> System.out.println(s.toUpperCase()));

        //引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);

        //Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

    }
    private static void usePrinter(Printer p){
        p.printUpperCase("HelloWorld");
    }


}
package Firmness004;

public class PrintString {
    //把字符串参数变成大写的数据，然后在控制台输出
    public void printUpper(String s){
        String result = s.toUpperCase();
        System.out.println(result);
    }
}

28.3.3引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

• 格式:类名::成员方法
• 范例: String::substring
  String类中的方法: public String substring(int beginIndex,int endIndex)
  从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度为endlndex-beginIndex

练习

• 定义一个接口(MyString)，里面定义一个抽象方法:
  String mySubString(String s,int x,int y);
• 定义一个测试类(MyStringDemo)，在测试类中提供两个方法
  一个方法是: useMyString(MyString my)
  一个方法是主方法，在主方法中调用useMyString方法

package Firmness005;

public interface MyString {
    String mySubString(String s,int x,int y);
}
package Firmness005;

public class MyStringDemo {
    public static void main(String[] args) {
        //在主方法中调用useMyString方法

//        useMyString((String s,int x,int y) -> {
//            return s.substring(x,y);
//        });

        useMyString(((s, x, y) -> s.substring(x,y)));

        //引用类的实例方法
        useMyString(String::substring);

        //Lambda表达式被类的实例方法替代的时候
        //第一个参数作为调用者
        //后面的参数全部传递给该方法作为参数

    }

    private static void useMyString(MyString my){
        String s = my.mySubString("HelloWorld",2,5);
        System.out.println(s);
    }
} 

28.3.4引用构造器

引用构造器，其实就是引用构造方法

• 格式:类名:new
• 范例: Student:new

练习

• 定义一个类(Student)，里面有两个成员变量(name,age)
  并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
• 定义一个接口(StudentBuilder)，里面定义一个抽象方法
  Student build(String name,int age);
• 定义一个测试类(StudentDemo)，在测试类中提供两个方法
  一个方法是: useStudentBuilder(StudentBuilder s)
  一个方法是主方法，在主方法中调用useStudentBuilder方法

package Firmness006;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
package Firmness006;

public interface StudentBuilder {
    Student build (String name,int age);
}
package Firmness006;
/*
练习

- 定义一个类(Student)，里面有两个成员变量(name,age)
  并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法
- 定义一个接口(StudentBuilder)，里面定义一个抽象方法
  Student build(String name,int age);
- 定义一个测试类(StudentDemo)，在测试类中提供两个方法
  一个方法是: useStudentBuilder(StudentBuilder s)
  一个方法是主方法，在主方法中调用useStudentBuilder方法
 */
public class StudentDemo {
    public static void main(String[] args) {
        //在主方法中中调用useStudentBuilder方法

//        useStudentBuilder((String name,int age) -> {
            Student s  = new Student(name,age);
            return s;
//            return new Student(name,age);
//        });

        useStudentBuilder(((name, age) -> new Student(name,age)));

        //引用构造器
        useStudentBuilder(Student::new);

        //Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

    }

    private static void useStudentBuilder(StudentBuilder sb){
        Student s = sb.build("林青霞",30);
        System.out.println(s.getName()+s.getAge());
    }
}

29.函数式接口

29.1函数式接口概述

Lambda表达式使用前提：有一个接口，且接口中有且仅有一个抽象方法。

函数式接口:有且仅有一个抽象方法的接口
Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

如何检测一个接口是不是函数式接口呢?

• @Functionallnterface
• 放在接口定义的上方:如果接口是函数式接口，编译通过;如果不是，编译失败

注意

• 我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

package Firmness007;
@FunctionalInterface
public interface MyInterface {
    void show();

    //void method();
}
package Firmness007;

public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterface my = () -> System.out.println("函数式接口");
        my.show();
    }
}

29.2函数式接口作为方法的参数

需求

• 定义一个类(RunnableDemo)，在类中提供两个方法
  一个方法是: startThread(Runnable r)方法参数Runnable是一个函数式接口
  一个方法是主方法，在主方法中调用startThread方法

如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递

• startThread(() -> System.out.printIn(Thread.currentThread).getName()+“线程启动了”));

package Firmness008;

public class RunnableDemo {
    public static void main(String[] args) {
        //在主方法中调用startThread方法

        //匿名内部类的方式
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });

        startThread(() -> System.out.println(Thread.currentThread().getName()+"线程启动了"));
        
    }

    private static void startThread(Runnable r){
//        Thread t = new Thread(r);
//        t.start();
        new Thread(r).start();
    }
}

29.3函数式接口作为方法的返回值

需求

• 定义一个类(ComparatorDemo)，在类中提供两个方法
  一个方法是:Comparator getComparator()方法返回值Comparator是一个函数式接口
  一个方法是主方法，在主方法中调用getComparator方法

如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回

• private static Comparator getComparator) {
  return (s1, s2) -> s1.length() - s2.length();
  }

package Firmness008;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/*
定义一个类(ComparatorDemo)，在类中提供两个方法
一个方法是:Comparator<String> getComparator()方法返回值Comparator是一个函数式接口
一个方法是主方法，在主方法中调用getComparator方法
 */
public class ComparatorDemo {
    public static void main(String[] args) {
        //构造使用场景

        //定义集合，存储字符串元素
        ArrayList<String> array = new ArrayList<String>();

        array.add("ccc");
        array.add("aa");
        array.add("b");
        array.add("ddd");

        System.out.println("排序前"+array);

        Collections.sort(array);
     //   Collections.sort(array,getComparator());
        System.out.println("排序后"+array);

    }
    private static Comparator<String> getComparator(){
        //匿名内部类的方式实现
//        Comparator<String> comp = new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };
//        return comp;

//        return new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };

//        return (String s1,String s2)->{
//            return s1.length()-s2.length();
//        };//用Lambda表达式作为结果返回

        return (s1,s2) -> s1.length()-s2.length();

    }
}

29.4常用的函数式接口

Java 8在java.util.function包下预定义了大量的函数式接口供我们使用
我们重点来学习下面的4个接口

• Supplier接口
• Consumer接口
• Predicate接口
• Function接口

29.4.1Suplier接口

Supplier:包含一个无参的方法

• T get():获得结果
• 该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
• Supplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用

package Firmness009;

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
//        String s = getString(() -> {
//            return "林青霞";
//        });

        String s = getString(() -> "林青霞");

        System.out.println(s);

        Integer i = gerInteger(() -> 30);
        System.out.println(i);
    }

    //定义一个方法，返回一个整数数据
    private static Integer gerInteger(Supplier<Integer> sup){
        return sup.get();
    }

    //定义一个方法，返回一个字符串数据
    private static String getString(Supplier<String> sup){
        return sup.get();
    }

}

29.4.1.1Supplier接口练习之获取最大值

练习

• 定义一个类(SupplierTest)，在类中提供两个方法
  一个方法是: int getMax(Supplier sup)用于返回一个int数组中的最大值一个方法是主方法，在主方法中调用getMax方法

package Firmness009;

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
//        String s = getString(() -> {
//            return "林青霞";
//        });

        String s = getString(() -> "林青霞");

        System.out.println(s);

        Integer i = gerInteger(() -> 30);
        System.out.println(i);
    }

    //定义一个方法，返回一个整数数据
    private static Integer gerInteger(Supplier<Integer> sup){
        return sup.get();
    }

    //定义一个方法，返回一个字符串数据
    private static String getString(Supplier<String> sup){
        return sup.get();
    }


}
package Firmness009;

import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        //定义一个int数组
        int[] arr = {19,50,28,37,46};

        int maxValue = getMax(() -> {
            int max = arr[0];

            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }

            return max;
        });

        System.out.println(maxValue);
    }

    //返回一个int数组中的最大值
    private static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

29.4.2Consumer接口

Consumer:包含两个方法

• void accept(Tt):对给定的参数执行此操作
• defaultConsumer andThen(Consumer after):返回一个组合的Consumer，依次执行此操作，然后执行after操作
• Consumer接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

package Firmness010;

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
//        operatorString("林青霞",(String s) -> {
//            System.out.println(s);
//        });

//        operatorString("利拉德",s -> System.out.println(s));
        //operatorString("利拉德", System.out::println());

//        operatorString("利拉德",s ->
//        {
//            System.out.println(new StringBuilder(s).reverse().toString());
//        });
        operatorString("利拉德",s -> System.out.println(new StringBuilder(s).reverse().toString()));
        System.out.println("-------");

        operatorString("利拉德" , s -> System.out.println(s) ,s -> System.out.println(new StringBuilder(s).reverse().toString()));//为啥报错？？？？
        //operatorString( "林青霞", s -> System.out.println(s) , s -> System.out.println(new StringBuilder(s).reverse().toString()));

    }

    //定义一个方法，用不同的方式消费同一个字符串数据两次
    private  static void opeartorString(String name,Consumer<String> con1,Consumer<String> con2){
        con1.accept(name);
        con2.accept(name);
//        con1.andThen(con2).accept(name);
    }

    //定义一个方法,消费一个字符串数组
    private static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }

}

29.4.2.1Consumer接口练习之按要求打印信息

练习

• String[]strArray = {“林青霞,30”,“张曼玉,35”,“王祖贤,33”};
• 字符串数组中有多条信息，请按照格式:“姓名:XX年龄:XX"的格式将信息打印出来
• 要求:
  把打印姓名的动作作为第一个Consumer接口的Lambda实例
  把打印年龄的动作作为第二个Consumer接口的Lambda实例
  将两个Consumer接口按照顺序组合到一起使用

package Firmness010;

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
//        operatorString("林青霞",(String s) -> {
//            System.out.println(s);
//        });

//        operatorString("利拉德",s -> System.out.println(s));
        //operatorString("利拉德", System.out::println());

//        operatorString("利拉德",s ->
//        {
//            System.out.println(new StringBuilder(s).reverse().toString());
//        });
        operatorString("利拉德",s -> System.out.println(new StringBuilder(s).reverse().toString()));
        System.out.println("-------");

       // operatorString("利拉德" , s -> System.out.println(s) ,s -> System.out.println(new StringBuilder(s).reverse().toString()));//为啥报错？？？？
        //operatorString( "林青霞", s -> System.out.println(s) , s -> System.out.println(new StringBuilder(s).reverse().toString()));

    }

    //定义一个方法，用不同的方式消费同一个字符串数据两次
    private  static void opeartorString(String name,Consumer<String> con1,Consumer<String> con2){
        con1.accept(name);
        con2.accept(name);
//        con1.andThen(con2).accept(name);
    }

    //定义一个方法,消费一个字符串数组
    private static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }

}
package Firmness010;

import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30","张曼玉,35","王祖贤,33"};

//        printInfo(strArray, (String str) -> {
//            String name = str.split(",")[0];
//            System.out.println("姓名"+name);
//        },(String str) -> {
//            int age = Integer.parseInt(str.split(",")[1]);
//            System.out.println("年龄"+age);
//        });

        printInfo(strArray,str -> System.out.println("姓名"+str.split(",")[0]),
                str -> System.out.println("年龄"+Integer.parseInt(str.split(",")[1])));
    }

    private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2){
        for(String str : strArray){
            con1.andThen(con2).accept(str);
        }
    }
}

29.4.3Predicate接口

Predicate:常用的四个方法

• boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
• default Predicate negate():返回一个逻辑的否定，对应逻辑非
• default Predicate and(Predicate other):返回一个组合判断，对应短路与
• default Predicate or(Predicate other):返回一个组合判断，对应短路或
• Predicate接口通常用于判断参数是否满足指定的条件

package Firmness011;

import java.util.function.Predicate;

public class PredicateDemo01 {
    public static void main(String[] args) {
//        boolean b1 = checkString("hello",(String s) ->{
//            return s.length()>8;
//        });

        boolean b1 = checkString("hello" , s-> s.length() >8);
        System.out.println(b1);

        boolean b2 = checkString("helloworld" , s -> s.length() >8);
        System.out.println(b2);
    }

    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre){
        //return pre.test(s);
        //return !pre.test(s);
        return pre.negate().test(s);
    }
}

package Firmness011;


import java.util.function.Predicate;

public class PredicateDemo02 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello" , s->s.length()>8);
        System.out.println(b1);
        boolean b2 = checkString("helloworld",s->s.length()>8);
        System.out.println(b2);

        boolean b3 = checkString("hello",s->s.length()>8, s -> s.length()<15);
        System.out.println(b3);

        boolean b4 = checkString("helloworld",s->s.length()>8, s -> s.length()<15);
        System.out.println(b4);

    }

    //同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
    private static boolean checkString (String s , Predicate<String> pre1,Predicate<String> pre2){
//        boolean b1 = pre1.test(s);
//        boolean b2 = pre2.test(s);
//        boolean b = b1 && b2;
//        return b;

//        return pre1.and(pre2).test(s);
        return pre1.or(pre2).test(s);
    }
    //判断给定的字符串是否满足要求
    private static boolean checkString (String s , Predicate<String> pre ){
        return pre.test(s);
    }
}

29.4.3.1Predicate接口练习之筛选满足条件数据

练习

• String[] strArray = {“林青霞,30”,“柳岩,34”,“张曼玉,35”，“貂蝉,31”,“王祖贤,33”};

• 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合

• 同时满足如下要求:姓名长度大于2;年龄大于33

• 分析
  有两个判断条件,所以需要使用两个Predicate接口,对条件讲行判断

package Firmness011;

import java.util.ArrayList;
import java.util.function.Predicate;

public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30","柳岩,34","张曼玉,35","貂蝉,31","王祖贤,33"};

        ArrayList<String> array = myFilter(strArray,s -> s.split(",")[0].length()>2,
                s-> Integer.parseInt(s.split(",")[1])>33);

        for(String s:array){
            System.out.println(s);
        }
    }

    //通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
    private static ArrayList<String> myFilter(String[] strArray,Predicate<String> pre1, Predicate<String> pre2){
        //定义一个集合
        ArrayList<String> array = new ArrayList<String>();

        //遍历数组
        for(String str : strArray){
            if(pre1.and(pre2).test(str)){
                array.add(str);
            }
        }

        return  array;
    }

}

29.4.4Function接口

Function<T,R>:常用的两个方法

• R apply(T t):将此函数应用于给定的参数
• default Function andThen(Function after):返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
• Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值

package Firmness012;

import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
//        convert("100",(String s) ->{
//            return Integer.parseInt(s);
//        });
        convert("100",s->Integer.parseInt(s));
//        convert("100",Integer::parseInt);

        convert(100,s->String.valueOf(s+566));

        convert("100",s->Integer.parseInt(s),i->String.valueOf(i+566));
    }

    //定义一个方法，把一个字符串转换int类型，在控制台输出
    private static void convert(String s, Function<String,Integer> fun){
        //Integer i = fun.apply(s);
        int i = fun.apply(s);
        System.out.println(i);
    }
    //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制条输出
    private static void convert(int i,Function<Integer,String> fun){
        String s = fun.apply(i);
        System.out.println(s);
    }
    //定义一个方法，把一个字符串转换为int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
    private static void convert(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
//        Integer i  =  fun1.apply(s);
//        String ss = fun2.apply(i);
//        System.out.println(ss);

        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
}

29.4.4.1Predicate接口练习之筛选满足条件数据

练习

• String s = “林青霞,30”;
• 请按照我指定的要求进行操作:
  1:将字符串截取得到数字年龄部分
  2:将上一步的年龄字符串转换成为int类型的数据
  3:将上一步的int数据加70，得到一个int结果，在控制台输出请
• 通过Function接口来实现函数拼接

package Firmness012;

import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        String s = "林青霞,30";

//        convert(s , (String ss ) -> {
//            return s.split(",")[1];
//        }),(String ss)->{//为什么报错
//            return Integer.parseInt(ss);
//        },(Integer i) ->{
//            return i+70;
//        });

        //convert(s,ss->ss.split(",")[1],ss -> Integer.parseInt(ss),i -> i+70);
        //convert(s,ss->ss.split(",")[1],ss -> Integer::parseInt(ss),i -> i+70);
    }

    private static void convert(String s , Function<String,String> fun1,Function<String,String> fun2,Function<Integer,Integer> fun3)
    {

        //int i = fun1.andThen(fun2).andThen(fun3).apply(s);
        //System.out.println(i);

    }
} 

30.Stream流

30.1体验Stream流

需求:按照下面的要求完成集合的创建和遍历

• 创建一个集合，存储多个字符串元素
• 把集合中所有以"张"开头的元素存储到一个新的集合
• 把"张"开头的集合中的长度为3的元素存储到一个新的集合
• 遍历上一步得到的集合

使用Stream流的方式完成过滤操作

• list.stream().filter(s -> s.startsWith(“张”)).filter(s-> s.length()== 3).forEach(System.out:printin);
• 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义:生成流、过滤姓张、过滤长度为3、逐一打印
• Stream流把真正的函数式编程风格引入到Java中

package Firmness013;

import java.util.ArrayList;

/*
需求:按照下面的要求完成集合的创建和遍历

- 创建一个集合，存储多个字符串元素
- 把集合中所有以"张"开头的元素存储到一个新的集合
- 把"张"开头的集合中的长度为3的元素存储到一个新的集合
- 遍历上一步得到的集合
 */
public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //把集合中所有以"张"开头的元素存储到一个新的集合
        ArrayList<String> zhangList = new ArrayList<>();

        for(String s:list){
            if(s.startsWith("张")){
                zhangList.add(s);
            }
        }

        System.out.println(zhangList);

        //把"张"开头的集合中的长度为3的元素存储到一个新的集合
        ArrayList<String> threeList = new ArrayList<String>();

        for(String s:zhangList){
            if(s.length() == 3){
                threeList.add(s);
            }
        }

        System.out.println(threeList);

        //遍历上一步得到的集合
        for(String s : threeList){
            System.out.println(s);
        }
        System.out.println("--------");

        //Stream流来改进
        //list.stream().filter(s -> s.startsWith("张")).filter(s->s.length()==3).forEach(s -> System.out.println(s));
        list.stream().filter(s -> s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println);
    }
}

30.2Stream流的生成方式

Stream流的使用

• 生成流
  通过数据源(集合,数组等)生成流
  list.stream()
• 中间操作
  一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
  filter()
• 终结操作
  一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。
  所以这必定是流的最后一个操作
  forEach()

Stream流的常见生成方式

• Collection体系的集合可以使用默认方法stream()生成流
  default Stream stream)
• Map体系的集合间接的生成流
• 数组可以通过Stream接口的静态方法of(T… values)生成流

package Firmness014;

import com.sun.jdi.PathSearchingVirtualMachine;

import java.util.*;
import java.util.stream.Stream;

/*
Stream流的常见生成方式

- Collection体系的集合可以使用默认方法stream()生成流
  default Stream<E> stream)
- Map体系的集合间接的生成流
- 数组可以通过Stream接口的静态方法of(T... values)生成流
 */
public class StreamDemo {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream()生成流
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> setStraem = set.stream();

        //Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String,Integer>> entryStream = map.entrySet().stream();

        //数组可以通过Stream接口的静态方法of(T... values)生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("hello","world","java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);

    }
}

30.3Stream流的常见中间操作方法

• Stream filter(Predicate predicate):用于对流中的数据进行过滤
  Predicate接口中的方法 boolean test(T t):对给定的参数讲行判断，返回一个布尔值

package Firmness015;

import java.util.ArrayList;

public class StreamDemo01 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1:把list集合中以张开头的元素在控制台输出
//        list.stream().filter((String s ) -> {
//            return s.startsWith("张");
//        }).forEach(System.out::println);


        //需求2:把list集合中长度为3的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("--------");

        //需求3:把list集合中以张开头的，长度为3的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);

    }
}

• Stream limit(long maxSize):返回此流中的元素组成的流，截取前指定参数个数的数据
• Stream skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流

package Firmness015;

import java.util.ArrayList;

public class StreamDemo02 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：取前3个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");

        //需求2：跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("--------");

        //需求3:跳过2个元素，把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

• static Stream concat(Stream a, Stream b):合并a和b两个流为一个流
• Stream distinct():返回由该流的不同元素（根据Objectequals(Object)）组成的流

package Firmness015;

import java.util.ArrayList;
import java.util.stream.Stream;

public class StreamDemo03 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);
        System.out.println("-----");

        //需求2：跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);
        System.out.println("-----");

        //需求3：合并需求1和需求2得到的流，并把结果在控制台输出
        //Stream.concat(s1,s2).forEach(System.out::println);//王祖贤和柳岩重复了

        System.out.println("-----");

        //需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

• Stream sorted():返回由此流的元素组成的流，根据自然顺序排序
• Stream sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序

package Firmness015;

import java.util.ArrayList;

public class StreamDemo04 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：按照字母顺序把数据在控制台输出
        //list.stream().sorted().forEach(System.out::println);

        //需求2：按照字符串长度把数据在控制台输出
        list.stream().sorted(((s1,s2) -> s1.length() - s2.length())).forEach(System.out::println);
    
        list.stream().sorted((s1,s2) -> {
            int num = s1.length() - s2.length();
            int num2 = num==0?s1.compareTo(s2):num;
            return num2;
        }).forEach(System.out::println);
    }
}

• Stream map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流
  Function接口中的方法 R apply(T t)
• IntStream mapToInt(ToIntFunction mapper):返回一个ntStream其中包含将给定函数应用于此流的元素的结果
  IntStream:表示原始int流
  ToIntFunction接口中的方法 int applyAsInt(T value)

package Firmness015;

import java.util.ArrayList;

public class StreamDemo05 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        //需求：将集合中的字符串数据转换为整数之后在控制台输出
        //list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        //list.stream().map(Integer::parseInt).forEach(System.out::println);

        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);

        //int sum() 返回此流中元素的总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

30.4Stream流的常见终结操作方法

Stream流的常见终结操作方法

• void forEach(Consumer action):对此流的每个元素执行操作
  Consumer接口中的方法 void accept(Tt):对给定的参数执行此操作

• long count():返回此流中的元素数

package Firmness016;

import java.util.ArrayList;

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：把集合中的元素在控制台输出
//        list.stream().forEach(System.out::println);

        //需求2：统计集合中有几个以张开头的元素，并把统计结果在控制台输出
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);
    }
}

30.5Stream流综合练习

现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作

• 男演员只要名字为3个字的前三人
• 女演员只要姓林的，并且不要第一个
• 把过滤后的男演员姓名和女演员姓名合并到一起
• 把上一步操作后的元素作为构造方法的参数创建演员对象遍历数据
  演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

package Firmness017;

public class Actor {
    private String name;

    public Actor(String name)   {this.name = name;}

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }
}
package Firmness017;

import java.util.ArrayList;
import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");

        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");

        //男演员只要名字为3个字的前三个人
        Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);

        //女演员只要姓林的，并且不要第一个
        Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);

        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream = Stream.concat(manStream,womanStream);

        //把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
        //stream.map(Actor::new).forEach(System.out::println);
        stream.map(Actor::new).forEach(p -> System.out.println(p.getName()));

        Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3),
                womanList.stream().filter(s -> s.startsWith("林")).skip(1)).map(Actor::new).
                forEach(p -> System.out.println(p.getName()));
        //合并完之后每个元素创建一个对象

    }
}

30.6Stream流的收集操作

对数据使用Stream流的方式操作完毕后，我想把流中的数据收集到集合中，该怎么办呢?
Stream流的收集方法

• R collect(Collector collector)
• 但是这个收集方法的参数是一个Collector接口

工具类Collectors提供了具体的收集方式

• public static Collector toList():把元素收集到List集合中
• public static Collector toSet():把元素收集到Set集合中
• public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中

package Firmness018;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CollectDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");

        /*
        //需求1：得到名字为3个字的流
        Stream<String> listStream = list.stream().filter(s -> s.length() == 3);

        //需求2：把使用Stream流操作完毕的数据收集到List集合中并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for (String name : names){
            System.out.println(name);
        }
        */

        //创建Set集合对象
        Set<Integer> set = new HashSet<Integer>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        set.add(35);

        /*
        //需求3：得到年龄大于25的流
        Stream<Integer> setStream = set.stream().filter(age -> age >25);

        //需求4：把使用Stream流操作完毕后的数据收集到Set集合中并遍历
        Set<Integer> ages  = setStream.collect(Collectors.toSet());
        for(Integer age :ages){
            System.out.println(age);
        }
        */

        //定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
        String[] strArray = {"林青霞，30","张曼玉，35","王祖贤，33","柳岩，25"};

        //需求5：得到字符串中年龄数据大于28的流
        Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);

        //需求6：把使用Straem流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值,前面是键，后面是值
        //两个Lambda表达式，第一个对键进行操作，第二个对值进行操作
        Map<String, Integer> map = arrayStream.collect(Collectors.toMap((s) -> s.split("，")[0], s -> Integer.parseInt(s.split("，")[1])));

        Set<String> keySet = map.keySet();
        for(String key:keySet){
            Integer value = map.get(key);
            System.out.println(key+"，"+value);
        }

    }
}

31.反射

31.1类加载器

31.1.1类加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，VM将会连续完成做三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化

类的加载

• 就是指将class文件读入内存，并为之创建一个java.lang.Class对象
• 任何类被使用时，系统都会为之建立一个java.lang.Class对象

类的连接

• 验证阶段:用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
• 准备阶段:负责为类的类变量分配内存，并设置默认初始化值
• 解析阶段:将类的二进制数据中的符号引用替换为直接引用心

类的初始化

• 在该阶段，主要就是对类变量进行初始化

类的初始化步骤

• 假如类还未被加载和连接，则程序先加载并连接该类
• 假如该类的直接父类还未被初始化，则先初始化其直接父类
• 假如类中有初始化语句，则系统依次执行这些初始化语句
  **注意:**在执行第2个步骤的时候，系统对直接父类的初始化步骤也遵循初始化步骤1-3

类的初始化时机:

• 创建类的实例
• 调用类的类方法
• 访问类或者接口的类变量，或者为该类变量赋值
• 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
• 初始化某个类的子类
• 直接使用java.exe命令来运行某个主类

31.1.2类加载器

类加载器的作用

• 负责将.class文件加载到内存中，并为之生成对应的java.lang.Class对象
• 虽然我们不用过分关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行

JVM的类加载机制

• 全盘负责:就是当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入
• 父类委托:就是当一个类加载器负责加载某个Class时，先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
• 缓存机制:保证所有加载过的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存储到缓存区

ClassLoader:是负责加载类的对象
Java运行时具有以下内置类加载器

• Bootstrap class loader:它是虚拟机的内置类加载器，通常表示为null，并且没有父null
• Platform class loader:平台类加载器可以看到所有平台类，平台类包括由平台类加载器或其祖先定义的Java SE平台API,其实现类和JDK特定的运行时类
• System class loader:它也被称为应用程序类加载器，与平台类加载器不同。系统类加载器通常用于定义应用程序类路径，模块路径和JDK特定工具上的类
• 类加载器的继承关系: System的父加载器为Platform，而Platform的父加载器为Bootstrap

ClassLoader中的两个方法

• static ClassLoader getSystemClassLoader():返回用于委派的系统类加载器
• ClassLoader getParent():返回父类加载器进行委派

package Firmness019;

public class ClassLoaderDemo {
    public static void main(String[] args) {
        //static ClassLoader getSystemClassLoader():返回用于委派的系统类加载器
        ClassLoader c = ClassLoader.getSystemClassLoader();
        System.out.println(c);//AppClassLoader

        //ClassLoader getParent():返回父类加载器进行委派
        ClassLoader c2 = c.getParent();
        System.out.println(c2);//PlatformClassLoader

        ClassLoader c3 = c2.getParent();
        System.out.println(c3);//null

    }
}

31.2反射

31.2.1反射概述

Java反射机制:是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性,可以极大的增强程序的灵活性,程序不用在编译期就完成确定,在运行期仍然可以扩展

31.2.2获取Class类的对象

我们要想通过反射去使用一个类， 首先我们要获取到该类的字节码文件对象，也就是类型为Class类型的对象
这里我们提供三种方式获取Class类型的对象

• 使用类的class属性来获取该类对应的Class对象。 举例: Student.class将会返回Student类对应的Class对象

• 调用对象的getClass0方法,返回该对象所属类对应的Class对象
  该访法是Object类中的方法，所有的Java对象都可以调用该方法

• 使用Class类中的静态方法forName(String className),方法需要传入字符串参数,该字符串参数的值是某
  个类的全路径，也就是完整包名的路径

package Firmness020;
/*
三种方式获取Class类型的对象

- 使用类的class属性来获取该类对应的Class对象。 举例: Student.class将会返回Student类对应的Class对象
- 调用对象的getClass0方法,返回该对象所属类对应的Class对象
  该访法是Object类中的方法，所有的Java对象都可以调用该方法
- 使用Class类中的静态方法forName(String className),方法需要传入字符串参数,该字符串参数的值是某
  个类的全路径，也就是完整包名的路径
 */
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性来获取该类对应的Class对象
        Class<Student> c1 = Student.class;
        System.out.println(c1);

        Class<Student> c2 = Student.class;
        System.out.println(c1==c2);
        System.out.println("--------");

        //调用对象的getClass0方法,返回该对象所属类对应的Class对象
        String s = new String();
        Class<? > c3 = s.getClass();
        //Class<? extends Student> c3 = s.getClass();
        System.out.println(c1 == c3);
        //不行呀运算符 '==' 不能应用于 'java.lang.Class<Firmness020.Student>'、'java.lang.Class<capture<? extends java.lang.String>>'
        System.out.println("---------");

        //使用Class类中的静态方法forName(String className),
        Class<?> c4 = Class.forName("class Firmness020.Student");//找不到
        System.out.println(c1 == c4);

    }
}
package Firmness020;

public class Student {
    //成员变量：一个私有，一个默认，一个公共
    private String name;
    int age;
    public String address;

    //构造方法：一个私有，一个默认，两个公共

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    //成员方法：一个私有，四个公共
    private void function(){
        System.out.println("function");
    }

    private void method1(){
        System.out.println("method");
    }
    private void method2(String s){
        System.out.println("method:" + s );
    }
    private String method3(String s,int i){
        return s + "," +i;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

31.2.3反射获取构造方法并使用

Class类中用于获取构造方法的方法

• Constructor<?>0 getConstructors():返回所有公共构造方法对象的数组
• Constructor<?> [] getDeclaredConstructors():返回所有构造方法对象的数组
• Constructor getConstructor(Class<?> … parameterTypes):返回单个公共构造方法对象
• Constructor getDeclaredConstructor(Class <?> … parameterTypes):返回单个构造方法对象

Constructor类中用于创建对象的方法

• T newlnstance(Objet… initargs):根据指定的构造方法创建对象

package Firmness021;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获取Class对象
        Class<?> c = Class.forName("Firmness020.Student");

        //Constructor<?>[] getConstructors()返回一个包含Constructor对象的数组，Constructor对象反映了由该Class对象
        //Constructor<?>[] cons = c.getConstructors();
        //Constructors<?>[] getDeclaredConstructors()返回反映由该Class对象表示的类声明的所有构造函数的Constructor对象
        Constructor<?>[] cons = c.getConstructors();
        for(Constructor con : cons){
            System.out.println(con);
        }
        System.out.println("---------");

        //Constructor<T> getConstructor (Class<?>... parameterTypes) 返回一个Constructor对象，该对象反映由该Class对象表示的类的指定公共构造函数
        //Constructor<T> getDecLaredConstructor(Class<?>... parameterTypes)返回一个Constructor对象，该对象反映由此Class对象表示的类或接口的指定构造函数
        //参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象

        Constructor<?> con = c.getConstructor();

        //Constructor提供了一个类的单个构造函数的信息和访问权限
        //T newInstance (Object... initargs)使用由此Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数
        Object obj = con.newInstance();
        System.out.println(obj);

//        Student s = new Student();
//        System.out.println(s);//这样不是反射

        
    }
}

31.2.4反射获取构造方法并使用练习

练习1:

通过反射实现如下操作

• Students = new Student(“林青霞” ,30,“西安”);

• System.out.println(s);

• 基本数据类型也可以通过.class得到对应的Class类型

package Firmness021;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获取Class对象
        Class<?> c = Class.forName("Firmness020.Student");

        //public Student (String name,int age,String address)
        //Constructor<T> getConstructor (Class<?>. .。parameterTypes )
        Constructor<?> con = c.getConstructor(String.class, int.class, String.class);
        //基本数据类型也可以通过.class得到对应的Class类型

        //T newInstance( Object... initargs)
        Object obj = con.newInstance("林青霞",30,"西安");
        System.out.println(obj);

    }
}

练习2:

通过反射实现如下操作

• Students = new Student(“林青霞”);
• System.out.println(s);
• public void setAccessible(boolean flag):值为true,取消访问检查

package Firmness021;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo03 {
    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        //获取Class对象
        Class<?> c = Class.forName("Firmness020.Student");

        //private Student(String name)
        //Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
        Constructor<?> con = c.getDeclaredConstructor(String.class);

        //暴力反射
        //public void setAccessible (boolean flag)值为true,取消访问检查
        con.setAccessible(true);

        Object obj = con.newInstance("林青霞");
        System.out.println(obj);
    }
}

31.2.5反射获取成员变量并使用

Class类中用于获取成员变量的方法

• Field[] getFields():返回所有公共成员变量对象的数组
• Field[] getDeclaredFields():返回所有成员变量对象的数组
• Field getField(String name):返回单个公共成员变量对象
• Field getDeclaredField(String name):返回单个成员变量对象

Field类中用于给成员变量赋值的方法

• void set(Object obj, Object value):给obj对象的成员变量赋值为value

package Firmness022;

import Firmness020.Student;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        //获取Class对象
        Class<?> c = Class.forName("Firmness020.Student");

        //Field[] getFields () 返回一个包含Field对象的数组， Field对象反映由该Class对象表示的类或接口的所有可访问的公共字段
        ///Field[] getDeclaredFields ()返回一个Field对象的数组，反映了由该Class对象表示的类或接口声明的所有字段
        //Field[] fields = c.getFields();
        Field[] fields = c.getDeclaredFields();
        for(Field field:fields){
            System.out.println(field);
        }
        System.out.println("---------");

        //Field getField (String name)返回一个Field对象，该对象反映由该Class对象表示的类或接口的指定公共成员字段
        //Field getDeclaredField (String name)返回一个Field对象，该对象反映由该Class对象表示的类或接口的指定声明字段
        Field addressField = c.getField("address");//address对应的成员变量方法对象

        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        //obj.addressField = "西安";

        //Field提供有关类或接口的单个字段的信息和动态访问
        //void set (Object obj,Object value) 将指定的对象参数中由此Field对象表示的字段设置为指定的新值
        addressField.set(obj,"西安");     //给obj的成员变量addressField赋值为西安

        System.out.println(obj);

//        Student s = new Student();
//        s.address = "西安";
//        System.out.println(s);
    }
}

31.2.6反射获取成员变量并使用练习

练习:通过反射实现如下操作

• Students = new Student(;
• s.name = “林青霞”, .
• s.age = 30;
• s.address= " 西安;
• System.out.println(s);

package Firmness022;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo02 {
    public static void main(String[] args) throws NoSuchMethodException, ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        //获取Class对象
        Class<?> c = Class.forName("Firmness020.Student");

        //Student s = new Student();
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        System.out.println(obj);

        //s.name = "林青霞";
        //Field nameField = c.getField("name");   //NoSuchFieldException:name
        Field nameField = c.getDeclaredField("name");   //NoSuchFieldException:name
        nameField.setAccessible(true);
        nameField.set(obj,"林青霞");
        System.out.println();

        //s.age = 30;
        Field ageField = c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj,30);
        System.out.println(obj);

        //s.address = "西安"
        Field addressField = c.getDeclaredField("address");
        addressField.setAccessible(true);
        addressField.set(obj,"西安");
        System.out.println(obj);
        
    }
}

31.2.7反射获取成员方法并使用

Class类中用于获取成员方法的方法

• Method[] getMethods():返回所有公共成员方法对象的数组，包括继承的
• Method ] getDeclaredMethods():返回所有成员方法对象的数组，不包括继承的
• Method getMethod(String name, Class<?>… parameterTypes):返回单个公共成员方法对象
• Method getDeclaredMethod(String name, Class<?>… parameterTypes):返回单个成员方法对象

Method类中用于调用成员方法的方法

• Object invoke(Objectobj, Object…args):调用obj对象的成员方法，参数是args,返回值是Object类型

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获取Class对象
        Class<?> c = Class.forName("Firmness020.Student");
       // Method[] v = c.getMethods();
        Method[] v = c.getDeclaredMethods();
        for (Method method:
             v) {
            System.out.println(method);
        }
        Method m = c.getMethod("method1");
        //获取无参构造方法创建对象

        Constructor<? > con = c.getConstructor();
        Object obj = con.newInstance();
        //obj.m( );//肯定不能这样用
        //在类或接口上提供有关单一方法的信息和访问权限
        //object invoke (Object obj，Object... args)在具有指定参数的指定对象上调用此方法对象表示的基础方法
        // Object:返回值类型
        // obj:调用方法的对象
        // args:方法需要的参数
        m.invoke(obj);
        
        //多参数用法
        Method m3 = c.getMethod( "method3",String.class, int.class);
        Object o = m3.invoke(obj,"利拉德",30);
        m3.setAccessible(true);//取消访问检查
        System.out.println(o);
    }
}

越过泛型检查练习

练习1:我有一个ArrayList集合，现在我想在这个集合中添加一个字符串数据，如何实现?

package Firmness024;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class ReflectDemo01 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //创建集合
        ArrayList<Integer> array = new ArrayList<Integer>();
        //array.add(10);
        //array.add(20) ;
        //array.add("heLLo");
        Class<? extends ArrayList> c = array.getClass();
        Method m = c.getMethod("add",Object.class);
        m.invoke( array ,"hello");
        m.invoke( array ,"world" );
        m.invoke( array,"java");
        System.out.println( array );
    }
}

输出结果：[hello, world, java]

通过配置文件运行类中方法

class.txt
className=Firmness020.Student
methodName=method1

package Firmness024;

import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

import static java.lang.Class.forName;

public class ReflectTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //加载数据
        Properties prop = new Properties();
        FileReader fr = new FileReader( "E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\Firmness\\src\\Firmness024\\class.txt");
        prop.load(fr);
        fr.close();

        String className = prop.getProperty("className" );
        String methodName = prop.getProperty( "methodName" );

        //通过反射来使用
        Class<?> c = Class.forName(className); // Firmness020.Student

        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        Method m = c.getMethod(methodName) ; // method1
        m.setAccessible(true);//取消访问检查
        m.invoke(obj);
    }
}

32.模块化

32.1模块化概述

Java语言随着这些年的发展已经成为了一门影响深远的编程语言，无数平台，系统都采用Java语言编写。但是，伴随着发展，Java也越来越庞大，逐渐发展成为一门“臃肿”的语言。而且，无论是运行一个大型的软件系统，还是运行一个小的程序，即使程序只需要使用Java的部分核心功能，VM也要加载整个JRE环境。为了给Java“瘦身”，让Java实现轻量化，Java 9正式的推出了模块化系统。Java被拆分为N多个模块，并允许Java程序可以根据需要选择加载程序必须的Java模块，这样就可以让Java以轻量化的方式来运行
其实，Java7的时候已经提出了模块化的概念，但由于其过于复杂，Java7，Java8都一直未能真正推出，直到Java 9才真正成熟起来。对于Java语言来说，模块化系统是一次真正的自我革新，这种革新使得“古老而庞大”的Java语言重新焕发年轻的活力

32.2 模块的基本使用

模块的基本使用步骤

• 创建模块(按照以前的讲解方式创建模块，创建包，创建类，定义方法)
  为了体现模块的使用，我们创建2个模块。一个是moduleOne，一个是moduleZero

• 在模块的src目录下新建一个名为module-info.java的描述性文件，该文件专门定义模块名，访问权限，模块依赖等信息描述性文件中使用模块导出和模块依赖来进行配置并使用

• 模块中所有未导出的包都是模块私有的，他们是不能在模块之外被访问的在myOne这个模块下的描述性文件中配置模块导出
  模块导出格式: exports包名;

• 一个模块要访问其他的模块，必须明确指定依赖哪些模块，未明确指定依赖的模块不能访问
  在moduleZero这个模块下的描述性文件中配置模块依赖
  模块依赖格式: requires模块名;
  注意:写模块名报错，需要按下Alt+Enter提示，然后选择模块依赖

• 在myTwo这个模块的类中使用依赖模块下的内容

  module moduleZero {
      exports zero01;//导出
      exports zero02;
  }
  
  module moduleOne {
      requires moduleZero;//导入
  }
  

32.3模块服务的使用

服务:从Java 6开始，Java提供了一种服务机制，允许服务提供者和服务使用者之间完成解耦简单的说，就是服务使用者只面向接口编程，但不清楚服务提供者的实现类
Java 9的模块化系统则进一步的简化了Java的服务机制。Java 9允许将服务接口定义在一个模块中，并使用uses语句来声明该服务接口，然后针对该服务接口提供不同的服务实现类，这些服务实现类可以分布在不同的模块中，服务实现模块则使用provides语句为服务接口指定实现类
服务使用者只需要面向接口编程即可

import zero02.MyService;

module moduleZero {
    exports zero01;//导出
    exports zero02;

    //provides MyService with zero01.zero02;
    provides MyService with zero01.zero01;//配置时提供了具体实现类
}

package zero02;

public interface MyService {
    void service();
}

package zero01;

import zero02.MyService;

public class zero01 implements MyService {
    @Override
    public void service() {
        System.out.println("实现了Service");
    }
}


import zero02.MyService;

module moduleOne {
    requires moduleZero;
    exports one01;
    uses MyService;//只是使用，但不知道具体实现是谁
}


package one01;

import zero02.MyService;

import java.util.ServiceLoader;

public class one01 {
    public static void main(String[] args) {
        ServiceLoader<MyService> serviceLoader = ServiceLoader.load(MyService.class);

        for (MyService s :
             serviceLoader) {
            s.service();
        }
    }
}

输出：实现了Service

模块服务的使用步骤

• 在moduleZero模块 下创建一个包zero02,在该包下提供一个接口， 接口中定义一个抽象方法
  public interface MyService {
  void service0;
  }
• 在com.itheima 03包下创建一个包zero01, 在该包下提供接口的两个实现类zero01和zero02
• 在moduleOne这个模块下的描述性文件中添如下配置
  模块导出: exports zero01;
  服务提供: provides MyService with zero01.zero01;
  指定MyService的服务实现类是zero01

参考资料

https://www.bilibili.com/video/BV18J411W7cE?p=1