Java Stream流及其方法使用

﹏ヽ暗。殇╰゛Y 2021-11-23 07:30 308阅读 0赞

## （一）概述 ##

过去我们在遍历一个数组的时候，使用的是循环的方式，但是，仔细想想，我们我们为什么一定要用for 循环，或者是while循环呢？我们的目的是得到数组中的某些，或者全部内容，而我们是通过for循环的方式去获取的，换言之，for循环只是过程，他并不是必须的，我们只需要得到结果，中间的过程我们可以不在乎。因此，便出现了Java Stream的方式，它是类似于生产线，流的方式去处理。

*  核心思想： 它关注的是要做什么，而不是怎么做

## （二）如何获取流 ##

Stream 是1.8 加入的常用接口，不是函数式接口

*  获取流的方式：  
    所有的Collection 集合都可以通过stream默认方法获得，  
    default Stream stream()  
    stream的静态方法of可以获得对应数组的流  
    staticStream of

代码：

public class Stream_huoqu {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            Stream<String> stream1 = list.stream();
            Set<String> set = new HashSet<>();
            Stream<String> stream2 = set.stream();
            //map,我们可以通过间接的方式，将其转化为Stream流
            //转换键
            Map<String,String> map = new HashMap();
            Set<String> keySet = map.keySet();
            Stream<String> stream3 = keySet.stream();
            //转换值
            Collection<String> values = map.values();
            Stream<String> stream4 = values.stream();
            //转换键值对
            Set<Map.Entry<String, String>> entries = map.entrySet();
            Stream<Map.Entry<String, String>> stream5 = entries.stream();
            //把数组转换为Stream
            Stream<Integer> stream6 = Stream.of(1,2,3,4,5,6);
            Integer[] arr ={1,2,3,4,5,6};
            Stream<Integer> stream7 = Stream.of(arr);
            String[] arr2 = {"a","b","c","d","e"};
            Stream<String> stream8 = Stream.of(arr2);
        }
    }

## (三)Stream中的方法 ##

**1）foreach 方法**  
     是一个终结方法

*  foreach(consumer)  
    所谓的终结方法就是一旦使用这个方法之后，就不能再使用这个流了。

**2）filter方法**  
     专递的是Predicate 函数接口，是一个判断的接口 这个接口中，有抽象方法test(T t) 主要用来判断，过滤。

**3) map 方法**  
     映射方法,中传的是Function 接口,使用map方法把字符串类型的数据，映射为Integer的数据

**4)limit方法**  
     是一个延时方法，返回一个新的流  
 **5)skip 方法**  
     跳过前几个数据

**6）concat方法**  
     组合方法，可以把两个流 合并成为一个流,是一个静态方法

代码：

import java.util.ArrayList;
    import java.util.stream.Stream;
    
    /*
    * 用来遍历流中的数据
    * foreach 是一个终结方法
    *
    *   foreach(consumer<T>)
    * */
    public class Stream_foreach {
        public static void main(String[] args) {
    
            //foreach 方法 终结方法， 使用之后，就不能使用其他流方法
            //因为传的接口是consumer 接口，而stream流，是管道流，只能消费一次，
            //所以消费一次之后，不能在进行第二次消费。
            Stream<String> stream = Stream.of("张三", "李四", "王五","张无忌","周芷若");
    //        stream.forEach(s-> System.out.println(s));
    
            //Predicate 函数接口，是一个判断的接口
            //其中有抽象方法test(T t)
            Stream<String> stream1 = stream.filter(s->s.startsWith("张"));
            stream1.forEach(s-> System.out.println(s));
    
            //map 方法，映射方法
            //其中传的是Function 接口
            //使用map方法把字符串类型的数据，映射为Integer的数据
            System.out.println("===================================");
            Stream<String> stream2 = Stream.of("1", "2", "3", "4", "5");
            Stream<Integer> stream3 = stream2.map(s->Integer.parseInt(s));
            stream3.forEach(s-> System.out.println(s));
    
            System.out.println("=================");
            //count方法 用于统计流中元素的个数
            //Long count 是一个终结方法
            ArrayList<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            list.add(4);
            list.add(5);
            list.add(6);
            list.add(7);
            Stream<Integer> stream4 = list.stream();
            long count1 = stream4.count();
            System.out.println(count1
            );
    
    
    //        limit方法 是一个延时方法，返回一个新的流
            String[] arr = {"美羊羊","喜洋洋","懒洋洋","灰太狼"};
            Stream<String> stream5 = Stream.of(arr);
            Stream<String> stream6 = stream5.limit(3);//截取前三个数据
            stream6.forEach(s-> System.out.println(s));
            System.out.println("===========================");
            //skip 方法，跳过前几个方法
            Stream<String> stream7 = Stream.of(arr);
            Stream<String> stream8 = stream7.skip(3);
            stream8.forEach(s-> System.out.println(s));
    
    
            //组合方法 concat 可以把两个流 合并成为一个流,是一个静态方法
            String[] arr2 = {"美羊羊","喜洋洋","懒洋洋","灰太狼"};
            Stream<String> stream10 = Stream.of(arr);
            Stream<String> stream9 = Stream.of("张三", "李四", "王五","张无忌","周芷若");
            Stream<String> con = Stream.concat(stream10,stream9);
            con.forEach(s-> System.out.println(s));
    
    
        }
    }

输出姓张的并且名字长度是3的人的名字

代码：

import java.util.ArrayList;
    import java.util.List;
    public class Stram_List_gaishu {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("张无忌");
            list.add("周芷若");
            list.add("赵敏");
            list.add("张量");
            list.add("张三丰");
    
            list.stream().filter(s->s.startsWith("张"))
                        .filter(s->s.length()==3)
                        .forEach(s-> System.out.println(s));
    
        }
    }

第一组数据，找出名字长度为3的前三个和第二组数据姓张的人的非前两个数据组合，并且用这些姓名产生一个新Person对象，输出最后的Person信息。

代码

主类

import java.util.ArrayList;
    import java.util.List;
    import java.util.stream.Stream;
    
    public class Stream_jihe {
    
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("迪丽热巴");
            list.add("赵敏");
            list.add("张三");
            list.add("李四");
            list.add("二狗");
            list.add("王二麻子");
            list.add("周芷若");
            Stream<String> stream = list.stream();
            Stream<String> stream1 = stream.filter(s->s.length()==3).limit(3);
    //        stream1.forEach(s-> System.out.println(s));
    
            List<String> list1 = new ArrayList<>();
            list1.add("张三");
            list1.add("王五");
            list1.add("建国");
            list1.add("国安");
            list1.add("张四");
            list1.add("张无忌");
            list1.add("张三丰");
    
            Stream<String> stream2 = list1.stream();
            Stream<String> stream3 = stream2.filter(s->s.startsWith("张")).skip(2);
    //        stream3.forEach(s-> System.out.println(s));
            Stream.concat(stream1,stream3).map(s->new Person(s)).forEach(s-> System.out.println(s));
    
        }
    }

Person类：

public class Person {
        private String name;
    
        public Person() {
    
        }
    
        public Person(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }