反射、类对象、Stream API

反射 reflect

定义：在运行期间，可以获取对象的类型、类型的方法、类型构造方法等等，让对象可以认识到自身的结构。
获取对象的类型（类对象）
方式一:Object.getclass()
方式二：class.forName(“全类名加包”)
方式三：类名.class

类对象的功能

（1）用反射方式创建对象
正常创建对象：new 类名();
反射的方式创建对象：类对象.newInstance（）；//创建新实例（对象）
限制一：要求对象有无参构造
限制二：构造方法不能私有
（2) 获取方法信息
类对象.getMethods(); // 获取所有公共方法（public），包括继承的
类对象.getDeclaredMethods(); // 获取本类的所有方法(public, private, protected, 不加)
类对象.getMethod(方法名, 参数类型); // 找公共方法， 包括继承的
类对象.getDeclaredMethod(方法名, 参数类型); // 找本类的，不包括继承的
（3）获取属性信息（了解）
类对象.getFields(); // 获取所有公共属性（包括继承的）
类对象.getDeclaredFields(); // 获取本类所有属性（private public protected 不加）（不包括继承的）
类对象.getField(“属性名”);
类对象.getDeclaredField(“属性名”);
（4) 获取构造方法（了解）
类对象.getConstructors(); // 获取所有公共的构造方法
类对象.getDeclaredConstructors(); // 获取本类所有构造方法（private public protected 不加）
类对象.getConstructor(int.class); // 获取int参数类型的构造
类对象.getConstructor(); // 获得无参构造
（5） 反射调用方法
正常调用方式： 对象.方法名(参数)
反射调用方式： 方法.invoke(对象， 参数);
缺点：调用复杂，效率低
优点：可以调用私有方法，突破正常方法的限制, 经常用在开源框架中

Stream API

都和集合有关

问题导入：

List list = Arrays.asList(1,2,3,4,5);
写一个方法找偶数，返回一个新的list包含结果
旧的实现：

// 设计模式中，策略模式
public static List<Integer> exec(List<Integer> list, Predicate<Integer> predicate) {
    List<Integer> list2 = new ArrayList<>();
    // 遍历原始集合
    for(Integer i :list) {
        if(predicate.test(i)) {
            list2.add(i);
        }
    }
    return list2;
}

调用时采用

List<Integer> list = Arrays.asList(1,2,3,4,5);
System.out.println(exec(list, new Predicate<Integer>(){
    @Override
    public boolean test(Integer i) {
        return i % 2 == 0;
    }
}));

采用lambda改进

// 返回一个经过了筛选后的新集合 , 其中筛选规则是 i ->  i % 2 == 0
System.out.println(exec(list, i ->  i % 2 == 0));

采用stream api改进,更加简洁，原来的exec方法也不需要了

list.filter(i ->  i % 2 == 0).collect(Collectors.toList());

** 重要接口**

1.Predicate 断言接口
对应的lambda 一个参数，返回结果是boolean
(a) -> { return true|false; }
2.Function 函数接口
对应的lambda 一个参数，一个返回结果，参数和返回结果的类型可以不一样
3. BiPredicate 双参数断言
对应的lambda 两个参数，返回结果是boolean
(a, b) -> { return true|false; }
4. BiFunction 双参数函数接口
对应的lambda 两个参数，一个结果
(a, b) -> { 根据ab返回一个结果}
5. Consumer 消费接口
对应的lambda 一个参数 没有结果
(a) -> { 不需要return }
6. BiConsumer 双参数消费接口
对应的lambda 两个参数，没有结果
7. Supplier 生产者接口
对应的lambda 没有参数，返回一个结果
() -> {return 结果}

常用方法
1. filter
进行过滤的，lambda返回true会留下，lambda返回为false的过滤掉

        // 过滤方法
 Stream<Integer> stream2 = stream1.filter(i -> i % 2 == 0); // 2， 4

2. map
映射的, lambda把原有的元素转换为另一个元素， 不会改变个数

 // 各个元素*2, 映射 2-> 2*2 ， 4-> 4*2
 Stream<Integer> stream3 = stream2.map((i) -> i * 2); // 4, 8

3. flatMap
扁平化映射

//                                         字符串数组 变为 流	strings -> Arrays.stream(strings)
List<String> list3 = list.stream().flatMap(strings -> Arrays.stream(strings)).collect(Collectors.toList());

4. forEach
遍历流，接收一个Consumer

list3.stream().forEach( (a) -> {
    System.out.println(a);
} );

5. map的流遍历
接收一个BiConsumer

Map<String, String> map = new HashMap<>();
map.put("a", "张");
map.put("b", "李");
map.forEach( (key, value) -> {
    System.out.println("key:" +key + " value:" + value);
} );

6. 其它常见api
求个数

System.out.println(list3.stream().count());

去除重复

System.out.println(list3.stream().distinct().collect(toList()));

获取最大最小值

// 返回的是Optional 类型，怕集合为空时，没有合法的最大值
List<String> list4 = Arrays.asList("zhang", "li", "zhao", "wang"); 
System.out.println(list4.stream().max((a, b) -> a.compareTo(b)));
System.out.println(list4.stream().min((a, b) -> a.compareTo(b)));

如果是数字流，除了最大最小值外，还有平均值，和

System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).max());
System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).min());
System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).average());
System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).sum());

7. 分组

List<Student> students = Arrays.asList(
        new Student("zhang", "男", "西安"),
        new Student("li", "男", "西安"),
        new Student("wang", "女", "北京"),
        new Student("zhao", "女", "上海"),
        new Student("zhou", "男", "北京")
);

// 按性别分组
Map<String, List<Student>> map3 = students.stream().collect(Collectors.groupingBy((s) -> s.getSex() ));
System.out.println(map3);
// 按城市分组
Map<String, List<Student>> map4 = students.stream().collect(Collectors.groupingBy((s) -> s.getCity()));
System.out.println(map4);

Stream api中有一个重要思想：
Pipeline 流水线思想：把流中的数据一个接一个进行处理。每个数据会经过后续的filter， map等方法依次调用。
在整个执行过程中，lambda表达式是懒惰的，不执行终结方法的话，不会触发lambda的执行。
终结方法： collect， sum， max， min …
运算过程中不会改变原始集合，收集器会生成新的集合对象
8. 流的生成

1. 用集合生成
   List.stream()

2. 根据数字
   IntStream.of(1,2,3,4);

3. 把数组变成流
   Arrays.stream(数组);

4. 把文件中的每一行读取出来作为流元素

Files.lines(Paths.get("1.txt")).forEach( s -> System.out.println(s) );

5. 使用生产者接口
   Stream.generate(生产者接口)
   生成5个随机数

Random r = new Random();
Stream.generate( () -> r.nextInt(100) ).limit(5).forEach( x->System.out.println(x));

10. 方法引用(了解)
    对lambda表达式的扩展
    第一种： 对象::方法名
    例子: System.out::println

第二种： 类名::静态方法名

class ABC {
    public static boolean aaa(Integer x ) {
        // 代码多
        return x % 2 == 0;
    }
}

可以使用： ABC::aaa

第三种： 类名::new
可以取代 Supplier接口的lambda
例如 () -> new Student()
可以替换为: Student::new