Stream流

1. 流式思想

微信截图_20200520094759.png

2. Stream流的简单尝试

• 传统for循环遍历的方法

import java.util.ArrayList;
import java.util.List;
/*
    使用传统的方式对集合中的元素进行过滤
    需求：
        1.过滤以y开头的字符串
        2.长度大于5
*/
public class Demo01List {
    public static void main(String[] args) {
        //创建一个list集合
        List<String> list = new ArrayList<>();
        list.add("yorick");
        list.add("lucy");
        list.add("yoyo");
        list.add("tom");
        list.add("youraka");
        //过滤以y开头的字符串存入listA中
        List<String> listA = new ArrayList<>();
        for (String s : list) {
            if(s.startsWith("y")){
                listA.add(s);
            }
        }
        //过滤长度大于5的字符串存入listB中
        List<String> listB = new ArrayList<>();
        for (String s : listA) {
            if(s.length()>5){
                listB.add(s);
            }
        }
        //打印结果
        for (String s : listB) {
            System.out.println(s);
        }
    }
}

• Steam流的方式

import java.util.ArrayList;
import java.util.List;
/*
    使用Stream流的方式遍历集合，对集合中的数据进行过滤
    关注的是做什么，而不是怎么做
*/
public class Demo02Stream {
    public static void main(String[] args) {
        //创建一个list集合
        List<String> list = new ArrayList<>();
        list.add("yorick");
        list.add("lucy");
        list.add("yoyo");
        list.add("tom");
        list.add("youraka");

        //过滤以y开头的字符串存入listA中
        //过滤长度大于5的字符串存入listB中
        //打印结果
        list.stream()
                .filter(name->name.startsWith("y"))
                .filter(name->name.length()>5)
                .forEach(name-> System.out.println(name));

    }
}

3. 获取stream流

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

/*
    获取Stream流的两种方式：
        1.Collection集合可以通过stream默认方法获取流
        2.Stream接口的静态方法of可以获取数组对应的流
 */
public class Demo03GetStream {
    public static void main(String[] args) {
        //1. Collection集合转换为stream流
        //List集合
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

        //Set集合
        Set<String> set = new HashSet<>();
        Stream<String> stream2 = set.stream();

        //Map集合间接获取stream流
        Map<String,String> map = new HashMap<>();
        //key流
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();
        //value流
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();
        //entry流
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();

        //2.把数组转换为stream流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        //可变参数
        String[] strings = {"a","bb","ccc"};
        Stream<String> stream7 = Stream.of(strings);
    }

4. stream常用方法
   • 延迟方法 和终结方法（延迟方法返回的类型仍然是Stream接口自身类型，可以支持链式调用；终结方法不再返回Stream接口自身类型，不再支持链式调用，终结方法包括count和forEach方法）
   • Stream流属于管道流，只能被消费(使用)一次。第一个Stream流调用完毕方法，数据就会流转到下一个Stream上，而这是第一个Stream流已经使用完毕，就会关闭不能再调用方法了。

• forEach方法

import java.util.stream.Stream;

/*
    Stream常用方法forEach
    该方法接收一个Consumer接口函数，将流中每个元素交给该函数进行处理

    简单记：
        forEach方法，用来遍历流中的数据
        是一个终结方法，后面不可以继续调用Stream流中的其他方法
 */
public class Demo04ForEach {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("yorick", "tom", "jerry");
        stream.forEach(name-> System.out.println(name));
    }

• filter方法

import java.util.stream.Stream;

/*
    Stream流中的常用方法filter，用于对stream流中的数据进行过滤
    filter方法的参数Predicate是一个函数式接口，用于对数据过滤
 */
public class Demo05Filter {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("yorick", "tom", "jerry", "youraka");
        Stream<String> stream2 = stream.filter(name -> name.startsWith("y"));
        stream2.forEach(name-> System.out.println(name));
    }

• map方法

import java.util.stream.Stream;

/*
    Stream流常用方法map,用于将流中的元素映射到另一个流中。
    该接口需要Function函数式接口参数，可以将当前流中的T类型转换为另一种R类型的流
 */
public class Demo06Map {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("1", "2", "3");
        Stream<Integer> integerStream = stream.map(strNum -> Integer.parseInt(strNum));
        integerStream.forEach(num-> System.out.println(num));
    }
}

• count方法

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

/*
    Stream流中的常用方法count，用于统计Stream流中元素的个数
    count方法是一个终结方法，返回值为long类型，不能继续调用Stream流中的其他方法
 */
public class Demo07Count {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

• limit方法

import java.util.stream.Stream;

/*
    Stream流的常用方法limit，用于截取流中的元素。
    limit方法可以对流进行截取，只取前n个。
    limit方法是延迟方法，可以返回一个新的流，继续调用Stream流中的其他方法
 */
public class Demo08Limit {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("yorick", "tom", "jerry");
        Stream<String> limitStream = stream.limit(2);
        limitStream.forEach(name-> System.out.println(name));
    }
}

• skip方法

import java.util.stream.Stream;

/*
    Steam流中的常用方法skip，用于跳过前n个元素
    若流的当前长度大于n，则跳过前n个元素，否则会得到一个长度为0的空流
 */
public class Demo09Skip {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("yorick", "tom", "jerry");
        Stream<String> skipStream = stream.skip(2);
        skipStream.forEach(name-> System.out.println(name));
    }
}

• concat静态方法

import java.util.stream.Stream;

/*
    Stream流中的常用方法Concat，用于把流组合到一起。
    若希望将两个流合并为一个流，可以使用Stream接口中的静态方法concat
 */
public class Demo10Concat {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("yorick", "tom", "jerry");
        Stream<String> stream2 = Stream.of("torasa", "jackson");
        Stream<String> concatStream = Stream.concat(stream1, stream2);
        concatStream.forEach(name-> System.out.println(name));
    }

• 练习

传统for循环方法

import java.util.ArrayList;

/*
    练习：集合元素处理(传统)
    现有两个ArrayList集合存储多个姓名，使用传统for循环处理集合
    1.listA 只要4个字母以上的，存储到一个新集合
    2.listA 只要其中的前2个，存储到新的集合
    3.listB 只要以y开头的，纯粹到新集合
    4.listB 筛选后不要前两个，存储新集合
    5.将两集合合并
    6.根据姓名创建Person对象，并存储到新集合
    7.打印

 */
public class Demo11StreanTestTraditional {
    public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        listA.add("tom");
        listA.add("smith");
        listA.add("jerry");
        listA.add("amanda");
        listA.add("bob");
        //1.listA 只要4个字母以上的，存储到一个新集合
        ArrayList<String> one1 = new ArrayList<>();
        for (String s : listA) {
            if(s.length()>4){
                one1.add(s);
            }
        }
        //2.listA 只要其中的前2个，存储到新的集合
        ArrayList<String> one2 = new ArrayList<>();
        for(int i=0 ;i<2 ; i++){
            one2.add(one1.get(i));
        }

        ArrayList<String> listB = new ArrayList<>();
        listB.add("yourka");
        listB.add("yoyo");
        listB.add("torasa");
        listB.add("yorick");
        listB.add("tomcat");
        //3.listB 只要以y开头的，纯粹到新集合
        ArrayList<String> two1 = new ArrayList<>();
        for (String s : listB) {
            if(s.startsWith("y")){
                two1.add(s);
            }
        }
        //4.listB 筛选后不要前两个，存储新集合
        ArrayList<String> two2 = new ArrayList<>();
        for(int i=2 ; i<two1.size() ; i++){
            two2.add(two1.get(i));
        }

        //5.将两集合合并
        ArrayList<String> allList = new ArrayList<>();
        allList.addAll(one2);
        allList.addAll(two2);
        //6.根据姓名创建Person对象，并存储到新集合
        ArrayList<Person> personList = new ArrayList<>();
        for (String s : allList) {
            personList.add(new Person(s));
        }
        //7.打印
        for (Person person : personList) {
            System.out.println(person);
        }
    }
}

stream流的方式处理

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

/*
    练习：集合元素处理(stram流)
    现有两个ArrayList集合存储多个姓名，使用传统for循环处理集合
    1.listA 只要4个字母以上的，存储到一个新集合
    2.listA 只要其中的前2个，存储到新的集合
    3.listB 只要以y开头的，纯粹到新集合
    4.listB 筛选后不要前两个，存储新集合
    5.将两集合合并
    6.根据姓名创建Person对象，并存储到新集合
    7.打印

 */
public class Demo12StreamTest {
    public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        listA.add("tom");
        listA.add("smith");
        listA.add("jerry");
        listA.add("amanda");
        listA.add("bob");
        //1.listA 只要4个字母以上的，存储到一个新集合
        //2.listA 只要其中的前2个，存储到新的集合
        Stream<String> listAStream = listA.stream().filter(name -> name.length() > 4).limit(2);

        ArrayList<String> listB = new ArrayList<>();
        listB.add("yourka");
        listB.add("yoyo");
        listB.add("torasa");
        listB.add("yorick");
        listB.add("tomcat");
        //3.listB 只要以y开头的，纯粹到新集合
        //4.listB 筛选后不要前两个，存储新集合
        Stream<String> listBStream = listB.stream().filter(name -> name.startsWith("y")).skip(2);

        //5.将两集合合并
        //6.根据姓名创建Person对象，并存储到新集合
        //7.打印
        Stream.concat(listAStream,listBStream).map(name->new Person(name)).forEach(person-> System.out.println(person));
    }
}