Stream流，方法引用

 

Stream流的思想：流水线思想，先拼接一个流式模型生产线

Stream操作的基础特征：1.Pipelining ：中间操作返回流对象本身

                                   2.内部迭代

可以用stream流来简化容器的相关操作

 

获取stream流的方式：java.util.Stream<T>      jdk8之后出现

1.Collection接口中的默认方法stream()  适用于单列集合

2.Stream接口静态of方法获取数组对应的流

 

延迟方法：还是返回Stream接口类型，支持链式调用

终结方法：不再返回Stream接口类型

1．Stream流中数据遍历forEach，forEach中传入Consumer消费型函数接口，无返回值，该方法是终结方法

2. 过滤filter：filter方法中传入Predicate接口（判断型的接口），接口的抽象方法返回true就不会被过滤掉.该方法返回stream

 

Stream流的特点：属于管道流，只能被使用一次

第一个Stream流调用完毕方法，数据就会流到下一个Stream上

所以第一个Stream流不能再调用方法。例如：

package demo1;

import java.util.stream.Stream;
public class StreamText {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张三", "里斯", "王五", "非得非","张三丰");
        stream.forEach(name-> System.out.println(name));//不可以有两个，forEach只能出现一次
        Stream<String> stream1 = stream.filter(name -> name.startsWith("张"));
        stream1.forEach(name-> System.out.println(name));

    }
}

控制台：Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed

3．Stream流中的映射方法：map

map传入Function转换型接口，把一种数据转换为另外一种数据

package demo1;

 import java.util.stream.Stream;
 
 public class Streamap {
     public static void main(String[] args) {
         Stream<String> stream = Stream.of("1", "2", "3");//获取一个string的stream流
         Stream<Integer> integerStream = stream.map(s -> Integer.parseInt(s)); //map方法将string类型转为int
         integerStream.forEach(integer -> System.out.println(integer)); //遍历新的stream流
     }
 }

 

4.Stream方法count，统计流中元素个数，返回long类型的整数。该方法是终结方法

5.Stream方法limit：对流进行截取，只取前n个。传入long类型数，返回新的流

package demo1;

import java.util.stream.Stream;
public class StramLinmit {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5");
        Stream<String> limit = stream.limit(3);
        limit.forEach(s-> System.out.print(s));
    }
}

6.Stream方法 skip 跳过前几个

Stream<T> skip(long n);  跳过前几个，得到新的流，如果传入的数大于流实际长度，返回长度为0的流

7.Stream静态方法concat，合并两个流

static<T> Stream<T> concat(Stream<?extends T> a, Stream<?extends T> b)

注意：两个流里面的数据类型必须一致

package demo1;

import java.util.stream.Stream;

public class StreamConcat {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("小赵", "小钱", "小孙", "小李");
        String[] arr = {"张三","里斯","王五","小牛","二狗"};
        Stream<String> stream1 = Stream.of(arr);
        Stream<String> concat = Stream.concat(stream, stream1);
        concat.forEach(s-> System.out.print(s));
    }
}

8.Stream的sorted自然排序；还可以再sorted中传入comparator比较器接口自定义排序

Stream<T> sorted(Comparator<? super T> comparator)

package demo1;

import java.util.stream.Stream;

public class StreamSorted {
    public static void main(String[] args) {
        Stream<Integer> integerStream = Stream.of(123, 45, 6, 65, 4, 44, 5);
        integerStream.sorted((a,b)->b-a).forEach(i-> System.out.println(i));
    }
}

 

9.Stream的toArray()

 

练习：集合元素处理方式

 

package demo1;

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

public class EndText {
    public static void main(String[] args) {
        ArrayList<String> one = new ArrayList<>();
        one.add("张三");
        one.add("里斯人");
        one.add("王五");
        one.add("庄子");
        one.add("老子发");
        one.add("墨子肉");
        //名字长度为3后的集合，且只要前三个名字
        Stream<String> oneStream = one.stream().filter(name->name.length() == 3).limit(3);

        ArrayList<String> two = new ArrayList<>();
        two.add("老钱");
        two.add("张三丰");
        two.add("张芈月");
        two.add("狄仁杰");
        two.add("百里守约");
        two.add("张二狗");
        Stream<String> twoStream = two.stream().filter(name->name.startsWith("张")).skip(2);
        //以张开头的名字的集合，且不要前两个
        Stream.concat(oneStream,twoStream).map(name->new Person(name)).forEach(person -> System.out.println(person));
        //以两个集合合并在一起，变为以名字为属性的Person类的集合
    }
}

方法引用

::引用运算符

1.     通过对象名引用成员方法

对象名 :: 成员方法

新建一个MethodObject类

package methodreference;

public class MethodObject {
    public void printUpperCaseString(String str){
        System.out.println(str.toUpperCase());
    }
}

 

新建一个接口类

package methodreference;

@FunctionalInterface
public interface Printable {
    void print(String s);
}

 

来一个测试类

package methodreference;

public class Demo1Text {
    public static void main(String[] args) {
        //调用printString方法，方法参数Printable是函数式接口，可以lambda
        printString((s)->{
            //使用MethodObject类对象的方法将字母变为大写
            MethodObject obj = new MethodObject();
            obj.printUpperCaseString(s);
        });
        
        /*使用方法调用优化lambda
        * 对象已经存在
        * 成员方法也已经存在
        * 所以可以使用方法引用用对象名引用成员方法
        * */
        MethodObject obj = new MethodObject();
        printString(obj::printUpperCaseString);
    }

    public static void printString(Printable p){
        p.print("hello");
    }
}

 

2.通过类名引用静态方法

条件：类已经存在，静态方法也已经存在

 

接口类：

package methodreference;

@FunctionalInterface
public interface Calcable {
   int calsABs(int number);
}

测试类：

package methodreference;

public class MethodClass {
    public static void main(String[] args) {
        int num = method(-10,Math::abs);
        System.out.println(num);
    }

    public static int method(int number,Calcable cal){
        return cal.calsABs(number);
    }
}

 

通过super引用父类的成员方法

super::父类的方法

 

通过this引用本类的成员方法

this::成员方法

 

特殊用法：

1类的构造器（构造方法）引用   

类名::new

 

2数组的构造器引用 ：需要数组长度已知，

数据类型[] :: new

静态方法只能使用类名引用不可以使用对象名引用

 

 

更多文章请扫描下面二维码

 

微信扫一扫
关注该公众号