Stream流的介绍

stream流的作用：

针对集合进行功能的简化开发

package com.itheima.demo1;

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

public class StreamDemo1 {
    public static void main(String[] args) {
        //集合
        List<String> list = new ArrayList<>();
        //存储元素
        list.add("张三疯");
        list.add("张三");
        list.add("熊大");
        list.add("张小小");

        //使用Stream流
        list.stream()
                .filter(name -> name.startsWith("张"))
                .filter(name -> name.length() == 3)
                .forEach(name -> System.out.println(name));

        /* 集合的传统解决方案：
         *  1、遍历list集合
         *     for(String name : list){
         *     2、判断元素是否以"张"开头 ：  是 就把元素存储到另一个集合
         *     if(name.startWith("张")){
         *        新集合.add(元素)
         *     }
         *   }
         *  3、遍历 存储"张"开头的集合
         *  4、判断元素(字符串)的长度 == 3    是  就把元素存储到另一个集合
         *
         * */
    }
}

stream流的使用通常是要配合lambda表达式

Stream流的思想

类似于生产流水线的思想

过滤操作，剩余输出

获取Stream方法（创建一条流水线，把数据都放在流水线上准备工作）-中间方法（流水线上的操作，一次操作完成以后，还可以去继续进行其他操作）- 终结操作（一个stream流只有一个终结方法）

Stream 流方法的分类

1.获取方法(创建一个流水线)

2.中间方法（过滤，截取）

3.终结方法（关闭流水线）

获取Stream流对象

//单列集合

（Collection接口中的默认方法stream（）生成流）

Collection（List ， set）

//双列集合

Map

先通过keyset和entryset获取到set集合

不能直接获取流对象

//数组

Stream 流对象  =  Arrays.stream

//特殊的操作

package com.itheima.demo1;

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

public class StreamDemo1 {
    public static void main(String[] args) {
        //集合
        List<String> list = new ArrayList<>();
        //存储元素
        list.add("张三疯");
        list.add("张三");
        list.add("熊大");
        list.add("张小小");

        //使用Stream流
        list.stream()
                .filter(name -> name.startsWith("张"))
                .filter(name -> name.length() == 3)
                .forEach(name -> System.out.println(name));

        /* 集合的传统解决方案：
         *  1、遍历list集合
         *     for(String name : list){
         *     2、判断元素是否以"张"开头 ：  是 就把元素存储到另一个集合
         *     if(name.startWith("张")){
         *        新集合.add(元素)
         *     }
         *   }
         *  3、遍历 存储"张"开头的集合
         *  4、判断元素(字符串)的长度 == 3    是  就把元素存储到另一个集合
         *
         * */
    }
}

package com.itheima.demo2;

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

//演示： 获取Stream流对象
public class StreamDemo1 {
    //Stream流的特殊操作： 把同一种类型的多个元素，转Stream流
    public static void method4(){
        Stream<String> stream = Stream.of("java", "mysql", "html");
    }


    //数组 => Stream流
    public static void method3(){
        Integer[] array ={1,2,3,4,5};

        //获取数组的Stream流对象
        Stream stream = Arrays.stream(array);

        System.out.println(stream);
    }

    //双列集合 => Stream流
    public static void method2(){
        Map<String,String> map = new HashMap<>();
        map.put("java","java基础");
        map.put("mysql","mysql入门");

        //获取Map集合的Stream流（不能直接获取）
        Stream<Map.Entry<String, String>> stream = map.entrySet().stream();

    }


    //单列集合 => Stream流
    public static void method1() {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "熊大", "能二", "光头强");

        //获取List集合的Stream流对象
        Stream<String> stream = list.stream();
        System.out.println(stream);
    }


    public static void main(String[] args) {
        method3();
    }
}


package com.itheima.demo3;

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

public class StreamDemo1 {
    public static void main(String[] args) {
        //集合
        List<String> list = new ArrayList<>();
        //存储元素
        list.add("张三疯");
        list.add("张三");
        list.add("熊大");
        list.add("张小小");

        //获取集合中所有的姓张的元素，并打印
//        Stream<String> stream1 = list.stream();
//        Stream<String> stream2 = stream1.filter(name -> name.startsWith("张"));
//        stream2.forEach( name -> System.out.println(name) );
        list.stream()
                .filter(name -> name.startsWith("张"))
                .forEach(name -> System.out.println(name));
    }
}


package com.itheima.demo4;

import java.util.ArrayList;
import java.util.List;

public class StreamDemo {
    public static void main(String[] args) {
        //集合
        List<String> list = new ArrayList<>();
        //存储元素
        list.add("张三疯");
        list.add("张三");
        list.add("熊大");
        list.add("张小小");

        //演示： 中间方法 limit
        list.stream()
                .skip(1) //指定跳过多少个数据
                .limit(2) //截取指定个数的数据
                .forEach(name-> System.out.println(name));

    }
}



package com.itheima.demo5;

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

public class StreamDemo {
    public static void main(String[] args) {
        //集合
        List<String> list1 = new ArrayList<>();
        //存储元素
        list1.add("张三疯");
        list1.add("张三");
        list1.add("张小小");

        List<String> list2 = new ArrayList<>();
        Collections.addAll(list2, "光头强", "张小小", "张老板");

        //第1个流对象
        Stream<String> stream1 = list1.stream();
        //第2个流对象
        Stream<String> stream2 = list2.stream();

        //合并流
        Stream<String> newStream = Stream.concat(stream2, stream1);


        newStream
                .distinct() //去除流中的重复元素（注意细节：流中存储的是自定义对象时，在自定义对象中要重写：hashCode、equals）
                .forEach(name -> System.out.println(name));
    }
}




package com.itheima.demo6;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

public class StreamDemo {
    public static void main(String[] args) {
        //集合
        List<User> list =new ArrayList<>();
        //集合中存储的元素是：User对象
        list.add(new User("张三"));

        list.stream()
                .map(user -> new SuperMan(user.getName()))//把User类型元素，转换为SuperMan类型元素
                .forEach(obj -> System.out.println(obj));


    }
}


package com.itheima.demo6;

public class SuperMan {
    private String name;

    public SuperMan() {
    }

    public SuperMan(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "SuperMan{" +
                "name='" + name + '\'' +
                '}';
    }
}



package com.itheima.demo6;

public class User {
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}


package com.itheima.demo7;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class StreamDemo {
    public static void main(String[] args) {
        //集合
        List<Integer> list = new ArrayList<>();
        //存储元素
        Collections.addAll(list, 8,3,9,2,6);

        //使用stream流对集合进行排序
        list.stream()
                .sorted() //默认排序方式：自然排序
                .forEach(num -> System.out.print(num+"\t"));

        System.out.println();

        list.stream()
                .sorted( (num1,num2) -> num2-num1 ) //指定了比较器排序
                .forEach(num -> System.out.print(num+"\t"));

    }
}