stream2
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector; public class MyListCollector<T> implements Collector<T, List<T>, List<T>>{ @Override
public Supplier<List<T>> supplier() {
return ArrayList<T>::new;
} @Override
public BiConsumer<List<T>, T> accumulator() {
// return ArrayList<T>::add;
return List::add;
} @Override
public BinaryOperator<List<T>> combiner() {
return null;
} @Override
public Function<List<T>, List<T>> finisher() {
return null;
} @Override
public Set<Characteristics> characteristics() {
return null;
}
}
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector; import static java.util.stream.Collector.Characteristics.CONCURRENT;
import static java.util.stream.Collector.Characteristics.IDENTITY_FINISH;
import static java.util.stream.Collector.Characteristics.UNORDERED; public class MySetCollector<T> implements Collector<T, Set<T>, Set<T>> { @Override
public Supplier<Set<T>> supplier() {
System.out.println("supplier");
return HashSet<T>::new;
} // 如果return HashSet<T>::add,那么会编译报错,原因在于
// 如果这里return的是HashSet,而supplier方法返回的是TreeSet
// 那么显然,中间用于累积的容器的类型二者是不一致的;就会出现问题
// 如果这里使用了Set::add,即接口类型,那么它就会兼容于supplier
// 所返回的容器类型
// 总之:这里return的类型必须要与泛型的类型保持完全一致
@Override
public BiConsumer<Set<T>, T> accumulator() {
System.out.println("accumulator");
// return Set<T>::add; return (set, item) -> {
System.out.println(item + ", " + set + ", " + Thread.currentThread().getName() );
set.add(item);
};
} @Override
public BinaryOperator<Set<T>> combiner() {
System.out.println("combiner"); return (set1, set2) -> {
set1.addAll(set2);
return set1;
};
} @Override
public Function<Set<T>, Set<T>> finisher() {
System.out.println("finisher"); return Function.identity(); // 对于IDENTITY_FINISH来说,该方法可以直接抛出异常,该方法实际上并不会被调用
// throw new UnsupportedOperationException();
} // 该方法会被调用2次,分别用于确定UNORDERED与IDENTITY_FINISH
@Override
public Set<Characteristics> characteristics() {
System.out.println("characteristics"); return Collections.unmodifiableSet(EnumSet.of(IDENTITY_FINISH, CONCURRENT, UNORDERED));
} public static void main(String[] args) {
List<String> list = Arrays.asList("hello", "world", "welcome", "hello", "a", "b", "c", "d", "e", "f", "g", "aa", "bb", "cc", "dd", "ee", "ff", "gg", "hh", "ii");
Set<String> preSet = new HashSet<>();
preSet.addAll(list); System.out.println(preSet); Set<String> set = preSet.stream().parallel().collect(new MySetCollector<>()); System.out.println("---------------"); System.out.println(set); // System.out.println(Runtime.getRuntime().availableProcessors());
}
}
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector; public class MySetCollector2<T> implements Collector<T, Set<T>, Map<T, T>> { @Override
public Supplier<Set<T>> supplier() {
System.out.println("supplier invoked!"); // 串行流调用时,只会生成一个HashSet
// 并行流调用时,每个线程都会生成一个HashSet
/**
* * A a1 = supplier.get();
* accumulator.accept(a1, t1);
* accumulator.accept(a1, t2);
* R r1 = finisher.apply(a1); // result without splitting
*
* A a2 = supplier.get();
* accumulator.accept(a2, t1);
* A a3 = supplier.get();
* accumulator.accept(a3, t2);
* R r2 = finisher.apply(combiner.apply(a2, a3)); // result with splitting
*/ return () -> {
System.out.println("~~~~~~~~~~~~~~~~~");
return new HashSet<T>();
}; // return HashSet<T>::new;
} @Override
public BiConsumer<Set<T>, T> accumulator() {
System.out.println("accumulator invoked!"); return (set, item) -> {
System.out.println("accumulator, " + set + ", " + Thread.currentThread().getName());
set.add(item);
};
} @Override
public BinaryOperator<Set<T>> combiner() {
System.out.println("combiner invoked!"); return (set1, set2) -> {
System.out.println("combiner, " + set1 + ", " + set2);
set1.addAll(set2);
return set1;
};
} @Override
public Function<Set<T>, Map<T, T>> finisher() {
System.out.println("finisher invoked!"); return set -> {
System.out.println("finisher, " + set);
Map<T, T> map = new TreeMap<>();
set.stream().forEach(item -> map.put(item, item));
return map;
};
} @Override
public Set<Characteristics> characteristics() {
System.out.println("characteristics invoked!");
// return Collections.unmodifiableSet(EnumSet.of(Characteristics.UNORDERED, Characteristics.IDENTITY_FINISH));
return Collections.unmodifiableSet(EnumSet.of(Characteristics.UNORDERED, Characteristics.CONCURRENT));
} public static void main(String[] args) {
System.out.println(Runtime.getRuntime().availableProcessors()); List<String> list = Arrays.asList("hello", "world", "welcome", "hello", "a", "b", "c", "d", "e", "f", "g");
Set<String> set = new HashSet<>();
set.addAll(list); System.out.println("set: " + set); System.out.println("----------"); //串行执行时combiner并不会得到调用,combiner只在并行流时会得到调用
// Map<String, String> map = set.stream().parallel().sequential().parallel().collect(new MySetCollector2<>());
Map<String, String> map = set.parallelStream().collect(new MySetCollector2<>());
System.out.println(map);
}
}
import java.util.Arrays;
import java.util.Comparator;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.Optional; import static java.util.stream.Collectors.averagingInt;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.counting;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.maxBy;
import static java.util.stream.Collectors.minBy;
import static java.util.stream.Collectors.partitioningBy;
import static java.util.stream.Collectors.summarizingInt;
import static java.util.stream.Collectors.summingInt;
import static java.util.stream.Collectors.toList; public class StreamTest1 { public static void main(String[] args) {
Student student1 = new Student("zhangsan", 80);
Student student2 = new Student("lisi", 90);
Student student3 = new Student("wangwu", 100);
Student student4 = new Student("zhaoliu", 90);
Student student5 = new Student("zhaoliu", 90); List<Student> students = Arrays.asList(student1, student2, student3, student4, student5); // List<Student> students1 = students.stream().collect(toList());
// students1.forEach(System.out::println);
// System.out.println("------------");
//
//
// System.out.println("count: " + students.stream().collect(counting()));
// System.out.println("count: " + students.stream().count());
// System.out.println("------------");
//
//
// students.stream().collect(minBy(Comparator.comparingInt(Student::getScore))).ifPresent(System.out::println);
//
// students.stream().collect(maxBy(Comparator.comparingInt(Student::getScore))).ifPresent(System.out::println);
//
// System.out.println(students.stream().collect(averagingInt(Student::getScore)));
//
// System.out.println(students.stream().collect(summingInt(Student::getScore)));
//
// IntSummaryStatistics intSummaryStatistics = students.stream().collect(summarizingInt(Student::getScore));
// System.out.println(intSummaryStatistics);
// System.out.println("------------");
//
// System.out.println(students.stream().map(Student::getName).collect(joining()));
// System.out.println(students.stream().map(Student::getName).collect(joining(", ")));
// System.out.println(students.stream().map(Student::getName).collect(joining(", ", "<begin> ", " <end>")));
// System.out.println("------------");
// // Map<Integer, Map<String, List<Student>>> map = students.stream().
// collect(groupingBy(Student::getScore, groupingBy(Student::getName)));
// System.out.println(map);
// System.out.println("------------"); //
// Map<Boolean, List<Student>> map2 = students.stream().
// collect(partitioningBy(student -> student.getScore() > 80));
// System.out.println(map2);
// System.out.println("------------");
// // Map<Boolean, Map<Boolean, List<Student>>> map3 = students.stream().
// collect(partitioningBy(student -> student.getScore() > 80,
// partitioningBy(student -> student.getScore() > 90)));
// System.out.println(map3);
// System.out.println("------------"); //
// Map<Boolean, Long> map4 = students.stream().
// collect(partitioningBy(student -> student.getScore() > 80, counting()));
// System.out.println(map4);
// System.out.println("------------");
////
// Map<String, Student> map5 = students.stream().
// collect(groupingBy(Student::getName,
// collectingAndThen(minBy(Comparator.comparingInt(Student::getScore)),
// Optional::get)));
// System.out.println(map5);
}
}
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List; public class StreamTest2 { public static void main(String[] args) { List<String> list = Arrays.asList("nihao", "hello", "world", "welcome"); // Collections.sort(list, (item1, item2) -> item1.length() - item2.length());
// Collections.sort(list, (item1, item2) -> item2.length() - item1.length()); // Collections.sort(list, Comparator.comparingInt(String::length).reversed());
//// 此处lambda参数的类型推断无法推断出item为String类型,需要显式指定;原因在于这是一个独立的参数,并不是通过list调用方法来得出的
// Collections.sort(list, Comparator.comparingInt((String item) -> item.length()).reversed());
//// 如下代码无法编译通过,因为lambda参数要求参数类型应该是String或是String的父类,而Boolean则不是
// Collections.sort(list, Comparator.comparingInt((Boolean item) -> 1).reversed()); //// Collections的sort就是调用List的sort实现的
// list.sort(Comparator.comparingInt(String::length).reversed());
//// 如下代码必须要显式声明item的类型为String
// list.sort(Comparator.comparingInt((String item) -> item.length()).reversed());
//
//
// Collections.sort(list, Comparator.comparingInt(String::length).thenComparing(String.CASE_INSENSITIVE_ORDER));
//
// // 为何下面这个thenComparing中的参数类型可以推断出来?
// Collections.sort(list, Comparator.comparingInt(String::length).
// thenComparing((item1, item2) -> item1.toLowerCase().compareTo(item2.toLowerCase())));
// Collections.sort(list, Comparator.comparingInt(String::length).
// thenComparing(Comparator.comparing(String::toLowerCase)));
// Collections.sort(list, Comparator.comparingInt(String::length).
// thenComparing(Comparator.comparing(String::toLowerCase, Comparator.reverseOrder())));
////
// // welcome, world, nihao, hello
// Collections.sort(list, Comparator.comparingInt(String::length).reversed().
// thenComparing(Comparator.comparing(String::toLowerCase, Comparator.reverseOrder())));
//
// // welcome, world, nihao, hello, 注意:thenComparing都是根据前一个compare的结果来决定此次是否进行再次排序,
// // 如果前一次排序不返回0,那么此次排序结果就直接返回之前的排序结果 Collections.sort(list, Comparator.comparingInt(String::length).reversed().
thenComparing(Comparator.comparing(String::toLowerCase, Comparator.reverseOrder())).
thenComparing(Comparator.reverseOrder())); System.out.println(list);
}
}
public class Student { private String name; private int score; public Student(String name, int score) {
this.name = name;
this.score = score;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getScore() {
return score;
} public void setScore(int score) {
this.score = score;
} @Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", score=" + score +
'}';
}
}
stream2的更多相关文章
- java8 Stream2
new Thread(() -> System.out.println("lambda表达式,取代匿名函数......")).start(); Stream.of(" ...
- 深入node之Transform
Transform流特性 在开发中直接接触Transform流的情况不是很多,往往是使用相对成熟的模块或者封装的API来完成流的处理,最为特殊的莫过于through2模块和gulp流操作.那么,Tra ...
- 最好的.NET开源免费ZIP库DotNetZip(.NET组件介绍之三)
在项目开发中,除了对数据的展示更多的就是对文件的相关操作,例如文件的创建和删除,以及文件的压缩和解压.文件压缩的好处有很多,主要就是在文件传输的方面,文件压缩的好处就不需要赘述,因为无论是开发者,还是 ...
- 一款开源免费的.NET文档操作组件DocX(.NET组件介绍之一)
在目前的软件项目中,都会较多的使用到对文档的操作,用于记录和统计相关业务信息.由于系统自身提供了对文档的相关操作,所以在一定程度上极大的简化了软件使用者的工作量. 在.NET项目中如果用户提出了相关文 ...
- 如何运行Spark程序
[hxsyl@CentOSMaster spark-2.0.2-bin-hadoop2.6]# ./bin/spark-submit --class org.apache.spark.examples ...
- 小菜学习设计模式(四)—原型(Prototype)模式
前言 设计模式目录: 小菜学习设计模式(一)—模板方法(Template)模式 小菜学习设计模式(二)—单例(Singleton)模式 小菜学习设计模式(三)—工厂方法(Factory Method) ...
- C# DESC加密
DESC加密方法 直接上代码: 1.加密 /// <summary> /// 加密 /// </summary> /// <param name="obj&qu ...
- [MVC_Json序列化]Json字符串反序列化成C#对象
上一篇中有Json序列化相关问题得到了解决. 那么结果集为Json串时,如何将Json串转成C#对象呢? 现举例说明: -现有如下字符串数据 string k = "{\"ring ...
- Matlab绘图函数一览
要查看Matlab所有绘图函数,请从Matlab主界面菜单查看“绘图目录”,或从Matlab帮助文档查看“Types of MATLAB Plots”(在线版本).本文的图和英文解释摘自Matlab帮 ...
随机推荐
- struts学习记录
see also:http://blog.csdn.net/chenggil10/article/details/5965806#_Toc250472631 0.struts2每一个请求,都new一个 ...
- 记一次OOM问题排查过程
上周运维反馈线上程序出现了OOM,程序日志中的输出为 Exception in thread "http-nio-8080-exec-1027" java.lang.OutOfMe ...
- delphi xe6 调用java GPS的方法
如果用xe6自带的LocationSensor控件,默认优先使用网络位置,网络位置定位精度不准确,不能满足高精度定位的要求.但xe6自带的LocationSensor控件不能指定网络定位优先还是GPS ...
- C# 写 LeetCode easy #14 Longest Common Prefix
14.Longest Common Prefix Write a function to find the longest common prefix string amongst an array ...
- jQuery的选择器+实例
返回目录 jQuery的冒号选择器 表单 :input :text :password :radio :checkbox :submit :image :reset :button :file :h ...
- .net core webapi +ddd(领域驱动)+nlog配置+swagger配置 学习笔记(1)
搭建一个.net core webapi项目 在开始之前,请先安装最新版本的VS2017,以及最新的.net core 2.1. 首先创建一个Asp.Net Core Web应用程序 这个应用程序是 ...
- C++时间操作的汇总
. 获取当前时间 time_t cur_time = time(NULL); . 把整数时间转为字符串时间 string GetStringTime(const time_t time) { stru ...
- UITouch
触摸事件基本都是发生在 viewController 中,首先触摸的对象是视图,而视图的类 UIView 继承了 UIRespnder 类,但是要对事件作出处理,还需要重写 UIResponder 类 ...
- Ubuntu小记
一. Ubuntu分区记忆 参考教程调整: 1. /boot用于安装grub,设为主分区 2. /根目录20G一般足够 3. /home剩下的给home 4. swap空间=物理内存 挂载点 大小 类 ...
- 从零开始安装 Ambari (3) -- 安装 Ambari
1. 安装 yum -y install ambari-server 2. ambari server 需要一个数据库存储元数据,默认使用的 Postgres 数据库.默认的用户名和密码是: amba ...