java stream下载_Java Stream

package com.stream;

import java.util.*;

import java.util.stream.Collectors;

import java.util.stream.Stream;

public class test {

public static void main(String[] args) {

List personList = new ArrayList();

personList.add(new Person("Tom", 8900, 15,"male", "New York"));

personList.add(new Person("Jack", 7000, 16,"male", "Washington"));

personList.add(new Person("Lily", 7800, 17,"female", "Washington"));

personList.add(new Person("Anni", 8200, 18,"female", "New York"));

personList.add(new Person("Owen", 9500, 19,"male", "New York"));

personList.add(new Person("Alisa", 7900, 20,"female", "New York"));

/*=============================遍历/匹配(foreach/find/match)================== */

List list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

// 遍历输出符合条件的元素

list.stream().filter(x -> x > 6).forEach(System.out::println);

// 匹配第一个

Optional first = list.stream().filter(x -> x > 6).findFirst();

System.out.println("配第一个" + first.get());

// 匹配任意(适用于并行流)

Optional findAny = list.parallelStream().filter(x -> x > 6).findAny();

System.out.println("匹配任意一个值：" + findAny.get());

// 是否包含符合特定条件的元素

boolean anyMatch = list.stream().anyMatch(s -> s < 6);

System.out.println("anyMatch : " + anyMatch);

//============== 筛选(filter)================================================

//筛选出Integer集合中大于7的元素

list.stream().filter(s -> s > 7).forEach(System.out::println);

//筛选员工中工资高于8000的人，并形成新的集合。 形成新集合依赖collect(收集)

personList.stream().filter(s -> s.getSalary() > 8000).map(Person::getName).collect(Collectors.toList()).forEach(System.out::println);

//============================== 聚合(max/min/count)====================================

//获取String集合中最长的元素。

List listStr = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");

Optional strMax = listStr.stream().max(Comparator.comparing(String::length));

System.out.println("最长" + strMax.get());

//获取Integer集合中的最大值

// 自然排序

Optional intMax = list.stream().max(Integer::compareTo);

//自定义

Optional intMax02 = list.stream().max(new Comparator() {

@Override

public int compare(Integer o1, Integer o2) {

return o1.compareTo(o2);

}

});

System.out.println(intMax.get());

System.out.println(intMax02.get());

//获取员工工资最高的人

Optional salMax = personList.stream().max(Comparator.comparing(Person::getSalary));

System.out.println("工资最高的人"+salMax.get().getSalary());

//计算Integer集合中大于6的元素的个数

long count = list.stream().filter(s -> s > 6).count();

System.out.println("个数"+count);

//=====================映射(map/flatMap)======================================

//映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap

//map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素

//flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

//英文字符串数组的元素全部改为大写。整数数组每个元素+3

String[] strArr = { "abcd", "bcdd", "defde", "fTr" };

Arrays.stream(strArr).map(s -> s.toUpperCase()).collect(Collectors.toList()).forEach(System.out::println);

list.stream().map(s -> s+3).collect(Collectors.toList());

//将员工的薪资全部增加1000。

// 不改变原来员工集合的方式

List personListNew = personList.stream().map(person -> {

Person personNew = new Person(person.getName(), 0, 0, null, null);

personNew.setSalary(person.getSalary() + 1000);

return personNew;

}).collect(Collectors.toList());

System.out.println("一次改动前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());

System.out.println("一次改动后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());

// 改变原来员工集合的方式

List personListNew2 = personList.stream().map(person -> {

person.setSalary(person.getSalary() + 1000);

return person;

}).collect(Collectors.toList());

System.out.println("二次改动前：" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());

System.out.println("二次改动后：" + personListNew2.get(0).getName() + "-->" + personListNew2.get(0).getSalary());

//将两个字符数组合并成一个新的字符数组

List listArr = Arrays.asList("m-k-l-a", "1-3-5-7");

List listArrNew = listArr.stream().flatMap(s -> {

// 将每个元素转换成一个stream

String[] split = s.split("-");

Stream stream = Arrays.stream(split);

return stream;

}).collect(Collectors.toList());

System.out.println("处理前的集合：" + listArr);

System.out.println("处理后的集合：" + listArrNew);

//=================================归约(reduce)=================================

//归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

//求Integer集合的元素之和、乘积和最大值

// 求和方式1

Optional sum01 = list.stream().reduce((x, y) -> x + y);

//求和方式2

Optional sum02 = list.stream().reduce(Integer::sum);

//求和方式3

Integer sum03 = list.stream().reduce(0, Integer::sum);

// 求乘积

Optional product = list.stream().reduce((x, y) -> x * y);

// 求最大值方式1

Optional max = list.stream().reduce((x, y) -> x > y ? x : y);

//求最大值写法2

Integer max02 = list.stream().reduce(1, Integer::max);

System.out.println("总和" + sum01.get() + "," + sum02.get() + "," + sum03);

System.out.println("乘积" + product.get());

System.out.println("最大值" + max.get() + ", 最大值" + max02);

//求所有员工的工资之和和最高工资

//所有员工的工资之和

Optional s1 = personList.stream().map(Person::getSalary).reduce(Integer::sum);

Integer s2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);

// 求最高工资方式

Integer high = personList.stream().map(Person::getSalary).reduce(1, Integer::max);

System.out.println("和："+s1.get() + "=======" + s2 );

System.out.println("高："+ high);

//===========================收集(collect)==================================

//把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合

//归集(toList/toSet/toMap)

//toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。

list.stream().filter(s -> s>6).collect(Collectors.toList()).forEach(System.out::println);

list.stream().filter(s -> s % 3 == 0).collect(Collectors.toSet()).forEach(System.out::println);

Map collect = personList.stream().filter(p -> p.getSalary() > 8000).collect(Collectors.toMap(Person::getName, p -> p));

for (String s : collect.keySet()) {

System.out.println(s);

}

System.out.println(collect);

//==============================统计(count/averaging)==========================

/*

Collectors提供了一系列用于数据统计的静态方法：

计数：count

平均值：averagingInt、averagingLong、averagingDouble

最值：maxBy、minBy

求和：summingInt、summingLong、summingDouble

统计以上所有：summarizingInt、summarizingLong、summarizingDouble

*/

//统计员工人数、平均工资、工资总额、最高工资。

// 求总数

Long count01 = personList.stream().collect(Collectors.counting());

// 求平均工资

Double aveSal = personList.stream().collect(Collectors.averagingInt(Person::getSalary));

// 求最高工资

Optional salMax02 = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));

//求工资之和

Optional he = personList.stream().map(Person::getSalary).collect(Collectors.reducing((x, y) -> x + y));

// 一次性统计所有信息

DoubleSummaryStatistics countCollect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));

System.out.println(count01);

System.out.println(aveSal);

System.out.println(salMax02.get());

System.out.println(he.get());

System.out.println(countCollect);

//==============================================分组(partitioningBy/groupingBy)========================

//分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。

//分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。

//将员工按薪资是否高于8000分为两部分；将员工按性别和地区分组

Map> fenZuBySal = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));

Map> fenZuBySex = personList.stream().collect(Collectors.groupingBy(Person::getSex));

// 将员工先按性别分组，再按地区分组

Map>> fenZu = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));

System.out.println(fenZuBySex);

System.out.println(fenZu);

//=====================================接合(joining)=======================

//joining可以将stream中的元素用特定的连接符(没有的话，则直接连接)连接成一个字符串

String joinTest = personList.stream().map(p -> p.getName()).collect(Collectors.joining("--"));

System.out.println(joinTest);

//=========================归约(reducing)==================================

//Collectors类提供的reducing方法，相比于stream本身的reduce方法，增加了对自定义归约的支持。

// 每个员工减去起征点后的薪资之和

Integer sum = personList.stream().collect(Collectors.reducing(1, Person::getSalary, (i, j) -> (i + j - 5000)));

System.out.println("员工扣税薪资总和：" + sum);

//stream的reduce

Optional reduceSum =personList.stream().map(Person::getSalary).reduce(Integer::sum);

System.out.println("员工薪资总和：" + reduceSum.get());

//================================================3.7 排序(sorted)===============================

//sorted，中间操作。有两种排序：

//sorted()：自然排序，流中元素需实现Comparable接口

//sorted(Comparator com)：Comparator排序器自定义排序

//将员工按工资由高到低(工资一样则按年龄由大到小)排序

// 按工资增序排序

List sortBySalIncr = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName).collect(Collectors.toList());

// 按工资倒序排序

List sortBySalDecr = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());

// 先按工资再按年龄自然排序(升序)

// 先按工资再按年龄自然排序(降序)

List salAndAgeDesc = personList.stream().sorted((p1, p2) -> {

if (p1.getSalary() == p2.getSalary()) {

return p2.getSalary() - p1.getSalary();

}

return p2.getSalary() - p1.getSalary();

}).map(Person::getName).collect(Collectors.toList());

System.out.println("先按工资再按年龄自定义降序排序：" + salAndAgeDesc);

//===============================提取/组合==============================================

String[] arr1 = { "a", "b", "c", "d" };

String[] arr2 = { "d", "e", "f", "g" };

Stream stream1 = Stream.of(arr1);

Stream stream2 = Stream.of(arr2);

// concat:合并两个流 distinct：去重

List concatAndDistinct = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());

//limit：限制从流中获得前n个数据

List limitStream = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());

//skip：跳过前n个数据

List skipStream = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());

System.out.println("流合并：" + concatAndDistinct);

System.out.println("limit：" + limitStream);

System.out.println("skip：" + skipStream);

}

}