Lambda表达式&接口更新&方法引用&函数式接口&Stream流

已于 2022-07-08 11:37:04 修改
阅读量565 收藏
点赞数 1
分类专栏： JavaSE 文章标签： java 开发语言
于 2022-06-30 00:32:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63016041/article/details/125481978
版权

Lambda表达式&接口更新&方法引用&函数式接口&Stream流

Lambda

1.程序启动三种不同的表现形式

1.正常静态代理启动

2.匿名内部类启动

3.Lambda表达式启动

package com.xm.lambda;

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("程序启动---正常静态代理启动");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //正常启动
        new Thread(new MyRunnable()).start();
        //匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("程序启动---匿名内部类");
            }
        }).start();
        //无参 lambda
        new Thread(()-> System.out.println("程序启动---Lambda")).start();
    }
}

2.Lambda表达式的标准格式

  • 格式：(形式参数)->{代码块}

  • 形式参数：如果由多个参数，参数之间用逗号隔开，没有参数留空即可

  • ->：固定写法，代表指向动作

  • 代码块：是我们具体要做的事情，也就是以前我们写方法题内容

3.练习 Lambda 无参无返回值

package com.xm.lambda;

interface Eat {
    void eat();
}

class EatImpl implements Eat {
    @Override
    public void eat() {
        System.out.println("多吃蔬菜，身体健康----正常代理");
    }
}

public class Demo2 {
    public static void main(String[] args) {
        //正常代理
        Eat e = new EatImpl();
        e.eat();
        //匿名内部类
        new Eat() {
            @Override
            public void eat() {
                System.out.println("多吃蔬菜，身体健康----匿名内部类");
            }
        }.eat();
        //Lambda
        e = () -> System.out.println("多吃蔬菜，身体健康----匿名内部类");
        e.eat();
    }
}

4.练习 Lambda 有参无返回值

package com.xm.lambda;
interface Flyable {
    void fiy(String s);
}
class FlyableImpl implements Flyable{
    @Override
    public void fiy(String s) {
        System.out.println(s);
        System.out.println("正常代理");
    }
}
public class Demo3 {
    public static void main(String[] args) {
        //正常代理
        useFlyable(new FlyableImpl());
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fiy(String s) {
                System.out.println(s);
                System.out.println("匿名内部类");
            }
        });
        //Lambda
        useFlyable((String s)->{
            System.out.println(s);
            System.out.println("Lambda");
        });

    }
    public static void useFlyable(Flyable f)
    {
        f.fiy("多吃蔬菜，身体健康!!!!");
    }
}

5.练习 Lambda 有参有返回值

方式1

与方式2相同

package com.xm.lambda;

interface Addable {
    int add(int x, int y);
}

class AddableImpl implements Addable {
    @Override
    public int add(int x, int y) {
        System.out.println("正常代理");
        return x + y;
    }
}

public class Demo4 {
    public static void main(String[] args) {
        //正常代理
        useAffable(new AddableImpl());
        //匿名内部类
        useAffable(new Addable() {
            @Override
            public int add(int x, int y) {
                System.out.println("匿名内部类");
                return x + y;
            }
        });
        //Lambda
        useAffable((x, y) -> {
            System.out.println("Lambda");
            return x + y;
        });

    }

    public static void useAffable(Addable a) {
        System.out.println(a.add(20, 30));
    }
}
方式2

与方式1相同

package com.xm.lambda;

interface Addable {
    int add(int x, int y);
}

class AddableImpl implements Addable {
    @Override
    public int add(int x, int y) {
        System.out.println("正常代理");
        return x + y;
    }
}

public class Demo4 {
    public static void main(String[] args) {
        //正常代理
        System.out.println(new AddableImpl().add(20, 30));
        //匿名内部类
        System.out.println(new Addable() {
            @Override
            public int add(int x, int y) {
                System.out.println("匿名内部类");
                return x + y;
            }
        }.add(30, 40));
        //Lambda 1
        Addable e = (x, y) -> {
            System.out.println("Lambda1");
            return x + y;
        };
        System.out.println(e.add(40, 50));
        //Lambda 2
        System.out.println(((Addable) (x, y) -> {
            System.out.println("Lambda2");
            return x + y;
        }).add(40, 50));

    }

}

6.Lambda 表达式的省略

  • 参数类型可以省略，在多参的情况下，不能只省略一个
  • 只有一个参数的时候，可以省略小括号
  • 如果代码块的语句只有一条，可以省略大括号和分号，return 语句可以省略

7.Lambda表达式的注意事项

  • 使用Lambda必须有接口，接口中仅有一个抽象方法
  • 必须要有上下文环境，才能推导出Lambda对应的接口
    • 根据局部变量的赋值得知Lambda对应的接口:Runnable r=()->System.out.print(“你好”)；
    • 根据调用的方法的参数得知Lambda对应的接口: new Thread()->System.out.println(“你好”).start();
    • 作为返回值为接口类型的返回值

8.Lambda表达式和匿名内部类的区别

所需类型不同
  • 匿名内部类：可以是接口，抽象类，具体类
  • Lambda：只能是接口
使用限制不同
  • 如果接口中有且仅有一个抽象方法，可以用Lambda，或匿名内部类
  • 如果接口中有多于一个抽象方法，只能用匿名内部类
实现原理不同
  • 匿名内部类：编译之后，产生一个单独的.class 字节码文件
  • Lambda：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

接口更新

正常 属性 public static final

正常方法 public abstract

  • 默认方法 Java8
  • 静态方法 Java8
  • 私有方法 Java9
接口中的默认方法

不强制重写，可以重写（去掉default); 接口中可以省略public

接口中的静态方法

不能重写，静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

public可以省略，static不能省略

接口中的私有方法

private void show()

private static void show()

默认方法可以调用私有的静态方法和非静态方法

静态方法只能调用私有的静态方法

具体实现
package com.xm.接口;

interface MyInterface {

    void show1();

    void show2();

    default void show3() {
        System.out.println("show3---接口");
    }
    static void show4()
    {
        System.out.println("show4---接口中的静态方法只能被接口调用");
    }
    default void method1()
    {
        System.out.println("method1");
        show();
    }
    default void method2()
    {
        System.out.println("method2");
        show();
    }
    private void show(){
        System.out.println("你好！");
        System.out.println("你也好！");
    }
    static void method3(){
        System.out.println("method3");
        showStatic();
    }
    private static void showStatic()
    {
        System.out.println("你好！");
        System.out.println("你也好！");
    }

}

class MyInterfaceImpl implements MyInterface {
    @Override
    public void show1() {
        System.out.println("show1");
    }

    @Override
    public void show2() {
        System.out.println("show2");
    }

    @Override
    public void show3() {
        System.out.println("show3---实现类");
    }
}

public class Demo1 {
    public static void main(String... args)//可变参数
    {
       MyInterface mi= new MyInterfaceImpl();
       mi.show1();
       mi.show2();
       mi.show3();
       MyInterface.show4();
       mi.method1();
       mi.method2();
       MyInterface.method3();

    }
}

方法引用

方法引用符

：：该符号为引用运算符，它所在的表达式被称为方法引用

  • Lambda 表达式中的参数s 传递给System.out 这个对象调用的println方法去处理
  • 方法引用 直接使用System.out 中的println方法来取代Lambda ,代码更加整洁
package com.xm.方法引用;
interface Printable {
    void printInt(int x);
}
public class Demo1 {
    public static void main(String[] args) {
        usePrintable(i->System.out.println(i));
        usePrintable(System.out::println);
        System.out.println(666);
        ((Printable) i->System.out.println(i)).printInt(8888);
        ((Printable)System.out::println).printInt(8888);
        System.out.println(8888);

    }
    public static void usePrintable(Printable p)
    {
        p.printInt(6666);
    }
}
引用类方法

实际上是引用类的静态方法

package com.xm.方法引用;

interface Converter {
    int convert(String s);
}

public class Demo2 {
    public static void main(String[] args) {
        //第一种写法
        useConverter(s -> Integer.parseInt(s));//省略return
        useConverter(Integer::parseInt);
        //Lambda表达式被方法引用代替的时候，它的形参全部传递给静态方法parseInt()作为参数
//      第二种写法
        System.out.println(((Converter) s -> Integer.parseInt(s)).convert("567"));
        System.out.println(((Converter) Integer::parseInt).convert("567"));
    }

    public static void useConverter(Converter c) {
        int num = c.convert("789");
        System.out.println(num);
    }
}
引用对象的实例方法

实际上是通过对象引用类中的成员方法

package com.xm.方法引用;

interface Printer {
    void printUpperCase(String s);
}

class PrintString {
    public void printUpper(String s) {
        System.out.println(s.toUpperCase());
    }
}

public class Demo3 {
    public static void main(String[] args) {
        usePrinter(s -> System.out.println(s.toUpperCase()));

        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);
        //Lambda表的式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数
    }

    public static void usePrinter(Printer p) {
        p.printUpperCase("helloWorld");

    }
}
引用类的实例方法

实际上是引用类中的成员方法

  • 格式： 类名：：成员方法
package com.xm.方法引用;

interface MyString {
    String mySubString(String s, int a, int b);
}

public class Demo4 {
    public static void main(String[] args) {
        int x = 5;
        System.out.println(x);
        useMyString((s, a, b) -> s.substring(a, b));
        useMyString(String::substring);
        // 第一个参数作为调用者
        //后边的参数全部传递给该方法作为参数
        System.out.println(((MyString) (s, a, b) -> s.substring(a, b)).mySubString("helloWorld!!!", 0, 10));
        System.out.println(((MyString) (String::substring)).mySubString("helloWorld!!!", 0, 10));
    }

    public static void useMyString(MyString m) {
        String result = m.mySubString("helloWorld!", 0, 5);
        System.out.println(result);
    }
}
引用构造器

实际上是引用构造方法

格式：类名：：new

举例：Student : : new

package com.xm.方法引用;

interface StudentBuilder {
    Student build(String name, int age);
}

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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Demo5 {
    public static void main(String[] args) {
        useStudentBuilder(((name, age) -> new Student(name, age)));
        //引用构造器，Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
        useStudentBuilder(Student::new);
    }

    public static void useStudentBuilder(StudentBuilder sb) {
        System.out.println(sb.build("肖猛", 18).toString());
    }
}

函数式接口

概述

函数式接口：有且仅有一个抽象方法的接口（可以有默认，静态，私有方法），是使用Lambda表达式的前提，是Lambda表达式能够顺利推导的前提；

@FunctionalInterface 注解 放在接口上方，若为函数式接口，则编译通过，否则编译失败

@FunctionalInterface 不加不报错，建议加上该注解；

package com.xm.函数式接口;

@FunctionalInterface
interface MyInterface {
    void show();
    //jdk8
    default void method() {
        show1();
    }
    //jdk8
    static void methods() {
        show1();
    }
    //jdk9
    private static void show1() {
        System.out.println("static---show1");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        //Lambda表达式用做局部变量
        MyInterface my = () -> System.out.println("你好！");
        my.show();
        //回顾接口更新
        my.method();
        MyInterface.methods();
    }
}
函数式接口用作方法的参数

参见方法引用，直接上代码比较直观：

package com.xm.函数式接口;

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "实现类线程启动");
    }
}

public class Demo2 {
    public static void main(String[] args) {
        useRunnable(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "匿名内部类线程启动");
            }
        });
        useRunnable(() -> System.out.println(Thread.currentThread().getName() + "Lambda表达式线程启动"));

        useRunnable(new MyRunnable());

    }

    public static void useRunnable(Runnable r) {
        new Thread(r).start();
    }
}
函数式接口作为方法的返回值

即为Lambda表达式作为返回值

本例中的Comparator是函数式接口

return (…) 返回的类型是Comparator 的实现，所以通过return 语句可以推导出Lambda 表达式的写法（实现Comparator 中的抽象方法）；

package com.xm.函数式接口;

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

public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("cccc");
        arrayList.add("aa");
        arrayList.add("b");
        arrayList.add("ddd");
        System.out.println("排序前");
        System.out.println(arrayList);
        Collections.sort(arrayList);
        System.out.println("默认排序");
        System.out.println(arrayList);
        Collections.sort(arrayList, getComparator());
        System.out.println("调用函数式接口作为返回值---按短长排序");
        System.out.println(arrayList);
        Collections.sort(arrayList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.length() - o1.length();
            }
        });
        System.out.println("匿名内部类做参数---按长短排序");
        System.out.println(arrayList);
        Collections.sort(arrayList, (s1, s2) -> s1.length() - s2.length());
        System.out.println("Lambda做参数---按短长排序");
        System.out.println(arrayList);

    }

    public static Comparator<String> getComparator() {
        return (s1, s2) -> s1.length() - s2.length();
//        return new Comparator<String>() {
//            public int compare(String s1, String s2) {
//                return s1.length() - s2.length();
//            }
//        };

    }
}

常用接口

Java8在java.uitl.function包下预定义了大量的函数式接口供我们使用；

1.Supplier接口

Supplier:包含一个无参构造方法

  • T get() :获得结果

  • 该方法不需要参数，他会按照某种逻辑（由Lambda表达式实现）返回一个数据

  • Supplier 接口被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据供我们使用

package com.xm.函数式接口;

import java.util.function.Supplier;

public class Demo4Supplier {
   public static void main(String[] args) {
       String s=(getString(() -> "yes"));
       System.out.println(s);
       System.out.println((getString(() -> "yes")));
       System.out.println(getInteger(()->12345));
   }
   private static Integer  getInteger(Supplier<Integer> supplier)
   {
       return supplier.get();
   }
   private static String  getString(Supplier<String> supplier)
   {
       return supplier.get();
   }
}
test得到数组最大值
package com.xm.函数式接口;

import java.util.function.Supplier;

public class TestSupplier {
    public static void main(String[] args) {
        int [] a= {19, 4, 7, 1, 80, 3};
        int maxValue = getMax(() -> {
            int max = a[0];
            for (int j : a)
                if (j > max)
                    max = j;
            return max;
        });
        System.out.println(maxValue);
    }

    public static Integer getMax(Supplier<Integer> supplier) {
        return supplier.get();
    }
}
2.consumer接口

可以作为Lambda表达式或方法引用的赋值目标

表示接受单个输入参数且不返回结果的操作。 与大多数其他功能接口不同， Consumer预计会通过副作用运行。

  • void accept(T t)
    对给定的参数执行此操作。

  • default Consumer andThen(Consumer<? super T> after)
    返回一个组合 Consumer ，它按顺序执行此操作，然后执行 after操作。

  • Consumer接口被称消费型接口，如果我们指定了接口的泛型是什么类型，那么接口中的accept方法就会消费什么类型的数据；

package com.xm.函数式接口;

import java.util.function.Consumer;

public class Demo5Consumer {
    public static void main(String[] args) {
        useConsumer((s) -> System.out.println(s));
        useConsumer((s) -> System.out.println(new StringBuilder(s).reverse()));
        ((Consumer<String>) (s) -> System.out.println(s)).accept("what");
        System.out.println("--------------");
        useConsumer("what",(s)->System.out.println(s),(s)->System.out.println(new StringBuilder(s).reverse()));

    }
    public static void useConsumer( String name ,Consumer<String> con,Consumer<String> con2) {
        con.accept(name);
        con2.accept(name);
        System.out.println("-------------");
        con.andThen(con2).accept(name);
    }
    public static void useConsumer(Consumer<String> con) {
        con.accept("what");
    }
}
test按要求打印信息
package com.xm.函数式接口;

import java.util.function.Consumer;

public class TestConsumer {
    public static void main(String[] args) {
        String[] strArray = {"肖猛，18", "李玮晴，18", "刘东旭，6"};
        printConsumer(str -> {
            String name = str.split("，")[0];
            System.out.print(name);
        }, str -> {
            int age = Integer.parseInt(str.split("，")[1]);
            System.out.println(age);
        }, strArray);
    }

    //正常情况是这样，因为我用了可变参数，所以strArray 必须是形参的最后一个；
//  printConsumer(strArray,str->{},str->{}); 
//public static void printConsumer(String... strArray,Consumer<String> con, Consumer<String> con2)    
    public static void printConsumer(Consumer<String> con, Consumer<String> con2, String... strArray) {
        for (String str : strArray) {
            con.andThen(con2).accept(str);
        } 
    }
}
3.Predicate接口

Predicate接口实际上是谓语匹配

方法：test(T t) 参数T： 输入参数 返回: true如果输入参数与谓词匹配，否则为 false

  • default Predicate and(Predicate<? super T> other)
    返回一个组合谓词，表示此谓词和另一个谓词的短路逻辑AND。

  • static Predicate isEqual(Object targetRef)
    返回一个谓词，根据 Objects.equals(Object, Object)测试两个参数是否相等。

  • default Predicate negate()
    返回表示此谓词的逻辑否定的谓词。

  • default Predicate or(Predicate<? super T> other)
    返回一个组合谓词，表示此谓词与另一个谓词的短路逻辑OR。

  • boolean test(T t)
    根据给定的参数计算此谓词。

package com.xm.函数式接口;

import java.util.function.Predicate;

public class Demo6Predicate {
    public static void main(String[] args) {
        //1.test
        boolean b1 = checkString("hello", w -> w.length() >= 8);
        System.out.println(b1);
        boolean b2 = checkString("helloWorld", w -> w.length() >= 8);
        System.out.println(b2);
        //3.and 与
        boolean b3 = checkString("hello", s -> s.length() > 29, s -> s.equals("hello"));
        System.out.println(b3);
        //4.or 或
        boolean b4 = CheckString("hello", s -> s.length() > 4, s -> s.equals("hello"));
        System.out.println(b4);
    }

    //1.test
    //判断字符串是否满足条件
    public static boolean checkString(String s, Predicate<String> predicate) {
//        return predicate.test(s);正常判断
//      2.negate(),逻辑非；
//      return !predicate.test(s);
        return predicate.negate().test(s);
    }

    //3.and 与
    //同一个字符串给出两个不同的判断条件，最后把这两个判断的条件做逻辑与运算的结果作为最终的结果
    public static boolean checkString(String s, Predicate<String> predicate, Predicate<String> predicate2) {
//        boolean b1=predicate.test(s);
//        boolean b2=predicate2.test(s);
//        boolean b=b1&&b2;
//        return b;
        return predicate.and(predicate2).test(s);
    }

    //4.or或
    public static boolean CheckString(String s, Predicate<String> predicate, Predicate<String> predicate2) {
//        boolean b1 = predicate.test(s);
//        boolean b2 = predicate2.test(s);
//        boolean b = b1 || b2;
//        return b;
        return predicate.or(predicate2).test(s);
    }


}
test筛选条件

条件：年龄字符大于2，年龄大于8的数据放入ArrayList 并遍历

package com.xm.函数式接口;

import java.util.ArrayList;
import java.util.function.Predicate;

//筛选条件，年龄字符大于2，年龄大于8；的数据放入ArrayList 并遍历
public class TestPredicate {
    public static void main(String[] args) {
        String[] strArray = {"肖猛，18", "李玮晴，10", "刘东旭，6"};
        ArrayList<String> array = new ArrayList<>();
        Check(strArray, array, s -> s.split("，")[0].length() > 2, s -> Integer.parseInt(s.split("，")[1]) > 8);
    }

    public static void Check(String[] strArray, ArrayList<String> array, Predicate<String> predicate, Predicate<String> predicate2) {
        for (String str : strArray) {
            if (predicate.and(predicate2).test(str))
                array.add(str);
        }
        for (String string : array)
            System.out.println(string);
    }

}
4.Function接口

Function(T,R) 表示接受一个参数并生成结果的函数。
这是functional interface，其功能方法是apply(Object) 。

T - 函数输入的类型

R - 函数结果的类型

  • default Function<T,V> andThen(Function<? super R,? extends V> after) 返回首先将此函数应用于其输入的 after函数，然后将 after函数应用于结果。
  • R apply(T t) 将此函数应用于给定的参数。
package com.xm.函数式接口;

import java.util.function.Function;

public class Demo7Function {
    public static void main(String[] args) {
        Integer integer = convert("12345", s -> {d
            return Integer.parseInt(s);
        });
        System.out.println("String--->Integer类型：" + integer);
// 有返回值的接口方法，Lambda表达式调用方法，会产生返回值，具体接收看情况而定
        convertString(2345, i -> {
            int x = 10000;
            return String.valueOf(i + x);
        });

        String s1 = convertPlus("345", s -> Integer.parseInt(s), i -> String.valueOf(i + 12000));
        System.out.println("String--->int--->String：" + s1);
    }

    //String 类型转化为Integer类型
    public static Integer convert(String s, Function<String, Integer> f) {
        return f.apply(s);
    }

    //int 类型加一个整数，转化为String类型
    public static void convertString(int i, Function<Integer, String> f) {
        String s = f.apply(i);
        System.out.println("Integer--->字符串类型：" + s);
    }

    //把一个字符串转化为int 类型，加上一个整数后，转为字符串输出
    public static String convertPlus(String s, Function<String, Integer> f, Function<Integer, String> f2) {
//        int i=f.apply(s);
//        String ss=f2.apply(i);
//        return ss;
        return f.andThen(f2).apply(s);
    }
}
计算肖猛真实年龄

假设：String s=“肖猛，20”；

要求：

  1. 将字符串截取，得到数字年龄部分
  2. 将数字年龄部分转化为int类型的数据
  3. 将上部int型的年龄减去2，得到一个int结果就是肖猛真实年龄，在控制台输出
package com.xm.函数式接口;

import java.util.function.Function;

public class TestFunction {
    public static void main(String[] args) {
        System.out.println("盲猜肖猛年龄为20");
        int answer = convertFunction("肖猛，20", s -> Integer.parseInt(s.split("，")[1]) - 2);
        System.out.println("肖猛的真实年龄：" + answer);
    }

    public static int convertFunction(String s, Function<String, Integer> f) {
        return f.apply(s);
    }
}

Stream流

体验Stream流

Stream 流把真正的函数式编程风格引入Java中

筛选学生

package com.xm.Stream流;

import java.util.ArrayList;

public class Demo1 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        ArrayList<String> array1 = new ArrayList<>();
        ArrayList<String> array2 = new ArrayList<>();
        array.add("肖猛");
        array.add("肖限量");
        array.add("李肥肥");
        array.add("肖扬1");
        for (String name : array) {
            if (name.charAt(0) == '肖') {
                array1.add(name);
                if (name.length() == 3)
                    array2.add(name);
            }
        }
        for (String name3 : array2)
            System.out.println(name3);
        System.out.println("-----------");
//        array.stream().filter(s -> s.startsWith("肖")).filter(s -> s.length() == 3).forEach(System.out::println);
        array.stream().filter(s -> s.startsWith("肖")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));


    }
}
Stream流的生成方式
  1. Collection 体系(Set，List的集合可以使用默认方法stream() 生成流
  2. Map体系的集合间接的生成流
  3. 数组可以通过Stream 接口的静态方法of (T … values)生成流
package com.xm.Stream流;

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

public class Demo2 {
    public static void main(String[] args) {
        //1.Collection 体系(Set，List的集合可以使用默认方法Stream() 生成流
        ArrayList<String> arrayList=new ArrayList<>();
        arrayList.add("1");
        arrayList.add("12");
        arrayList.add("123");
        arrayList.add("1234");
        arrayList.add("12345");
        arrayList.add("123456");
        Stream<String> arrayStream = arrayList.stream();
        
        //2.Map体系的集合间接的生成流
        Map<String,Integer> map=new HashMap<>();
        //键的Stream流
        Stream<String> keyStream = map.keySet().stream();
        //值的Stream流
        Stream<Integer> valueStream = map.values().stream();
        //键值对的Stream流
        Stream<Map.Entry<String, Integer>> mapStream = map.entrySet().stream();
        
        // 数组的Stream流
        String []str={"你好","你也好","都挺好"};
        Stream<String> strStream = Stream.of(str);
        Stream<Integer> integerStream = Stream.of(10, 20, 30);


    }
}
1.Stream流中间操作filter,limit,skip concate,distinct

Streamfilter (Predicate predicate):用于对流中的数据进行过滤

Predicate 接口中的方法 boolean test(T t) :对给定的参数进行判断，返回布尔值；

Stream limit(long maxSize) :返回此流中的元素组成的流，截取前指定参数个数的数据

Streamskip(long n):跳过指定个数的数据，返回有该流的剩余元素组成的流

staticStreamconcat(Stream a,Stream b):合并a和b两个流为一个流

StreamDistinct():返回由该流的不同元素（根据Object.equals(Object))组成的流 底层实现：equal方法；

package com.xm.Stream流;

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

public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<>();
        array.add("肖彦斌");
        array.add("肖限量");
        array.add("李肥肥");
        array.add("肖扬1");
        array.add("肖志强");
        
        //filter    过滤
        array.stream().filter(s->s.startsWith("肖")).filter(s -> s.length()==3).forEach(s->System.out.println(s));
        System.out.println("-------");
        
        //limit   返回前N 个数据组成的流
        Stream<String> limit = array.stream().limit(3);
        array.stream().limit(3).forEach(System.out::println);
        System.out.println("-------");
        
        //skip 跳过 前N个数据，返回 剩余数据组成的流
        Stream<String> skip = array.stream().skip(2);
        array.stream().skip(2).forEach(System.out::println);
        System.out.println("-------");
        
        //concat Stream流合并
//        Stream.concat(limit,skip).forEach(System.out::println);
//        Stream.concat(array.stream().limit(3),array.stream().skip(2)).forEach(System.out::println);
        
        //distinct 返回由该流的不同元素（根据Object.equals(Object))组成的流 底层实现：equal方法；
        System.out.println("what");
        Stream.concat(limit,skip).distinct().forEach(System.out::println);
    }
}
2.Stream流中间操作sorted()

Streamsorted():返回由此流的元素组成的流，根据自然顺序排序

Streamstored(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序

package com.xm.Stream流;

import java.util.ArrayList;
import java.util.Collections;

public class Demo4 {
    public static void main(String[] args) {
        ArrayList<String > list=new ArrayList<>();
        list.add("bbb");
        list.add("aaaa");
        list.add("aaac");
        list.add("aaab");
        list.add("c");
        Collections.sort(list);
        Collections.sort(list,(s1,s2)->s1.length()-s2.length());
        for(String s:list)
            System.out.println(s);
        list.stream().sorted().forEach(System.out::println);
        list.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);
        list.stream().sorted((s1,s2)->{
            int num1=s1.length()-s2.length();
            return num1==0?s1.compareTo(s2):num1;}
        ).forEach(System.out::println);
    }
}
3.Stream流中间操作map,mapToInt

Streammap(Function mapper) :返回由给定函数应用于此流的元素的结果组成的流 Function 接口中的方法 R apply(T t);

IntStream mapToInt (ToIntFunction mapper):返回一个IntStream其中包含将给定函数应用于此流的元素的结果。

package com.xm.Stream流;

import java.util.ArrayList;
import java.util.stream.IntStream;

public class Demo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        //map   将字符串数据转化为整数之后在控制台输出
        list.stream().map(Integer::parseInt).forEach(System.out::println);
        //list.stream().map(s -> Integer.parseInt(s)).forEach(s->System.out.println(s));

        //mapToInt
        // sum方法返回 IntStream 中的数值总和；
        IntStream intStream = list.stream().mapToInt(Integer::parseInt);
        int sum = intStream.sum();
        System.out.println(sum);
    }
}
4.Stream流终结操作forEach,count

void ForEach(Consumer action):对此流的每一个元素执行操作 Consumer接口中的方法 void accept(T t):对给定的参数执行此操作

long count() :返回此流中的元素个数

package com.xm.Stream流;

import java.util.ArrayList;

public class Demo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        // forEach
        list.stream().forEach(System.out::println);
        //count
        long count = list.stream().count();
        System.out.println(count);
6.Stream流的收集操作
  • R collect(Collector collector) 该收集方法的参数是一个Collector接口

工具类Collectors提供了具体的收集方式

  • public static Collector toList():把元素收集到List集合中
  • public static Collector toSet():把元素收集到Set集合中
  • public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合
package com.xm.Stream流;

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

public class Demo7 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("李肥肥");
        arrayList.add("肖一");
        arrayList.add("动见");
        arrayList.add("曾国藩");
        arrayList.add("左宗棠");
        List<String> list = arrayList.stream().filter(s -> s.length() == 3).collect(Collectors.toList());
        for (String s : list)
            System.out.println(s);
        Set<Integer> hashSet = new HashSet<>();
        hashSet.add(10);
        hashSet.add(20);
        hashSet.add(30);
        hashSet.add(40);
        hashSet.add(50);
        hashSet.add(6000_000);
        Set<Integer> set = hashSet.stream().filter(s -> s >= 40).collect(Collectors.toSet());
        for (Integer i : set)
            System.out.println(i);

        String[] str = {"肖猛，18", "李肥肥，18", "刘东旭，8", "小透明，7"};
        Stream<String> strStream = Stream.of(str).filter(s -> Integer.parseInt(s.split("，")[1]) > 10);
        Map<String, Integer> map = strStream.collect(Collectors.toMap(s -> s.split("，")[0], s -> Integer.parseInt(s.split("，")[1])));
        //遍历1
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> element : entries) {
            System.out.println(element.getKey() + element.getValue());
        }
        System.out.println("-----------------");
        //遍历2
        Set<String> keySet = map.keySet();
        for(String key:keySet) {
            System.out.println(key+map.get(key));
        }


    }
}
Stream流综合练习

现在要有ArrayList集合，分别储存5名男生和5名女生，要求完成如下的操作

男生只要名字为3个字的前3人

女生只要姓林的，并且不要第一个

把过滤后的男生姓名和女生姓名合并到一起

把上一步操作后的元素作为构造方法的参数创建性别对象，遍历数据Person类已经提供，里面有一个成员变量，一个带参构造方法，已经成员变量对应的get/set方法

package com.xm.Stream流;

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

public class Demo6 {
    public static void main(String[] args) {
        ArrayList<String>  boyList=new ArrayList<>();
        boyList.add("李肥肥");
        boyList.add("肖一");
        boyList.add("动见");
        boyList.add("曾国藩");
        boyList.add("左宗棠");
        ArrayList<String> girlList=new ArrayList<>();
        girlList.add("窦漪房");
        girlList.add("肖涵");
        girlList.add("武则天");
        girlList.add("肖允许");
        girlList.add("小透明");
        ArrayList<Person> peopleList=new ArrayList<>();
        Stream<String> boy = boyList.stream().filter(s -> s.length() == 3).limit(3);
        Stream<String> girl=girlList.stream().filter(s->s.startsWith("肖")).skip(1);//先把肖挑选出来组成新流，再从中跳过第一个；
//        Stream.concat(boy,girl).forEach(s-> peopleList.add(new Person(s)));
//        for(Person person:peopleList)
//            System.out.println(person);
        Stream<String> stream = Stream.concat(boy, girl);
        Stream<Person> personStream = stream.map(s -> new Person(s));
        personStream.forEach(System.out::println);

    }
}
class Person{
    private String name;

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

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

    public Person(){}
}
ILFFQ
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java8 Lambda表达式和流操作如何让你的代码变慢5倍
12-22
有许许多多关于 Java 8 中流效率的讨论，但根据 Alex Zhitnitsky 的测试结果显示：坚持使用传统的 Java 编程风格——iterator 和 for-each 循环——比 Java 8 的实现性能更佳。 　　Java 8 中的 Lambda 表达式和流（Stream）受到了热烈欢迎。这是 Java 迄今为止令人激动的特征。这些新的语言特征允许采用函数式风格来进行编码，我们可以用这些特性完成许多有趣的功能。这些特性如此有趣以至于被认为是不合理的。我们对此表示怀疑，于是决定对这些特性进行测试。 　　我们创建一个简单的任务：从一个 ArrayList 找出大值，将传统方式与
10.第十节-使用lambda表达式实现排序.mp4
10-25
Java8发布到现在至少3年了，但是对Lambda表达式不熟悉、看不懂、不会用的现象非常常见。 即使是升级到JDK1.8了，但是很多开发者依然是停留在1.8之前的开发方式，使用的也是非常老旧和过时的API，遇到函数式接口也是依然使用匿名内部类解决。 本系列课程从Lambda表达式、方法的引用、Stream API三处着手分析Lambda表达式的使用。 通过大量的实战例子讲解如何使用Lambda表达式
lambda表达式使用及缺陷分析展示
谢白羽
07-27 959
文章目录1.lambda表达式与for_each、find_if间接1.1 用法简介1.2 捕获列表1.3 lambda表达式延迟调用易出错细节分析1.4 lambda表达式中的mutable1.5 lambda表达式再演示和优点总结1.5.1 for_each中的lambda表达式1.5.2 find_if中的lambda表达式2.lambda表达式捕获模式的缺陷分析和展示2.1 捕获列表中的&2.2 形参列表可以使用auto2.3 成员变量的捕获问题2.4 广义lambda捕获2.5 静态局部变
使用lambda表达式时，this数据失效的bug
u010434924的专栏
06-02 3793
在一次回调中使用了lambda表达式，传进来的值失效，主要是对lambda表达式了解的不够深入，记录下来！ 如下改正，问题就解决了： Director::getInstance()->getScheduler()->performFunctionInCocosThread([&, this, region, delay, speed, percent]() //注意要加：thi
lambda操作LIst(持续更新中)
唆了蜜.
05-25 1761
int total = List.stream().mapToInt(bean::getAmt).sum();
lambda表达式更新数据库
热门推荐
韩丽萍
08-28 1万+
前言 在Itoo中，遇到了要用lambda表达式来更新数据的需求，之前接触过用lambda表达式查询的代码，但是更新还是第一次遇到，在大神的帮助下，又学到一点。lambda表达式更新数据 ta_userrole t_UserRole = new ta_userrole();//定义要更新的那张表 t_UserRole.IsDeleted = "Y";//要更新的字段 this.DbSession.
Lambda表达式
u014016330的博客
04-26 319
1. 更新方式：2. 查询是否存在.exists();
MyBatis-Plus 如何使用 Lambda 表达式进行更新操作
奇妙的Bug之旅
01-06 607
通过以上步骤，我们已经学会了如何使用 MyBatis-Plus 的 Lambda 表达式进行更新操作。在实际项目中，你可以根据需要灵活地添加各种更新条件，以满足不同的业务需求。希望这篇文章能帮助你更好地理解和使用 MyBatis-Plus。
lambad批量更新字典&按key排序
weixin_45292006的博客
11-05 609
lambad批量更新字典
mybatis-plus lambda自动填充更新生效
qq_37795502的博客
03-09 983
非XML的更新或新增的操作，要想自动填充功能生效需要添加对应的实体类，才能走到自定义更新策略中、
Lambda+函数式接口+表达式和方法引用+实践
02-26
Lambda+函数式接口+表达式和方法引用+实践 - 本资源是一个Lambda的实践，教你如何用Java的Lambda表达式和方法引用简化代码，实现函数式编程，包括使用函数式接口，Stream，Optional等。
06.第六节-如何精简lambda表达式.mp4
10-25
Java8发布到现在至少3年了，但是对Lambda表达式不熟悉、看不懂、不会用的现象非常...本系列课程从Lambda表达式、方法的引用、Stream API三处着手分析Lambda表达式的使用。 通过大量的实战例子讲解如何使用Lambda表达式
java8源码-LambdaExpression:Lambda表达式
06-04
java8 源码 Lambda表达式 Lambda表达式是一个匿名方法,将行为像数据一样进行传递。 Lambda 表达式常见的结构： BinaryOperator ...Java8的新特性：函数式编程(要先能看的懂Lambda)：流 tips1:A stream does not
Lambda架构实现数据实时更新
leone911的博客
07-15 860
当前股票市场的交易者可以了解丰富的股票交易信息。从金融新闻到传统的报纸和杂志再到博客和社交媒体，汇聚着海量的数据，远比股票交易者想关注的股票信息要大得多，这就需要为股票交易者提供信息的有效过滤。这里将开发一个新闻服务给股票证券投资交易者使用，并为股票交易者提供个性化新闻。 这个新闻服务就叫“自动获取金融新闻”，输入各个数据源的金融新闻，也同时输入用户实时股票交易信息。不管何时，在股票交易者所
22.1、Java中的Lambda表达式&接口组成更新&方法引用
qq1092881420的博客
01-02 245
案例需求启动一个线程，在控制台输出一句话：多线程程序启动了实现方式一实现步骤定义一个类MyRunnable实现Runnable接口，重写run()方法创建MyRunnable类的对象创建Thread类的对象，把MyRunnable的对象作为构造参数传递启动线程实现方式二匿名内部类的方式改进实现方式三Lambda表达式的方式改进 函数式编程思想概述函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”而我们要学习的Lambda表达式就是函数式思想的体现格式：​ (形式参数) -> {
Lambda表达式、接口组成更新、方法引用
gy99csdn的博客
01-22 320
Lambda表达式1.函数式编程思想概述2.Lambda表达式的标准格式2.1 Lambda表达式练习1(抽象方法无参无返回值)2.2 Lambda表达式练习2(抽象方法带参无返回值)2.3 Lambda表达式练习3(抽象方法带参有返回值)2.4 Lambda表达式的省略模式 1.函数式编程思想概述 public class MyRunnable implements Runnable { @Override public void run() { System.out
java8新特性 lambda表达式升级 方法引用
sugarbank的博客
09-06 391
java8新特性 lambda表达式升级 方法引用 在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿什么参数做什么操作。那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑？ 1 冗余的Lambda场景 来看一个简单的函数式接口以应用Lambda表达式： @FunctionalInterface publi...
android高斯模糊填充imageview背景
最新发布
cf8833的博客
05-21 595
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
lambda表达式和stream流
08-19
Lambda表达式和Stream流是Java 8中引入的两个重要特性。 Lambda表达式是一种轻量级的匿名函数，它可以作为参数传递给方法或存储在变量中，使得代码更加简洁和易读。它的语法形式为：(parameters) -> expression 或 (parameters) -> { statements; }。其中，parameters表示参数列表，expression表示单个表达式，statements表示代码块。 Lambda表达式常用于函数式接口的实现，函数式接口是只包含一个抽象方法的接口。通过Lambda表达式，我们可以以更简洁的方式实现这个抽象方法，避免了繁琐的匿名内部类的写法。 Stream流是一种处理集合数据的抽象概念，它提供了一种统一的方式来操作集合中的元素。通过Stream流可以对集合进行过滤、映射、排序、归约等操作，使得代码更加简洁和易读。 Stream流的使用可以分为三个步骤：创建流、中间操作和终端操作。创建流可以通过集合、数组、I/O通道等方式实现；中间操作可以对流进行过滤、映射、排序等操作；终端操作可以对流进行归约、收集、遍历等操作。 Lambda表达式和Stream流的引入使得Java编程更加灵活和高效，能够更好地支持函数式编程的思想。它们在Java编程中得到了广泛的应用，并且成为了Java编程的重要特性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ILFFQ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值