Java------Stream流

作用：简化操作

步骤

1 得到一条stream流

2 利用流中API操作

在一堆零散数据里面的细节：

可以放相同类型的内容 或者数组 但是数组只能放引用数据类型，不能放基本数据类型，否则基本数据类型会把数组当初一个元素，放到stream中 

 

终结方法

 foreach count toArray：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.IntFunction;

//stream终结方法
public class stream5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"郭佳乐","郭佳乐","郭佳乐","郭佳乐","郭家","郭器","郭乐","佳乐");

//        遍历
        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });


//        统计
        System.out.println("--------------------------");
        long count = list.stream().count();
        System.out.println(count);

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

//        转化为数组，然后用arrys方法转成字符串放入数组
        Object[] objects = list.stream().toArray();
        System.out.println(Arrays.toString(objects));
        /*IntFunction的泛型：具体类型
        apply中形参：具体流中个数
        apply的返回值：具体类型数组*/

        //toarray中方法参数的作用：创建一个指定类型的数组
        //toarray中方法底层：依次得到流中数据斌且把数据放数组
        //toarray中方法的返回值：是装着流的一个数组。

        String[] strings = list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.println(Arrays.toString(strings));

//lamada表达式、创建一个和流一样长的数组，打印数组
        String[] s1 = list.stream().toArray(v -> new String[v]);
        System.out.println(Arrays.toString(s1));

    }
}

collect注意点：

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class stream6 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"郭佳乐-男-27","郭佳-女-20","佳乐-男-20","郭1-男-20","郭2-男-20","郭3-男-20");

//收集男性信息
        /*1 过滤男性
        2 收集信息并且创建一个新数组Collectors.toList()来储存内容
        3 打印    */
        List<String> collect = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toList());

        System.out.println(collect);
        System.out.println("---------------");
//        区别在于去重hashset会去重
        Set<String> collect1 = list.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toSet());
        System.out.println(collect1);


//        收集到map集合中
        /*
         *   toMap : 参数一表示键的生成规则
         *           参数二表示值的生成规则
         *
         * 参数一：
         *       Function泛型一：表示流中每一个数据的类型
         *               泛型二：表示Map集合中键的数据类型
         *
         *        方法apply形参：依次表示流里面的每一个数据
         *               方法体：生成键的代码
         *               返回值：已经生成的键
         *
         *
         * 参数二：
         *        Function泛型一：表示流中每一个数据的类型
         *                泛型二：表示Map集合中值的数据类型
         *
         *       方法apply形参：依次表示流里面的每一个数据
         *               方法体：生成值的代码
         *               返回值：已经生成的值
         *
         * */
         /*
            collect(Collector collector)            收集流中的数据，放到集合中 (List Set Map)

            注意点：
                如果我们要收集到Map集合当中，键不能重复，否则会报错
       */
        Map<String, Integer> c2 = list.stream().filter(s -> "男".equals(s.split("-")[1]))
                .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]);
                    }
                }));
        System.out.println(c2);

//        lamada表达式、
        Map<String, Integer> c3 = list.stream().filter(s -> "男".equals(s.split("-")[1]))
                .collect(Collectors.toMap(
                        s -> s.split("-")[0],
                        s -> Integer.parseInt(s.split("-")[2])
                ));

        System.out.println(c3);


    }
}

 总结

---

---

---

练习：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.stream.Collectors;

public class text2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        Collections.addAll(list,"zhangsan,23","lisi,24","wangwu,25");

/*        Map<String, Integer> collect1 = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 24)
                .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(",")[1]);
                            }
                        }));*/
//lamada表达式
        Map<String, Integer> collect1 = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 24)
                .collect(Collectors.toMap(
                        s -> s.split(",")[0],
                        s -> Integer.parseInt(s.split(",")[1])
                ));


        System.out.println(collect1);

    }
}