javaStream流

Stream流

Stream流的作用:
结合了Lambda表达式 简化集合、数组的操作

Stream流的使用步骤

1. 先得到一条Stream流 并把数据放上去
   1. 利用Stream流中的API进行各种操作(如 过滤 转换 统计 打印等等)
      1. 中间方法: 方法调用完之后,还可以调用其他方法 如:过滤 转换
      2. 终结方法: 最后一步,调用完毕之后,不能调用其他方法 如:统计 打印
2. 使用中间方法对流水线上的数据进行操作
3. 使用终结方法对流水线上的数据进行操作

先得到一条Stream流 并把数据放上去

中间方法

代码示例

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","ab","bc");
// filter 过滤 把a开头的留下 其余数据过滤不要
list.stream().filter(new Predicate<String>() {
    @Override
    public boolean test(String s) {
        // 如果返回值为true 表示当前数据留下
        // 如果返回值为false 表示当前数据舍弃
        return s.startsWith("a");
    }
}).forEach(s -> System.out.println(s));
// lambda 表达式简化
list.stream().filter(s -> s.startsWith("a")).forEach(s-> System.out.printl(s));
/*
*  limit 获取前几个元素
*  skip 跳过前几个元素
* */
list.stream().limit(3)
        .forEach(s-> System.out.println(s));
list.stream().skip(4)
        .forEach(s-> System.out.println(s));
/*
* distinct 元素去重 依赖(hashCode和)
* */
list.stream()
        .distinct().forEach(s-> System.out.println(s));
/*
* concat 合并  a和b两个流为一个流
* 尽量保持数据类型一致 否则会返回ab两个类的父类
* */
Stream.concat(list.stream(),list.stream())
        .forEach(s-> System.out.println(s));
/*
* map 转换流中的数据类型
* */
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1,"a-1","b-2","c-3");
// 需求: 只打印 数字   String->int
/*
* 第一个类型: 流中原本的数据类型
* 第二个类型: 要转成之后的类型
* appley 的形参s: 依次表示流里面的每一个数据
* 返回值: 表示转换之后的数据
* */
// 当map方法执行完后 流上的数据就变成了整数
// 所以在下面forEach当中 s依次表示流里面的每一个数据 这个数据现在就是整数了
list1.stream().map(new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        String[] arr = s.split("-");
        return Integer.parseInt(arr[1]);
    }
}).forEach(s-> System.out.println(s));
// 转换lambda表达式的形式
list.stream().map(s-> Integer.parseInt(s.split("-")[1]))
        .forEach(s-> System.out.println(s));

终结方法

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","ab","bc");
// filter 过滤 把a开头的留下 其余数据过滤不要
list.stream().filter(new Predicate<String>() {
    @Override
    public boolean test(String s) {
        // 如果返回值为true 表示当前数据留下
        // 如果返回值为false 表示当前数据舍弃
        return s.startsWith("a");
    }
}).forEach(s -> System.out.println(s));
// lambda 表达式简化
list.stream().filter(s -> s.startsWith("a")).forEach(s-> System.out.printl(s));
/*
*  limit 获取前几个元素
*  skip 跳过前几个元素
* */
list.stream().limit(3)
        .forEach(s-> System.out.println(s));
list.stream().skip(4)
        .forEach(s-> System.out.println(s));
/*
* distinct 元素去重 依赖(hashCode和)
* */
list.stream()
        .distinct().forEach(s-> System.out.println(s));
/*
* concat 合并  a和b两个流为一个流
* 尽量保持数据类型一致 否则会返回ab两个类的父类
* */
Stream.concat(list.stream(),list.stream())
        .forEach(s-> System.out.println(s));
/*
* map 转换流中的数据类型
* */
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1,"a-1","b-2","c-3");
// 需求: 只打印 数字   String->int
/*
* 第一个类型: 流中原本的数据类型
* 第二个类型: 要转成之后的类型
* appley 的形参s: 依次表示流里面的每一个数据
* 返回值: 表示转换之后的数据
* */
// 当map方法执行完后 流上的数据就变成了整数
// 所以在下面forEach当中 s依次表示流里面的每一个数据 这个数据现在就是整数了
list1.stream().map(new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        String[] arr = s.split("-");
        return Integer.parseInt(arr[1]);
    }
}).forEach(s-> System.out.println(s));
// 转换lambda表达式的形式
list.stream().map(s-> Integer.parseInt(s.split("-")[1]))
        .forEach(s-> System.out.println(s));
/*
* Consumer的泛型 表示流体中数据的类型
* accept方法的形参s 依次表示流里面的每一个数据
* 方法体 对每一个数据的处理操作
* */
list.stream().forEach(new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
});
// 转为lambda
// forEach方法 为 void 故之后不能对forEach()的返回 进行调用
list.stream().forEach(s-> System.out.println(s));
// count
long count = list.stream().count();
System.out.println(count);
// toArray()
Object[] arr1 = list.stream().toArray();
System.out.println(arr1.toString());
/*
*  IntFunction的泛型 具体类型的数据
* apply的形参: 流中数据的个数 要跟数组的长度保持一致
* apply的返回值: 具体类型的数组
* 方法体: 就是创建数组
* */
/*
* toArray方法的参数的作用 负责创建一个指定类型的数组
* toArray方法的底层 会依次得到流里面的每一个数据 并把数据放到数组当中
* toArray方法的返回值 是一个装着流里面所有数组的数组
* */
String[] arr2 = list.stream().toArray(new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
});
System.out.println(Arrays.toString(arr2));
String[] arr3 = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr3));
/*
* collect(Collector collector)  收集流中的数据 放到集合中(List Set Map)
*
* 注意点:
*   如果我们要收集到Map集合当中 健不能重复 否则会报错
* */
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2,"a-男-1","b-女-2","c-男-3");
// 收集到List集合当中
// 需求: 收集所有男性
List<String> collect = list.stream().filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toList());
System.out.println(collect);
// 收集到Set集合中
// Set会对收集的数据进行去重
Set<String> collect1 = list.stream().filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toSet());
System.out.println(collect1);
// 收集到Map中
// 谁作为键 谁作为值
// 键: 姓名  值:年龄
Map<String, Integer> collect2 = list.stream()
        .filter(s -> "男".equals(s.split("-")[1]))
        // toMap(键的规则,值的规则)
        /*
         * toMap: 参数一表示键的生成规则
         *        参数二表示值的生成规则
         * 参数一:
         *    Function泛型一: 表示流中每一个数据的类型
         *            泛型二: 表示Map集合中键的数据类型
         *    方法apply形参 值依次表示流里面的每一个数据
         *       方法体: 生成键的代码
         *       返回值: 已经生成的键
         *
         * 参数二:
         *   Function泛型一: 表示流中每一个数据的类型
         *           泛型二: 表示Map集合中值的数据类型
         *   方法apply形参; 依次表示流里面的每一个数据
         *       方法体: 生成值的代码
         *       返回值: 已经生成的值
         * */
        .collect(Collectors.toMap(new Function<String, String>() {
                                      @Override
                                      public String apply(String s) {
                                          return s.split("-")[0];
                                      }
                                  },
                new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) {
                        return Integer.parseInt(s.split("-")[2]);
                    }
                }));
// 转换为lambda
Map<String, Integer> collect3 = list.stream()
        .filter(s -> "男".equals(s.split("-")[1]))
        .collect(Collectors.toMap(
                s -> s.split("-")[0],
                s -> Integer.parseInt(s.split("-")[2])));
System.out.println(collect3);