JAVA中的Stream

其他 2020-03-17 11:13:22 阅读次数: 0

1. Stream流

1.1. Stream流引入
  • Stream流完全不是I/O流，按照流水线处理方式来考虑代码中的思想。
    JDK1.8 之后，我们拥有了Lambda表达式，让代码的中心偏向解决实际问题，直到重点，可以提高效率。
    Stream流中使用了大量Lambda表达式，利用Lambda操作方式，提供开发效率
1.2 传统遍历方式和Stream类处理方式对比
import java.util.ArrayList;

/**
 * 操作集合处理集合
 *      操作过程中创建了多个ArrayList，但是这些ArrayList都是过客，
 *      不涉及到程序的核心，这里会导致资源的浪费。
 * @author Anonymous 2020/3/12 9:56
 */
public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("宫保鸡丁");
        list.add("酱牛肉");
        list.add("羊肉串");
        list.add("烤羊排");
        list.add("羊肉汤");
        list.add("驴肉火烧");

        // 第一步: 对List进行过程，找出list中保存元素带有肉的，保存到另一个集合中
        ArrayList<String> list1 = new ArrayList<>();
        for (String s : list) {
            if (s.contains("肉")) {
                list1.add(s);
            }
        }

        // 第二步: 找出菜名长度==3的，保存到另一个集合中
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if (3 == s.length()) {
                list2.add(s);
            }
        }

        // 第三步：遍历展示对应的数据
        for (String s : list2) {
            System.out.println(s);
        }


    }
}

import java.util.ArrayList;

/**
 * 操作集合处理集合
 *      采用Stream流方式
 *
 * @author Anonymous 2020/3/12 9:56
 */
public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("宫保鸡丁");
        list.add("酱牛肉");
        list.add("羊肉串");
        list.add("烤羊排");
        list.add("羊肉汤");
        list.add("驴肉火烧");

        /*
        采用Stream流方式来处理
        直观角度可以发现，这里Stream流处理方式可以简化代码逻辑，
        更侧重于操作的重点

        第一步: 对List进行过程，找出list中保存元素带有肉的，
        第二步: 找出菜名长度==3的
        第三步：遍历展示对应的数据
        */
        list.stream()
                .filter(s->s.contains("肉"))
                .filter(s -> 3 == s.length())
                .forEach(s -> System.out.println(s));

    }
}
1.3 Stream流对应的思想

在这里插入图片描述

  • 流水线:
    原材料从头到尾只会占用一份空间，中间的过程中不会占用空间。最后生成一个结果。
    在这里插入图片描述
  • Stream流有一些特征:
  1. 带有很多Stream流操作的方法， filter，limit，map，sorted，skip…这些方法大多是都会使用到函数式接口，有lambda表达式
  2. 整个Stream流模型操作过程中，只有执行到count，foreach这些方法，操作真正的执行中的模型，如果不存在结果导向，中间的所有操作是无效的，这里得益于Lambda表达式的延后性
  3. Stream流是存在一定的管道性 Pipelining 流水线
1.4 获取Stream流
  • java.util.stream.Stream JDK1.8的新特征
  1. 所有的Collection集合都有对应的Stream();
  2. 可以通过Stream类中的static Stream of()获取
    static Stream of(T… t);
    static Stream of(T t);
import java.util.*;
import java.util.stream.Stream;

/**
 * Stream流获取方式
 *      1. Collection集合
 *      2. Map双边队列
 *      3. 数组
 *
 * @author Anonymous 2020/3/12 11:16
 */
public class Demo1 {
    public static void main(String[] args) {
        // List接口获取对应的Stream流类对象
        List<String> list = new ArrayList<>();
        // 根据list保存元素的类型来约束对应的Stream流对象操作所需类型
        Stream<String> stream = list.stream();

        // 通过Set集合获取对应Stream流对象
        HashSet<String> set1 = new HashSet<>();
        Stream<String> stream1 = set1.stream();

        HashMap<String, String> map = new HashMap<>();
        // Map双边队列中所有键对应的Set集合
        Set<String> keySet = map.keySet();
        Stream<String> stream2 = keySet.stream();

        // Map双边队列中所有value对应的Collection集合
        Collection<String> values = map.values();
        Stream<String> stream3 = values.stream();

        // map中有一个方法，可以获取所有键值对类型的Set集合
        // Entry ==> 键值对，是Map接口的一个成员接口
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        // 获取Map键值对集合的Stream流对象
        Stream<Map.Entry<String, String>> stream4 = entrySet.stream();

        // 使用不定长参数获取对应的Stream流对象
        // Stream类内的静态方法of，更多的是用于数组操作提供Stream流对象
        Stream<String> stringStream = Stream.of("酱牛肉", "羊肉抓饭", "羊肉汤", "羊蝎子");

        String[] arr = {"黄河大鲤鱼", "方中山胡辣汤", "萧记烩面", "蔡记蒸饺", "葛记焖饼"};
        Stream<String> arrStream = Stream.of(arr);

        // 不建议这样使用！！！
        ArrayList<String> list1 = new ArrayList<>();
        Stream<ArrayList<String>> list11 = Stream.of(list1);

    }
}
1.5 Stream常用方法
  • 延迟方法:
    返回值类型依然是Stream接口本身，并没有影响我们操作真正的资源允许链式操作，
  • 例如
    filter(XXX).limit(XXX).sorted(XXX).
  • 终结方法:
    返回值类型不是Stream接口本身，要么处理数据，要么返回其他类型数据，并且不再支持Stream流对象链式操作，count，foreach
1.5.1 foreach方法【终结方法】
void foreach(Consumer<? super T> action);
/*
终结方法:
	需要一个Consumer接口进行操作处理，消耗一个数据
	Consumer接口是一个【函数式接口】那就可以使用Lambda表达式
	Consumer接口中方法是
		void accept(T t);
*/

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Stream;

/**
 * Stream流foreach方法使用
 *
 * @author Anonymous 2020/3/12 11:39
 */
public class Demo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("蛋炒饭");
        list.add("虎皮青椒");
        list.add("手撕包菜");
        list.add("鲱鱼罐头");

        // 得到List对应的Stream流对象
        Stream<String> stream = list.stream();

        /*
        Stream<String> Stream流，这里操作的是String类型
            匿名内部类的匿名对象作为方法的参数，曾经多么厉害，现在是有点low
         */
        stream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        // 这里需要的参数是Consumer函数式接口，完成可以使用Lambda表达式完成
        stream.forEach(string -> System.out.println(string));

        // 我们在哪里见过??? 方法引用
        stream.forEach(System.out::println);
    }
}
1.5.2 filter方法
Stream<T> filter(Predicate<? super T> condition);
/*
	filter是过滤方式，需要的参数是Predicate接口，Predicate是一个函数式接口，可以直接使用Lambda表达运行。
	这里返回值类型是Stream类对象，是经过过滤之后的Stream类型，可以进行链式操作
	Predicate接口中需要实现的方法
		boolean test(T t);
*/

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

/**
 * Stream流对象filter方法演示
 *
 * @author Anonymous 2020/3/12 11:50
 */
public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("擀面皮");
        list.add("肉夹馍");
        list.add("冰峰");
        list.add("水盆羊肉");

        Stream<String> stringStream = list.stream().filter(s -> s.length() >= 3);
        stringStream.forEach(System.out::println);

        Stream<String> stringStream1 = stringStream.filter(s -> 4 == s.length());
        stringStream1.forEach(System.out::println);
        /*
        Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
            at java.util.stream.AbstractPipeline.<init>(AbstractPipeline.java:203)
            at java.util.stream.ReferencePipeline.<init>(ReferencePipeline.java:94)
            at java.util.stream.ReferencePipeline$StatelessOp.<init>(ReferencePipeline.java:618)
            at java.util.stream.ReferencePipeline$2.<init>(ReferencePipeline.java:163)
            at java.util.stream.ReferencePipeline.filter(ReferencePipeline.java:162)
            at com.qfedu.c_streamfunction.Demo2.main(Demo2.java:23)
         */
    }
}
1.5.3 map方法
<R> Stream<R> map(Function<? super T, ? super R> fun);
/*
类型转换操作，得到的一个转换之后数据类型的Stream流对象
这里需要的参数是Functtion函数式接口，
	R apply(T t);
	T类型的数据转换成R类型数据
*/

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

/**
 * Stream流 map映射方法演示
 *
 * @author Anonymous 2020/3/12 14:39
 */
public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("1,骚磊,16");
        list.add("2,骚杰,66");
        list.add("3,老黑,46");
        list.add("4,老付,36");
        list.add("5,污云,56");
        list.add("6,帅栋,26");

        System.out.println(list);

        Stream<Person> personStream = list.stream().map(s -> {
            String[] split = s.split(",");
            Person person = new Person();

            person.setId(Integer.parseInt(split[0]));
            person.setName(split[1]);
            person.setAge(Integer.parseInt(split[2]));

            return person;
        });

        personStream.forEach(System.out::println);
    }
}
1.5.4 count方法【终结方法】
long count();
/*
返回当前Stream流对象中有多少个元素
类似有Collection接口下的size(). String的length();
【终结方法】
	一旦执行Stream流对象被关闭
*/

import java.util.ArrayList;

/**
 * Stream流对象 count方法演示【终结方法】
 *
 * @author Anonymous 2020/3/12 14:50
 */
public class Demo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("擀面皮");
        list.add("肉夹馍");
        list.add("冰峰");
        list.add("水盆羊肉");

        // 当前Stream流对象中有多少个元素，终结方法
        long count = list.stream().filter(s -> s.length() >= 3).count();
        System.out.println(count);
    }
}
1.5.5 limit方法
Stream<T> limit(long maxSize);
/*
对于当前Stream流对象操作的数据进行限制操作，限制个数到maxSize
例如:
	Stream流中保存的有10个元素，limit 5 ==> 前五个元素
*/

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

/**
 * Stream流对象 limit方法
 *
 * @author Anonymous 2020/3/12 15:03
 */
public class Demo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("红旗");
        list.add("领克");
        list.add("吉利");
        list.add("比亚迪");
        list.add("长安");
        list.add("五菱宏光");

        Stream<String> stream = list.stream();
        // @throws IllegalArgumentException if {@code maxSize} is negative
        stream.limit(5).forEach(System.out::println);
    }
}
1.5.6 skip方法
Stream<T> skip(long n);
/*
返回值依然是一个Stream流对象，这里跳过当前Stream流对象前n个元素
*/

import java.util.ArrayList;

/**
 * Stream流对象 skip方法
 *
 * @author Anonymous 2020/3/12 15:10
 */
public class Demo6 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("陆巡");
        list.add("高R");
        list.add("RS7");
        list.add("s4");
        list.add("霸道");
        list.add("道奇");

        list.stream().skip(2).forEach(System.out::println);
    }
}
1.5.7 concat方法
static Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) 
/*
拼接两个Stream流对象，是一个静态方法，得到新的Stream流对象
*/

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

/**
 * Stream流 静态成员方法 concat方法
 *
 * @author Anonymous 2020/3/12 15:15
 */
public class Demo7 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("红旗");
        list.add("领克");
        list.add("吉利");
        list.add("比亚迪");
        list.add("长安");
        list.add("五菱宏光");

        ArrayList<String> list1 = new ArrayList<>();

        list1.add("陆巡");
        list1.add("高R");
        list1.add("RS7");
        list1.add("s4");
        list1.add("霸道");
        list1.add("道奇");

        // 获取到两个Stream流，其中保存的数据类型都是String类型
        Stream<String> stream = list.stream();
        Stream<String> stream1 = list1.stream();

        Stream<String> concat = Stream.concat(stream, stream1);

       concat.forEach(System.out::println);

    }
}
1.5.8 原始操作方式和Stream流方式对比
import java.util.ArrayList;

/**
 * 采用原始的List集合方式操作
 *   1. 一个String类型的字符串集合，"1,骚磊,16"
 *   2. 过滤没有5的数据
 *   3. 跳过前三个数据
 *   4. 限制得到前5个数据
 *   5. 两个String类型集合字符串合并
 *   6. 转换成Person类型
 *   7. 展示数据
 *
 *   太浪费资源，浪费时间！！！
 * @author Anonymous 2020/3/12 15:22
 */
public class Demo8 {
    public static void main(String[] args) {
        //  1. 一个String类型的字符串集合，"1,骚磊,16"
        ArrayList<String> list1 = new ArrayList<>();

        list1.add("1,骚磊,15");
        list1.add("2,骚杰,65");
        list1.add("3,老黑,45");
        list1.add("4,老付,56");
        list1.add("5,污云,56");
        list1.add("6,帅栋,26");
        list1.add("7,帅栋,56");
        list1.add("8,帅栋,25");
        list1.add("9,帅栋,26");
        list1.add("10,帅栋,26");
        list1.add("11,帅栋,25");
        list1.add("12,帅栋,56");
        list1.add("13,帅栋,55");

        // 2. 过滤没有5的数据
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if (s.contains("5")) {
                list2.add(s);
            }
        }
        System.out.println(list2);

        // 3. 跳过前三个数据
        ArrayList<String> list3 = new ArrayList<>();
        for (int i = 3; i < list2.size(); i++) {
            list3.add(list2.get(i));
        }
        System.out.println(list3);

        // 4. 限制得到前5个数据
        ArrayList<String> list4 = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list4.add(list3.get(i));
        }

        // 5. 两个String类型集合字符串合并
        ArrayList<String> list5 = new ArrayList<>();

        list5.add("1,骚磊,15");
        list5.add("2,骚杰,65");
        list5.add("3,老黑,45");
        list5.add("4,老付,56");
        list5.add("5,污云,56");

        list4.addAll(list5);

        // 6. 转换成Person类型
        ArrayList<Person> list6 = new ArrayList<>();
        for (String s : list4) {
            String[] split = s.split(",");
            Person person = new Person();

            person.setId(Integer.parseInt(split[0]));
            person.setName(split[1]);
            person.setAge(Integer.parseInt(split[2]));

            list6.add(person);
        }

        // 7. 展示数据
        for (Person person : list6) {
            System.out.println(person);
        }

    }
}

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

/**
 * 采用原始的Stream流对象思想方式操作
 *   1. 一个String类型的字符串集合，"1,骚磊,16"
 *   2. 过滤没有5的数据
 *   3. 跳过前三个数据
 *   4. 限制得到前5个数据
 *   5. 两个String类型集合字符串合并
 *   6. 转换成Person类型
 *   7. 展示数据
 * @author Anonymous 2020/3/12 15:29
 */
public class Demo9 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();

        list1.add("1,骚磊,15");
        list1.add("2,骚杰,65");
        list1.add("3,老黑,45");
        list1.add("4,老付,56");
        list1.add("5,污云,56");
        list1.add("6,帅栋,26");
        list1.add("7,帅栋,56");
        list1.add("8,帅栋,25");
        list1.add("9,帅栋,26");
        list1.add("10,帅栋,26");
        list1.add("11,帅栋,25");
        list1.add("12,帅栋,56");
        list1.add("13,帅栋,55");

        ArrayList<String> list2 = new ArrayList<>();

        list2.add("1,骚磊,15");
        list2.add("2,骚杰,65");
        list2.add("3,老黑,45");
        list2.add("4,老付,56");
        list2.add("5,污云,56");
        list2.add("6,帅栋,26");
        list2.add("7,帅栋,56");

        Stream<String> stream = list1.stream();

        Stream<String> limit = stream.filter(s -> s.contains("5")).
                skip(3).
                limit(5);

        Stream.concat(limit, list2.stream()).map(s -> {
            String[] split = s.split(",");
            Person person = new Person();

            person.setId(Integer.parseInt(split[0]));
            person.setName(split[1]);
            person.setAge(Integer.parseInt(split[2]));

            return person;
        }).forEach(System.out::println);

    }
}
  • 总结
    流思想让我们更加的直接，它在没有出结果之前，几乎是不会消耗资源的（之前的过滤、限制、映射等，都是在进行完count或foreach后才会真正的进行）
ヾ剑仙の凉城づ
发布了23 篇原创文章 · 获赞 32 · 访问量 7780
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_46288317/article/details/104845997
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022