精华内容
下载资源
问答
  • java stream

    2018-12-02 20:22:53
    java stream doc.
  • java stream过滤_Java Stream过滤器

    千次阅读 2020-07-14 20:24:52
    java stream过滤Java Stream filter can be very helpful when you want to do some processing only on some elements of the Stream based on certain condition. 当您希望仅基于特定条件对Stream的某些元素进行...

    java stream过滤

    Java Stream filter can be very helpful when you want to do some processing only on some elements of the Stream based on certain condition.

    当您希望仅基于特定条件对Stream的某些元素进行某些处理时,Java Stream过滤器可能会非常有用。

    Java Stream过滤器 (Java Stream filter)

    java stream filter

    Stream was introduced in Java 8. Java Stream filter is an intermediate operation, i.e. it returns a new Stream.


    Stream是Java 8中引入的。Java Stream过滤器是一个中间操作,即它返回一个新的Stream。

    Java Stream过滤器示例 (Java Stream filter example)

    Let’s look at a simple example to count the even numbers in a list of integers. We can do it like below.

    让我们看一个简单的示例来计算整数列表中的偶数。 我们可以像下面这样。

    List<Integer> intList = generateList(); //some method to create the list of integers
    int evenCount = 0;
    for(int i : intList){
    	if(i%2==0){
    		evenCount++;
    		//code to do some processing
    	}
    }
    System.out.println("Even Number Count: "+evenCount);

    Now let’s see how we can do the same thing using java stream filter api.

    现在,让我们看看如何使用java流过滤器api来做同样的事情。

    Predicate<Integer> predicate = new Predicate<Integer>(){
    
    	@Override
    	public boolean test(Integer i) {
    		return (i%2==0);
    	}
    	
    };
    List<Integer> evenList = intList.parallelStream().filter(predicate).collect(Collectors.toList());
    evenCount = evenList.size();
    System.out.println("Even Number Count: "+evenCount);

    Predicate is a functional interface that takes one argument and return boolean based on the test function. Above code can also be written as below using lambda expression.

    谓词是一个功能接口,它接受一个参数并根据测试函数返回布尔值。 上面的代码也可以使用lambda表达式如下编写。

    evenCount = intList.parallelStream().filter(i -> {
    	return (i % 2 == 0);
    }).collect(Collectors.toList()).size();

    Java流过滤器示例2 (Java Stream Filter Example 2)

    Let’s look at another example where we want to filter a list of integers and keep only numbers greater than 90.

    让我们看另一个示例,我们要过滤一个整数列表,并且仅保留大于90的数字。

    List<Integer> intList = new ArrayList<>();
    for(int i=50; i<100; i++) intList.add(i);
    
    Stream<Integer> sequentialStream = myList.stream(); // we can create parallel stream too
    
    Stream<Integer> highNumsStream = sequentialStream.filter(p -> p > 90); //filter numbers greater than 90
    System.out.print("High Nums greater than 90=");
    highNumsStream.forEach(p -> System.out.print(p+" "));
    //prints "High Nums greater than 90=91 92 93 94 95 96 97 98 99 "

    带对象的Java流过滤器示例 (Java Stream filter Example with Objects)

    Let’s say we have list of employees and we want to print names of all employees with age greater than 32. Below is a simple program to do this using java stream filter.

    假设我们有一个雇员列表,并且想打印所有年龄大于32岁的雇员的姓名。下面是一个使用Java流过滤器执行此操作的简单程序。

    package com.journaldev.examples;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class StreamFilterExample {
    
    	public static void main(String[] args) {
    		List<Employee> empList = new ArrayList<>();
    		empList.add(new Employee("Pankaj", 35));
    		empList.add(new Employee("David", 25));
    		empList.add(new Employee("Lisa", 31));
    		empList.add(new Employee("Dean", 40));
    
    		// print all employees above 32 years of age
    		empList.stream().filter(p -> (p.getAge() > 32)).forEach(p -> System.out.println(p.getName()));
    
    	}
    
    }
    
    class Employee {
    	private String name;
    	private int age;
    
    	public Employee() {
    	}
    
    	public Employee(String n, int a) {
    		this.name = n;
    		this.age = a;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    }

    Above program produces below output.

    上面的程序产生下面的输出。

    Pankaj
    Dean

    If we want to get the first employee only with age over 32, then we can use filter with findFirst method as shown below.

    如果我们只想获取年龄在32岁以上的第一位员工,则可以将filter与findFirst方法结合使用,如下所示。

    Optional<Employee> empO = empList.stream().filter(p -> (p.getAge() > 32)).findFirst();
    
    if(empO.isPresent())
    	System.out.println(empO.get().getName()+","+empO.get().getAge());

    That’s all for java stream filter examples.

    Java流过滤器示例的全部内容。

    Reference: Java 8 Official Documentation on Stream Filter

    参考: 有关流过滤器的Java 8官方文档

    翻译自: https://www.journaldev.com/14068/java-stream-filter

    java stream过滤

    展开全文
  • 一文带你入门Java Stream流,太强了

    万次阅读 多人点赞 2020-04-01 09:51:55
    两个星期以前,就有读者强烈要求我写一篇 Java Stream 流的文章,我说市面上不是已经有很多了吗,结果你猜他怎么说:“就想看你写的啊!”你看你看,多么苍白的喜欢啊。那就“勉为其难”写一篇吧,嘻嘻。 单从...

    两个星期以前,就有读者强烈要求我写一篇 Java Stream 流的文章,我说市面上不是已经有很多了吗,结果你猜他怎么说:“就想看你写的啊!”你看你看,多么苍白的喜欢啊。那就“勉为其难”写一篇吧,嘻嘻。

    单从“Stream”这个单词上来看,它似乎和 java.io 包下的 InputStream 和 OutputStream 有些关系。实际上呢,没毛关系。Java 8 新增的 Stream 是为了解放程序员操作集合(Collection)时的生产力,之所以能解放,很大一部分原因可以归功于同时出现的 Lambda 表达式——极大的提高了编程效率和程序可读性。

    Stream 究竟是什么呢?

    Stream 就好像一个高级的迭代器,但只能遍历一次,就好像一江春水向东流;在流的过程中,对流中的元素执行一些操作,比如“过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等。

    要想操作流,首先需要有一个数据源,可以是数组或者集合。每次操作都会返回一个新的流对象,方便进行链式操作,但原有的流对象会保持不变。

    流的操作可以分为两种类型:

    1)中间操作,可以有多个,每次返回一个新的流,可进行链式操作。

    2)终端操作,只能有一个,每次执行完,这个流也就用光光了,无法执行下一个操作,因此只能放在最后。

    来举个例子。

    List<String> list = new ArrayList<>();
    list.add("武汉加油");
    list.add("中国加油");
    list.add("世界加油");
    list.add("世界加油");
    
    long count = list.stream().distinct().count();
    System.out.println(count);
    

    distinct() 方法是一个中间操作(去重),它会返回一个新的流(没有共同元素)。

    Stream<T> distinct();
    

    count() 方法是一个终端操作,返回流中的元素个数。

    long count();
    

    中间操作不会立即执行,只有等到终端操作的时候,流才开始真正地遍历,用于映射、过滤等。通俗点说,就是一次遍历执行多个操作,性能就大大提高了。

    理论部分就扯这么多,下面直接进入实战部分。

    01、创建流

    如果是数组的话,可以使用 Arrays.stream() 或者 Stream.of() 创建流;如果是集合的话,可以直接使用 stream() 方法创建流,因为该方法已经添加到 Collection 接口中。

    public class CreateStreamDemo {
        public static void main(String[] args) {
            String[] arr = new String[]{"武汉加油", "中国加油", "世界加油"};
            Stream<String> stream = Arrays.stream(arr);
    
            stream = Stream.of("武汉加油", "中国加油", "世界加油");
    
            List<String> list = new ArrayList<>();
            list.add("武汉加油");
            list.add("中国加油");
            list.add("世界加油");
            stream = list.stream();
        }
    }
    

    查看 Stream 源码的话,你会发现 of() 方法内部其实调用了 Arrays.stream() 方法。

    public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }
    

    另外,集合还可以调用 parallelStream() 方法创建并发流,默认使用的是 ForkJoinPool.commonPool()线程池。

    List<Long> aList = new ArrayList<>();
    Stream<Long> parallelStream = aList.parallelStream();
    

    02、操作流

    Stream 类提供了很多有用的操作流的方法,我来挑一些常用的给你介绍一下。

    1)过滤

    通过 filter() 方法可以从流中筛选出我们想要的元素。

    public class FilterStreamDemo {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("周杰伦");
            list.add("王力宏");
            list.add("陶喆");
            list.add("林俊杰");
            Stream<String> stream = list.stream().filter(element -> element.contains("王"));
            stream.forEach(System.out::println);
        }
    }
    

    filter() 方法接收的是一个 Predicate(Java 8 新增的一个函数式接口,接受一个输入参数返回一个布尔值结果)类型的参数,因此,我们可以直接将一个 Lambda 表达式传递给该方法,比如说 element -> element.contains("王") 就是筛选出带有“王”的字符串。

    forEach() 方法接收的是一个 Consumer(Java 8 新增的一个函数式接口,接受一个输入参数并且无返回的操作)类型的参数,类名 :: 方法名是 Java 8 引入的新语法,System.out 返回 PrintStream 类,println 方法你应该知道是打印的。

    stream.forEach(System.out::println); 相当于在 for 循环中打印,类似于下面的代码:

    for (String s : strs) {
        System.out.println(s);
    }
    

    很明显,一行代码看起来更简洁一些。来看一下程序的输出结果:

    王力宏
    

    2)映射

    如果想通过某种操作把一个流中的元素转化成新的流中的元素,可以使用 map() 方法。

    public class MapStreamDemo {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("周杰伦");
            list.add("王力宏");
            list.add("陶喆");
            list.add("林俊杰");
            Stream<Integer> stream = list.stream().map(String::length);
            stream.forEach(System.out::println);
        }
    }
    

    map() 方法接收的是一个 Function(Java 8 新增的一个函数式接口,接受一个输入参数 T,返回一个结果 R)类型的参数,此时参数 为 String 类的 length 方法,也就是把 Stream<String> 的流转成一个 Stream<Integer> 的流。

    程序输出的结果如下所示:

    3
    3
    2
    3
    

    3)匹配

    Stream 类提供了三个方法可供进行元素匹配,它们分别是:

    • anyMatch(),只要有一个元素匹配传入的条件,就返回 true。

    • allMatch(),只有有一个元素不匹配传入的条件,就返回 false;如果全部匹配,则返回 true。

    • noneMatch(),只要有一个元素匹配传入的条件,就返回 false;如果全部匹配,则返回 true。

    public class MatchStreamDemo {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("周杰伦");
            list.add("王力宏");
            list.add("陶喆");
            list.add("林俊杰");
    
            boolean  anyMatchFlag = list.stream().anyMatch(element -> element.contains("王"));
            boolean  allMatchFlag = list.stream().allMatch(element -> element.length() > 1);
            boolean  noneMatchFlag = list.stream().noneMatch(element -> element.endsWith("沉"));
            System.out.println(anyMatchFlag);
            System.out.println(allMatchFlag);
            System.out.println(noneMatchFlag);
        }
    }
    

    因为“王力宏”以“王”字开头,所以 anyMatchFlag 应该为 true;因为“周杰伦”、“王力宏”、“陶喆”、“林俊杰”的字符串长度都大于 1,所以 allMatchFlag 为 true;因为 4 个字符串结尾都不是“沉”,所以 noneMatchFlag 为 true。

    程序输出的结果如下所示:

    true
    true
    true
    

    4)组合

    reduce() 方法的主要作用是把 Stream 中的元素组合起来,它有两种用法:

    • Optional<T> reduce(BinaryOperator<T> accumulator)

    没有起始值,只有一个参数,就是运算规则,此时返回 Optional

    • T reduce(T identity, BinaryOperator<T> accumulator)

    有起始值,有运算规则,两个参数,此时返回的类型和起始值类型一致。

    来看下面这个例子。

    public class ReduceStreamDemo {
        public static void main(String[] args) {
            Integer[] ints = {0, 1, 2, 3};
            List<Integer> list = Arrays.asList(ints);
    
            Optional<Integer> optional = list.stream().reduce((a, b) -> a + b);
            Optional<Integer> optional1 = list.stream().reduce(Integer::sum);
            System.out.println(optional.orElse(0));
            System.out.println(optional1.orElse(0));
    
            int reduce = list.stream().reduce(6, (a, b) -> a + b);
            System.out.println(reduce);
            int reduce1 = list.stream().reduce(6, Integer::sum);
            System.out.println(reduce1);
        }
    }
    

    运算规则可以是 Lambda 表达式(比如 (a, b) -> a + b),也可以是类名::方法名(比如 Integer::sum)。

    程序运行的结果如下所示:

    6
    6
    12
    12
    

    0、1、2、3 在没有起始值相加的时候结果为 6;有起始值 6 的时候结果为 12。

    03、转换流

    既然可以把集合或者数组转成流,那么也应该有对应的方法,将流转换回去——collect() 方法就满足了这种需求。

    public class CollectStreamDemo {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("周杰伦");
            list.add("王力宏");
            list.add("陶喆");
            list.add("林俊杰");
    
            String[] strArray = list.stream().toArray(String[]::new);
            System.out.println(Arrays.toString(strArray));
    
            List<Integer> list1 = list.stream().map(String::length).collect(Collectors.toList());
            List<String> list2 = list.stream().collect(Collectors.toCollection(ArrayList::new));
            System.out.println(list1);
            System.out.println(list2);
    
            String str = list.stream().collect(Collectors.joining(", ")).toString();
            System.out.println(str);
        }
    }
    

    toArray() 方法可以将流转换成数组,你可能比较好奇的是 String[]::new,它是什么东东呢?来看一下 toArray() 方法的源码。

    <A> A[] toArray(IntFunction<A[]> generator);
    

    也就是说 String[]::new 是一个 IntFunction,一个可以产生所需的新数组的函数,可以通过反编译字节码看看它到底是什么:

    String[] strArray = (String[])list.stream().toArray((x$0) -> {
        return new String[x$0];
    });
    System.out.println(Arrays.toString(strArray));
    

    也就是相当于返回了一个指定长度的字符串数组。

    当我们需要把一个集合按照某种规则转成另外一个集合的时候,就可以配套使用 map() 方法和 collect() 方法。

    List<Integer> list1 = list.stream().map(String::length).collect(Collectors.toList());
    

    通过 stream() 方法创建集合的流后,再通过 map(String:length) 将其映射为字符串长度的一个新流,最后通过 collect() 方法将其转换成新的集合。

    Collectors 是一个收集器的工具类,内置了一系列收集器实现,比如说 toList() 方法将元素收集到一个新的 java.util.List 中;比如说 toCollection() 方法将元素收集到一个新的 java.util.ArrayList 中;比如说 joining() 方法将元素收集到一个可以用分隔符指定的字符串中。

    来看一下程序的输出结果:

    [周杰伦, 王力宏, 陶喆, 林俊杰]
    [3, 3, 2, 3]
    [周杰伦, 王力宏, 陶喆, 林俊杰]
    周杰伦, 王力宏, 陶喆, 林俊杰
    

    最后,一定会有不少读者想要问我怎么学习 Java 的,那我干脆就把我看过的优质书籍贡献出来:

    1)入门版:《Head First Java》、《Java 核心技术卷》

    2)进阶版:《Java编程思想》、《Effective Java》、《Java网络编程》、《代码整洁之道》

    3)大牛版:《Java并发编程》、《深入理解Java虚拟机》、《Java性能权威指南》、《重构》、《算法》

    就先介绍这么多,希望对那些不知道看什么书的同学有所帮助。

    对了,我介绍的这些书籍,已经顺便帮你整理好了,你可以在我的原创微信公众号『沉默王二』回复『书籍』获取哦

    有收获?希望老铁们来个三连击,给更多的同学看到这篇文章

    展开全文
  • Java Stream collect()方法示例

    千次阅读 2020-07-05 17:04:52
    Java Stream collect() performs a mutable reduction operation on the elements of the stream. This is a terminal operation. Java Stream collect()对流的元素执行可变的约简操作。 这是终端操作。 什么是...

    Java Stream collect() performs a mutable reduction operation on the elements of the stream. This is a terminal operation.

    Java Stream collect()对流的元素执行可变的约简操作。 这是终端操作。

    什么是可变归约运算? (What is Mutable Reduction Operation?)

    A mutable reduction operation process the stream elements and then accumulate it into a mutable result container. Once the elements are processed, a combining function merges all the result containers to create the result.

    可变还原操作处理流元素,然后将其累积到可变结果容器中。 处理完元素后,合并功能将合并所有结果容器以创建结果。

    Java Stream collect()方法签名 (Java Stream collect() Method Signature)

    There are two variants of Java Stream collect() method.

    Java Stream collect()方法有两种变体。

    1. <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator,BiConsumer<R, R> combiner)

      <R> R收集(供应商<R>供应商,BiConsumer <R 、?超级T>累加器,BiConsumer <R,R>组合器)
    2. <R, A> R collect(Collector<? super T, A, R> collector)

      <R,A> R收集器(Collector <?super T,A,R>收集器)

    The Collector is an interface that provides a wrapper for the supplier, accumulator, and combiner objects. The second method is useful when we are utilizing the Collectors class to provide built-in Collector implementation.

    收集器是一个接口,为供应商,累加器和合并器对象提供包装。 当我们利用Collectors类提供内置的Collector实现时,第二种方法很有用。

    The three parameters of the collect() function are:

    collect()函数的三个参数是:

    1. supplier: a function that creates a new mutable result container. For the parallel execution, this function may be called multiple times and it must return a fresh value each time.

      Supplier :一个创建新的可变结果容器的函数。 对于并行执行,可以多次调用此函数,并且每次必须返回一个新值。
    2. accumulator is a stateless function that must fold an element into a result container.

      累加器是一种无状态函数,必须将元素折叠到结果容器中。
    3. combiner is a stateless function that accepts two partial result containers and merges them, which must be compatible with the accumulator function.

      组合器是一个无状态函数,它接受两个部分结果容器并将其合并,这些容器必须与累加器功能兼容。

    流collect()方法示例 (Stream collect() Method Examples)

    Let’s look at some examples of Stream.collect() method.

    让我们看一下Stream.collect()方法的一些示例。

    1.串联字符串列表 (1. Concatenating List of Strings)

    Let’s say you want to concatenate the list of strings to create a new string. We can use Stream collect() function to perform a mutable reduction operation and concatenate the list elements.

    假设您要连接字符串列表以创建新字符串。 我们可以使用Stream collect()函数执行可变的约简操作并连接列表元素。

    List<String> vowels = List.of("a", "e", "i", "o", "u");
    
    // sequential stream - nothing to combine
    StringBuilder result = vowels.stream().collect(StringBuilder::new, (x, y) -> x.append(y),
    		(a, b) -> a.append(",").append(b));
    System.out.println(result.toString());
    
    // parallel stream - combiner is combining partial results
    StringBuilder result1 = vowels.parallelStream().collect(StringBuilder::new, (x, y) -> x.append(y),
    		(a, b) -> a.append(",").append(b));
    System.out.println(result1.toString());

    Output:

    输出:

    aeiou
    a,e,i,o,u
    • The supplier function is returning a new StringBuilder object in every call.

      供应商函数在每次调用中都返回一个新的StringBuilder对象。
    • The accumulator function is appending the list string element to the StringBuilder instance.

      累加器功能将列表字符串元素附加到StringBuilder实例。
    • The combiner function is merging the StringBuilder instances. The instances are merged with each other with a comma between them.

      合并器功能正在合并StringBuilder实例。 实例彼此之间用逗号合并。
    • In the first case, we have a sequential stream of elements. So they are processed one by one and there is only one instance of StringBuilder. There is no use of the combiner function. That’s why the output produced is “aeiou”.

      在第一种情况下,我们有一个顺序的元素流。 因此,它们被一个接一个地处理,并且只有一个StringBuilder实例。 没有使用合并器功能。 这就是为什么产生的输出是“ aeiou”的原因。
    • In the second case, we have a parallel stream of strings. So, the elements are processed parallelly and there are multiple instances of StringBuilder that are being merged by the combiner function. Hence, the output produced is “a,e,i,o,u”.

      在第二种情况下,我们有并行的字符串流。 因此,元素是并行处理的,并且组合器函数正在合并StringBuilder的多个实例。 因此,产生的输出为“ a,e,i,o,u”。
    • If the stream source is ordered such as List, the collect() method maintains the order while processing. If the stream source is unordered such as Set, then the collect() method can produce different results in each invocation.

      如果流源按顺序排序(例如List) ,则collect()方法将在处理时保持顺序。 如果流源是无序的(例如Set) ,则collect()方法在每次调用中会产生不同的结果。

    If you want to concatenate the list of strings, we can use the method references to reduce the code size.

    如果要串联字符串列表,我们可以使用方法引用来减少代码大小。

    String result2 = vowels.parallelStream()
    		.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
    		.toString();

    2.使用collectors类将collect()流传输到列表 (2. Stream collect() to List using Collectors Class)

    The Collectors class provides many useful implementations of the Collector interface. Let’s look at an example where we will filter the list of integers to select only even integers. Stream filter() is an intermediate operation and returns a stream. So, we will use the collect() function to create the list from this stream.

    Collector类提供了Collector接口的许多有用的实现。 让我们看一个示例,其中我们将过滤整数列表以仅选择偶数整数。 Stream filter()是一个中间操作,返回一个流。 因此,我们将使用collect()函数从此流中创建列表。

    List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
    		
    List<Integer> evenNumbers = numbers.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
    System.out.println(evenNumbers);  // [2, 4, 6]

    The Collectors.toList() returns a Collector implementation that accumulates the input elements into a new List.

    Collectors.toList()返回一个Collector实现,该实现将输入元素累积到新的List中。

    3.流collect()到集合 (3. Stream collect() to a Set)

    We can use Collectors.toSet() to collect the stream elements into a new Set.

    我们可以使用Collectors.toSet()将流元素收集到一个新的Set中。

    List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
    
    Set<Integer> oddNumbers = numbers.parallelStream().filter(x -> x % 2 != 0).collect(Collectors.toSet());
    System.out.println(oddNumbers); // [1, 3, 5]

    3.流collect()到Map (3. Stream collect() to Map)

    We can use Collectors.toMap() function to collect the stream elements to a Map. This method accepts two arguments for mapping key and the corresponding value in the Map.

    我们可以使用Collectors.toMap()函数将流元素收集到Map中 。 此方法接受两个用于映射键的参数和Map中的对应值。

    List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
    
    Map<Integer, String> mapOddNumbers = numbers.parallelStream().filter(x -> x % 2 != 0)
    		.collect(Collectors.toMap(Function.identity(), x -> String.valueOf(x)));
    System.out.println(mapOddNumbers); // {1=1, 3=3, 5=5}

    4.收集器join()示例 (4. Collectors joining() Example)

    We can use Collectors joining() methods to get a Collector that concatenates the input stream CharSequence elements in the encounter order. We can use this to concatenate a stream of strings, StringBuffer, or StringBuilder.

    我们可以使用Collectors join()方法来获取Collector,该Collector以遭遇顺序将输入流CharSequence元素串联在一起。 我们可以使用它来连接字符串流, StringBuffer或StringBuilder。

    jshell> String value = Stream.of("a", "b", "c").collect(Collectors.joining());
    value ==> "abc"
    
    jshell> String valueCSV = Stream.of("a", "b", "c").collect(Collectors.joining(","));
    valueCSV ==> "a,b,c"
    
    jshell> String valueCSVLikeArray = Stream.of("a", "b", "c").collect(Collectors.joining(",", "{", "}"));
    valueCSVLikeArray ==> "{a,b,c}"
    
    jshell> String valueObject = Stream.of("1", new StringBuffer("2"), new StringBuilder("3")).collect(Collectors.joining());
    valueObject ==> "123"

    Output:

    输出:

    Java Stream Collect Example

    Java Stream collect() Example

    Java Stream collect()示例

    结论 (Conclusion)

    Java Stream collect() is mostly used to collect the stream elements to a collection. It’s a terminal operation. It takes care of synchronization when used with a parallel stream. The Collectors class provides a lot of Collector implementation to help us out.

    Java Stream collect()通常用于将流元素收集到一个集合中。 这是终端操作。 与并行流一起使用时,它负责同步。 Collectors类提供了许多Collector实现来帮助我们。

    参考资料 (References)

    翻译自: https://www.journaldev.com/32457/java-stream-collect-method-examples

    展开全文
  • Java stream List 求和、分组操作

    千次阅读 2021-03-17 13:51:46
    Java stream List 求和、分组操作前言项目中经常会使用Stream操作一些集合数据,今天记录一下我经常使用的Stream操作求和操作publicstaticvoidmain(String[]args){Listusers=generateUserList();intreduce=users....

    Java stream List 求和、分组操作

    前言

    项目中经常会使用Stream操作一些集合数据,今天记录一下我经常使用的Stream操作

    求和操作public static void main(String[] args) {

    List users = generateUserList();int reduce = users.stream().mapToInt(x -> x.getSalary().intValue()).reduce(0, Integer::sum);

    log.info("Int sum - {}", reduce);

    BigDecimal reduce1 = users.stream().map(User::getSalary).reduce(BigDecimal.ZERO, BigDecimal::add);

    log.info("BigDecimal sum - {}", reduce);

    }private static List generateUserList() {

    List users = new ArrayList<>();for (int i = 0; i 

    users.add(new User((long) (i + 1), StrFormatter.format("用户-{}", i), RandomUtil.randomBigDecimal(new BigDecimal(1000), new BigDecimal(100000))));

    }return users;

    }复制代码

    结果:16:03:32.966 [main] INFO com.springboot.example.stream.StreamTest - Int sum - 31128616:03:32.977 [main] INFO com.springboot.example.stream.StreamTest - BigDecimal sum - 311286复制代码

    这里使用了Integer 及BigDecimal类型的求和,其他的例如Long Double类型的自行尝试,操作都是一样的。

    分组操作Map> groups = users.stream().collect(Collectors.groupingBy(User::getName, Collectors.toList()));复制代码

    结果16:19:24.018 [main] INFO com.springboot.example.stream.StreamTest - groups - {"用户-0":[{"name":"用户-0","id":1,"salary":44133.974869422615}],"用户-1":[{"name":"用户-1","id":2,"salary":32433.52878974182}],"用户-4":[{"name":"用户-4","id":5,"salary":26726.1799749091}],"用户-2":[{"name":"用户-2","id":3,"salary":83274.99312309967}],"用户-3":[{"name":"用户-3","id":4,"salary":1579.9248811900475}]}复制代码

    自定义分组的数据结构List groupCustomize = users.stream().collect(Collectors.groupingBy(User::getName, Collectors.toList())).entrySet().stream().map(e -> {

    Map newObj = new HashMap<>();

    newObj.put("name", e.getKey());

    newObj.put("items", e.getValue());return newObj;

    }).collect(Collectors.toList());复制代码

    结果16:24:23.554 [main] INFO com.springboot.example.stream.StreamTest - groups customize - [{"name":"用户-0","items":[{"name":"用户-0","id":1,"salary":69329.43639757435}]},{"name":"用户-1","items":[{"name":"用户-1","id":2,"salary":14632.879595342842}]},{"name":"用户-4","items":[{"name":"用户-4","id":5,"salary":52953.301688394306}]},{"name":"用户-2","items":[{"name":"用户-2","id":3,"salary":29500.813638173757}]},{"name":"用户-3","items":[{"name":"用户-3","id":4,"salary":30750.353923258994}]}]复制代码

    展开全文
  • Java Stream 分页

    千次阅读 2020-08-07 11:50:06
    //当前页码 int page = 1; //每页条数 int displayLength = 10; //忽略上一页,如果是第一页肯定不用忽略 ...List list= list.stream().skip(skipnum).limit(displayLength).collect(Collectors.toList()); ...
  • Java 8 新特性】Java Stream 通过min和max方法获取列表最小值和最大值1.Stream.min()2.Stream.max()3.在字符串(`String`)和整数(`Integer`)中如何使用min和max方法4.在对象类型(`Object`)中使用Min和Max方法5.在...
  • java Stream Map集合处理

    千次阅读 2020-04-23 16:52:28
    java Stream 使用 stream对Map集合的处理 Map x 处理成 Map y 简单示例: Map<String, String> x; Map<String, Integer> y = x.entrySet().stream() .collect(Collectors.toMap( e -> e.getKey(), e ...
  • Java Stream流之求和

    千次阅读 2020-08-24 16:03:53
    BigDecimal: BigDecimal bb =list.stream().map(Plan::getAmount).reduce(BigDecimal.ZERO,BigDecimal::add); int、double、long: double max = list.stream().mapToDouble(User::getHeight).sum();
  • Java stream根据对象的某个字段去重

    千次阅读 2021-05-12 14:18:52
    记录一个不常见但使用的stream用法 List<EnforcementImportDto> enforcementList 是一个不为空的列表 EnforcementImportDto有 bidId的字段 所以可以实现根据bidId字段,去重列表enforcementList ...
  • java stream中Collectors的用法

    千次阅读 2020-04-24 07:46:58
    java stream中,我们通常需要将处理后的stream转换成集合类,这个时候就需要用到stream.collect方法。collect方法需要传入一个Collector类型,要实现Collector还是很麻烦的,需要实现好几个接口。 于是java提供了...
  • java stream 删除元素

    千次阅读 2021-04-15 10:40:14
    List<Long> userIds = userList.stream().filter(item -> item.getUserId() != null).map(User::getUserId).collect(Collectors.toList());
  • Java Stream flatMap()

    千次阅读 2020-07-12 12:24:52
    Java Stream flatMap() is a very useful function to flatten the Stream after applying the given function to all the elements of the stream. 在将给定函数应用于流的所有元素之后, Java Stream flatMap()...
  • java stream根据字段名排序

    千次阅读 2021-03-10 11:23:28
    List.stream().sorted(Comparator.comparing(PersEmpHouseholdExcelDto::getId)).collect(Collectors.toList()); 降序 List.stream().sorted(Comparator.comparing(PersEmpHouseholdExcelDto::getId).reversed())....
  • java stream debug 技巧

    千次阅读 2018-12-29 17:42:14
    java 8 stream intellij debug 技巧 java8的stream操作写起来感觉很爽,但是一旦出现错误,之前的单步debug操作并不管用,现在idea提供了一个debug的技巧,使用的插件是 :Java Stream Debugger 插件地址:...
  • 本页将介绍Java Stream.of方法示例。Stream.of用于为给定元素创建顺序流。我们可以传递单个元素或多个元素。 查看javadoc中Stream.of方法声明。 static <T> Stream<T> of(T t) 参数:传递单个元素。 ...
  • Java Stream流封装速度竟然如此给力!

    千次阅读 2020-11-24 22:49:36
    hello你好我是辰兮,很高兴你能来阅读,本篇文章是初识Java Stream流,先简单的聊一聊相关知识,应用场景,后续会陆续更新相关用法,分享获取新知,大家一起进步! 文章目录一、Stream序言二、Stream测试三、Stream...
  • Java stream操作toMap总结

    千次阅读 2020-07-07 14:23:43
    1、map 对象本身,重复的key,放入List。 Map<String, List<... workings.stream().collect(Collectors.toMap(Working::getInvoicePage, e -> { ArrayList<Working> list = new Arr
  • Stream的findAny方法选择该流中的任何元素。 findAny方法的行为是不确定的,它可以自由选择流中的任何元素。 findAny方法有助于在并行操作中获得最大的性能,但它不能保证每次调用都得到相同的结果。 在java doc中的...
  • JAVA Stream流的map映射

    千次阅读 2020-02-03 21:30:26
    获取流之后,可以使用映射方法: map(用于转换的Lambda表达式) 映射:就是将一个对象转换成另一个对象,把老对象映射到新对象上。...public class StreamMap { public static void main(String[] args) {...
  • 本页将遍历Stream.count()方法示例。count()方法返回此流中元素的总数。 count()方法是获取流总数简写的方法。 在javadoc中count()方法声明。 long count() 返回:count()返回此流中元素的总数。 count()是流终端...
  • Stream的limit方法返回一个新的流,该流的元素被截断为给定的最大长度。limit方法包含前n个元素,其中n小于或等于给定的最大大小。 在javadoc中的limit方法声明。 Stream<T> limit(long maxSize) 参数:参数...
  • java Stream debug 调试

    千次阅读 2020-03-18 15:08:26
    今天就来说说javaStream是怎么调试的。官方的链接地址是:https://www.jetbrains.com/help/idea/analyze-java-stream-operations.html,如果英文好的话也可以直接看英文的。 先写一个简单的Stream方法 public ...
  • 背景 (需求经过修改过)判断一个...既然已经JDK8了,那就用lambda吧,如果是foreach可能比较难处理,用stream的filter则可以这样做. 核心代码可以这么写 int intCheck = profileServiceDtoList.stream().filter(e -> ...
  • Java 8 新特性】Java Stream 通过skip方法跳过前N个子元素1.skip() 示例2.skip() vs limit()参考文献 本页将介绍Stream.skip方法示例。skip方法在跳过流的第一个给定元素之后返回一个由该流的其余元素组成的流。 ...
  • java stream list转map

    千次阅读 2020-07-29 10:26:37
    java 8 使用stream流来对集合进行处理: Stream将List转换为Map,使用Collectors.toMap方法进行转换 背景:User类,类中分别有id,name,age三个属性。List集合,userList,存储User对象 1、指定key-value,value是...
  • Stream的findFirst方法在此流中查找第一个元素作为Optional。 如果流中没有元素,findFirst返回空的Optional。 如果流没有顺序,那么findFirst可以选择任何元素。 如果findFirst选择的元素为null,它将抛出...
  • Java Stream 流的合并操作

    千次阅读 2020-05-12 08:00:00
    1. 前言Java Stream Api[1] 提供了很多有用的 Api 让我们很方便将集合或者多个同类型的元素转换为流进行操作。今天我们来看看如何合并 Stream 流。2. Stre...
  • Java Stream流之BigDecimal求和

    千次阅读 2020-08-13 14:33:54
    List<Entity> roleEdit = roleService.findAll(roleEntity);...roleEdit.stream().map(re -> re.getNum() == null ? BigDecimal.ZERO : re.getNum()).reduce(BigDecimal.ZERO,BigDecimal::add);
  • 使用Java Stream,提取集合中的某一列/按条件过滤集合/求和/最大值/最小值/平均值。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 400,643
精华内容 160,257
关键字:

javastream

java 订阅