Java中Lambda表达式与反射

最新推荐文章于 2024-10-17 19:11:48 发布
最新推荐文章于 2024-10-17 19:11:48 发布
阅读量633 收藏 11
点赞数 22
文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70718945/article/details/141180108
版权

一、函数式编程思想和Lambda表达式定义格式

面向对象思想：是Java的核心编程思想

强调的是找对象，帮我们做事儿

比如->去北京->强调的是怎么去，火车，高铁，飞机，汽车，自行车，腿儿

jdk8开始又了个新的思想：函数式编程思想

强调的是结果，不强调过程

比如：去北京->只强调去了还是没去

Lambda表达式：

定义格式：()->{}

各部分解释：（）：重写方法的参数位置

->:将参数传递到方法体中

{}:重写方法的方法体

public class Demo01Lambda {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我执行了");
            }
        }).start();
        System.out.println("=========");

        //lambda表达式

        new Thread(()-> { System.out.println("我执行了"); }).start();
    }
}

Lambda表达式使用前提

  1. 必须是函数式接口做方法传递
  2. 啥叫函数式接口：

   有且只有一个抽象方法的接口，用@FunctionInterface去检测

Lambda表达式省略规则

怎么写？

  1. 观察是否是函数式接口做方法参数传递
  2. 如果是，考虑使用Lambda表达式
  3. 调用方法，以匿名内部类的形式传递实参
  4. 从new接口开始到重写方法的方法名结束，选中，删除，别忘记在删除一个右半个大括号
  5. 在重写方法的参数后面，方法体的大括号前面加上  ->

省略规则：

重写方法的参数类型可以干掉

如果重写方法只有一个参数，所在的小括号可以干掉

如果方法体中只有一句话，那么所在的大括号以及分号部分可以干掉

如果方法体中只有一句话并且带return的，那么所在的大括号分号以及return可以干掉

/*
1.观察是否是函数式接口做方法参数传递
2.如果是，考虑使用Lambda表达式
3.调用方法，以匿名内部类的形式传递实参
4.从new接口开始到重写方法的方法名结束，选中，删除，别忘记在删除一个右半个大括号
5.在重写方法的参数后面，方法体的大括号前面加上  ->*/

public class Demo02Lambda {

    public static void main(String[] args) {


        method(new USB() {
            @Override
            public void open() {
                System.out.println("让usb打开了");
            }
        });


        System.out.println("==========lambda表达式===========");

        method(() ->{ System.out.println("让usb打开了"); });


        method(() ->System.out.println("让usb打开了"));

    }

    /*
    *
    *
    *
    * @param  usb
    * */

    private static void method(USB usb) {
        usb.open();
    }
}
@FunctionalInterface
public interface USB {
    void open();
}
public class Person {
    private String name;
    private Integer age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

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

public class Demo03Lambda {
    public static void main(String[] args) {

        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三",10));
        list.add(new Person("李四",9));
        list.add(new Person("王五",8));

        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });

        System.out.println("======================Lambda==============");
        Collections.sort(list, (Person o1, Person o2) ->{ return o1.getAge()-o2.getAge(); });


        System.out.println("======================Lambda简化==============");
        Collections.sort(list, ( o1,  o2) -> o1.getAge()-o2.getAge());
        System.out.println(list);

    }
}

二、函数式接口

函数式接口：有且只有一个抽象方法的接口

检测：@FunctionalInterface

@FunctionalInterface
public interface USB {
    void open(String s);
}
public class Test01 {
    public static void main(String[] args) {

        method(new USB() {
            @Override
            public void open(String s) {
                System.out.println(s+"开启了");
            }
        });


        System.out.println("===========Lambda======");
        method((String s)-> {
                System.out.println(s+"开启了");
        });
        System.out.println("===========Lambda======");
        method(s-> System.out.println(s+"开启了"));


    }


    public static void method(USB usb){
        usb.open("鼠标");
    }
}

1.Supplier接口

java.util.function.Supplier<T>接口，它意味着“供给”->我们想要什么就给什么

方法：

T   get（）->我们想要什么，get方法就可以返回什么

需求：使用Supplier接口作为方法的参数

用Lambda表达式求出int数组中的最大值

泛型：<引用数据类型>->规定了我们操作的数据是什么类型

<>最终只能写引用数据类型，不能写基本数据类型

import java.util.Arrays;
import java.util.function.Supplier;

public class Demo01Supplier {
    public static void main(String[] args) {

        method(new Supplier<Integer>() {
            @Override
            public Integer get() {
                int[] arr={4,3,4,6,7};
                Arrays.sort(arr);
                return arr[arr.length-1];
            }
        });

        System.out.println("====================");

        method(() ->{
                int[] arr={4,3,4,6,7};
                Arrays.sort(arr);
                return arr[arr.length-1];
        });


    }



    public static void method(Supplier<Integer> supplier){
        Integer max=supplier.get();//让get方法返回一个数组最大值
        System.out.println("max="+max);



    }
}

2.Consumer

java.util.function.Consumer<T>->消费型接口->操作

方法：void  accept（T  t）意为消费一个指定泛型的数据

“消费”就是“操作”，至于怎么操作，就看重写accept方法之后，方法体怎么写了

import java.util.function.Consumer;

public class Demo02Consumer {
    public static void main(String[] args) {

method(new Consumer<String>() {
        @Override
        public void accept(String s) {
        System.out.println(s.length());
    }
},"abcdefg");


        System.out.println("================");
        method(s-> System.out.println(s.length()),"abcdefg");

    }


    public static void method(Consumer<String> consumer,String s){
        consumer.accept(s);
    }
}

3.Function

java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据

方法：

R  apply（T  t）根据类型T参数获取类型R的结果

import java.util.function.Function;

public class Demo03Function {
    public static void main(String[] args) {


        method(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return integer+"";
            }
        },100);

        System.out.println("=============");
        method(integer-> integer+"",100);
    }
    
    public static void method(Function<Integer,String> function,Integer number){
        String s=function.apply(number);
        System.out.println("s="+(s+1));
    }
}

4.Predicate

java.util.function.Predicate<T>接口->判断型接口

   boolean  test（T t）->用于判断的方法，返回值为boolean型

import java.util.function.Predicate;

public class Demo04Predicate {
    public static void main(String[] args) {

        method(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()==7;
            }
        },"abcdefg");
        System.out.println("============");

        method(s->s.length()==7,"abcdefg");
    }

    public static void method(Predicate<String> predicate,String s){
        boolean test=predicate.test(s);
        System.out.println("test="+test);
    }
}

三、Stream流

Stream流中的“流”不是特指“IO流”它是一种“流式编程”（编程方式），可以看做是“流水线”

1.Stream的获取

针对集合：Collection中的方法

Stream<E> stream()

针对数组：Stream接口中的静态方法

static<T>  Stream<T>  of(T.....values)

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

public class Demo01Stream {
    public static void main(String[] args) {
        //针对集合：collection中的方法

        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        Stream<String> stream = list.stream();
        System.out.println(stream);

        //针对数组String接口中的静态方法

        Stream<String> stream1=Stream.of("武松","李青","李逵");
        System.out.println(stream1);

    }
}

2.Stream的方法

(1)Stream中的forEach方法：void  forEach（Consumer<？ super T>action）

forEach：逐一处理->遍历

void  ForEach（Consumer<? super  T>action）

注意：forEach方法是一个终结2方法，使用完之后，Stream流不能使用了

（2）Stream中的long  count（）方法

作用：统计元素个数

注意：count也是一个终结方法

（3）Stream中的long  count（）方法

作用：统计元素个数

注意：count也是一个终结方法

（4）Stream中的Stream<T> filter(Predicate<? super T>predicate)方法

方法：Stream中的Stream<T> filter(Predicate<? super T>predicate)方法，返回一个新的Stream流对象

作用：根据某个条件进行元素过滤

(5)Stream<T> limit(long  maxSize):获取Stream流对象按那个中的前n个元素返回一个新的Stream流对象

Stream<T> limit(long  maxSize):获取Stream流对象按那个中的前n个元素返回一个新的Stream流对象

（6）Stream<T> slip(long n):跳过Stream流对象中的前n个元素，返回一个新的Stream流对象

Stream<T> slip(long n):跳过Stream流对象中的前n个元素，返回一个新的Stream流对象

（7）static<T> Stream<T>  concat(Stream<?  extends  T>a,Stream<? extend T>b):两个流合成一个流

static<T> Stream<T>  concat(Stream<?  extends  T>a,Stream<? extend T>b):两个流合成一个流

import java.util.function.Consumer;

import java.util.stream.Stream;

public class Demo02Stream {
    public static void main(String[] args) {
        //foreach();

    //    count();

   //     filter();

      //  limit();

      //  slip();

        concat();
    }

    private static void concat(){
        Stream<String> stream1=Stream.of("武松","李青","李逵","诸葛");
        Stream<String> stream2=Stream.of("武","李","李","诸");

        Stream.concat(stream1,stream2).forEach(s -> System.out.println(s));


    }

    private static void slip() {
        Stream<String> stream1=Stream.of("武松","李青","李逵","诸葛");
        stream1.skip(2).forEach(s -> System.out.println(s));


    }

    private static void limit() {
        Stream<String> stream1=Stream.of("武松","李青","李逵","诸葛");
        stream1.limit(3).forEach(s -> System.out.println(s));


    }


    private static void filter() {
        Stream<String> stream1=Stream.of("武松","李青","李逵","诸葛");
     /*stream1.filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()==2;
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        System.out.println("==============");
stream1.filter(s -> s.length()==2).forEach(s -> System.out.println(s));





        /*newStream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
*/
    }

    /*
*
*
* 统计元素个数
*
* */
    private static void count() {

        Stream<String> stream1=Stream.of("武松","李青","李逵");
        long count=stream1.count();
        System.out.println("count="+count);

    }

    /*
    * 逐一处理，可以用来遍历
    *
    * */
    private static void foreach() {

        Stream<String> stream1=Stream.of("武松","李青","李逵");
        stream1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        System.out.println("=================");
        stream1.forEach( s-> System.out.println(s));

    }
}

四、方法引用

1.方法引用介绍

概述：引用方法

啥时候使用：

  被引用的方法要写在重写方法里面

  被引用的方法从参数上，返回值上要和所在的重写方法一致，而且引用的方法最好是操作重写方法的参数值的

  干掉重写方法的参数；干掉->;干掉被引用方法的参数->将被饮用方法的.改成：：

import java.util.function.Consumer;
import java.util.stream.Stream;

public class Demo01Method {
    public static void main(String[] args) {

        Stream<String> stream = Stream.of("今天", "明天", "后天");

            /*
            * accept是重写方法：参数类型string  无返回值
            *
            * accept方法里面有println方法：println参数类型位String被引用的方法操作重写方参数值println没有返回值
            *
            * */
        /*stream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
*/
        System.out.println("==================");

      //  stream.forEach( s-> System.out.println(s));
        System.out.println("==================");

        stream.forEach( System.out::println);

    }
}

2.对象名-引用成员方法

使用对象名引用成员方法

格式：

对象：：成员方法名

需求：

函数式接口：Supplier

  java.util.function.Supplier<T>接口

抽象方法：

 T get（）用来获取一个泛型参数指定类型的对象数据

Supplier接口使用什么泛型，就可以使用get方法获取一个什么类型的数据

import java.util.function.Supplier;

public class Demo02Method {
    public static void main(String[] args) {


        /*
        *
        * get为重写方法无参的返回值位string
        * trim方法在get中无参的返回值为string
        * 考虑使用方法引用
        *
        * */
        method(new Supplier<String>() {
            @Override
            public String get() {
                return " abc ".trim();
            }
        });

        System.out.println("=============");

        method(()->" abc ".trim());

        System.out.println("====================");

        method(" abc "::trim);



    }

    public static void method(Supplier<String> supplier){
        String s=supplier.get();
        System.out.println("s="+s);
    }
}

3.类名-引用静态方法

类名-引用静态方法

格式：

类名：：静态成员方法

4.类-构造引用

类-构造方法引用

格式：

构造方法名称：：new

5.数组-数组引用

数组-数组引用

格式：

数组中的数据类型[]：：new

int[]：：new  创建一个int型的数组

double[]：：new  创建于一个double型的数据

编程里的小白
关注
Java(反射，接口新特性，Lambda表达式)
LzyGamber的博客
11-28 296
反射 概念 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 在程序执行过程中动态的调用没有书写调用其他类的代码. 类加载器 将编译好的class二进制字节码文件交由jvm进行执行 三种默认类加载器 **启动类加载器：**将启动jvm的class文件进行加载执行 **扩展加载器：**将java运行基本jar包进行加载执行 **系统加载器：**将我们编
java lambda 反射_反射调用与Lambda表达式调用
weixin_42511517的博客
02-27 1042
想调用一个方法很容易，直接代码调用就行，这人人都会。其次呢，还可以使用反射。不过通过反射调用的性能会远远低于直接调用——至少从绝对时间上来看的确是这样。虽然这是个众所周知的现象，我们还是来写个程序来验证一下。比如我们现在新建一个Console应用程序，编写一个最简单的Call方法。class Program{static void Main(string[] args){}public void ...
使用Lambda表达式进行映射
alai_5186_cdsn的专栏
08-31 94
【代码】使用Lambda表达式进行映射。
【JAVA】反射、枚举、Lambda的使用
Xian meng在努力呐-的博客
10-14 1263
1. 反射可以拿到隐私的方法、属性 2. 枚举不能反射 3. Lambda的语法（精简语句） 4. 变量捕获 5. 匿名内部类 6. 反射、枚举以及Lambda的使用
9.反射和Lambda表达式
mmm174的博客
06-18 1092
1.反射是什么2.反射操作的四个核心类（都处在java.lang.reflect）3.在java中获取一个类的class对象一共有三种途径：4.想通过反射来操作类或者对象，第一步就是要获得该类的class对象。 5.Constructor应用 6.Method应用 7.Field应用二、Lambda表达式（有的语言称为闭包）1.最常见的写法： 2.使用匿名内部类来简化子类的实现。 3.使用Lambda表达式 4.不同情况的Lambda表达式动态（运行时）获取类信息以及动态调用该对象的属性和方法的
lambda表达式优化反射_反射选择器表达式
最佳 Java 编程
07-06 274
lambda表达式优化反射 Java :: Geci是一个在单元测试期间运行的代码生成器。 如果生成的代码适合源代码的实际版本，则测试不会失败。 如果需要进行任何修改，则测试将修改源代码并失败。 例如，存在一个需要setter和getter的新字段，然后访问器生成器将生成新的setter和getter，然后失败。 如果没有新字段，那么生成的代码就是已经存在的代码，没有理由触摸源代码：启动生成器...
反射、Lambda表达式（Java学习笔记十二）
一只黑猩猩
06-05 1779
尚硅谷Java课程学习笔记。
数据结构之反射与Lambda表达式
m0_58006481的博客
03-26 1459
反射：Class:反射操作的核心类（区别class，class是一个声明类的关键字）；Constructor:与构造方法相关的类；Method:与类中方法相关的类；Field:与类中属性相关的类。Lambda表达式使用：不同情况Lambda表达式使用（返回值有无，参数有无）
【javase高级-反射与lambda表达式】
weixin_53061888的博客
12-11 1512
知识回顾1.反射1.1什么是反射？1.2通过反射对对象进行操作；1.2.1通过反射加载类的三种方式；1.2.2通过反射拿到类名，包名1.2.3通过反射拿到属性，方法1.2.4通过反射拿到构造方法，创建对象lambda表达式 1.反射 1.1什么是反射？ 把类的各个组成部分通过映射成为对象，然后通过对象再对类的各个部分进行操作，这就是反射； 1.2通过反射对对象进行操作； 1.2.1通过反射加载类的三种方式； package blue; import java.lang.reflect.Field; imp
Java中反射、枚举及lambda表达式的使用
dddddrrrzz的博客
03-02 1389
目录一、反射1.1 定义1.2 用途1.3 反射基本信息1.4 与反射相关的类1.5 Class类(反射机制的起源 )1.6 Class类中的相关方法1.7 获得Class对象的三种方式1.8 反射的使用1.9 反射优点和缺点二、枚举2.1 Enum 类的常用方法2.2 枚举的优点和缺点三、Lambda 表达式总结 一、反射 1.1 定义 Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到，那
java 多态替代switch表达式+lambda表达式
guohao_Kwok的博客
07-10 4385
精选30+云产品，助力企业轻松上云！>>> 原代码：...
方法的直接调用，反射调用与……Lambda表达式调用
weixin_34153893的博客
11-24 207
想调用一个方法很容易，直接代码调用就行，这人人都会。其次呢，还可以使用反射。不过通过反射调用的性能会远远低于直接调用——至少从绝对时间上来看的确是这样。虽然这是个众所周知的现象，我们还是来写个程序来验证一下。比如我们现在新建一个Console应用程序，编写一个最简单的Call方法。class Program { static void Main(string[] args) ...
Java泛型、反射、注解、Lambda表达式
Shingle_的博客
08-22 1072
泛型介绍 （使用频率高） 泛型类型是通过类型参数化的泛型类或接口。通过类型参数化，来解决程序的通用性设计和实现的若干问题。 泛型试图解决的问题： 编译期类型检查：可以避免运行时错误的发生 强制类型检查 可读性和灵活性 泛型本身就是对于继承在使用上的一种增强。编译器在编译源码时，首先进行泛型类型参数的检查，然后进行类型 擦除并同时在类型参数出现的位置插入强制类型转换指令从而实现。 ...
java 异常包装
最新发布
fdvvg的博客
10-17 213
通过异常包装，可以在Java中有效地处理和传递异常。这样做不仅能保持原始异常的信息，还能为上层调用者提供更多的上下文信息。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 355
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 669
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
qq_57340195的博客
10-17 520
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
Java注解与Lambda表达式详解
总结起来，这篇笔记涵盖了Java中注解的创建与使用，以及Lambda表达式的构成和应用，这些都是现代Java开发中不可或缺的知识点。理解并熟练运用这些特性，能提高代码的可读性和可维护性，同时利用Lambda可以更好地实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值