【Java-Stram】

---

Stram

---

* stream处理数据大体过程

数组/集合类 --> 流 --各种操作(排序,过滤)–> 结果(数组/集合类)
*数组合集合类更偏向于存储数据(各种结构)

Stram更偏向于数据操作(处理数据)

import java.util.Arrays;

public class Demo2 {
    public static void main(String[] args) {
         /*
        流操作：
        1.获取流，把集合/数组转换为Stram对象

        2.流的操作分为：
           中间操作:流的各种数据处理
           终端操作: 把流转为最終绐果(鼗組/集合/单值)
         */

        Integer[] array = new Integer[]{1,2,3,4,2,5};
        Arrays.stream(array)
                .skip(4) //跳过指定数量个元素
                .limit(2)//取出指定数量个元素
                .forEach((e)->{
                    System.out.println(e);
    });
        /*Arrays.stream(array)
               .filter((e)->{ //过滤
                   return e<5;
               })
               .sorted((o1,o2)->{  //排序 默认是升序 我们可以自定义排序规则
                   return o2-o1;
               })
               .distinct() //去重
               .forEach((e)->{ //遍历
                   System.out.println(e);
               });*/
    }
}

import java.util.Arrays;

public class Demo3 {
 /*
        流操作：
        1.获取流，把集合/数组转换为Stram对象

        2.流的操作分为：
           中间操作:流的各种数据处理
           filter:过滤流中的某些元素，
           sorted():自然排序，流中元素需实现 Comparable 接口
           distinct: 去除重复元素
           limit(n):获取n 个元素
           skip(n):跳过n 元素，配合 limit(n)可实现分页
           map()
           终端操作: 把流转为最終绐果(鼗組/集合/单值)
           Min:返回流中元素最小值
           Max:返回流中元素最大值
           count:返回流中元素的总个数
           Reduce:所有元素求和
           anyMatch:按收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true. 否则返回 false
           allMatch:按收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true.否则返网 false
           findFirst:返回流中第一个元素
         */
 public static void main(String[] args) {
     Integer[] array = new Integer[]{1,2,3,4,2,5};

     /*boolean result = Arrays.stream(array)
           .distinct()
           .anyMatch((e)->{ //只要有一个元素满足条件，返回true
               return e>2;
           });
     System.out.println(result);*/
    /* boolean result = Arrays.stream(array)
           .distinct()
           .allMatch((e)->{ //所有的元素都满足条件，返回true
               return e>=1;
           });
     System.out.println(result);*/

     Integer result = Arrays.stream(array)
           .distinct()
           .findFirst()
           .get();
     System.out.println(result);

    /*Integer max = Arrays.stream(array)
            .distinct()
            .max((o1,o2)->{
                return o1-o2;
            }).get();
     System.out.println(max);*/
     /*Integer min = Arrays.stream(array)
             .distinct()
             .min((o1,o2)->{
                 return o1-o2;
             }).get();
     System.out.println(min);*/
    /* long count = Arrays.stream(array)
           .distinct()
           .count(); //统计元素个数
     System.out.println(count);*/
    /* Arrays.stream(array)
           .distinct()
           .reduce((a,b)->{
               return a+b;
           }).get();*/
 }

}

示例

public class Student {
    private int num;
    private String name;
    private int age;

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

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    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;
    }
}
import java.awt.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Demo4 {
    public static void main(String[] args) {
        Student s1 = new Student(101, "张三1", 18);
        Student s2 = new Student(102, "张三2", 19);
        Student s3 = new Student(103, "张三3", 20);
        Student s4 = new Student(104, "张三4", 21);
        Student s5 = new Student(105, "张三5", 22);

        ArrayList<Student> students = new ArrayList<>();
        students.add(s2);
        students.add(s1);
        students.add(s4);
        students.add(s3);
        students.add(s5);

       /*List<Student> students1 = students.stream()
                .sorted((stu1,stu2)->{ //对学生对象集合进行排序，必须给定排序规则
                    return stu1.getNum()-stu2.getNum();
                }).collect(Collectors.toList());
        System.out.println(students1);*/

        /*List<Student> students1 = students.stream()
                .filter((stu)->{
                    return stu.getAge()>18;
                }).collect(Collectors.toList());
        System.out.println(students1);*/
        /*List<Student> students1 = students.stream()
                .filter((stu)->{
                    return stu.getAge()>18;
                }).collect(Collectors.toList());
        System.out.println(students1.toString());*/
        /*Object[] array = students.stream()
                                 .map(Student::getNum)
                                 .toArray();
        System.out.println(Arrays.toString(array));*/
        /*List list = students.stream()
                .map(Student::getNum)//将对象中某个属性的值 映射到一个新的集合中
                .collect(Collectors.toList());
        System.out.println(list);*/
        Map<Integer,String> map = students.stream()
                .collect(Collectors.toMap(Student::getNum,Student::getName));
        System.out.println(map);
    }

}