栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java8新特性之Stream

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java8新特性之Stream

文章目录
  • Stream是什么?
  • 如何操作Stream


Stream是什么?

Stream API (java.util.stream)把真正的函数式编程风格引入到Java中,这是目前为止对Java类库最好的补充,因为Stream API可以极大提供Java程序员的生产力,让程序员写出高效、干净、简洁的代码、
Stream是Java8中处理集合的关键抽象概念,它可以指定你对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作,就类似于使用SQL执行的数据库查询。也可以使用Stream API来执行操作。简言之,Stream API提供了一种高效且易于使用的处理数据的方式。

是数据渠道,用于操作数据源(集合,数组等)所生成的元素序列。
“集合讲的是数据,Stream讲的是计算!”

注意

  1. Stream自己不会存储元素。
  2. Stream不会改变该源对象,相反,他们会返回一个持有结果的新Stream。
  3. Stream操作是延迟执行的,这意味着他们会等到需要结果的时候才执行。
如何操作Stream

三个步骤:

  1. 创建Stream (四种方法) 常用前两个
import ming.lambda.Cat;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;


public class StreamDemo1 {
//    Stream实例化 
    
//    一、通过集合
    @Test
    public void test1(){
        //1. 利用List的stream() : 返回一个顺序流
        List catList = CatData.getCatList();
        Stream stream = catList.stream();

        //2. List中的parallelStream() : 返回一个并行流
        Stream stream1 = catList.parallelStream();
    }

//   二、 通过数组
    @Test
    public void test2(){
        //1. 利用Arrays类的static Stream stream(T[] array): 返回一个流
        int[] arr=new int[]{1,2,3,4,5,6};
        IntStream stream = Arrays.stream(arr);
        
        Cat cat1 = new Cat();
        Cat cat2 = new Cat();
        Cat[] cats = new Cat[]{cat1,cat2};
        Stream stream1 = Arrays.stream(cats);
    }

//    三、Stream的of()
    @Test
    public void test3(){
        Stream stream = Stream.of(1, 2, 3, 4, 5, 6);
    }

//    四、创建无限流  (用于造数据)
    @Test
    public void test4(){
        //迭代 public static Stream iterate(final T seed, final UnaryOperator f){}
        //遍历前10个偶数
        Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);

        //生成 public static Stream generate(Supplier s){}
        //遍历生成前10个随机数
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
}
  1. 中间操作
    三种类型
    (1)筛选与切片
    (2)映射
    (3)排序
    前期准备
import ming.lambda.Cat;      //自己定义Cat实体类
import java.util.ArrayList;
import java.util.List;


public class CatData {
    public static List getCatList(){
        List cats = new ArrayList<>();
        cats.add(new Cat( "cat1",  1,  "bule",  1400));
        cats.add(new Cat( "cat2",  2,  "red",  1500));
        cats.add(new Cat( "cat3",  3,  "yellow",  4000));
        cats.add(new Cat( "cat4",  4,  "bule",  2000));
        cats.add(new Cat( "cat5",  1,  "bule",  2500));
        cats.add(new Cat( "cat6",  2,  "bule",  1600));
        cats.add(new Cat( "cat10",  3,  "orange",  2100));
        cats.add(new Cat( "cat11",  4,  "bule",  1900));
        return cats;
    }
}

import ming.lambda.Cat;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;


public class StreamDemo2 {
//    Stream的中间操作
    //1.筛选与切片
    @Test
    public void test1(){
        List list = CatData.getCatList();
        //filter :  Stream filter(Predicate predicate) --接收lambda,从流中排除某些元素
        //查找小猫价格大于2000的猫
        Stream stream = list.stream();
        stream.filter(cat -> cat.getPrice()>2000).forEach(System.out::println);

        System.out.println();
        //limit(n)  -截断流,使其元素不超过给定的数量
        list.stream().limit(3).forEach(System.out::println);

        System.out.println();
        //skip(n) -跳过元素
        list.stream().skip(3).forEach(System.out::println);

        System.out.println();
        //distinct --筛选
        list.add(new Cat("cat9",1,"bule",2000));
        list.add(new Cat("cat9",1,"bule",2000));
        list.add(new Cat("cat9",1,"bule",2000));
        list.add(new Cat("cat9",1,"bule",2000));
//        System.out.println(list); //出现重复元素
//        list.stream().distinct().forEach(System.out::println);   //需要重写hashcode与equals
    }

    //2.映射
    @Test
    public void test2(){
        //1.   Stream map(Function mapper);  映射   相当于add()
        List list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str->str.toUpperCase()).forEach(System.out::println);

        System.out.println();
        //获取Cat name名字长度大于4的Cat名字
        List list1 = CatData.getCatList();
        Stream nameStream = list1.stream().map(Cat::getName);
        nameStream.filter(name->name.length()>4).forEach(System.out::println);   //cat10,cat11
        System.out.println();

        //练习2: 遍历每个元素
        Stream> streamStream = list.stream().map(StreamDemo2::fromStringTOStream);
        streamStream.forEach(s->{
            s.forEach(System.out::println);
        });
        System.out.println();

        //2.   Stream flatMap(Function> mapper);  相当于addAll()
        //利用flatMap 简化 练习2 遍历每个元素
        list.stream().flatMap(StreamDemo2::fromStringTOStream).forEach(System.out::println);
    }

    //将字符串中的多个字符构成的集合转换成对应的Stream的实例
    public static Stream fromStringTOStream(String str){
        ArrayList list = new ArrayList<>();
        for (Character c:str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

    @Test
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        ArrayList list1 = new ArrayList();
        list1.add(4);
        list1.add(5);
        list1.add(6);
//        list.add(list1);  // [1, 2, 3, [4, 5, 6]]
        list.addAll(list1);  // [1, 2, 3, 4, 5, 6]
        System.out.println(list);
    }

//    3.排序
    @Test
    public void test4(){
       //1.sorted() --自然排序
        List list = Arrays.asList(12, 59, 0, -20, 10, 30);
        list.stream().sorted().forEach(System.out::println);

        //抛出异常 ClassCastException: ming.lambda.Cat cannot be cast to java.lang.Comparable
//        List list1 = CatData.getCatList();
//        list1.stream().sorted().forEach(System.out::println);
        System.out.println();
        //2. sorted(Comparator com)  --定制排序
        List list1 = CatData.getCatList();
        list1.stream().sorted((cat1,cat2)->{
            return Integer.compare(cat1.getAge(),cat2.getAge());
        }).forEach(System.out::println);

    }
}
  1. 终止操作
    三种类型
    (1)匹配与查找
    (2)规约
    (3)收集
import ming.lambda.Cat;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;


public class StreamDemo3 {
    //1. 匹配与查找
    @Test
    public void test1(){
        List catList = CatData.getCatList();
        //allMatch() :boolean allMatch(Predicate predicate);
        //是否所有的Cat的价格都大于2000
        boolean allMatch = catList.stream().allMatch(cat -> cat.getPrice() > 2000);
        System.out.println(allMatch);  //false
        System.out.println();

        //anyMatch() :boolean anyMatch(Predicate predicate);
        //是否存在的Cat的价格大于2000
        boolean anyMatch = catList.stream().anyMatch(cat -> cat.getPrice() > 2000);
        System.out.println(anyMatch); //true
        System.out.println();

        //noneMatch() :boolean noneMatch(Predicate predicate);  检查是否没有匹配的元素
        //是否没有Cat的价格大于5000
        boolean noneMatch = catList.stream().noneMatch(cat -> cat.getPrice() > 5000);
        System.out.println(noneMatch);  //true
        System.out.println();

        //findFirst() :Optional findFirst();
        //返回第一个元素
        Optional first = catList.stream().findFirst();
        System.out.println(first);
        System.out.println();

        //findAny() :Optional findAny();
        //返回第一个元素
        Optional any = catList.stream().findAny();
        System.out.println(first);
        System.out.println();

        //count() :long count();
        //返回大于2000的个数
        long count = catList.stream().filter(cat -> cat.getPrice() > 2000).count();
        System.out.println(count);
        System.out.println();

        //max() :Optional max(Comparator comparator);
        //返回最高价格
        Stream priceStream = catList.stream().map(cat -> cat.getPrice());
        Optional max = priceStream.max((cat1price, cat2price) -> Double.compare(cat1price,cat2price));
        System.out.println(max);
        System.out.println();

        //min() :Optional min(Comparator comparator);
        //返回最低价格的Cat
        Optional min = catList.stream().min((cat1, cat2) -> Double.compare(cat1.getPrice(), cat2.getPrice()));
        System.out.println(min);
        System.out.println();

        //forEach() : 遍历
        catList.stream().forEach(System.out::println);
    }

    //2. 规约
    @Test
    public void test2(){

        //reduce() :T reduce(T identity, BinaryOperator accumulator);
        //计算1到10的和
        List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);
        System.out.println();

        //reduce() :Optional reduce(BinaryOperator accumulator);
        //计算Cat的价格总和
        List catList = CatData.getCatList();
        Stream priceStream = catList.stream().map(cat -> cat.getPrice());
        Optional priceSum = priceStream.reduce(Double::sum);
        System.out.println(priceSum);
        System.out.println();

    }

    //3. 搜集
    @Test
    public void test3(){
        //collect() :将流转换成其他形式
        //查找价格大于2000的Cat 并放入Set/List
        List catList = CatData.getCatList();
        Stream catStream = catList.stream().filter(cat -> cat.getPrice() > 2000);
        List list = catStream.collect(Collectors.toList());  //toSet()/toCollection()
        list.forEach(System.out::println);
        System.out.println();
    }
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/956783.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号