标签：static oid 集合 world 类型 sys int bool long
在日常开发中，对集合或者Map之类的数据整合操作是十分常见的。Java8中提供了Stream流的处理方式，可以极大的简化书写长度，便于查阅和使用。
生成操作
通过数据源（集合、数组等）生成流。如：list.steam()
中间操作
对流进行某种程度的过滤/映射，并返回一个新的流。如：filter()
终结操作
执行某个终结操作，一个流只能有一个终结操作。如：forEach()
Collection集合，使用自身stream()方法Map集合，间接生成Stream接口的静态方法of(T...values)// Collection集合使用自带的stream()方法
ArrayList<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
// Map使用间接方式 - 获取集合类型后再生成流
HashMap<Integer, String> map = new HashMap<>(16);
Stream<Map.Entry<Integer, String>> stream2 = map.entrySet().stream();
Stream<Integer> stream3 = map.keySet().stream();
Stream<String> stream4 = map.values().stream();
// 数组使用Stream接口的静态方法
String[] array = {"a", "b", "c"};
Stream<String> stream5 = Stream.of(array);
格式：Stream<T> filter(Predicate<? super T> predicate)
说明：Predicate断言返回一个boolean值，符合true条件的才会被保留
public static void testFilter(){
// 定义集合并生成流
ArrayList<String> list = new ArrayList<>();
list.add("Hello world");
list.add("Hello China");
list.add("Hello java");
list.add("Hey man");
Stream<String> stream = list.stream();
// 使用filter进行过滤。只有以Hello开头的才会被保留
stream.filter(s -> s.startsWith("Hello")).forEach(System.out::println);
}
格式：Stream<T> skip(long n)
说明：long n代表要跳过的长度
public static void testSkip(){
ArrayList<String> list = new ArrayList<>();
list.add("d");
list.add("c");
list.add("b");
list.add("a");
Stream<String> stream = list.stream();
// 使用skip进行操作。跳过前3个元素
stream.skip(3).forEach(System.out::println);
}
格式：Stream<T> limit(long maxSize)
说明：long maxSize表示要截取的长度，从1开始
public static void testLimit(){
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Stream<String> stream = list.stream();
// 使用limit进行操作。获取前3个元素
stream.limit(3).forEach(System.out::println);
}
格式：Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
private static void testConcat(){
ArrayList<String> list1 = new ArrayList<>();
list1.add("a");
list1.add("b");
list1.add("c");
ArrayList<String> list2 = new ArrayList<>();
list2.add("d");
list2.add("e");
list2.add("f");
// 获取两个流
Stream<String> stream1 = list1.stream();
Stream<String> stream2 = list2.stream();
// 使用concat操作，合并两个流
Stream.concat(stream1, stream2).forEach(System.out::println);
}
格式：Stream<T> distinct()
private static void testDistinct(){
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("a");
list.add("a");
list.add("b");
list.add("b");
list.add("b");
Stream<String> stream = list.stream();
// 使用distinct操作，去重
stream.distinct().forEach(System.out::println);
}
格式：
Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator)
说明：使用比较器进行排序，返回排序结果
private static void testSorted() {
ArrayList<String> list = new ArrayList<>();
list.add("ccc");
list.add("dd");
list.add("bb");
list.add("aaaa");
Stream<String> stream = list.stream();
// 使用默认方式排序
stream.sorted().forEach(System.out::println);
// 使用指定比较器比较
stream.sorted((a, b) -> {
return a.length() - b.length();
}).forEach(System.out::println);
// 示例：根据字符串长度进行升序排序，当前后长度相同时，根据字母顺序升序排序
stream.sorted((a, b) -> {
int num = a.length() - b.length();
return num == 0 ? a.compareTo(b) : num;
}).forEach(System.out::println);
// 优化写法
stream.sorted(Comparator.comparingInt(String::length).thenComparing(a -> a)).forEach(System.out::println);
}
格式：<R> Stream<R> map(Function<? super T, ? extends R> mapper)
说明：Function函数式接口代表要执行的操作
private static void testMap(){
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
Stream<String> stream = list.stream();
// 使用map操作，对流中每一个元素进行处理。此处是进行字符串拼接
stream.map(s -> s+"-OK").forEach(System.out::println);
}
格式：IntStream mapToInt(ToIntFunction<? super T> mapper)
说明：ToIntFunction函数式接口代表转换的方法，常用Integer.parseInt()
private static void testMapToInt(){
ArrayList<String> list = new ArrayList<>();
list.add("61");
list.add("65");
list.add("72");
Stream<String> stream = list.stream();
// 使用mapToInt操作，将流转换为int流。（相似的，还有mapToDouble,mapToLong等）
IntStream intStream = stream.mapToInt(Integer::parseInt);
// 此时，可以使用int流中的特殊方法。此处计算平均数
OptionalDouble average = intStream.average();
System.out.println(average);
}
格式：void forEach(Consumer<? super T> action)
说明：Consumer函数式接口代表要执行的操作
private static void testForEach(){
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("s");
list.add("d");
// 使用forEach操作，此处输出每一个元素
list.stream().forEach(System.out::println);
}
格式：long count()
private static void testCount(){
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("s");
list.add("d");
// 使用count操作，统计元素个数
long count = list.stream().count();
System.out.println(count);
}
方法：<R, A> R collect(Collector<? super T, A, R> collector)
/**
* 收集为List。结果为
* a,b,c,
*/
private static void testToList() {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Stream<String> stream = list.stream().limit(3);
// 使用collection操作收集并还原成List
List<String> newList = stream.collect(Collectors.toList());
for (String l : newList) {
System.out.print(l+",");
}
}
/**
* 收集为Map。结果为
* 1=a
* 2=b
* 3=c
*/
private static void testToMap() {
String regex = ",";
String[] strArray = {"1,a", "2,b", "3,c"};
Stream<String> stream = Stream.of(strArray);
// 使用collection操作收集并还原成Map
Map<String, String> map = stream.collect(Collectors.toMap((o -> o.split(regex)[0]), (o -> o.split(regex)[1])));
map.entrySet().forEach(System.out::println);
}
标签：static oid 集合 world 类型 sys int bool long
原文地址：https://www.cnblogs.com/Weihaom/p/14469432.html
