4.7学习总结 - 技术栈

java学习

一.Stream流

(一.)概念:

Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。Stream流是对集合（Collection）对象功能的增强，与Lambda表达式结合，可以提高编程效率、间接性和程序可读性。

特点:

stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。

stream不会改变数据源，通常情况下会产生一个新的集合或一个值。

stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。

(二.)Stream的创建

1.Collection集合创建

List<Integer> integerList = new ArrayList<>();
Collection.addAll(integerList,1,2,3,4,5);        
Stream<Integer> listStream = integerList.stream();

2.Stream创建对象

List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();  //串行流
Stream<String> parallelStream = list.parallelStream(); //并行流

3.Arrays数组创建

int[] Arr = {1, 2, 3, 4, 5};
IntStream arrayStream = Arrays.stream(Arr);

(三.)操作符

1.中间操作符

中间操作会返回一个新的流，一个流可以后面跟随零个或多个中间操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后会返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。而是在终结操作开始的时候才真正开始执行。

public class stream4 {
    public static void main(String[] args) {
        //中间方法,返回新的steam流,原来的stream流只能使用一次
        //修改stream流中的数据,不会改变原来集合中的元素

        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张三","张三疯","喜洋洋","美洋洋","柳如烟","李四");

        //1.filter 过滤作用
        list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(s-> System.out.println(s));
        System.out.println("--------------------------------");
        //2.skip 跳过元素
        list.stream().skip(3).forEach(s-> System.out.println(s));
        System.out.println("--------------------------------");
        //3.limit 获取前几个元素
        list.stream().limit(3).forEach(s-> System.out.println(s));
        System.out.println("--------------------------------");
        //4.获取中间的两元素的方法:
        //1.仙截取后跳过
        list.stream().limit(4).skip(2).forEach(s-> System.out.println(s));
        System.out.println("--------------------------------");
        //2.仙跳过后截取
        list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));
        System.out.println("--------------------------------");
    }
}

运行结果:

2.终结操作符

终结操作是指返回最终的结果。一个流只能有一个终结操作，当这个操作执行后，这个流就被使用"光"了，无法再被操作。所以这必定这个流的最后一个操作 。只有终结操作执行的时候，才会真正开始流的遍历，并且会生成一个结果。

(四.)使用实例

要求将一组数据中,对大于一定年龄的人放入到map集合中,并进行输出

public class TEXT2 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张三,12","李四,15","王五,16");

        //匿名内部类的写法
        Map<String, Integer> map = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 15).collect(Collectors.toMap(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.split(",")[0];
            }
        }, new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s.split(",")[1]);
            }
        }));
        System.out.println(map);
        System.out.println("---------------------------");

        //lambda表达式写法
        Map<String, String> map2 = list.stream()
                .filter(s -> Integer.parseInt(s.split(",")[1]) >= 15)
                .collect(Collectors.toMap(s -> s.split(",")[1],
                        s -> s.split(",")[0]));
        System.out.println(map2);
        System.out.println("----------------------------");
    }
}

运行结果:

二.方法引用

(一.)方法引用的概念和规则

方法引用:把已经有的方法拿过来用,当做函数式接口中抽象方法的方法体.

方法引用的规则:

1.需要具有函数式接口

2.被引用的方法必须存在.

3.被引用的方法和返回值和形参与抽象方法一致.

4.被引用方法的功能要满足当前需求.

(二.)引用静态方法

格式:类名::静态方法

引用类方法，其实就是引用类的静态方法

public class yinyong {
    public static void main(String[] args) {
        ArrayList<String> list =new ArrayList<>();
        Collections.addAll(list,"1","2","3","15564222","126");

        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                Integer i = Integer.parseInt(s);
                return i;
            }
        }).forEach(s-> System.out.println(s));
        System.out.println("-------------------");

        //1.方法需要已经存在
        //2.方法的形参和返回值需要跟抽象方法的形参和返回值一样
        //3.方法的功能需要吧形参的字符串转换成整数
        list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));
    }
}

(三).引用成员方法

格式:对象::成员方法

引用对象的实例方法，其实就引用类中的成员方法

public class StringOperation {
    public boolean stringJudge(String s) {
        return s.startsWith("张");
    }
}

public class yinyong2 {
    public static void main(String[] args) {
        ArrayList<String> list =new ArrayList<>();
        Collections.addAll(list,"张三","李四","王五","张飞","客小二");
        //通过在其他类中进行引用
        //先创建对象,在进行引用
        list.stream()
                .filter(new StringOperation()::stringJudge)
                .forEach(s-> System.out.println(s));
    }
}

(四.)引用构造器

格式:类名::构造方法

(注意构造方法中的形参必须和抽象方法保持一致)

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

    public Student(String s) {
        String[] arr=s.split(",");
        this.name=arr[0];
        this.age=Integer.parseInt(arr[1]);
    }

    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;
    }
}

public class yinyong3 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张三,15","李四,16","王五,17");
        List<Student> cc = list.stream().map(Student::new).collect(Collectors.toList());
        System.out.println(cc);
    }
}