JavaSE重点知识点总结后篇_Java

一、面向对象

1、深拷贝和其那拷贝的区别

在 java 中，深拷贝（deep copy）和浅拷贝（shallow copy）是两种拷贝对象的方式，它们在拷贝对象的方式上有很大不同。

浅拷贝会创建一个新对象，但这个新对象的属性（字段）和原对象的属性完全相同。如果属性是基本数据类型，拷贝的是基本数据类型的值；如果属性是引用类型，拷贝的是引用地址，因此新旧对象共享同一个引用对象。

浅拷贝的实现方式为：实现 cloneable 接口并重写 clone() 方法。

class person implements cloneable {
    string name;
    int age;
    address address;

    public person(string name, int age, address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @override
    protected object clone() throws clonenotsupportedexception {
        return super.clone();
    }
}

class address {
    string city;

    public address(string city) {
        this.city = city;
    }
}

public class main {
    public static void main(string[] args) throws clonenotsupportedexception {
        address address = new address("张家口");
        person person1 = new person("寻星探路", 18, address);
        person person2 = (person) person1.clone();

        system.out.println(person1.address == person2.address); // true
    }
}

深拷贝也会创建一个新对象，但会递归地复制所有的引用对象，确保新对象和原对象完全独立。新对象与原对象的任何更改都不会相互影响。

深拷贝的实现方式有：手动复制所有的引用对象，或者使用序列化与反序列化。

①、手动拷贝

class person {
    string name;
    int age;
    address address;

    public person(string name, int age, address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public person(person person) {
        this.name = person.name;
        this.age = person.age;
        this.address = new address(person.address.city);
    }
}

class address {
    string city;

    public address(string city) {
        this.city = city;
    }
}

public class main {
    public static void main(string[] args) {
        address address = new address("张家口");
        person person1 = new person("寻星探路", 18, address);
        person person2 = new person(person1);

        system.out.println(person1.address == person2.address); // false
    }
}

②、序列化与反序列化

import java.io.*;

class person implements serializable {
    string name;
    int age;
    address address;

    public person(string name, int age, address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public person deepclone() throws ioexception, classnotfoundexception {
        bytearrayoutputstream bos = new bytearrayoutputstream();
        objectoutputstream oos = new objectoutputstream(bos);
        oos.writeobject(this);

        bytearrayinputstream bis = new bytearrayinputstream(bos.tobytearray());
        objectinputstream ois = new objectinputstream(bis);
        return (person) ois.readobject();
    }
}

class address implements serializable {
    string city;

    public address(string city) {
        this.city = city;
    }
}

public class main {
    public static void main(string[] args) throws ioexception, classnotfoundexception {
        address address = new address("张家口");
        person person1 = new person("寻星探路", 18, address);
        person person2 = person1.deepclone();

        system.out.println(person1.address == person2.address); // false
    }
}

2、java创建对象有哪几种方式？

java 有四种创建对象的方式：

①、new 关键字创建，这是最常见和直接的方式，通过调用类的构造方法来创建对象。

person person = new person();

②、反射机制创建，反射机制允许在运行时创建对象，并且可以访问类的私有成员，在框架和工具类中比较常见。

class clazz = class.forname("person");
person person = (person) clazz.newinstance();

③、clone 拷贝创建，通过 clone 方法创建对象，需要实现 cloneable 接口并重写 clone 方法。

person person = new person();
person person2 = (person) person.clone();

④、序列化机制创建，通过序列化将对象转换为字节流，再通过反序列化从字节流中恢复对象。需要实现 serializable 接口。

person person = new person();
objectoutputstream oos = new objectoutputstream(new fileoutputstream("person.txt"));
oos.writeobject(person);
objectinputstream ois = new objectinputstream(new fileinputstream("person.txt"));
person person2 = (person) ois.readobject();

二、string

1、string 和stringbuilder、stringbuffer 的区别?

string 和stringbuilder、stringbuffer在 java 中都是用于处理字符串的，它们之间的区别是，string 是不可变的，平常开发用得最多，当遇到大量字符串连接时，就用 stringbuilder，它不会生成很多新的对象，stringbuffer 和 stringbuilder 类似，但每个方法上都加了 synchronized 关键字，所以是线程安全的。

string的特点

string类的对象是不可变的。也就是说，一旦一个string对象被创建，它所包含的字符串内容是不可改变的。
每次对string对象进行修改操作（如拼接、替换等）实际上都会生成一个新的string对象，而不是修改原有对象。这可能会导致内存和性能开销，尤其是在大量字符串操作的情况下。

stringbuilder的特点

stringbuilder提供了一系列的方法来进行字符串的增删改查操作，这些操作都是直接在原有字符串对象的底层数组上进行的，而不是生成新的 string 对象。
stringbuilder不是线程安全的。这意味着在没有外部同步的情况下，它不适用于多线程环境。
相比于string，在进行频繁的字符串修改操作时，stringbuilder能提供更好的性能。 java 中的字符串连+操作其实就是通过stringbuilder实现的。

stringbuffer的特点

stringbuffer和stringbuilder类似，但stringbuffer是线程安全的，方法前面都加了synchronized关键字。

使用场景

string：适用于字符串内容不会改变的场景，比如说作为 hashmap 的 key。
stringbuilder：适用于单线程环境下需要频繁修改字符串内容的场景，比如在循环中拼接或修改字符串，是 string 的完美替代品。
stringbuffer：现在已经不怎么用了，因为一般不会在多线程场景下去频繁的修改字符串内容

2、string 是不可变类吗?

string 是不可变的，这意味着一旦一个 string 对象被创建，其存储的文本内容就不能被改变。这是因为：

①、不可变性使得 string 对象在使用中更加安全。因为字符串经常用作参数传递给其他 java 方法，例如网络连接、打开文件等。

如果 string 是可变的，这些方法调用的参数值就可能在不知不觉中被改变，从而导致网络连接被篡改、文件被莫名其妙地修改等问题。

②、不可变的对象因为状态不会改变，所以更容易进行缓存和重用。字符串常量池的出现正是基于这个原因。

当代码中出现相同的字符串字面量时，jvm 会确保所有的引用都指向常量池中的同一个对象，从而节约内存。

③、因为 string 的内容不会改变，所以它的哈希值也就固定不变。这使得 string 对象特别适合作为 hashmap 或 hashset 等集合的键，因为计算哈希值只需要进行一次，提高了哈希表操作的效率。

如何保证string不可变？

第一，string 类内部使用一个私有的字符数组来存储字符串数据。这个字符数组在创建字符串时被初始化，之后不允许被改变。

private final char value[];

第二，string 类没有提供任何可以修改其内容的公共方法，像 concat 这些看似修改字符串的操作，实际上都是返回一个新创建的字符串对象，而原始字符串对象保持不变。

public string concat(string str) {
    if (str.isempty()) {
        return this;
    }
    int len = value.length;
    int otherlen = str.length();
    char buf[] = arrays.copyof(value, len + otherlen);
    str.getchars(buf, len);
    return new string(buf, true);
}

第三，string 类本身被声明为 final，这意味着它不能被继承。这防止了子类可能通过添加修改方法来改变字符串内容的可能性。

public final class string

三、异常处理

1、java中的异常体系？

java 中的异常处理机制用于处理程序运行过程中可能发生的各种异常情况，通常通过 try-catch-finally 语句和 throw 关键字来实现。

throwable 是 java 语言中所有错误和异常的基类。它有两个主要的子类：error 和 exception，这两个类分别代表了 java 异常处理体系中的两个分支。

error 类代表那些严重的错误，这类错误通常是程序无法处理的。比如，outofmemoryerror 表示内存不足，stackoverflowerror 表示栈溢出。这些错误通常与 jvm 的运行状态有关，一旦发生，应用程序通常无法恢复。

exception 类代表程序可以处理的异常。它分为两大类：编译时异常（checked exception）和运行时异常（runtime exception）。

①、编译时异常（checked exception）：这类异常在编译时必须被显式处理（捕获或声明抛出）。

如果方法可能抛出某种编译时异常，但没有捕获它（try-catch）或没有在方法声明中用 throws 子句声明它，那么编译将不会通过。例如：ioexception、sqlexception 等。

②、运行时异常（runtime exception）：这类异常在运行时抛出，它们都是 runtimeexception 的子类。对于运行时异常，java 编译器不要求必须处理它们（即不需要捕获也不需要声明抛出）。

运行时异常通常是由程序逻辑错误导致的，如 nullpointerexception、indexoutofboundsexception 等。

2、异常的处理方式

①、遇到异常时可以不处理，直接通过throw 和 throws 抛出异常，交给上层调用者处理。

throws 关键字用于声明可能会抛出的异常，而 throw 关键字用于抛出异常。

public void test() throws exception {
    throw new exception("抛出异常");
}

②、使用 try-catch 捕获异常，处理异常。

try {
    //包含可能会出现异常的代码以及声明异常的方法
}catch(exception e) {
    //捕获异常并进行处理
}finally {
    //可选，必执行的代码
}

catch和finally的异常可以同时抛出吗?

如果 catch 块抛出一个异常，而 finally 块中也抛出异常，那么最终抛出的将是 finally 块中的异常。catch 块中的异常会被丢弃，而 finally 块中的异常会覆盖并向上传递。

public class example {
    public static void main(string[] args) {
        try {
            throw new exception("exception in try");
        } catch (exception e) {
            throw new runtimeexception("exception in catch");
        } finally {
            throw new illegalargumentexception("exception in finally");
        }
    }
}

try 块首先抛出一个 exception。
控制流进入 catch 块，catch 块中又抛出了一个 runtimeexception。
但是在 finally 块中，抛出了一个 illegalargumentexception，最终程序抛出的异常是 finally 块中的 illegalargumentexception。

虽然 catch 和 finally 中的异常不能同时抛出，但可以手动捕获 finally 块中的异常，并将 catch 块中的异常保留下来，避免被覆盖。常见的做法是使用一个变量临时存储 catch 中的异常，然后在 finally 中处理该异常：

public class example {
    public static void main(string[] args) {
        exception catchexception = null;
        try {
            throw new exception("exception in try");
        } catch (exception e) {
            catchexception = e;
            throw new runtimeexception("exception in catch");
        } finally {
            try {
                throw new illegalargumentexception("exception in finally");
            } catch (illegalargumentexception e) {
                if (catchexception != null) {
                    system.out.println("catch exception: " + catchexception.getmessage());
                }
                system.out.println("finally exception: " + e.getmessage());
            }
        }
    }
}

四、i/o

1、java中io流分为几种？

jaa io 流的划分可以根据多个维度进行，包括数据流的方向（输入或输出）、处理的数据单位（字节或字符）、流的功能以及流是否支持随机访问等。

按照数据流方向进行划分？

输入流（input stream）：从源（如文件、网络等）读取数据到程序。
输出流（output stream）：将数据从程序写出到目的地（如文件、网络、控制台等）。

按处理数据单位如何划分？

字节流（byte streams）：以字节为单位读写数据，主要用于处理二进制数据，如音频、图像文件等。
字符流（character streams）：以字符为单位读写数据，主要用于处理文本数据。

按功能如何划分？

节点流（node streams）：直接与数据源或目的地相连，如 fileinputstream、fileoutputstream。
处理流（processing streams）：对一个已存在的流进行包装，如缓冲流 bufferedinputstream、bufferedoutputstream。
管道流（piped streams）：用于线程之间的数据传输，如 pipedinputstream、pipedoutputstream。

io流用到了什么设计模式?

用到了——装饰器模式，装饰器模式的核心思想是在不改变原有对象结构的前提下，动态地给对象添加新的功能。

具体到 java io 中，inputstream 和 outputstream 这些抽象类定义了基本的读写操作，然后通过各种装饰器类来增强功能。比如 bufferedinputstream 给基础的输入流增加了缓冲功能，datainputstream 增加了读取基本数据类型的能力，它们都是对基础流的装饰和增强。

inputstream input = new bufferedinputstream(
    new datainputstream(
        new fileinputstream("data.txt")
    )
);

这里 fileinputstream 提供基本的文件读取能力，datainputstream 装饰它增加了数据类型转换功能，bufferedinputstream 再装饰它增加了缓冲功能。每一层装饰都在原有功能基础上增加新特性，而且可以灵活组合。

我对装饰器模式的理解是它很好地体现了“组合优于继承”的设计原则。优势在于运行时动态组合功能，而且遵循开闭原则，可以在不修改现有代码的情况下增加新功能。

java 缓冲区溢出，如何预防？

java 缓冲区溢出主要是由于向缓冲区写入的数据超过其能够存储的数据量。可以采用这些措施来避免：

①、合理设置缓冲区大小：在创建缓冲区时，应根据实际需求合理设置缓冲区的大小，避免创建过大或过小的缓冲区。

②、控制写入数据量：在向缓冲区写入数据时，应该控制写入的数据量，确保不会超过缓冲区的容量。java 的 bytebuffer 类提供了remaining()方法，可以获取缓冲区中剩余的可写入数据量。

import java.nio.bytebuffer;

public class bytebufferexample {

    public static void main(string[] args) {
        // 模拟接收到的数据
        byte[] receiveddata = {1, 2, 3, 4, 5};
        int buffersize = 1024;  // 设置一个合理的缓冲区大小

        // 创建bytebuffer
        bytebuffer buffer = bytebuffer.allocate(buffersize);

        // 写入数据之前检查容量是否足够
        if (buffer.remaining() >= receiveddata.length) {
            buffer.put(receiveddata);
        } else {
            system.out.println("not enough space in buffer to write data.");
        }

        // 准备读取数据：将limit设置为当前位置，position设回0
        buffer.flip();

        // 读取数据
        while (buffer.hasremaining()) {
            byte data = buffer.get();
            system.out.println("read data: " + data);
        }

        // 清空缓冲区以便再次使用
        buffer.clear();
    }
}

2、有了字节流为什么还要有字符流？

其实字符流是由 java 虚拟机将字节转换得到的，问题就出在这个过程还比较耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。

所以， i/o 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。

文本存储是字节流还是字符流，视频文件呢?

在计算机中，文本和视频都是按照字节存储的，只是如果是文本文件的话，我们可以通过字符流的形式去读取，这样更方面的我们进行直接处理。

比如说我们需要在一个大文本文件中查找某个字符串，可以直接通过字符流来读取判断。

处理视频文件时，通常使用字节流（如 java 中的fileinputstream、fileoutputstream）来读取或写入数据，并且会尽量使用缓冲流（如bufferedinputstream、bufferedoutputstream）来提高读写效率。

3、bio、nio、aio 之间的区别?

bio：采用阻塞式 i/o 模型，线程在执行 i/o 操作时被阻塞，无法处理其他任务，适用于连接数较少的场景。

nio：采用非阻塞 i/o 模型，线程在等待 i/o 时可执行其他任务，通过 selector 监控多个 channel 上的事件，适用于连接数多但连接时间短的场景。

aio：使用异步 i/o 模型，线程发起 i/o 请求后立即返回，当 i/o 操作完成时通过回调函数通知线程，适用于连接数多且连接时间长的场景。

五、序列化

1、什么是序列化？什么是反序列化？

序列化（serialization）是指将对象转换为字节流的过程，以便能够将该对象保存到文件、数据库，或者进行网络传输。

反序列化（deserialization）就是将字节流转换回对象的过程，以便构建原始对象。

解释一下序列化的过程和作用

序列化过程通常涉及到以下几个步骤：

第一步，实现 serializable 接口。

public class person implements serializable {
    private string name;
    private int age;

    // 省略构造方法、getters和setters
}

第二步，使用 objectoutputstream 来将对象写入到输出流中。

objectoutputstream out = new objectoutputstream(new fileoutputstream("person.ser"));

第三步，调用 objectoutputstream 的 writeobject 方法，将对象序列化并写入到输出流中。

person person = new person("寻星探路", 18);
out.writeobject(person);

2、有几种序列化方式？

java 对象序列化：java 原生序列化方法即通过 java 原生流(inputstream 和 outputstream 之间的转化)的方式进行转化，一般是对象输出流 objectoutputstream和对象输入流objectinputstream。
json 序列化：这个可能是我们最常用的序列化方式，json 序列化的选择很多，一般会使用 jackson 包，通过 objectmapper 类来进行一些操作，比如将对象转化为 byte 数组或者将 json 串转化为对象。
protobuff 序列化：protocolbuffer 是一种轻便高效的结构化数据存储格式，protobuff 序列化对象可以很大程度上将其压缩，可以大大减少数据传输大小，提高系统性能。

六、网络编程

1、了解过socket网络套接字吗？

socket 是网络通信的基础，表示两台设备之间通信的一个端点。socket 通常用于建立 tcp 或 udp 连接，实现进程间的网络通信。

一个简单的 tcp 客户端：

class tcpclient {
    public static void main(string[] args) throws ioexception {
        socket socket = new socket("127.0.0.1", 8080); // 连接服务器
        bufferedreader in = new bufferedreader(new inputstreamreader(socket.getinputstream()));
        printwriter out = new printwriter(socket.getoutputstream(), true);

        out.println("hello, server!"); // 发送消息
        system.out.println("server response: " + in.readline()); // 接收服务器响应

        socket.close();
    }
}

tcp 服务端：

class tcpserver {
    public static void main(string[] args) throws ioexception {
        serversocket serversocket = new serversocket(8080); // 创建服务器端socket
        system.out.println("server started, waiting for connection...");
        socket socket = serversocket.accept(); // 等待客户端连接
        system.out.println("client connected: " + socket.getinetaddress());

        bufferedreader in = new bufferedreader(new inputstreamreader(socket.getinputstream()));
        printwriter out = new printwriter(socket.getoutputstream(), true);

        string message;
        while ((message = in.readline()) != null) {
            system.out.println("received: " + message);
            out.println("echo: " + message); // 回送消息
        }

        socket.close();
        serversocket.close();
    }
}

rpc框架了解吗？

rpc是一种协议，允许程序调用位于远程服务器上的方法，就像调用本地方法一样。rpc 通常基于 socket 通信实现。

rpc，remote procedure call，远程过程调用

rpc 框架支持高效的序列化（如 protocol buffers）和通信协议（如 http/2），屏蔽了底层网络通信的细节，开发者只需关注业务逻辑即可。

常见的 rpc 框架包括：

grpc：基于 http/2 和 protocol buffers。
dubbo：阿里开源的分布式 rpc 框架，适合微服务场景。
spring cloud openfeign：基于 rest 的轻量级 rpc 框架。
thrift：apache 的跨语言 rpc 框架，支持多语言代码生成。

七、泛型

1、java泛型了吗？

泛型主要用于提高代码的类型安全，它允许在定义类、接口和方法时使用类型参数，这样可以在编译时检查类型一致性，避免不必要的类型转换和类型错误。

没有泛型的时候，像 list 这样的集合类存储的是 object 类型，导致从集合中读取数据时，必须进行强制类型转换，否则会引发 classcastexception。

list list = new arraylist();
list.add("hello");
string str = (string) list.get(0);  // 必须强制类型转换

泛型一般有三种使用方式:泛型类、泛型接口、泛型方法。

1.泛型类：

//此处t可以随便写为任意标识，常见的如t、e、k、v等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定t的具体类型
public class generic<t>{

    private t key;

    public generic(t key) {
        this.key = key;
    }

    public t getkey(){
        return key;
    }
}

如何实例化泛型类：

generic<integer> genericinteger = new generic<integer>(123456);

2.泛型接口 ：

public interface generator<t> {
    public t method();
}

实现泛型接口，指定类型：

class generatorimpl<t> implements generator<string>{
    @override
    public string method() {
        return "hello";
    }
}

3.泛型方法 ：

   public static < e > void printarray( e[] inputarray )
   {
         for ( e element : inputarray ){
            system.out.printf( "%s ", element );
         }
         system.out.println();
    }

使用：

// 创建不同类型数组： integer, double 和 character
integer[] intarray = { 1, 2, 3 };
string[] stringarray = { "hello", "world" };
printarray( intarray  );
printarray( stringarray  );

泛型常用的通配符有哪些？

常用的通配符为： t，e，k，v，？

？表示不确定的 java 类型
t (type) 表示具体的一个 java 类型
k v (key value) 分别代表 java 键值中的 key value
e (element) 代表 element

什么是泛型擦除？

所谓的泛型擦除，官方名叫“类型擦除”。

java 的泛型是伪泛型，这是因为 java 在编译期间，所有的类型信息都会被擦掉。

也就是说，在运行的时候是没有泛型的。

例如这段代码，往一群猫里放条狗：

linkedlist<cat> cats = new linkedlist<cat>();
linkedlist list = cats;  // 注意我在这里把范型去掉了，但是list和cats是同一个链表！
list.add(new dog());  // 完全没问题！

因为 java 的范型只存在于源码里，编译的时候给你静态地检查一下范型类型是否正确，而到了运行时就不检查了。上面这段代码在 jre（java运行环境）看来和下面这段没区别：

linkedlist cats = new linkedlist();  // 注意：没有范型！
linkedlist list = cats;
list.add(new dog());

为什么要类型擦除呢？

主要是为了向下兼容，因为 jdk5 之前是没有泛型的，为了让 jvm 保持向下兼容，就出了类型擦除这个策略。

八、反射

1、什么是反射？原理？应用？

反射允许 java 在运行时检查和操作类的方法和字段。通过反射，可以动态地获取类的字段、方法、构造方法等信息，并在运行时调用方法或访问字段。

比如创建一个对象是通过 new 关键字来实现的：

person person = new person();

person 类的信息在编译时就确定了，那假如在编译期无法确定类的信息，但又想在运行时获取类的信息、创建类的实例、调用类的方法，这时候就要用到反射。

反射功能主要通过 java.lang.class 类及 java.lang.reflect 包中的类如 method, field, constructor 等来实现。

比如说我们可以动态加载类并创建对象：

string classname = "java.util.date";
class<?> cls = class.forname(classname);
object obj = cls.newinstance();
system.out.println(obj.getclass().getname());

比如说我们可以这样来访问字段和方法：

// 加载并实例化类
class<?> cls = class.forname("java.util.date");
object obj = cls.newinstance();

// 获取并调用方法
method method = cls.getmethod("gettime");
object result = method.invoke(obj);
system.out.println("time: " + result);

// 访问字段
field field = cls.getdeclaredfield("fasttime");
field.setaccessible(true); // 对于私有字段需要这样做
system.out.println("fasttime: " + field.getlong(obj));

反射有哪些应用场景？

①、spring 框架就大量使用了反射来动态加载和管理 bean。

class<?> clazz = class.forname("com.example.myclass");
object instance = clazz.newinstance();

②、java 的动态代理机制就使用了反射来创建代理类。代理类可以在运行时动态处理方法调用，这在实现 aop 和拦截器时非常有用。

invocationhandler handler = new myinvocationhandler();
myinterface proxyinstance = (myinterface) proxy.newproxyinstance(
    myinterface.class.getclassloader(),
    new class<?>[] { myinterface.class },
    handler
);

③、junit 和 testng 等测试框架使用反射机制来发现和执行测试方法。反射允许框架扫描类，查找带有特定注解（如 @test）的方法，并在运行时调用它们。

method testmethod = testclass.getmethod("testsomething");
testmethod.invoke(testinstance);

④、最常见的是写通用的工具类，比如对象拷贝工具。比如说 beanutils、mapstruct 等等，能够自动拷贝两个对象之间的同名属性，就是通过反射来实现的。

反射的原理是什么？

每个类在加载到 jvm 后，都会在方法区生成一个对应的 class 对象，这个对象包含了类的所有元信息，比如字段、方法、构造器、注解等。

通过这个 class 对象，我们就能在运行时动态地创建对象、调用方法、访问字段。

反射的优缺点是什么？

反射的优点还是很明显的。首先是能够在运行时动态操作类和对象。其次是能够编写通用的代码，一套代码可以处理不同类型的对象。还有就是能够突破访问限制，访问 private 字段和方法，这在反编译场景下很有用。

但反射的缺点也不少。最明显的是性能问题，反射操作比直接调用要慢很多，因为需要在运行时解析类信息、进行类型检查、权限验证等。

其次是反射能够绕过访问控制，访问和修改 private 成员，这会破坏类的封装。

九、lambda表达式

1、lambda表达式了解多少？

lambda 表达式主要用于提供一种简洁的方式来表示匿名方法，使 java 具备了函数式编程的特性。

比如说我们可以使用 lambda 表达式来简化线程的创建：

new thread(() -> system.out.println("hello world")).start();

这比以前的匿名内部类要简洁很多。

所谓的函数式编程，就是把函数作为参数传递给方法，或者作为方法的结果返回。比如说我们可以配合 stream 流进行数据过滤：

list<integer> numbers = arrays.aslist(1, 2, 3, 4, 5, 6);
list<integer> evennumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(collectors.tolist());

其中 n -> n % 2 == 0 就是一个 lambda 表达式。表示传入一个参数 n，返回 n % 2 == 0 的结果。

到此这篇关于javase重点知识点总结的文章就介绍到这了,更多相关javase重点知识点内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

JavaSE重点知识点总结后篇

2026年09月03日 • Java •我要评论