手把手带你了解Java-Stream流方法学习及总结

void forEach(Consumer<!--? super T--> action);

public void testForEach() {
     /**
      * 使用forEach()内部迭代
      * ints()表示整数类型
      * limit()表示限制流个数(次数)
      */
     Random random = new Random();
     random.ints().limit(10).forEach(System.out::println);
}

public void testForEach() {
    /**
     * 使用forEach()转换集合类型，如List->Map
     */
    AtomicInteger i = new AtomicInteger();//原子类型
    Map<Integer,String> map = new HashMap<>();
    List<String> list = new ArrayList<>(Arrays.asList("Hello",",","world"));
    list.stream().forEach(s->{
        map.put(i.getAndIncrement(),s);
    });
}

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

public void testMap(){
    /**
     * map()获取list每个元素的平方值
     * distinct()去重操作
     * collect()将map()产生的新的流转为List类型
     */
    List<Integer> list = Arrays.asList(1,2,3);
    list.stream().map(num -> num * num)
                 .distinct()
                 .collect(Collectors.toList())
                 .forEach(System.out::println);
}

Stream<T> filter(Predicate<? super T> predicate);

public void testFilter(){
    /**
     * filter()过滤空字符串
     * count()统计符合条件的个数，返回类型long
     */
    List<String> list = new ArrayList<>(Arrays.asList("ab","","abc","","acd"));
    long count = list.stream()
                     .filter(str -> str.isEmpty())
                     .count();
}

Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);

public void testSorted(){
    /**
     * sort()无参默认为自然排序
     * 返回类型Stream 会产生新的流
     */
    List<String> list = new ArrayList<>(Arrays.asList("aaa","ccc","bbb"));
    list.stream().sorted().forEach(System.out::println);
}

public void testSorted(){
    /**
     * sort(Comparator comp)按自定义比较器进行排序
     * 返回类型同样是Stream 会产生新的流
     */
    List<User> userList = new ArrayList<>(Arrays.asList(
       new User("zhangsan",22),
       new User("wangwu",22),
       new User("badao",32),
       new User("kongfu",16)
    ));
    Stream<User> sorted = userList.stream().sorted((x, y) -> {
        if (x.getAge() == y.getAge()) { // 使用流中的序列两两进行比较
            return x.getName().compareTo(y.getName());
        } else {
            return x.getAge() - y.getAge();//顺序
            // y.getAge() - x.getAge() 为逆序
        }
    });
    sorted.forEach(System.out::println);
}

<R> R collect(Supplier<R> supplier,
              BiConsumer<R, ? super T> accumulator,
              BiConsumer<R, R> combiner);

public void testCollect(){

    Stream<String> stream = Stream.of("hello","world","hello,world");
	
    // new()
    List<String> list = stream.collect(Collectors.toList());//List
    // 指定集合类型，如ArrayList
    ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));
    //Set
    stream.collect(Collectors.toSet());
    // 指定HashSet
    HashSet<String> hashSet = stream.collect(Collectors.toCollection(HashSet::new));
    // 拼接字符串
    String str = stream.collect(Collectors.joining());

public void testCollect(){
    /**
     * 参数传递行为相当于: new() -> add() -> addAll()
     */
    Stream<String> stream = Stream.of("hello","world","hello,world");
    // new() -> add() -> addAll()完整演示
    HashMap<String,String> map = stream.collect(HashMap::new,(x,y)->{
        x.put(y,y); // x 为集合，y 为当前遍历元素，以当前遍历元素作为kv
    },HashMap::putAll);
    map.forEach((x,y)->{
        System.out.println(x+" : "+y);
    });