java基础复习——day18（Stream流 ； 反射）

Stream流

1. 生成方式

Stream流 函数式编程 牛逼666 用到Lambda表达式

Stream流操作：

stream流的使用

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

常见的生成流的方式：

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

package Lambda;

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

//测试类
public class Demo {
    public static void main(String[] args) {
        //Collection体系生成流 默认方法生成流
        List<String> list = new ArrayList<>();
        Stream<String> liststream = list.stream();

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

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

        //数组通过Stream接口的静态方法of 生成流
        String[] str = {"hello", "world", "java"};
        Stream<String> strStream = Stream.of(str);
        Stream<String> strStream1 = Stream.of("hello", "world", "java");
        Stream<Integer> integerStream = Stream.of(10, 20, 30, 40);
    }
}

2. Stream常见的中间操作方法

2.1 filter

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

package Lambda;

import java.util.*;

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("张添胜");
        arrayList.add("张天");
        arrayList.add("张天神");
        arrayList.add("文天");
        arrayList.add("胜");
        arrayList.add("添胜");
        arrayList.add("张天胜");
        System.out.println(arrayList);

        arrayList.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() >= 3).forEach(System.out::println);
        //张添胜
        //张天神
        //张天胜
    }
}

2.2 limit和skip

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

package Lambda;

import java.util.*;

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("张添胜");
        arrayList.add("张天");
        arrayList.add("张天神");
        arrayList.add("文天");
        arrayList.add("胜");
        arrayList.add("添胜");
        arrayList.add("张天胜");

        //取前三个 输出
        arrayList.stream().limit(3).forEach(System.out::println);
        System.out.println("---------------------");

        //跳过前三个
        arrayList.stream().skip(3).forEach(System.out::println);
        System.out.println("---------------------");

        //跳过前两个，剩下的前三个
        arrayList.stream().skip(2).limit(3).forEach(System.out::println);
    }
}

2.3 concat和distint

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

package Lambda;

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

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("张添胜");
        arrayList.add("张天");
        arrayList.add("张天神");
        arrayList.add("文天");
        arrayList.add("胜");
        arrayList.add("添胜");
        arrayList.add("张天胜");

        //流1：前四个   .3
        Stream<String> s1 = arrayList.stream().limit(4);

        //流2：跳过前两个  5
        Stream<String> s2 = arrayList.stream().skip(2);

        //合并两个流 输出
        //Stream.concat(s1,s2).forEach(System.out::println);

        //合并， 去重 输出
        Stream.concat(s1, s2).distinct().forEach(System.out::println);

    }
}

2.4 sorted

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

package Lambda;

import java.util.*;

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("adjflka");
        arrayList.add("jfldfjaldk");
        arrayList.add("osdfsf");
        arrayList.add("xncod");
        arrayList.add("werod");
        arrayList.add("nclasdnf");

        //按照字母顺序排序 默认
        //  arrayList.stream().sorted().forEach(System.out::println);

        //按照字符串长度 次：字母顺序
        arrayList.stream().sorted((s1, s2) -> {
            int num = s1.length() - s2.length();
            int num1 = num == 0 ? s1.compareTo(s2) : num;
            return num1;
        }).forEach(System.out::println);
        //werod
        //xncod
        //osdfsf
        //adjflka
        //nclasdnf
        //jfldfjaldk
    }
}

2.5 Map和MapToInt

• Stream map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流Function接口中的方法 R apply(T t)
• IntStream mapTolnt(TolntFunction mapper):返回一个Stream其中包含将给定函数应用于此流的元素的结果 ， 比如sum()

IntStream:表示原始int流
ToIntFunction接口中的方法 ： int applyAsInt(T value)

package Lambda;

import java.util.*;

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("10");
        arrayList.add("20");
        arrayList.add("30");
        arrayList.add("40");
        arrayList.add("50");

        //Stirng -> int , 输出
        arrayList.stream().map(Integer::parseInt).forEach(System.out::println);
        arrayList.stream().mapToInt(Integer::parseInt).forEach(System.out::println);//都可以转类型

        //mapToInt求和
        int sum = arrayList.stream().mapToInt(Integer::parseInt).sum(); //注意返回类型
        System.out.println(sum);
    }
}

3. Stream常见的终结操作方法

• forEach()方法:对每个元素操作
• count()方法：返回此流的元素数

package Lambda;

import java.util.*;

//测试类
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();

        arrayList.add("张添胜");
        arrayList.add("张天");
        arrayList.add("张天神");
        arrayList.add("文天");
        arrayList.add("添胜");
        arrayList.add("张天胜");

        //姓张的数量
        long sum = arrayList.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(sum);//4
    }
}

Stream练习：

package Lambda;

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

//测试类
public class Demo {
    public static void main(String[] args) {
        //创建男女集合
        ArrayList<String> manList = new ArrayList<>();
        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> concatStream = Stream.concat(manStream, womanStream);

        //把结果创建成对象
        concatStream.map(Actor::new).forEach(p -> System.out.println(p.getName()));//这确实离谱 创建对象的Lambda表达式不熟练
        System.out.println("-----------------------");

        //熟练方法
        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()));
    }
}

4. Stream流的收集操作

把流中的数据收集到集合中：
收集方法：

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

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

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

package Lambda;

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

//测试类
public class Demo {
    public static void main(String[] args) {
        //  1.  名字大于3个字存入list集合 遍历
        List<String> list = new ArrayList<>();
        list.add("文天圣");
        list.add("天圣");
        list.add("文天s");
        list.add("文t圣");

        Stream<String> listStream = list.stream().filter(s -> s.length() >= 3);
        List<String> list1 = listStream.collect(Collectors.toList());

        for (String s : list1) {
            System.out.println(s);
        }
        //文天圣
        //文天s
        //文t圣


        //  2.   数值大于25存入set集合
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(32);

        Stream<Integer> integerStream = set.stream().filter(i -> i > 25);
        Set<Integer> set1 = integerStream.collect(Collectors.toSet());

        for (Integer i : set1) {
            System.out.println(i);
        }
        //32
        //30


        // 3. 流存入map集合  年龄大小于30
        String[] strarray = {"wts,20", "xwb,30", "cyc,40"};
        Stream<String> mapStream = Stream.of(strarray).filter(s -> Integer.parseInt(s.split(",")[1]) >= 30);
        Map<String, Integer> map1 = mapStream.collect(Collectors.toMap(k -> k.split(",")[0], v -> Integer.parseInt(v.split(",")[1])));

        Set<String> keySet = map1.keySet();
        for (String k : keySet) {
            Integer value = map1.get(k);
            System.out.println(k + value);
            //xwb30
            //cyc40
        }
    }
}

反射（一言难尽）

1. 类加载和类加载器

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

类加载：

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

类的连接：

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

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

类的初始化步骤

• 假如类还未被加载和连接，则程序先加载并连接该类
• 假如该类的直接父类还未被初始化，则先初始化其直接父类（先父后子）
• 假如类中有初始化语句，则系统依次执行这些初始化语句

类初始化时机

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

类加载器

2. 反射

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