stream 订阅
Stream泛指流媒体技术。流媒体实际指的是一种新的媒体传送方式,而非一种新的媒体,是指采用流式传输的方式在Internet播放的媒体格式。可指大河,也可指小河或小溪,指小溪时与brook,creek同义。creek侧重其狭长蜿蜒,缓缓流动,且多流入大河或湖泊。brook侧重发源于山泉。creek和stream都比brook大。stream还可引申表示事物连绵不断。stream还可作动词,意为“流动,飘动”。常用作不及物动词,也可用作及物动词。 展开全文
Stream泛指流媒体技术。流媒体实际指的是一种新的媒体传送方式,而非一种新的媒体,是指采用流式传输的方式在Internet播放的媒体格式。可指大河,也可指小河或小溪,指小溪时与brook,creek同义。creek侧重其狭长蜿蜒,缓缓流动,且多流入大河或湖泊。brook侧重发源于山泉。creek和stream都比brook大。stream还可引申表示事物连绵不断。stream还可作动词,意为“流动,飘动”。常用作不及物动词,也可用作及物动词。
信息
外文名
Stream
基本解释
泛指流媒体技术
词    性
动词,名词
中文名
流媒体技术
stream英语单词
基本释义v. [striːm] ( streams; streamed; streaming )vt. & vi. 流; 移动 flow freely; move continuously and smoothly in one directionvi. 飘扬; 招展 float or wave (in the wind)词语要点1.stream的基本意思是“流动”,指受限制的流动,如通过一定的路线或出口。也可指大量不断地流动。引申可指“飘动”。2.stream既可用作及物动词,也可用作不及物动词。用作及物动词时,可接名词或代词作宾语。3.stream接介词with表示“被…覆盖”。词语搭配~+副词stream torrentially 激流涌进stream back 向后飘动stream in 络绎进入~+介词stream behind 在…后面飘动stream down one's cheeks (眼泪)从脸颊流下stream into the auditorium (人群)络绎不绝进入礼堂stream out of the station (人群)涌出车站stream with 被…覆盖辨析pour, flow, run, stream这组词的共同意思是“流”“流动”。其区别是:1.flow, run, stream和pour都可指液体流动; flow还可指气体流动; pour还可指光线、微粒等倾泻。2.时间上:flow一般指源源不断地、长时间地流动; run既可以是源源不断地、长时间地流动,也可以是流动一段时间; stream和pour多指短时间地流动。3.方向上:指液体流动时, flow是水平流动; run和stream既可水平流动,也可垂直流动; pour是垂直流动。4.流速上:从快到慢依次为pour, stream, run, flow。具体说就是flow是平平稳稳地流动; run比较湍急; stream比run更有力; pour则是“倾泻”。5.flow, stream和pour常用于比喻, run很少用于比喻。例如:The river was flowing quietly.河水静静流着。She let her hair down so that it flew darkly over her shoulders.她让乌黑的头发披散下来,飘垂到肩上。  The river runs through hills and fields.河水流经山冈和田野。The water runs out of the pipe into the bucket.水自管内注入水桶中。Tears were streaming down her face.她脸上热泪滚滚而下。The students streamed into the auditorium.学生们络绎不绝地进入礼堂。下面三句话的意思相同:She poured me a cup of tea.She poured a cup of tea for me.She poured me out a cup of tea.她给我倒了一杯茶。词源<古英语stream(流动)基本释义C 小河,溪流 a small river C 流,一股,一串 flow (of liquid, people, things, etc.)S 水流方向,潮流 current or direction of sth flowing or movingC (按能力分的)班级 class or division of a class into which children of the same age and level of ability are placedC 川流不息 a continuous series of people, things, or events, usually moving in a line or in a certain direction常见搭配动词+~cross a stream 涉过一条小溪tap a stream 引流形容词+~clear〔dancing, quiet, running〕 stream 清澈〔奔腾欢跳,平静,流动〕的溪流rapid〔strong〕 stream 湍急〔强劲〕的水流rushing stream 激流名词+~mountain stream 山涧sun streams 太阳光线介词+~in streams 连续不断,川流不息on stream 进行生产,投入生产up the stream 向〔在〕上游~+介词a stream of light 一缕光线a stream of words 滔滔不绝的话the stream of history 历史潮流词语辨析branch,brook,canal,creek,river,stream,torrent这组词的共同意思是“流水的通道”。其区别是:1.除canal指人工开挖的河流或渠道外,其余各词均指自然形成的水道。2.river和torrent均指流量较大的河流,river可泛指(自然形成的)江河;torrent则特指急流、湍流。这两个词还常用于比喻。3.stream可指大河,也可指小河或小溪,指小溪时与brook,creek同义。creek侧重其狭长蜿蜒,缓缓流动,且多流入大河或湖泊。brook侧重发源于山泉。creek和stream都比brook大。stream还可引申表示事物连绵不断。4.branch指江河的支流。同义词n. brook, course, flow, rush, streamlet [1] 
收起全文
精华内容
下载资源
问答
  • Java集合Stream类filter的使用

    万次阅读 多人点赞 2018-05-11 11:49:42
    之前的Java集合中removeIf的使用一文写了使用removeIf来实现按条件对集合进行过滤。这篇文章使用同样是JDK1.8新加入的Stream中filter方法来实现同样的效果。

    之前的Java集合中removeIf的使用一文写了使用removeIf来实现按条件对集合进行过滤。这篇文章使用同样是JDK1.8新加入的Streamfilter方法来实现同样的效果。并且在实际项目中通常使用filter更多。关于Stream的详细介绍参见Java 8系列之Stream的基本语法详解
    同样的场景:你是公司某个岗位的HR,收到了大量的简历,为了节约时间,现需按照一点规则过滤一下这些简历。比如要经常熬夜加班,所以只招收男性

    //求职者的实体类
    public class Person {
        private String name;//姓名
        private Integer age;//年龄
        private String gender;//性别
    
        ...
        //省略构造方法和getter、setter方法
        ...
    
        //重写toString,方便观看结果
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", gender='" + gender + '\'' +
                    '}';
        }
    }
    

    这里就不展示使用传统Iterator来进行过滤了,有需要做对比的可以参见之前的Java集合中removeIf的使用
    使用Streamfilter进行过滤,只保留男性的操作:

    Collection<Person> collection = new ArrayList();
    collection.add(new Person("张三", 22, "男"));
    collection.add(new Person("李四", 19, "女"));
    collection.add(new Person("王五", 34, "男"));
    collection.add(new Person("赵六", 30, "男"));
    collection.add(new Person("田七", 25, "女"));
    
    Stream<Person> personStream = collection.stream().filter(new Predicate<Person>() {
        @Override
        public boolean test(Person person) {
             return "男".equals(person.getGender());//只保留男性
        }
    });
    
    collection = personStream.collect(Collectors.toList());//将Stream转化为List
    System.out.println(collection.toString());//查看结果
    

    运行结果如下:

    [Person{name=‘张三’, age=22, gender=‘男’}, Person{name=‘王五’, age=34, gender=‘男’}, Person{name=‘赵六’, age=30, gender=‘男’}]
    Process finished with exit code 0

    上面的demo没有使用lambda表达式,下面的demo使用lambda来进一步精简代码:

    Collection<Person> collection = new ArrayList();
    collection.add(new Person("张三", 22, "男"));
    collection.add(new Person("李四", 19, "女"));
    collection.add(new Person("王五", 34, "男"));
    collection.add(new Person("赵六", 30, "男"));
    collection.add(new Person("田七", 25, "女"));
    
    Stream<Person> personStream = collection.stream().filter(
            person -> "男".equals(person.getGender())//只保留男性
    );
    
    collection = personStream.collect(Collectors.toList());//将Stream转化为List
    System.out.println(collection.toString());//查看结果
    

    效果和不用lambda是一样的。

    不过读者在使用filter时不要和removeIf弄混淆了:

    • removeIf中的test方法返回true代表当前元素会被过滤掉
    • filter中的test方法返回true代表当前元素会保留下来
    展开全文
  • Java8 Stream横空出世,让我们从繁琐冗长的迭代中解脱出来,集合数据操作变得优雅简洁。 这些操作:集合的filter(筛选)、归约(reduce)、映射(map)、收集(collect)、统计(max、min、avg)等等,一行代码即可...

    点波关注不迷路,一键三连好运连连!

    免费在线作图工具,点击邀请链接注册赠送7天会员:https://www.processon.com/i/5c51384de4b08a7683b99e16
    在这里插入图片描述

    先贴上几个案例,水平高超的同学可以挑战一下:

    1. 从员工集合中筛选出salary大于8000的员工,并放置到新的集合里。
    2. 统计员工的最高薪资、平均薪资、薪资之和。
    3. 将员工按薪资从高到低排序,同样薪资者年龄小者在前。
    4. 将员工按性别分类,将员工按性别和地区分类,将员工按薪资是否高于8000分为两部分。

    用传统的迭代处理也不是很难,但代码就显得冗余了,跟Stream相比高下立判。

    1 Stream概述

    Java 8 是一个非常成功的版本,这个版本新增的Stream,配合同版本出现的 Lambda ,给我们操作集合(Collection)提供了极大的便利。

    那么什么是Stream

    Stream将要处理的元素集合看作一种流,在流的过程中,借助Stream API对流中的元素进行操作,比如:筛选、排序、聚合等。

    Stream可以由数组或集合创建,对流的操作分为两种:

    1. 中间操作,每次返回一个新的流,可以有多个。
    2. 终端操作,每个流只能进行一次终端操作,终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。

    另外,Stream有几个特性:

    1. stream不存储数据,而是按照特定的规则对数据进行计算,一般会输出结果。
    2. stream不会改变数据源,通常情况下会产生一个新的集合或一个值。
    3. stream具有延迟执行特性,只有调用终端操作时,中间操作才会执行。

    2 Stream的创建

    Stream可以通过集合数组创建。

    1、通过 java.util.Collection.stream() 方法用集合创建流

    List<String> list = Arrays.asList("a", "b", "c");
    // 创建一个顺序流
    Stream<String> stream = list.stream();
    // 创建一个并行流
    Stream<String> parallelStream = list.parallelStream();
    

    2、使用java.util.Arrays.stream(T[] array)方法用数组创建流

    int[] array={1,3,5,6,8};
    IntStream stream = Arrays.stream(array);
    

    3、使用Stream的静态方法:of()、iterate()、generate()

    Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    
    Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
    stream2.forEach(System.out::println);
    
    Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
    stream3.forEach(System.out::println);
    

    输出结果:

    0 3 6 9
    0.6796156909271994
    0.1914314208854283
    0.8116932592396652

    streamparallelStream的简单区分: stream是顺序流,由主线程按顺序对流执行操作,而parallelStream是并行流,内部以多线程并行执行的方式对流进行操作,但前提是流中的数据处理没有顺序要求。例如筛选集合中的奇数,两者的处理不同之处:
    在这里插入图片描述
    如果流中的数据量足够大,并行流可以加快处速度。

    除了直接创建并行流,还可以通过parallel()把顺序流转换成并行流:

    Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();
    

    3 Stream的使用

    在使用stream之前,先理解一个概念:Optional

    Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。
    更详细说明请见:菜鸟教程Java 8 Optional类

    接下来,大批代码向你袭来!我将用20个案例将Stream的使用整得明明白白,只要跟着敲一遍代码,就能很好地掌握。
    在这里插入图片描述

    案例使用的员工类

    这是后面案例中使用的员工类:

    List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, "male", "New York"));
    personList.add(new Person("Jack", 7000, "male", "Washington"));
    personList.add(new Person("Lily", 7800, "female", "Washington"));
    personList.add(new Person("Anni", 8200, "female", "New York"));
    personList.add(new Person("Owen", 9500, "male", "New York"));
    personList.add(new Person("Alisa", 7900, "female", "New York"));
    
    class Person {
    	private String name;  // 姓名
    	private int salary; // 薪资
    	private int age; // 年龄
    	private String sex; //性别
    	private String area;  // 地区
    
    	// 构造方法
    	public Person(String name, int salary, int age,String sex,String area) {
    		this.name = name;
    		this.salary = salary;
    		this.age = age;
    		this.sex = sex;
    		this.area = area;
    	}
    	// 省略了get和set,请自行添加
    
    }
    

    3.1 遍历/匹配(foreach/find/match)

    Stream也是支持类似集合的遍历和匹配元素的,只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。
    在这里插入图片描述

    // import已省略,请自行添加,后面代码亦是
    
    public class StreamTest {
    	public static void main(String[] args) {
            List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
    
            // 遍历输出符合条件的元素
            list.stream().filter(x -> x > 6).forEach(System.out::println);
            // 匹配第一个
            Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
            // 匹配任意(适用于并行流)
            Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
            // 是否包含符合特定条件的元素
            boolean anyMatch = list.stream().anyMatch(x -> x < 6);
            System.out.println("匹配第一个值:" + findFirst.get());
            System.out.println("匹配任意一个值:" + findAny.get());
            System.out.println("是否存在大于6的值:" + anyMatch);
        }
    }
    

    3.2 筛选(filter)

    筛选,是按照一定的规则校验流中的元素,将符合条件的元素提取到新的流中的操作。
    在这里插入图片描述

    案例一:筛选出Integer集合中大于7的元素,并打印出来

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
    		Stream<Integer> stream = list.stream();
    		stream.filter(x -> x > 7).forEach(System.out::println);
    	}
    }
    

    预期结果:

    8 9

    案例二: 筛选员工中工资高于8000的人,并形成新的集合。 形成新集合依赖collect(收集),后文有详细介绍。

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Person> personList = new ArrayList<Person>();
    		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    		personList.add(new Person("Owen", 9500, 25, "male", "New York"));
    		personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
    
    		List<String> fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName)
    				.collect(Collectors.toList());
    		System.out.print("高于8000的员工姓名:" + fiterList);
    	}
    }
    

    运行结果:

    高于8000的员工姓名:[Tom, Anni, Owen]

    3.3 聚合(max/min/count)

    maxmincount这些字眼你一定不陌生,没错,在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法,极大地方便了我们对集合、数组的数据统计工作。
    在这里插入图片描述

    案例一:获取String集合中最长的元素。

    public class StreamTest {
    	public static void main(String[] args) {
    		List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
    
    		Optional<String> max = list.stream().max(Comparator.comparing(String::length));
    		System.out.println("最长的字符串:" + max.get());
    	}
    }
    

    输出结果:

    最长的字符串:weoujgsd

    案例二:获取Integer集合中的最大值。

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
    
    		// 自然排序
    		Optional<Integer> max = list.stream().max(Integer::compareTo);
    		// 自定义排序
    		Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
    			@Override
    			public int compare(Integer o1, Integer o2) {
    				return o1.compareTo(o2);
    			}
    		});
    		System.out.println("自然排序的最大值:" + max.get());
    		System.out.println("自定义排序的最大值:" + max2.get());
    	}
    }
    

    输出结果:

    自然排序的最大值:11
    自定义排序的最大值:11

    案例三:获取员工工资最高的人。

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Person> personList = new ArrayList<Person>();
    		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    		personList.add(new Person("Owen", 9500, 25, "male", "New York"));
    		personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
    
    		Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));
    		System.out.println("员工工资最大值:" + max.get().getSalary());
    	}
    }
    

    输出结果:

    员工工资最大值:9500

    案例四:计算Integer集合中大于6的元素的个数。

    import java.util.Arrays;
    import java.util.List;
    
    public class StreamTest {
    	public static void main(String[] args) {
    		List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
    
    		long count = list.stream().filter(x -> x > 6).count();
    		System.out.println("list中大于6的元素个数:" + count);
    	}
    }
    

    输出结果:

    list中大于6的元素个数:4

    3.4 映射(map/flatMap)

    映射,可以将一个流的元素按照一定的映射规则映射到另一个流中。分为mapflatMap

    • map:接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
    • flatMap:接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流。

    在这里插入图片描述
    在这里插入图片描述
    案例一:英文字符串数组的元素全部改为大写。整数数组每个元素+3。

    public class StreamTest {
    	public static void main(String[] args) {
    		String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
    		List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
    
    		List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
    		List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());
    
    		System.out.println("每个元素大写:" + strList);
    		System.out.println("每个元素+3:" + intListNew);
    	}
    }
    

    输出结果:

    每个元素大写:[ABCD, BCDD, DEFDE, FTR]
    每个元素+3:[4, 6, 8, 10, 12, 14]

    案例二:将员工的薪资全部增加1000。

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Person> personList = new ArrayList<Person>();
    		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    		personList.add(new Person("Owen", 9500, 25, "male", "New York"));
    		personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
    
    		// 不改变原来员工集合的方式
    		List<Person> personListNew = personList.stream().map(person -> {
    			Person personNew = new Person(person.getName(), 0, 0, null, null);
    			personNew.setSalary(person.getSalary() + 10000);
    			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<Person> personListNew2 = personList.stream().map(person -> {
    			person.setSalary(person.getSalary() + 10000);
    			return person;
    		}).collect(Collectors.toList());
    		System.out.println("二次改动前:" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());
    		System.out.println("二次改动后:" + personListNew2.get(0).getName() + "-->" + personListNew.get(0).getSalary());
    	}
    }
    

    输出结果:

    一次改动前:Tom–>8900
    一次改动后:Tom–>18900
    二次改动前:Tom–>18900
    二次改动后:Tom–>18900

    案例三:将两个字符数组合并成一个新的字符数组。

    public class StreamTest {
    	public static void main(String[] args) {
    		List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
    		List<String> listNew = list.stream().flatMap(s -> {
    			// 将每个元素转换成一个stream
    			String[] split = s.split(",");
    			Stream<String> s2 = Arrays.stream(split);
    			return s2;
    		}).collect(Collectors.toList());
    
    		System.out.println("处理前的集合:" + list);
    		System.out.println("处理后的集合:" + listNew);
    	}
    }
    

    输出结果:

    处理前的集合:[m-k-l-a, 1-3-5]
    处理后的集合:[m, k, l, a, 1, 3, 5]

    3.5 归约(reduce)

    归约,也称缩减,顾名思义,是把一个流缩减成一个值,能实现对集合求和、求乘积和求最值操作。
    在这里插入图片描述

    案例一:求Integer集合的元素之和、乘积和最大值。

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
    		// 求和方式1
    		Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
    		// 求和方式2
    		Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
    		// 求和方式3
    		Integer sum3 = list.stream().reduce(0, Integer::sum);
    		
    		// 求乘积
    		Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
    
    		// 求最大值方式1
    		Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
    		// 求最大值写法2
    		Integer max2 = list.stream().reduce(1, Integer::max);
    
    		System.out.println("list求和:" + sum.get() + "," + sum2.get() + "," + sum3);
    		System.out.println("list求积:" + product.get());
    		System.out.println("list求和:" + max.get() + "," + max2);
    	}
    }
    

    输出结果:

    list求和:29,29,29
    list求积:2112
    list求和:11,11

    案例二:求所有员工的工资之和和最高工资。

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Person> personList = new ArrayList<Person>();
    		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    		personList.add(new Person("Owen", 9500, 25, "male", "New York"));
    		personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
    
    		// 求工资之和方式1:
    		Optional<Integer> sumSalary = personList.stream().map(Person::getSalary).reduce(Integer::sum);
    		// 求工资之和方式2:
    		Integer sumSalary2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(),
    				(sum1, sum2) -> sum1 + sum2);
    		// 求工资之和方式3:
    		Integer sumSalary3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);
    
    		// 求最高工资方式1:
    		Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
    				Integer::max);
    		// 求最高工资方式2:
    		Integer maxSalary2 = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
    				(max1, max2) -> max1 > max2 ? max1 : max2);
    
    		System.out.println("工资之和:" + sumSalary.get() + "," + sumSalary2 + "," + sumSalary3);
    		System.out.println("最高工资:" + maxSalary + "," + maxSalary2);
    	}
    }
    

    输出结果:

    工资之和:49300,49300,49300
    最高工资:9500,9500

    3.6 收集(collect)

    collect,收集,可以说是内容最繁多、功能最丰富的部分了。从字面上去理解,就是把一个流收集起来,最终可以是收集成一个值也可以收集成一个新的集合。

    collect主要依赖java.util.stream.Collectors类内置的静态方法。

    3.6.1 归集(toList/toSet/toMap)

    因为流不存储数据,那么在流中的数据完成处理后,需要将流中的数据重新归集到新的集合里。toListtoSettoMap比较常用,另外还有toCollectiontoConcurrentMap等复杂一些的用法。

    下面用一个案例演示toListtoSettoMap

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
    		List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
    		Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
    
    		List<Person> personList = new ArrayList<Person>();
    		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    		
    		Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
    				.collect(Collectors.toMap(Person::getName, p -> p));
    		System.out.println("toList:" + listNew);
    		System.out.println("toSet:" + set);
    		System.out.println("toMap:" + map);
    	}
    }
    

    运行结果:

    toList:[6, 4, 6, 6, 20]
    toSet:[4, 20, 6]
    toMap:{Tom=mutest.Person@5fd0d5ae, Anni=mutest.Person@2d98a335}

    3.6.2 统计(count/averaging)

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

    • 计数:count
    • 平均值:averagingIntaveragingLongaveragingDouble
    • 最值:maxByminBy
    • 求和:summingIntsummingLongsummingDouble
    • 统计以上所有:summarizingIntsummarizingLongsummarizingDouble

    案例:统计员工人数、平均工资、工资总额、最高工资。

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Person> personList = new ArrayList<Person>();
    		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    
    		// 求总数
    		Long count = personList.stream().collect(Collectors.counting());
    		// 求平均工资
    		Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
    		// 求最高工资
    		Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
    		// 求工资之和
    		Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
    		// 一次性统计所有信息
    		DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
    
    		System.out.println("员工总数:" + count);
    		System.out.println("员工平均工资:" + average);
    		System.out.println("员工工资总和:" + sum);
    		System.out.println("员工工资所有统计:" + collect);
    	}
    }
    

    运行结果:

    员工总数:3
    员工平均工资:7900.0
    员工工资总和:23700
    员工工资所有统计:DoubleSummaryStatistics{count=3, sum=23700.000000,min=7000.000000, average=7900.000000, max=8900.000000}

    3.6.3 分组(partitioningBy/groupingBy)

    • 分区:将stream按条件分为两个Map,比如员工按薪资是否高于8000分为两部分。
    • 分组:将集合分为多个Map,比如员工按性别分组。有单级分组和多级分组。

    在这里插入图片描述

    案例:将员工按薪资是否高于8000分为两部分;将员工按性别和地区分组

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Person> personList = new ArrayList<Person>();
    		personList.add(new Person("Tom", 8900, "male", "New York"));
    		personList.add(new Person("Jack", 7000, "male", "Washington"));
    		personList.add(new Person("Lily", 7800, "female", "Washington"));
    		personList.add(new Person("Anni", 8200, "female", "New York"));
    		personList.add(new Person("Owen", 9500, "male", "New York"));
    		personList.add(new Person("Alisa", 7900, "female", "New York"));
    
    		// 将员工按薪资是否高于8000分组
            Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
            // 将员工按性别分组
            Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
            // 将员工先按性别分组,再按地区分组
            Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
            System.out.println("员工按薪资是否大于8000分组情况:" + part);
            System.out.println("员工按性别分组情况:" + group);
            System.out.println("员工按性别、地区:" + group2);
    	}
    }
    

    输出结果:

    员工按薪资是否大于8000分组情况:{false=[mutest.Person@2d98a335, mutest.Person@16b98e56, mutest.Person@7ef20235], true=[mutest.Person@27d6c5e0, mutest.Person@4f3f5b24, mutest.Person@15aeb7ab]}
    员工按性别分组情况:{female=[mutest.Person@16b98e56, mutest.Person@4f3f5b24, mutest.Person@7ef20235], male=[mutest.Person@27d6c5e0, mutest.Person@2d98a335, mutest.Person@15aeb7ab]}
    员工按性别、地区:{female={New York=[mutest.Person@4f3f5b24, mutest.Person@7ef20235], Washington=[mutest.Person@16b98e56]}, male={New York=[mutest.Person@27d6c5e0, mutest.Person@15aeb7ab], Washington=[mutest.Person@2d98a335]}}
    

    3.6.4 接合(joining)

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

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Person> personList = new ArrayList<Person>();
    		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    
    		String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
    		System.out.println("所有员工的姓名:" + names);
    		List<String> list = Arrays.asList("A", "B", "C");
    		String string = list.stream().collect(Collectors.joining("-"));
    		System.out.println("拼接后的字符串:" + string);
    	}
    }
    

    运行结果:

    所有员工的姓名:Tom,Jack,Lily
    拼接后的字符串:A-B-C

    3.6.5 归约(reducing)

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

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Person> personList = new ArrayList<Person>();
    		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    
    		// 每个员工减去起征点后的薪资之和(这个例子并不严谨,但一时没想到好的例子)
    		Integer sum = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));
    		System.out.println("员工扣税薪资总和:" + sum);
    
    		// stream的reduce
    		Optional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);
    		System.out.println("员工薪资总和:" + sum2.get());
    	}
    }
    

    运行结果:

    员工扣税薪资总和:8700
    员工薪资总和:23700

    3.7 排序(sorted)

    sorted,中间操作。有两种排序:

    • sorted():自然排序,流中元素需实现Comparable接口
    • sorted(Comparator com):Comparator排序器自定义排序

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

    public class StreamTest {
    	public static void main(String[] args) {
    		List<Person> personList = new ArrayList<Person>();
    
    		personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
    		personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
    		personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
    		personList.add(new Person("Lily", 8800, 26, "male", "New York"));
    		personList.add(new Person("Alisa", 9000, 26, "female", "New York"));
    
    		// 按工资升序排序(自然排序)
    		List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
    				.collect(Collectors.toList());
    		// 按工资倒序排序
    		List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
    				.map(Person::getName).collect(Collectors.toList());
    		// 先按工资再按年龄升序排序
    		List<String> newList3 = personList.stream()
    				.sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName)
    				.collect(Collectors.toList());
    		// 先按工资再按年龄自定义排序(降序)
    		List<String> newList4 = personList.stream().sorted((p1, p2) -> {
    			if (p1.getSalary() == p2.getSalary()) {
    				return p2.getAge() - p1.getAge();
    			} else {
    				return p2.getSalary() - p1.getSalary();
    			}
    		}).map(Person::getName).collect(Collectors.toList());
    
    		System.out.println("按工资升序排序:" + newList);
    		System.out.println("按工资降序排序:" + newList2);
    		System.out.println("先按工资再按年龄升序排序:" + newList3);
    		System.out.println("先按工资再按年龄自定义降序排序:" + newList4);
    	}
    }
    

    运行结果:

    按工资升序排序:[Lily, Tom, Sherry, Jack, Alisa]
    按工资降序排序:[Sherry, Jack, Alisa, Tom, Lily]
    先按工资再按年龄升序排序:[Lily, Tom, Sherry, Jack, Alisa]
    先按工资再按年龄自定义降序排序:[Alisa, Jack, Sherry, Tom, Lily]

    3.8 提取/组合

    流也可以进行合并、去重、限制、跳过等操作。
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    public class StreamTest {
    	public static void main(String[] args) {
    		String[] arr1 = { "a", "b", "c", "d" };
    		String[] arr2 = { "d", "e", "f", "g" };
    
    		Stream<String> stream1 = Stream.of(arr1);
    		Stream<String> stream2 = Stream.of(arr2);
    		// concat:合并两个流 distinct:去重
    		List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
    		// limit:限制从流中获得前n个数据
    		List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
    		// skip:跳过前n个数据
    		List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
    
    		System.out.println("流合并:" + newList);
    		System.out.println("limit:" + collect);
    		System.out.println("skip:" + collect2);
    	}
    }
    

    运行结果:

    流合并:[a, b, c, d, e, f, g]
    limit:[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
    skip:[3, 5, 7, 9, 11]

    好,以上就是全部内容,能坚持看到这里,你一定很有收获,那么动一动拿offer的小手,点个赞再走吧,听说这么做的人2021年都交了好运!

    展开全文
  • Stream和parallelStream

    万次阅读 多人点赞 2019-04-22 15:16:54
    Stream 和 parallelStream 一.什么是StreamStream 是在 Java8 新增的特性,普遍称其为流;它不是数据结构也不存放任何数据,其主要用于集合的逻辑处理。 二.和Iterator的区别 Iterator 做为迭代器,其按照一定的...

    Stream parallelStream

    一.什么是Stream?

    Stream 是在 Java8 新增的特性,普遍称其为流;它不是数据结构也不存放任何数据,其主要用于集合的逻辑处理。

    二.和Iterator的区别

    Iterator 做为迭代器,其按照一定的顺序迭代遍历集合中的每一个元素,并且对每个元素进行指定的操作。而 Stream 在此基础上还可以将这种操作并行化,利用多核处理器的优势快速处理集合(集合的数据会分成多个段,由多个线程处理)。

    Stream 的数据源可以有无限多个。

    三.Stream的使用

    在使用Stream之前,建义先理解接口化编程,Stream将完全依赖于接口化编程方式。接下来我们以“打印集合中的每一个元素”为例,了解一下 Stream 的使用。

    ​ 例3.1

    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9); 
    numbers.stream().forEach(num->System.out.println(num));
    
    输出:1 2 3 4 5 6 7 8 9
    

    由以上的列子可以看出,Stream 的遍历方式和结果与 Iterator 没什么差别,这是因为Stream的默认遍历是和迭代器相同的,保证以往使用迭代器的地方可以方便的改写为 Stream。

    Stream 的强大之处在于其通过简单的链式编程,使得它可以方便地对遍历处理后的数据进行再处理。我们以“对集合中的数字加1,并转换成字符串”为例进行演示。

    ​ 例3.2

    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);`
    
    `List<String> strs = numbers.stream()`
    
    `.map(num->Integer.toString(++num)).collect(Collectors.toList());
    

    其中map()方法遍历处理每一个元素,并且返回一个新的Stream,随后collect方法将操作后的Stream解析为List。

    Stream还提供了非常多的操作,如filter()过滤、skip()偏移等等,想要了解更多可以去翻阅JDK1.8手册或者相关资料。

    四.并行流parallelStream

    parallelStream提供了流的并行处理,它是Stream的另一重要特性,其底层使用Fork/Join框架实现。简单理解就是多线程异步任务的一种实现。

    我们用例3.1中的示例演示一下parallelStream的使用。

    ​ 例4.1

    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9); 
    numbers.parallelStream().forEach(num->System.out.println(num));
    
    输出:3 4 2 6 7 9 8 1 5
    

    我们发现,使用parallelStream后,结果并不按照集合原有顺序输出。为了进一步证明该操作是并行的,我们打印出线程信息。

    ​ 例4.2

       List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9); 
       numbers.parallelStream() .forEach(num-
       		>System.out.println(Thread.currentThread().getName()+">>"+num)); 
    

    输出:

    main>>6 
    ForkJoinPool.commonPool-worker-2>>8 
    main>>5 ForkJoinPool.commonPool-worker-2>>9 
    ForkJoinPool.commonPool-worker-1>>3 
    ForkJoinPool.commonPool-worker-3>>2 
    ForkJoinPool.commonPool-worker-1>>1 
    ForkJoinPool.commonPool-worker-2>>7 
    main>>4
    

    通过例4.2可以确信parallelStream是利用多线程进行的,这可以很大程度简化我们使用并发操作。

    我们可以通过虚拟机启动参数

    -Djava.util.concurrent.ForkJoinPool.common.parallelism=N

    来设置worker的数量。

    五.并行流的陷阱

    5.1.线程安全

    由于并行流使用多线程,则一切线程安全问题都应该是需要考虑的问题,如:资源竞争、死锁、事务、可见性等等。

    5.2.线程消费

    在虚拟机启动时,我们指定了worker线程的数量,整个程序的生命周期都将使用这些工作线程;这必然存在任务生产和消费的问题,如果某个生产者生产了许多重量级的任务(耗时很长),那么其他任务毫无疑问将会没有工作线程可用;更可怕的事情是这些工作线程正在进行IO阻塞。

    本应利用并行加速处理的业务,因为工作者不够反而会额外增加处理时间,使得系统性能在某一时刻大打折扣。而且这一类问题往往是很难排查的。我们并不知道一个重量级项目中的哪一个框架、哪一个模块在使用并行流。

    接下来我们对这个问题进行演示:

    ​ 例5.1

    定义两个并行流逻辑
    执行两个并行流
    输出:
    并行流竞争输出结果

    通过示例我们会发现,第一个并行流率先获得worker线程的使用权,第二个并行流变为串行;直到第14行,第一个并行流处理完毕,第二个并行流获取worker线程,开始并行处理。

    小结:

    串行流:适合存在线程安全问题、阻塞任务、重量级任务,以及需要使用同一事务的逻辑。

    并行流:适合没有线程安全问题、较单纯的数据处理任务。

    展开全文
  • Stream

    千次阅读 2016-12-30 14:39:30
    Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream,也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的 ...

    为什么需要Stream

    Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream,也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的 Stream 是对集合(Collection)对象功能的增强,它专注于对集合对象进行各种非常便利、高效的聚合操作(aggregate operation),或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式,极大的提高编程效率和程序可读性。同时它提供串行和并行两种模式进行汇聚操作,并发模式能够充分利用多核处理器的优势,使用 fork/join 并行方式来拆分任务和加速处理过程。通常编写并行代码很难而且容易出错, 但使用 Stream API 无需编写一行多线程的代码,就可以很方便地写出高性能的并发程序。所以说,Java 8 中首次出现的 java.util.stream 是一个函数式语言+多核时代综合影响的产物。

    @FunctionalInterface

    被这个注解标记的inteface可以用lambda表达式替代参数。

    Function<String, String> getAge = (s) -> s;
    Consumer<String> getAge2 = (s) -> {};
    Supplier<String> heh = () -> "a";

    Function和BiFunction对应1个入参和2个入参的
    lambda表达式也是这么对应的1个还是2个参数

    使用::

    java8可以用::产生lambda,不如:
    System.out::println
    String::concat

    ::有上下文这个概念,我理解的就是调用这个方法需不需要一个对象去调用。
    1.对于System.out::println,不需要上下文(可以直接调用,不需要对象去调用这个方法,因为System.out是static的,System.out.printn(a)),且println需要一个参数,那么System.out::println生成的lambda就是1个入参的,即() -> {}.
    2.对于String::concat,需要上下文,且concat方法需要一个参数,那么String::concat生成的lambda机会是2个入参的,即(a, b) -> {},需要的上下文即第一个参数的类型必须为::前面的类型或者子类。如果因为方法能给提供的参数类型和上下文需要的类型不一致也不对,会报Non-static method cannot be referenced from a static context。

    example

    List<String> list = Stream.of("1111", "222", "333", "4")
    .filter(e -> e.length() > 3)
    .peek(System.out::println)
    .map(ss -> ss.toUpperCase())
    .peek(e -> System.out.println("Mapped value: " + e))
    .collect(Collectors.toList());
    Set<String> widgets = new HashSet<>();
    widgets.add("1");
    widgets.add("2");
    widgets.add("3");
    widgets.add("4");
    String s = widgets.stream().collect(Collectors.joining(",", "(", ")"));
    Stream<List<Integer>> inputStream = Stream.of(
    Arrays.asList(1),
    Arrays.asList(2, 3),
    Arrays.asList(4, 5, 6)
    );
    Stream<Integer> outputStream = inputStream.flatMap((childList) -> childList.stream());

    参考

    https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/

    展开全文
  • C++编程语言中stringstream类介绍

    万次阅读 多人点赞 2018-09-10 23:20:54
    本文主要介绍 C++ 编程语言中 stringstream 类的相关知识,同时通过示例代码介绍 stringstream 类的使用方法。 1 概述 <sstream> 定义了三个类:istringstream、ostringstream 和 stringstream,分别用来...
  • Java 8 stream的详细用法

    万次阅读 多人点赞 2019-01-08 23:12:43
    Stream 是 Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询。也可以...
  • 对于中间操作和终端操作的定义,请看《JAVA8 stream接口 中间操作和终端操作》,这篇主要讲述的是stream的count,anyMatch,allMatch,noneMatch操作,我们先看下函数的定义 long count(); boolean anyMatch...
  • Java 8 Stream常用方法学习

    万次阅读 多人点赞 2021-01-21 09:21:11
    Stream Stream流是 Java8 API 新增的一个处理集合的关键抽象概念,是一个来自数据源的元素队列并支持聚合操作。以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对...
  • java.util.stream.Stream

    千次阅读 2020-03-22 20:21:38
    Stream
  • Java8新特性Stream之list转map及问题解决

    万次阅读 多人点赞 2018-10-11 14:57:44
    List集合转Map,用到的是Stream中Collectors的toMap方法:Collectors.toMap 具体用法实例如下: //声明一个List集合 List&amp;lt;Person&amp;gt; list = new ArrayList(); list.add(new Person(&...
  • stream().map()方法详解

    万次阅读 多人点赞 2020-11-04 17:16:46
    使用Stream流时发现其中的map方法使用不好容易理解,以一个小案例详细探讨Stream中map的使用。 案例涉及知识点: 1、Stream中of方法传入可变参数 2、Stream中map元素类型转化方法 3、Function匿名接口,自定义类匿名...
  • list去重,根据对象某个属性、某几个属性... List unique = list.stream().distinct().collect(Collectors.toList()); 去除List中重复的对象 // Person 对象 public class Person { private String id; ...
  • Java8 stream 之groupingBy() 分组排序

    万次阅读 热门讨论 2017-12-29 12:06:37
    List matchsList = new ArrayList();... MatchsListMap = matchsList.stream() .collect(Collectors.groupingBy(Matchs::getMatchDate)); 此时MatchsListMap的排序规则是根据MatchDate降序的(默认),也就是说ma
  • Stream API

    万次阅读 2020-03-29 19:04:13
    Java8新特性--操作集合Stream API
  • Arrays.stream()

    万次阅读 多人点赞 2018-12-09 15:04:55
    为什么需要 Stream Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream,也不是 Amazon Kinesis 对大数据实时处理的 ...
  • 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的某些元素进行...
  • JAVA8 Stream接口,map操作,filter操作,flatMap操作

    万次阅读 多人点赞 2018-06-10 17:22:18
    这篇,我们来看Stream的一些中间操作,关于中间操作的一些介绍,可以看《JAVA8 stream接口 中间操作和终端操作》 1,filter操作,我们先看方法的定义 Stream<T> filter(Predicate<? super T> ...
  • Java8 Stream

    千次阅读 多人点赞 2021-01-25 18:44:18
    简单认识Java stream Java8出了一个stream流式编程,在开发中或多或少用到接触过。怎么说呢!举个例子把,一起我们在遍历一个集合的时候,我们是从外部去遍历的,然后才能拿到结果,这样来效率就会变得相对低一点。...
  • JDK新特性——Stream代码简洁之道

    千次阅读 多人点赞 2020-10-24 12:17:54
    Stream 是一组用来处理数组、集合的API,Stream API 提供了一种高效且易于使用的处理数据的方式。 Java 8 中之所以费这么大的功夫引入 函数式编程 ,原因有两个: 代码简洁函数式编程写出的代码简洁且意图明确,...
  • Arrays.streamStream.of

    千次阅读 2020-08-24 19:59:20
    在 java8 中,您可以使用 Arrays.StreamStream.of 将 Array 转换为 Stream。 对象数组 对于对象数组,Arrays.streamStream.of 都返回相同的输出。 private static void ObjectArrays() { String[] array...
  • Java Stream从精通到陌生

    万次阅读 2020-04-12 17:36:09
    一.Stream是什么,为什么用它 Stream 是数据渠道,用于操作数据源生成的元素序列,集合讲的是数据,流讲的是计算,就像粮食加工厂一样 粮食就是集合,加工厂就是Stream,对粮食进行一系列的操作。 用来以 做什么而非...
  • 最近使用Apache poi 做excel导出的功能,遇到了如下问题: ...Your stream was neither an OLE2 stream, nor an OOXML stream 起初对比其他的web工程,没有发现如何解决。最后找到抛出此异常的源码: or...
  • java8 stream常用方法

    万次阅读 多人点赞 2019-05-20 15:50:04
    什么是 Stream Stream 中文称为“流”,通过将集合转换为这么一种叫做 “流” 的元素序列,通过声明性方式,能够对集合中的每个元素进行一系列并行或串行的流水线操作。 二. 流操作 整个流操作就是一条流水线...
  • Lambda表达式&Stream

    千人学习 2020-12-17 21:31:55
    该课程基于最新的java14平台,由浅入深的详细讲解了Lambda表达式/Stream/函数式接口/Optional类的使用,本课程属于java技术的进阶课程。
  • Stream是Java8新引入的API,有着广泛的运用 创建一个Stream Stream创建之后,就不能修改 创建一个空的Stream StreamString> streamEmpty = Stream.empty(); 一般的,我们用如下这种写法避免空指针异常 ...
  • Stream 求和

    万次阅读 2017-07-30 17:17:28
    Stream 求和
  • java Stream 和 parallelStream比较

    万次阅读 2018-02-11 13:27:28
    java 8 有一个新的特性就是流,其中stream和parallelStream就是一种流的处理方式,前者是单管,后者是多管道,在性能上做一个对比看看两者的差别。 首先写一个方法,用来生成一个大小为60000的list: public ...
  • collection.stream()以及collect()方法

    万次阅读 多人点赞 2018-08-06 20:57:00
    stream()方法和collect()方法都是java8的新特性 工作的时候看到同事写的代码有点不懂,故搜索 List&lt;String&gt; widgetIds = widgets.stream().map(Widget::getWidgetId).collect(Collectors.toList())...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 968,364
精华内容 387,345
关键字:

stream