Java8 中Stream类中源码方法例子
package com.h3c;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream.Builder;
public class Stream {
public static void main(String[] args) {
List<String> list = Arrays.asList("a", "bb", "ccc", "dddd", "eeeee", "ffffff");
List<String> list1 = Arrays.asList("a", "bb", "ccc", "a", "bb", "ccc");
List<String> list2 = Arrays.asList("dd", "da", "ac", "cc", "ee", "ea");
/**
* filter 过滤 length()>=2 返回值是Stream<String>类型
*/
List<String> collect1 = list.stream().filter(s -> s.length() >= 2).collect(Collectors.toList());
System.out.println(collect1);
/**
* map 转换 [ length()>=2 ] 返回值为 Stream<Boolean>
*/
List<Integer> collect2 = list.stream().map(s -> s.length()).collect(Collectors.toList());
System.out.println(collect2);
/**
* mapToInt 转换方法结果为int 返回值是IntStream类型
* 同样的方法 mapToLong mapToDouble
*/
int[] array = list.stream().mapToInt(s -> s.length()).toArray();
double mapToInt = list.stream().mapToInt(s -> s.length()).average().getAsDouble();
System.out.println(array.length);
System.out.println(mapToInt);
/**
* flatMap 转换方法 结果必须为stream 返回值是stream
*/
List<String> collect3 = list.stream().flatMap(s -> list.stream()).collect(Collectors.toList());
System.out.println(collect3);
/**
* flatMapToInt 转换方法结果为 IntStream 返回值是IntStream
* 类似 flatMapToLong flatMapToDouble
*/
int[] array1 = list.stream().flatMapToInt(s -> list.stream().mapToInt(ss -> ss.length())).toArray();
System.out.println(array1.length);
/**
* distinct 去重 和sql中distinct一样 返回值为Stream
*/
Object[] array2 = list1.stream().distinct().toArray();
System.out.println(array2.length);
/**
* sorted 排序方法 对list进行排序
* java8 提供直接java.util.List中的sort方法,而不是旧的Collections.sort
*/
//实例方法的引用和Comparator.comparing
Collections.sort(list2, Comparator.comparing(String::toString));
List<String> collect4 = list2.stream().sorted().collect(Collectors.toList());
System.out.println(collect4);
//排序反转 reversed()
Comparator<String> comparator = (h1, h2) -> h1.compareTo(h2);
list2.sort(comparator);
list2.sort(comparator.reversed());
System.out.println(list2);
/**
* sorted(Comparator<? super T> comparator) 排序方法
*/
Comparator<String> comparator1 = (h1, h2) -> h1.compareTo(h2);
List<String> collect5 = list2.stream().sorted(comparator1.reversed()).collect(Collectors.toList());
System.out.println(collect5);
/**
* peek 用来<偷看一眼>的方法 不会改变list
*/
List<String> collect6 = list.stream().peek(string -> System.out.println("偷看一眼" + string)).collect(Collectors.toList());
List<String> collect7 = list.stream().peek(string -> string.concat("!")).map(string -> string.concat("!")).collect(Collectors.toList());
System.out.println(collect6);
System.out.println(collect7);
/**
* limit 限制多少个
*/
List<String> collect8 = list.stream().limit(4).collect(Collectors.toList());
System.out.println(collect8);
/**
* skip 跳过
*/
List<String> collect = list.stream().skip(2).collect(Collectors.toList());
System.out.println(collect);
/**
* forEach 循环 终止语句,返回值void
*/
list.stream().forEach(System.out::println);
list.forEach(System.out::println);
/**
* forEachOrdered 排序循环 终止语句,返回值void
*/
list2.stream().forEachOrdered(System.out::println);
/**
* toArray 转成数组
*/
Object[] array3 = list.stream().toArray();
Object[] array4 = list.toArray();
System.out.println(array3);
System.out.println(array4);
/**
* reduce 归约 前面的a+后面的b+后面的b+...
*/
List<Integer> ints = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
String reduce = list.stream().reduce((a, b) -> a + b.length()).get();
String reduce2 = list.stream().reduce("reduce ", (a, b) -> a + b.length());
Integer reduce3 = ints.stream().reduce(11, (a, b) -> a + b);
System.out.println(reduce);
System.out.println(reduce2);
System.out.println(reduce3);
/**
* collect
*/
List<String> collect9 = list.stream().collect(Collectors.toList());
System.out.println(collect9);
/**
* min 最小的 参数是Comparator
*/
String min = list.stream().min((h1, h2) -> h1.compareTo(h2)).get();
System.out.println(min);
/**
* max 最大的 参数是Comparator
*/
String max = list.stream().max((h1, h2) -> h1.compareTo(h2)).get();
System.out.println(max);
/**
* count 元素的总数
*/
long count = list.stream().count();
System.out.println(count);
/**
* anyMatch 任何一个 返回值boolean
*/
boolean anyMatch = list.stream().anyMatch(s -> s.length() > 7);
System.out.println(anyMatch);
/**
* allMatch 所有的 返回值boolean
*/
boolean allMatch = list.stream().allMatch(s -> s.length() > 1);
System.out.println(allMatch);
/**
* noneMatch 没有一个 返回值boolean
*/
boolean noneMatch = list.stream().noneMatch(s -> s.length() > 7);
System.out.println(noneMatch);
/**
* findFirst 找到第一个 返回值Optional<T>
*/
String string = list.stream().filter(s->s.length()>2).findFirst().get();
System.out.println(string);
/**
* findAny
*/
String string2 = list.stream().filter(s -> s.length() > 3).peek(s -> System.out.println(s)).findAny().get();
System.out.println(string2);
/**
* 创建stream方法 Stream的静态方法
*
* builder static方法 返回值Builder
*/
java.util.stream.Stream.Builder<String> builder1 = java.util.stream.Stream.builder();
builder1.accept("ss");
builder1.add("xxx");
Builder<String> add = builder1.add("xxx1");
java.util.stream.Stream<String> stream1 = add.build();
java.util.stream.Stream<String> stream = builder1.build();
List<String> collect10 = stream.collect(Collectors.toList());
List<String> collect11 = stream1.collect(Collectors.toList());
System.out.println(collect10);
System.out.println(collect11);
/**
* empty 创建一个不含任何元素的Stream
*/
java.util.stream.Stream<Object> empty = java.util.stream.Stream.empty();
List<Object> collect16 = empty.collect(Collectors.toList());
System.out.println(collect16);
/**
* of 转换成String的静态发放 ,里面可以是 数组,list,
*/
Map<String,String> map = new HashMap<String,String>();
map.put("1", "a");
map.put("2", "b");
map.put("3", "c");
List<String> collect13 = java.util.stream.Stream.of("ssss,sss,ss,1111".split(",")).collect(Collectors.toList());
List<List<String>> collect14 = java.util.stream.Stream.of(list,list2,list1).collect(Collectors.toList());
List<Map<String,String>> collect15 = java.util.stream.Stream.of(map,map,map).collect(Collectors.toList());
System.out.println(collect13);
System.out.println(collect14);
System.out.println(collect15);
/**
* iterate 循环1到n 必须要有limit限制 和reduce类似
*/
java.util.stream.Stream.iterate(0 , n -> n +3).limit(10).forEach(System.out::println);
/**
* generate 创建无限Stream的静态方法
*/
java.util.stream.Stream<Double> echos = java.util.stream.Stream.generate(Math::random);
System.out.println(echos.findFirst().get()+"======");
Random seed = new Random();
Supplier<Integer> random = seed::nextInt;
java.util.stream.Stream.generate(random).limit(10).forEach(System.out::println);
/**
* concat static方法 拼接stream 返回值stream
*/
java.util.stream.Stream<String> concat = java.util.stream.Stream.concat(list.stream(), list1.stream());
List<String> collect12 = concat.collect(Collectors.toList());
System.out.println(collect12);
/**
* parallel 并行流
*/
list.stream().parallel().forEach(System.out::println);
list.stream().forEach(System.out::println);
}
}