记一下java流处理的操作

1.去重，按照billTypeCode去重

list = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getBillTypeCode()))), ArrayList::new));
排序：

List<DictValue> sortedDictValues = dictValues.stream().sorted(Comparator.comparingInt(DictValue::getOrderNum)).collect(Collectors.toList());

2.求和

Double sum = workDoc.getItemList().stream().mapToDouble(e -> e.getAllocatedQuantity().doubleValue()).reduce(0, Double::sum);
Integer ageSum = persons .stream() .reduce(0, (sum, p) -> sum += p.age, (sum1, sum2) -> sum1 + sum2);

3.遍历赋值

list.stream().forEach(e -> e.setStatus("30"));

4.过滤

List<ItemInfo> itemone = new ArrayList<>(itemInfos);
itemone = itemone.stream().filter(o -> matnr.equals(o.getItemCode())).collect(Collectors.toList());

5.map: stream().map()可以让你转化一个对象成其他的对象

List<String> lineList = itemCodeNoExistList.stream().map(ShopOrderExcelDto::getLine).collect(Collectors.toList());

6.把list转化为map，key是id，value是实体，如果存在重复的key，取第一个实体

Map<Integer, Person> mapp = list.stream().collect(Collectors.toMap(Person::getId, Function.identity(),(k1, k2) -> k1));

7.取值去重

List<String> targetFactoryCode = targetLocationList.stream().map(Location::getFactoryCode).distinct().collect(Collectors.toList());

8.分组，对于list中的对象按照名字分组，返回一个map<String,List>

Map<String,List<Person>> m = list.stream().collect(Collectors.groupingBy(l->l.getName()));

9.分组，返回一个Map<Boolean,List>,如果分组了，就是list的size>1,则是true，否则是false

Map<Boolean,List<Person>> m = list.stream().collect(Collectors.groupingBy(p->p.getName().equals("haha")));

10.groupingBy()提供第二个参数，表示downstream，即对分组后的value作进一步的处理，返回map<String,Set>

Map<String,Set<Person>> m = list.stream().collect(Collectors.groupingBy(l->l.getName(),Collectors.toSet()));

11.分组，返回value集合中元素的数量

Map<String,Long> m = list.stream().collect(Collectors.groupingBy(l->l.getName(),Collectors.counting()));

12.分组，对value集合中元素求和

Map<String,Integer> m = list.stream().collect(Collectors.groupingBy(l->l.getName(),Collectors.summingInt(Person::getId)));

13.分组，并取value集合中某个元素最大的实体，在这里先按照name分组，然后取id最大的的实体，注意value是Optional的

Map<String,Optional<Person>> m = list.stream().collect(Collectors.groupingBy(l->l.getName(),Collectors.maxBy(Comparator.comparing(Person::getId))));

14.分组，并通过mapping对value字段进行处理

Map<String,Set<Integer>> m = list.stream().collect(Collectors.groupingBy(l->l.getName(),Collectors.mapping(Person::getId,Collectors.toSet())));

 15.对于list集合的空指针问题java8的处理方式：如果list不为空，那就赋值给newList，否则重新new一个list

public static void main(String[] args) {
List<String> list = null;
List<String> newList = Optional.ofNullable(list).orElse(Lists.newArrayList());
newList.forEach(x -> System.out.println(x));
}

 16.循环

IntStream.range(1, 4) .forEach(System.out::println); // 相当于 for (int i = 1; i < 4; i++) {} // 1 // 2 // 3

17.原始类型聚合操作

Arrays.stream(new int[] {1, 2, 3})

.map(n -> 2 * n + 1) // 对数值中的每个对象执行 2*n + 1 操作

.average() // 求平均值

.ifPresent(System.out::println); // 如果值不为空，则输出 // 5.0

18.常规对象转为原始类型

Stream.of("a1", "a2", "a3") .map(s -> s.substring(1)) // 对每个字符串元素从下标1位置开始截取

.mapToInt(Integer::parseInt) // 转成 int 基础类型类型流

.max() // 取最大值

.ifPresent(System.out::println); // 不为空则输出 // 3

19.原始类型转化为对象

IntStream.range(1, 4) .mapToObj(i -> "a" + i) // for 循环 1->4, 拼接前缀

a .forEach(System.out::println); // for 循环打印

20.元素连接

String phrase = persons .stream() .filter(p -> p.age >= 18) // 过滤出年龄大于等于18的

.map(p -> p.name) // 提取名字

.collect(Collectors.joining(" and ", "In Germany ", " are of legal age.")); // 以 In Germany 开头，and 连接各元素，再以 are of legal age. 结束

System.out.println(phrase); // In Germany Max and Peter and Pamela are of legal age.

21.流转化为map

Map<Integer, String> map = persons .stream()

.collect(Collectors.toMap( p -> p.age, p -> p.name, (name1, name2) -> name1 + ";" + name2)); // 对于同样 key 的，将值拼接 System.out.println(map);

// {18=Max, 23=Peter;Pamela, 12=David}

22.自定义收集器，不使用内置收集器Collectors

Collector<Person, StringJoiner, String> personNameCollector = Collector.of(

() -> new StringJoiner(" | "), // supplier 供应器

(j, p) -> j.add(p.name.toUpperCase()), // accumulator 累加器

(j1, j2) -> j1.merge(j2), // combiner 组合器

StringJoiner::toString); // finisher 终止器

String names = persons .stream() .collect(personNameCollector); // 传入自定义的收集器

System.out.println(names); // MAX | PETER | PAMELA | DAVID

归约

23.找出年龄最大的人

persons .stream() .reduce((p1, p2) -> p1.age > p2.age ? p1 : p2) .ifPresent(System.out::println); // Pamela

24.第二种reduce方法接受标识值和BinaryOperator累加器。此方法可用于构造一个新的 Person，其中包含来自流中所有其他人的聚合名称和年龄：

Person result = persons .stream()

.reduce(new Person("", 0), (p1, p2) -> { p1.age += p2.age; p1.name += p2.name; return p1; });

System.out.format("name=%s; age=%s", result.name, result.age);

// name=MaxPeterPamelaDavid; age=76

25.第三种reduce方法接受三个参数：标识值，BiFunction累加器和类型的组合器函数BinaryOperator。由于初始值的类型不一定为Person，我们可以使用这个归约函数来计算所有人的年龄总和：

Integer ageSum = persons .stream() .reduce(0, (sum, p) -> sum += p.age, (sum1, sum2) -> sum1 + sum2);

System.out.println(ageSum); // 76

26.集合操作

CollectionUtils.subList：截取list

---------------------------------111------------------------------------------------------------------------------------

java中的treeset函数可以用于对集合进行排序。与其他集合不同，treeset会按照元素的自然排序对其进行排序。下面将详细介绍如何使用treeset函数对集合进行排序。

1. TreeSet介绍

TreeSet是一种基于红黑树实现的有序集合。TreeSet继承自AbstractSet类，并实现了NavigableSet接口。TreeSet通过实现元素的自然排序或按传入的Comparator对象进行排序。

对于TreeSet，最重要的方法是add()、remove()、contains()等方法，这些方法通过调用AbstractSet类中的方法实现。此外，TreeSet还实现了几个有序集合方法如first()、last()、headSet()、tailSet()和subSet()等。

1. 使用TreeSet进行集合排序

下面将使用一个例子来介绍如何使用TreeSet对集合进行排序。我们将使用一个Student类，并创建一个包含多个Student对象的集合来进行排序。

首先，我们需要定义Student类：

立即学习“Java免费学习笔记（深入）”；

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

public class Student implements Comparable<student> {     private String name;     private int age;     public Student(String name, int age) {         this.name = name;         this.age = age;     }     public String getName() {         return name;     }     public int getAge() {         return age;     }     @Override     public int compareTo(Student student) {         return this.age - student.age;     }     @Override     public String toString() {         return "Student{" +                 "name='" + name + ''' +                 ", age=" + age +                 '}';     } }</student>

上面的代码中，我们定义了一个Student类，并实现了Comparable接口。我们通过实现compareTo()方法来定义元素的自然排序方法。

在比较两个Student对象时，我们比较它们的年龄，因为我们希望按照年龄对学生进行排序。

接下来，我们创建一个包含多个Student对象的集合：

1 2 3 4 5

Set<student> students = new TreeSet(); students.add(new Student("张三", 20)); students.add(new Student("李四", 19)); students.add(new Student("王五", 22)); students.add(new Student("赵六", 21));</student>

我们可以看到，我们向集合添加了四个Student对象。我们并没有使用Collections.sort()方法来对集合进行排序，而是使用了TreeSet函数，它会自动按照元素的自然排序进行排序。

最后，我们可以使用for-each循环来遍历集合，并输出学生的信息：

1 2 3

for (Student student : students) {     System.out.println(student); }

最终的输出结果会按照学生的年龄从小到大进行排序：

1 2 3 4

Student{name='李四', age=19} Student{name='张三', age=20} Student{name='赵六', age=21} Student{name='王五', age=22}

1. 自定义排序方法

如果我们不想按照元素的自然排序进行排序，我们可以使用Comparator对象来自定义排序方法。下面的代码演示了如何使用Comparator对象来自定义排序方法：

1 2 3 4 5

Set<student> students = new TreeSet(Comparator.comparing(Student::getName)); students.add(new Student("张三", 20)); students.add(new Student("李四", 19)); students.add(new Student("王五", 22)); students.add(new Student("赵六", 21));</student>

上面的代码中，我们在创建TreeSet对象时传入了一个Comparator对象。我们通过调用Comparator.comparing()方法，并使用Student类中的getName()方法来定义排序方法。这意味着我们将按照学生的姓名进行排序。

最后，我们仍然使用for-each循环来遍历集合，并输出学生的信息：

1 2 3

for (Student student : students) {     System.out.println(student); }

最终的输出结果将按照学生的姓名从小到大进行排序：

1 2 3 4

Student{name='李四', age=19} Student{name='张三', age=20} Student{name='赵六', age=21} Student{name='王五', age=22}

1. 总结

使用TreeSet函数对集合进行排序比其他方法更为简便。它会自动按照元素的自然排序进行排序，也可以通过传入Comparator对象来自定义排序方法。通过掌握TreeSet的使用方法，我们可以更轻松地对Java中的集合进行排序。

--------------------------------------------2222222222222----------------------------

Java中的TreeSet集合解析_java_脚本之家