Java Stream流

1Stream流

1.1Stream流初体验

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)->{
            return name.startsWith("张");
        }).filter(name->name.length()==3).forEach((name)-> System.out.println(name));
    }
}

1.2Stream流的三类方法

• 获取Stream流
  • 创建一条流水线，并把数据放到流水线上准备进行操作
• 中间方法
  • 流水线上的操作。
  • 一次操作完毕之后，还可以继续进行其他操作
• 终结方法
  • 一个Stream流只能有一个终结方法
  • 是流水线上的最后一个操作

1.3Stream流的获取方法

• 单列集合
  • 可以使用Collection接口中的默认方法stream()生成流
    default Stream stream()
• 双列集合
  • 双列集合不能直接获取 , 需要间接的生成流
    可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流
• 数组
  • Arrays中的静态方法stream生成流

   public class StreamDemo2 {
    public static void main(String[] args) {
        //单列集合
        List<String> list =new ArrayList<>();
        list.add("string");
        //双列集合
        Map<String,String> map =new HashMap<>();
        map.put("双列","集合");
        //数组
        int[] arr={1,2,3,4,5};

        //单列集合的流
        Stream<String> s1=list.stream();

        //双列集合的流
        Set<Map.Entry<String,String>> entries=map.entrySet();
        Stream<Map.Entry<String, String>> s2 = entries.stream();

        //数组的流
        IntStream s3=Arrays.stream(arr);//使用Arrays工具类中的静态方法：stream( int[] )
        //使用Stream类中提供的静态方法（把多个相同类型的元素，转换为Stream流对象）
        Stream<Integer> s4=Stream.of(11,22,33,44,55);
    }
}

1.4Stream流的中间方法

• Stream filter(Predicate predicate)：用于对流中的数据进行过滤
  • Predicate接口中的方法 : boolean test(T t)：对给定的参数进行判断，返回一个布尔值
• Stream limit(long maxSize)：截取指定参数个数的数据
• Stream skip(long n)：跳过指定参数个数的数据
• static Stream concat(Stream a, Stream b)：合并a和b两个流为一个流
• Stream distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
• Stream sorted () : 将流中元素按照自然排序的规则排序
• Stream sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序

public class StreamDemo3 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        //把多个元素，添加到list集合中
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7);
        //Stream流，推荐：链式写法
        list.stream().filter((num)->num>5).forEach(num-> System.out.println(num));
        System.out.println("--------------------------------------------------------");
        //1、把集合转换为Stream流对象
        Stream<Integer> s1 =list.stream();
        Stream<Integer> s2 =s1.filter(num->num>5);
        s2.forEach(num-> System.out.println(num));
    }
}
//limit foreach
public class StreamDemo4 {
    public static void main(String[] args) {
        //集合
        List<Integer> list = new ArrayList<>();
        //把多个元素，添加到list集合中
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7);

        //截取集合中的部分元素
        list.stream().limit(3).forEach(num-> System.out.println(num));
    }
}

//skip
public class StreamDemo5 {
    //演示：Stream流操作元素的方法 skip
    public static void main(String[] args) {
        //集合
        List<Integer> list = new ArrayList<>();
        //把多个元素，添加到list集合中
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7);

        //截取Stream流中的元素
        list.stream()
                .skip(3)//跳过指定个数的元素数量，截取后续的元素
                .forEach(num -> System.out.println(num));

    }
}
//流的合并(contact)
public class StreamDemo6 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        //把多个元素，添加到list集合中
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7);

        //数组
        Integer[] arr = {8,9,10};

        //把集合和数组中的元素合并在一起
        Stream<Integer> s1 =list.stream();
        Stream<Integer> s2 = Arrays.stream(arr);
        //使用Stream类中的静态方法：concat  合并两个stream流
        Stream<Integer> newStream= Stream.concat(s1,s2);
        newStream.forEach(num -> System.out.println(num));
    }
}
//distinct
public class StreamDemo7 {
    //演示：对流中的元素进行去重
    public static void main(String[] args) {
        //集合
        List<Integer> list = new ArrayList<>();
        //把多个元素，添加到list集合中
        Collections.addAll(list, 1, 2, 3, 2, 5, 3, 6, 4, 7);

        list.stream()
                .distinct() //对流中的元素进行去重
                .forEach(num -> System.out.println(num));
    }
}
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

public class StreamDemo8 {
    //演示：对流中的元素进行去重
    public static void main(String[] args) {
        //集合
        List<Student> studentList = new ArrayList<>();

        //添加学生
        studentList.add(new Student("张三",22));
        studentList.add(new Student("李四",24));
        studentList.add(new Student("张三",22));
        studentList.add(new Student("王五",25));
        studentList.add(new Student("李四",23));

        //去除集合中重复元素
        studentList.stream()
                .distinct()//针对自定义类型元素，去重时：要保障自定义类型元素有重写hashCode()、equals()
                .forEach(student -> System.out.println(student));
    }
}

public class StreamDemo9 {
    public static void main(String[] args) {
        //集合
        List<String> list = new ArrayList<>();
        //集合中添加元素
        Collections.addAll(list, "张三", "李四");

        //把集合中的元素类型,从String类型,转换为Student类型
        list.stream() //Stream流中都是String类型元素
                .map(name->new Student(name))
                .forEach(student-> System.out.println(student));
    }
}
public class StreamDemo10 {
    public static void main(String[] args) {
        //集合
        List<String> list = new ArrayList<>();
        //集合中添加元素
        Collections.addAll(list, "shanghai", "beijing");

        //需求: 把集合中所有的元素转换为大写
        list.stream()
                .map(city->city.toUpperCase())
                .forEach(city-> System.out.println(city));
    }
}
//sort
public class StreamDemo11 {
    public static void main(String[] args) {
        //集合
        List<Integer> list = new ArrayList<>();
        //把多个元素，添加到list集合中
        Collections.addAll(list, 11, 2, 13, 42, 15, 6, 7);


        //需求: 针对集合中小于30的元素进行排序
        list.stream()
                .filter(num->num<30)
                .sorted()
                .forEach(num-> System.out.println(num));
    }
}

public class StreamDemo2 {
    //演示：Stream流中的排序(降序)
    public static void main(String[] args) {
        //集合
        List<Integer> list = new ArrayList<>();
        //把多个元素，添加到list集合中
        Collections.addAll(list, 11, 2, 13, 42, 15, 6, 7);


        //需求: 针对集合中小于30的元素进行排序
//        sorted(new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return 0;
//            }
//        })
        list.stream()
                .filter(num -> num < 30)//过滤掉值大于30的元素
                .sorted( (num1, num2) -> num2-num1)//降序（元素自身默认的排序规则不适合，需要改变排序规则。 使用比较器）
                .forEach(num -> System.out.println(num));
    }
}