5.Stream流

最新推荐文章于 2024-03-16 11:11:07 发布
最新推荐文章于 2024-03-16 11:11:07 发布
阅读量374 收藏
点赞数
分类专栏： Java基础和进阶 文章标签： java stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45940433/article/details/122061831
版权

1.Stream流

1.体验Stream流

需求：按照下面的要求完成集合的创建和遍历

  • 创建一个集合，存储多个字符串元素
  • 把集合中所有以“张”开头的元素存储到一个新的集合
  • 把“张”开头的集合中的长度为3的元素存储到一个新的集合
  • 遍历上一步得到的集合

代码：

package Study05;

import java.util.ArrayList;

/*
需求：按照下面的要求完成集合的创建和遍历
- 创建一个集合，存储多个字符串元素
- 把集合中所有以“张”开头的元素存储到一个新的集合
- 把“张”开头的集合中的长度为3的元素存储到一个新的集合
- 遍历上一步得到的集合
*/
public class StreamDemo {
    public static void main(String[] args) {
        //- 创建一个集合，存储多个字符串元素
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("张小胖");
        arrayList.add("张春华");
        arrayList.add("张胖虎");
        arrayList.add("李小乐");
        arrayList.add("张华");

        //- 把集合中所有以“张”开头的元素存储到一个新的集合
        ArrayList<String> zhangList = new ArrayList<String>();
        for (String s:arrayList){
            if (s.startsWith("张")){
                zhangList.add(s);
            }
        }

        //- 把“张”开头的集合中的长度为3的元素存储到一个新的集合
        ArrayList<String> zhang3List = new ArrayList<String>();
        for (String s:zhangList){
            if (s.length()==3){
                zhang3List.add(s);
            }
        }

        //- 遍历上一步得到的集合
        for (String s:zhang3List){
            System.out.println(s);
        }
        System.out.println("====================================");
        //采用Stream流来改写
//        arrayList.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(s-> System.out.println(s));
        arrayList.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println);
    }
}

使用Stream流的方式完成过滤操作

  • arrayList.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println);

  • 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：生成流，过滤张，过滤长度为3，逐一打印

  • Stream流把真正的函数式编程风格引入到Java中

2.Stream流概述

Stream流的使用

  • 生成流
    • 通过数据源(集合，数组等)生成流
    • list.stream()
  • 中间操作
    • 一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
    • filter()
  • 终结操作
    • 一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作
    • forEach()

2.Stream流的常见生成方式

Stream流的常见生成方式

  • Collection体系的集合可以使用默认方法stream()生成流
    • default Stream <E> stream()
  • Map体系的集合间接生成流
  • 数组可以通过Stream接口的静态方法of(T…values)生成流

代码示例：

package Study06;

import java.util.*;
import java.util.stream.Stream;

/*`Stream`流的常见生成方式
- `Collection`体系的集合可以使用默认方法`stream()`生成流
	- `default Stream <E> stream()`
- `Map`体系的集合间接生成流
- 数组可以通过`Stream`接口的静态方法`of(T…values)`生成流
*/
public class StreamDemo {
    public static void main(String[] args) {
        //`Collection`体系的集合可以使用默认方法`stream()`生成流
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();

        Set<String> set = new HashSet<String>();
        Stream<String> setStream = set.stream();

        //- `Map`体系的集合间接生成流
        Map<String,Integer> map = new HashMap<String,Integer>();
        Stream<String> KeyStream = map.keySet().stream();//键的Stream流；map.keySet()返回的是Set类型的集合
        Stream<Integer> valuesStream = map.values().stream();//值的Stream流；map.values()返回的是Collection类型的集合
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();//键值对的Stream流； map.entrySet()返回的是Set类型的集合

        //- 数组可以通过`Stream`接口的静态方法`of(T…values)`生成流
        String[]strArray ={"迪丽热巴","王冰冰"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("迪丽热巴", "王冰冰");
        Stream<Integer> integerStream = Stream.of(10, 20, 30);
    }
}

3.Stream流的常见中间操作方法

  • Stream filter(Predicate predicate):用于对流中的数据进行过滤。

  • Predicate接口中的方法：

    • boolean test(T t):对给定的参数进行判断，返回一个布尔值

  • Stream<T>limit (long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据

  • Stream<T> skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流

  • static<T> Stream<T> concat(Stream a,Stream b):合并a和b两个流为一个流。

  • Stream<T> distinct():返回由该流的不同元素(根据Object.equals(Object))组成的流

  • Stream<T> sorted()：返回由此流的元素组成的流，根据自然顺序排序

  • Stream<T> sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序

  • <R> Stream <R>map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流

    • Function接口的方法：R apply(T t)

  • IntStream mapToInt(TOIntFunction mapper):返回一个IntStream其中包含给定函数应用于此流的元素的结果

    • IntStream：表示原始int流
    • ToIntFunction接口的方法：int applyAsInt(T value)

1.filter

  • Stream filter(Predicate predicate):用于对流中的数据进行过滤。
  • Predicate接口中的方法：
    • boolean test(T t):对给定的参数进行判断，返回一个布尔值

代码：

package Study06;

import java.util.ArrayList;

/*
- Stream<T> filter(Predicate predicate):用于对流中的数据进行过滤。
- Predicate接口中的方法：
	- boolean test(T t):对给定的参数进行判断，返回一个布尔值
	*/
public class StreamDemo01 {
    public static void main(String[] args) {
        //- 创建一个集合，存储多个字符串元素
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("张小胖");
        arrayList.add("张春华");
        arrayList.add("张胖虎");
        arrayList.add("李小乐");
        arrayList.add("张华");

        //需求1：把集合中所有以“张”开头的元素在控制台输出
        arrayList.stream().filter(s->s.startsWith("张")).forEach(System.out::println);
        System.out.println("----------------");
        //需求2：把“张”开头的集合中的长度为3的元素在控制台输出
        arrayList.stream().filter(s->s.length()==3).forEach(System.out::println);
        System.out.println("----------------");
        //需求3：把“张”开头的集合中的长度为3的元素在控制台输出
        arrayList.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println);
        System.out.println("----------------");
    }
}

2.limit&&skip

  • Stream<T>limit (long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
  • Stream<T> skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流

代码示例：

package Study06;

import java.util.ArrayList;
/*
- `Stream<T>limit (long maxSize)`：返回此流中的元素组成的流，截取前指定参数个数的数据
- `Stream<T> skip(long n)`:跳过指定参数个数的数据，返回由该流的剩余元素组成的流
*/
public class StreamDemo02 {
    public static void main(String[] args) {
        //- 创建一个集合，存储多个字符串元素
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("张小胖");
        arrayList.add("张春华");
        arrayList.add("张胖虎");
        arrayList.add("李小乐");
        arrayList.add("张华");

        //需求1：取前三个数据在控制台输出
        arrayList.stream().limit(3).forEach(System.out::println);
        System.out.println("-----------");
        //需求2：跳过3个元素，把剩下的元素在控制台输出
        arrayList.stream().skip(3).forEach(System.out::println);
        System.out.println("-----------");
        //需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
        arrayList.stream().skip(2).limit(2).forEach(System.out::println);
        System.out.println("-----------");
    }
}

3.concat&&distinct

  • static<T> Stream<T> concat(Stream a,Stream b):合并a和b两个流为一个流。
  • Stream<T> distinct():返回由该流的不同元素(根据Object.equals(Object))组成的流

代码示例：

package Study06;

import java.util.ArrayList;
import java.util.stream.Stream;

/*
- `static<T> Stream<T> concat(Stream a,Stream b)`:合并a和b两个流为一个流。
- `Stream<T> distinct()`:返回由该流的不同元素(根据`Object.equals(Object)`)组成的流
*/
public class StreamDemo03 {
    public static void main(String[] args) {
        //- 创建一个集合，存储多个字符串元素
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("张小胖");
        arrayList.add("张春华");
        arrayList.add("张胖虎");
        arrayList.add("李小乐");
        arrayList.add("张华");

        //需求1：取前4个数据组成一个流
        Stream<String> limit = arrayList.stream().limit(4);
        //需求2：跳过2个数据组成一个流
        Stream<String> skip = arrayList.stream().skip(2);
        //需求3：合并需求1和需求2得到的流，并把结果在控制台输出
//        Stream.concat(limit,skip).forEach(System.out::println);
        System.out.println("-----------");
        //需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(limit,skip).distinct().forEach(System.out::println);
    }
}

4.sorted

  • Stream<T> sorted()：返回由此流的元素组成的流，根据自然顺序排序
  • Stream<T> sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序

代码示例：

package Study06;

import java.util.ArrayList;
import java.util.Comparator;

/*
- `Stream<T> sorted()`：返回由此流的元素组成的流，根据自然顺序排序
- `Stream<T> sorted(Comparator comparator):`返回由该流的元素组成的流，根据提供的`Comparator`进行排序
*/
public class StreamDemo04 {
    public static void main(String[] args) {
        //- 创建一个集合，存储多个字符串元素
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("zhangxiaopang");
        arrayList.add("zhangchunhua");
        arrayList.add("zhangpanghu");
        arrayList.add("lixiaole");
        arrayList.add("zhanghua");

        //需求1：按照字符顺序把数据在控制台输出
//        arrayList.stream().sorted().forEach(System.out::println);
        //需求2：按照字符串长度把数据在控制台输出
//        arrayList.stream().sorted((s1, s2) -> s1.length() - s2.length()).forEach(System.out::println);//当长度相同时，先输入的在前
        arrayList.stream().sorted((s1,s2)->{
            int num = s1.length()-s2.length();
            int num1 = num==0?s1.compareTo(s2):num;
            return num1;
        }).forEach(System.out::println);//当长度相同时，按字符顺序进行排序
    }
}

5.map&&mapToInt

  • <R> Stream <R>map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流
    • Function接口的方法：R apply(T t)
  • IntStream mapToInt(TOIntFunction mapper):返回一个IntStream其中包含给定函数应用于此流的元素的结果
    • IntStream：表示原始int流
    • ToIntFunction接口的方法：int applyAsInt(T value)

代码示例：

package Study06;

import java.util.ArrayList;

/*
- `<R> Stream <R>map(Function mapper)`:返回由给定函数应用于此流的元素的结果组成的流
	- `Function`接口的方法：`R apply(T t)`
- `IntStream mapToInt(TOIntFunction mapper):`返回一个`IntStream`其中包含给定函数应用于此流的元素的结果
	- `IntStream`：表示原始int流
	- `ToIntFunction`接口的方法：`int applyAsInt(T value)`
	*/
public class StreamDemo05 {
    public static void main(String[] args) {
        //- 创建一个集合，存储多个字符串元素
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("10");
        arrayList.add("20");
        arrayList.add("30");
        arrayList.add("40");
        arrayList.add("50");

        //需求：将集合中的字符数据转换为整数类型的数据并在控制台输出
//        arrayList.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
//        arrayList.stream().map(Integer::parseInt).forEach(System.out::println);

//        arrayList.stream().mapToInt(Integer::parseInt).forEach(System.out::println);

        //int sum()：返回此流中元素的总和
        int sum = arrayList.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
    }
}

4.Stream流的常见终结操作方法

Stream流的常见终结操作

  • void forEach(Consumer action):对此流的每个元素执行操作
    • Consumer接口中的方法
      • void accept(T t):对给定的参数执行操作
  • long count():返回此流中的元素数

代码示例：

package Study06;

import java.util.ArrayList;

/*
Stream流的常见终结操作
- void forEach(Consumer action):对此流的每个元素执行操作
	- Consumer接口中的方法
		- void accept(T t):对给定的参数执行操作
- long count():返回此流中的元素数
*/
public class StreamDemo06 {
    public static void main(String[] args) {
        //- 创建一个集合，存储多个字符串元素
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("张小胖");
        arrayList.add("张春华");
        arrayList.add("张胖虎");
        arrayList.add("李小乐");
        arrayList.add("张华");

        //需求1：把集合中的元素在控制台输出
        arrayList.stream().forEach(System.out::println);
        System.out.println("-----------");
        //需求2：统计集合中以张开头的元素，统计结果在控制台输出
        long count = arrayList.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);
    }
}

5.Stream流的练习

需求：

现有两个ArrayList集合，分别存储6名男生名称和6名女生名称，要求完成如下操作：

  • 男生只要名字为三个字的前三人
  • 女生只要姓林的，并且不要第一个
  • 把过滤后的男生和女生姓名合并在一起
  • 把上一步操作后的元素作为构造方法的参数穿件演员对象，遍历数据
    • 演员类Actor：有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

代码:

  • Actor类:
package Study06;

public class Actor {
    private String name;

    public Actor() {
    }

    public Actor(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
  • StreamTest测试类:
package Study06;

import java.util.ArrayList;
import java.util.stream.Stream;

/*需求：
现有两个`ArrayList`集合，分别存储6名男生名称和6名女生名称，要求完成如下操作：
- 男生只要名字为三个字的前三人
- 女生只要姓林的，并且不要第一个
- 把过滤后的男生和女生姓名合并在一起
- 把上一步操作后的元素作为构造方法的参数穿件演员对象，遍历数据
	- 演员类`Actor`：有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法
*/
public class StreamTest {
    public static void main(String[] args) {
        ArrayList<String>boy=new ArrayList<String>();
        boy.add("懒洋洋");
        boy.add("灰太狼");
        boy.add("沸羊羊");
        boy.add("村长");
        boy.add("喜洋洋");
        ArrayList<String>girl=new ArrayList<String>();
        girl.add("林琳");
        girl.add("林颖");
        girl.add("张素华");
        girl.add("林志玲");

/*        //- 男生只要名字为三个字的前三人
        Stream<String> boy3 = boy.stream().filter(s->s.length()==3).limit(3);
        //- 女生只要姓林的，并且不要第一个
        Stream<String> girl1 = girl.stream().filter(s->s.startsWith("林")).skip(1);
        //- 把过滤后的男生和女生姓名合并在一起
        Stream<String> BoyAndGirl = Stream.concat(boy3, girl1);
        //- 把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
//        BoyAndGirl.map(Actor::new).forEach(System.out::println);
        BoyAndGirl.map(Actor::new).forEach(p-> System.out.println(p.getName()));*/

        //合并上述操作
        Stream.concat(boy.stream().filter(s->s.length()==3).limit(3),
                girl.stream().filter(s->s.startsWith("林")).skip(1)).
                map(Actor::new).forEach(p-> System.out.println(p.getName()));
    }
}

6.Stream流的收集操作

对数据使用Stream流的方式操作完毕后，如何将流中的数据收集到集合中？

Stream流的搜集方法

  • R collect(Collector collector)
  • 这个收集方法的参数是一个Collector接口

工具类Collectors提供了具体的搜集方式

  • public static <T>Collection toList():把元素收集到List集合中
  • public static <T>Collector toSet():把元素收集到Set集合中
  • public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中

示例代码：

package Study06;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/*`Stream`流的搜集方法
- `R collect(Collector collector)`
- 这个收集方法的参数是一个`Collector`接口

工具类`Collectors`提供了具体的搜集方式
- `public static <T>Collection toList():`把元素收集到`List`集合中
- `public static <T>Collector toSet()`:把元素收集到`Set`集合中
- `public static Collector toMap(Function keyMapper,Function valueMapper)`:把元素收集到`Map`集合中
*/
public class CollectDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("懒洋洋");
        list.add("灰太狼");
        list.add("沸羊羊");
        list.add("村长");
        list.add("喜洋洋");

        //- `public static <T>Collection toList():`把元素收集到`List`集合中
        /*//需求1：得到名字为3个字的流
        Stream<String> listStream = list.stream().filter(s -> s.length() == 3);
        //需求2：把使用Stream流操作完毕的数据收集到List集合中并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for (String s:names){
            System.out.println(s);
        }*/

        //- `public static <T>Collector toSet()`:把元素收集到`Set`集合中
        //创建Set集合
        Set<Integer> set = new HashSet<Integer>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);

        /*//需求3：得到年龄大于20的流
        Stream<Integer> ages = set.stream().filter(s -> s > 20);
        //需求4：把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> age = ages.collect(Collectors.toSet());
        for (Integer i : age) {
            System.out.println(i);
        }*/

        //定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
        String[] str = {"喜洋洋,10","懒洋洋,20","美洋洋,30","沸羊羊,40","村长,50"};
        //需求5：得到字符串中年龄大于20的流
        Stream<String> stringStream = Stream.of(str).filter(s -> Integer.parseInt(s.split(",")[1]) > 20);
        //需求6：把使用Stream流操作完毕的数据收集到Map集合并遍历，字符串中的姓名作键，年龄作值
        Map<String, Integer> map = stringStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
        Set<String> key = map.keySet();
        for (String k:key){
            System.out.println("姓名："+k+";年龄："+map.get(k));
        }
    }
}
幺洞两肆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java8 Stream的常用方式
古城的博客
01-17 910
文章目录什么是Stream？
Arraylist.stram()玩法 流
mayaohao的博客
06-04 656
package kgc_byme.day19.test.tt2; import java.util.*; import java.util.stream.Collectors; /** * @Description: * @author:myh * @date: 2021/6/4 10:54 */ public class tes { public static void main(String[] args) { ArrayList<Stu> stus .
java List(ArrayList)的5种遍历方式解析
热门推荐
萧逸才的博客
04-08 3万+
前言 对于ArrayList来说，从名字”数组列表”就知道它的底层其实是由数组实现的，同时ArrayList实现了RandomAccess接口，我们可以并且最好通过索引来访问ArrayList中的元素，这样的效率是最高的。 调用代码public static void main(String[] args) { List<Integer> list = new ArrayList
Java Stream流
APCSZDDXM的博客
12-24 510
什么是Stream流？ 当我们有一个需求： 现在有一份名单{“李博”,“张伟”,“曾小贤”,“胡一菲”,“张无忌”}，要求筛选出姓“张”的人，并且名字长度是3的，放到一个新的数组里面去 如果我们使用传统方法来写，可能是这样的 public class B { public static void main(String[] args) throws IOException { ArrayList<String> arr=new ArrayList<>();
Java List常用方法Stream()简要总结
BHSZZY的博客
02-10 1万+
一、简介 Java中，ArrayList应该是比较常用的一个对象了；那么它的stream()方法大家了解过吗？ 如果可以熟练使用stream()方法，就可以方便地获取list中元素的某个特定字段、对list中的元素进行筛选、或者把list转成map。 下方是常用的4种stream()用法。 二、代码样例 import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.Set; import j
adodb.stream
07-24
`ADODB.Stream`是Microsoft ActiveX Data Objects (ADO)中的一个核心组件，它提供了一种处理数据流的方式，无论数据是文本、二进制还是其他形式。在编程中，特别是VBScript、VBA或者Classic ASP中，`ADODB.Stream`...
详解JAVA Stream流
08-18
5. Stream<T> limit(long n)：用于截取流中的元素，只取用前n个元素，此方法是延迟方法，可以继续调用Stream流中的其他方法。 stream1.limit(2).forEach(name -> System.out.println(name)); Stream流还提供了其他...
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
deepstream_test5.rar
08-29
【标题】"deepstream_test5.rar" 是一个与深度学习流处理相关的压缩包，其中包含了一个名为 "test5" 的教学资源。这个资源是专为那些想要深入理解并应用DeepStream SDK和TensorRT进行视频分析的学员设计的。 【描述...
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
JDK1.8----Stream流（过滤、分组、循环、映射、排序、计算等方法的详细使用）
Promise_J_Z
07-13 5734
steam流的常用用法，有它就够了
2021-03-31：java第29天: stream流处理ArrayList,或者array； 方法引用的规则
qq_41179957的博客
04-01 827
Stream 流 1. 使用传统的方式对集合里的元素进行过滤 String name; name.startsWith(" ") 题目；首先筛选姓张的人，其次筛选名字有3个字的人，最后对结果进行打印输出 用stream流的方式对案例进行优化:JDK 1.8之后才有，关注的是做什么，而不是怎么做。Lambda的衍生物 冗杂的代码： 简化后的代码： package Part3.Day_29; import java.util.ArrayList; import java.util.L.
Java 中 List 集合 Stream 流详解
weixin_51423778的博客
10-08 3151
Java 中 List 集合 Stream 流详解
对集合数组操作的神器：Stream流
yygr的博客
03-16 75
https://blog.csdn.net/weixin_52394141/article/details/127327056
Stream流（简化开发）
qq_53677566的博客
01-27 512
Stream流Stream流什么是 Stream？获取流操作流注： Stream流 什么是 Stream？ Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把 它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后 编码效率与大大提高，并且可读性更强。 要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全不同的概念. 简单案例: 我们的需求是在 applestore 集合中找出红色苹果手
【Java】集合List转换为数组【toArray() /stream()流】实现
hhb442的博客
08-28 7336
在Java中，集合（List 接口的实现类）提供了一个名为 toArray 的方法，用于将集合中的元素转换成数组。该方法有两个主要的重载形式，分别用于不同的情况。
如何在Java 8中从Stream获取ArrayList
qq_32232949的博客
09-10 3831
给定Stream,任务将此Stream转换为Java8中的ArrayList. 1.使用Collectors.toList()方法： 1.1 获取要转换的流 1.2 使用collect()和Collectors.toList()方法将流收集为List. 1.3 将List转换为ArrayList 1.4 返回/打印ArrayList 程序示例：...
ArrayList合并、通过stream()去重
pengsaiwei的专栏
09-10 2351
List<Bean> list1 = new ArrayList(); List<Bean> list2 = new ArrayList(); ...... list1.addAll(list2 ); //根据typeCode去重 List<FileTypesDaoDto> listNew = list.stream().collect( Collectors.collectingAndThen( Collectors.t.
Java8新特新--Stream语法应用在ArrayList的元素移除和排序
Appleyk的专栏
12-22 2万+
A sequence of elements supporting sequential and parallel aggregate operations：支持顺序和并行聚合操作的元素序列。
list.stream.filter详解
最新发布
05-08
list.stream.filter是Java 8中Stream API...Stream<Integer> stream = list.stream().filter(i -5数字的List集合，并将其转换为一个Stream流，然后使用filter()方法过滤掉其中的奇数，最终得到包含偶数的新的Stream流。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

幺洞两肆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值