JDK8之Stream新特性

https://www.cnblogs.com/cbxBlog/p/9123106.html

/** *JDK8 Stream特性 * Created by chengbx on 2018/5/27. * Java 8 中的 Stream 是對集合（Collection）對象功能的加強，它專一於對集合對象進行各類很是便利、高效的聚合操做（aggregate operation）， * 或者大批量數據操做 (bulk data operation)。Stream API 藉助於一樣新出現的 Lambda 表達式，極大的提升編程效率和程序可讀性。 * 同時它提供串行和並行兩種模式進行匯聚操做，併發模式可以充分利用多核處理器的優點，使用 fork/join 並行方式來拆分任務和加速處理過程。 * 一般編寫並行代碼很難並且容易出錯, 但使用 Stream API 無需編寫一行多線程的代碼，就能夠很方便地寫出高性能的併發程序。 * 因此說，Java 8 中首次出現的 java.util.stream 是一個函數式語言+多核時代綜合影響的產物。 * 1、Stream API 的操做步驟： * * 1. 建立 Stream * * 2. 中間操做 * * 3. 終止操做(終端操做) * * 4. 接口中的默認方法 * 接口默認方法的」類優先」原則 * 若一個接口中定義了一個默認方法，而另一個父類或接口中 * 又定義了一個同名的方法時 * 1.選擇父類中的方法。若是一個父類提供了具體的實現，那麼 * 接口中具備相同名稱和參數的默認方法會被忽略. * 2.接口衝突。若是一個父接口提供一個默認方法，而另外一個接 * 口也提供了一個具備相同名稱和參數列表的方法（無論方法 * 是不是默認方法），那麼必須覆蓋該方法來解決衝突 * 5. 新增的重複註解@Repeatble和類型註解 * java8新增了重複註解，其使用方式爲： @Repeatable(Authorities.class) public @interface Authority { String role(); } public @interface Authorities { Authority[] value(); } public class RepeatAnnotationUseNewVersion { @Authority(role="Admin") @Authority(role="Manager") publicvoiddoSomeThing(){ } } 2.Java8爲ElementType枚舉增長了TYPE_PARAMETER、TYPE_USE兩個枚舉值， 從而能夠使用@Target(ElementType_TYPE_USE)修飾註解定義，這種註解被稱爲類型註解， 能夠用在任何使用到類型的地方 */
public class TestStream { List<Employee> employees = Arrays.asList( new Employee("aaa",11,5000), new Employee("bbb",21,5200), new Employee("ccc",13,5500), new Employee("ddd",54,6400), new Employee("eee",16,7100), new Employee("fff",74,7120), new Employee("ggg",12,7150) ); /** * 建立stream */ @Test public void test1(){ //1. Collection 提供了兩個方法 stream() 與 parallelStream()
        List<String> list = new ArrayList<>(); Stream<String> stream = list.stream(); Stream<String> parallelStream = list.parallelStream(); //獲取一個並行流 //2. 經過 Arrays 中的 stream() 獲取一個數組流
        Integer[] nums = new Integer[10]; Stream<Integer> stream1 = Arrays.stream(nums); //3. 經過 Stream 類中靜態方法 of()
        Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6); //4. 建立無限流 //迭代
        Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10); stream3.forEach(System.out::println); //生成
        Stream<Double> stream4 = Stream.generate(Math::random).limit(2); stream4.forEach(System.out::println); } /* 篩選與切片 filter——接收 Lambda ， 從流中排除某些元素。 limit——截斷流，使其元素不超過給定數量。 skip(n) —— 跳過元素，返回一個扔掉了前 n 個元素的流。若流中元素不足 n 個， 則返回一個空流。與 limit(n) 互補 distinct——篩選，經過流所生成元素的 hashCode() 和 equals() 去除重複元素 */
    //內部迭代：迭代操做 Stream API 內部完成
 @Test public void test2(){ //中間操做,不會執行任何操做
        Stream<Employee> str = employees.stream().filter((e) -> e.getAge()>30).limit(1); //終止操做,一次性執行所有內容，即"惰性求值"
 str.forEach(System.out::println); // employees.stream().filter((e) -> e.getAge()<30) // .forEach((employee) -> System.out.println(employee));
 } //外部迭代
 @Test public void test3(){ Iterator<Employee> it = employees.iterator(); while(it.hasNext()){ System.out.println(it.next()); } } @Test public void test4(){ employees.stream() .filter((e) -> { System.out.println("短路！"); // && ||
                    return e.getSalary() >= 5000; }).limit(3) .forEach(System.out::println); } @Test public void test5(){ employees.parallelStream() .filter((e) -> e.getSalary() >= 5000) .skip(2) .forEach(System.out::println); } @Test public void test6(){ employees.stream() .distinct() .forEach(System.out::println); } /** * 映射 * map -接收lambda，將元素轉換成其餘形式獲取信息，接收一個函數做爲參數， 該函數會被應用在每一個元素上，並將其映射成一個新的元素。 * flatmap-接收一個函數做爲參數，將流中的每一個值都換成另外一個流，而後把全部流鏈接成一個流 */ @Test public void test7(){ List<String> list = Arrays.asList("aaa","bbb","ccc","ddd"); list.stream().map((str) -> str.toUpperCase()) .forEach((str) -> System.out.println(str)); System.out.println("---------------"); employees.stream().map(Employee::getName) .forEach((name) ->System.out.println(name)); } /** * 排序 * sorted()--天然排序(comparable) * sorted(Comparator com)--定製排序(Comparator) */ @Test public void test8(){ List<String> list = Arrays.asList("eee","ggg","ccc","ddd"); list.stream().sorted().forEach(System.out::println); System.out.println("-------------------如下是定製排序-------------"); employees.stream().sorted((e1,e2) ->{ if (e1.getAge() ==e2.getAge()) { return e1.getName().compareTo(e2.getName()); }else{ return Integer.compare(e1.getAge(),e2.getAge()); } }).forEach((employee) -> System.out.println(employee)); } //3. 終止操做
    /* allMatch——檢查是否匹配全部元素 anyMatch——檢查是否至少匹配一個元素 noneMatch——檢查是否沒有匹配的元素 findFirst——返回第一個元素 findAny——返回當前流中的任意元素 count——返回流中元素的總個數 max——返回流中最大值 min——返回流中最小值 注意：流進行了終止操做後，不能再次使用 */ @Test public void test9(){ boolean b = employees.stream().allMatch((emp) -> emp.getAge()==15); System.out.println(b); System.out.println("---------------"); boolean b1 = employees.stream().anyMatch((emp) -> emp.getAge()==15); System.out.println(b1); System.out.println("---------------"); boolean b2 = employees.stream().noneMatch((emp) -> emp.getAge()==15); System.out.println(b2); System.out.println("---------------"); Optional<Employee> optional = employees.stream() .sorted((emp1, emp2) -> Double.compare(emp1.getSalary(),emp2.getSalary())) .findFirst(); System.out.println(optional.get()); System.out.println("---------------"); Optional<Employee> optional1 = employees.parallelStream() .filter((emp) -> emp.getAge() >15).findAny(); System.out.println(optional1); System.out.println("---------------"); Long count = employees.parallelStream().filter((emp) -> emp.getAge() >15).count(); System.out.println(count); Optional<Double> optiona3 = employees.stream() .map((emp) -> emp.getSalary()).max(Double::compareTo); System.out.println(optiona3.get()); System.out.println("---------------"); Optional<Employee> optiona4 = employees.stream() .min((e1,e2) ->Double.compare(e1.getSalary(),e2.getSalary())); System.out.println(optiona4); } /** * 歸約 reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——能夠將流中元素反覆結合起來，獲得一個值。 */ @Test public void test10(){ List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); Integer sum = list.stream().reduce(0,(x,y) -> x+y); System.out.println(sum);//55
        System.out.println("---------------------"); Optional<Double> sumSal = employees.stream().map(Employee::getSalary).reduce(Double::sum); System.out.println(sumSal); } /** * 收集: * collect——將流轉換爲其餘形式。接收一個 Collector接口的實現，用於給Stream中元素作彙總的方法 */
    //將employee集合中name值取出來放入集合中 aaa bbb ccc ddd eee fff ggg
 @Test public void test11(){ List list = employees.stream().map(Employee::getName).collect(Collectors.toList()); list.forEach(System.out::println); } @Test public void test12(){ Set set = employees.stream().map(Employee::getName).collect(Collectors.toSet()); set.forEach(System.out::println); } @Test public void test13(){ HashSet hashSet = employees.stream().map(Employee::getName) .collect(Collectors.toCollection(HashSet::new)); hashSet.forEach(System.out::println); } //獲取集合中元素的個數 7
 @Test public void test14(){ long count = employees.stream().collect(Collectors.counting()); System.out.println(count); System.out.println("----------------"); //獲取工資平均值
        Double avgMoney = employees.stream() .collect(Collectors.averagingDouble((emp) -> emp.getSalary())); System.out.println(avgMoney);//6210.0
        System.out.println("----------------"); //工資總和
        Double sumMoney = employees.stream() .collect(Collectors.summingDouble(Employee::getSalary)); System.out.println(sumMoney); //最大值
        Optional<Employee> optional= employees.stream() .collect(Collectors.maxBy((emp1,emp2) -> Double.compare(emp1.getSalary(),emp2.getSalary()))); System.out.println(optional.get());//Employee{name='ggg', age=12, salary=7150.0} //最小值
        Optional<Double> minMoney = employees.stream() .map(Employee::getSalary).collect(Collectors.minBy(Double::compare)); System.out.println(minMoney.get()); } //分組
 @Test public void test15(){ employees.stream() .collect(Collectors.groupingBy(Employee::getAge)); } //分區
 @Test public  void test16(){ Map<Boolean,List<Employee>> map =employees.stream() .collect(Collectors.partitioningBy((e) -> e.getSalary() >6000)); System.out.println(map); //{false=[Employee{name='aaa', age=11, salary=5000.0}, Employee{name='bbb', age=21, salary=5200.0}, // Employee{name='ccc', age=13, salary=5500.0}], // true=[Employee{name='ddd', age=54, salary=6400.0}, Employee{name='eee', age=16, salary=7100.0}, // Employee{name='fff', age=74, salary=7120.0}, Employee{name='ggg', age=12, salary=7150.0}]}
 } @Test public void test17(){ DoubleSummaryStatistics dss =employees.stream() .collect(Collectors.summarizingDouble(Employee::getSalary)); //求平均值
 System.out.println(dss.getAverage()); //求最大值
 System.out.println(dss.getMax()); //求和
 System.out.println(dss.getSum()); } @Test public void test18(){ String name = employees.stream().map(Employee::getName).collect(Collectors.joining(",")); System.out.println(name);//aaa,bbb,ccc,ddd,eee,fff,ggg
 } }