Java 和 C++ 的区别是什么？

一：Java 和 C++ 的区别是什么？

1. 应用领域：Java 主要用于开发跨平台的企业级应用、Web 应用、移动应用和大型系统。C++ 则广泛应用于系统级开发、游戏开发、嵌入式系统和性能要求较高的应用。

2. 语言风格：Java 是一种面向对象的纯粹的面向对象编程语言，所有的代码都必须写在类中。而 C++ 具有面向对象和面向过程的特性，可以使用类和函数来组织代码。

3. 内存管理：Java 使用自动垃圾回收机制进行内存管理，程序员不需要手动分配或释放内存。C++ 则需要手动管理内存，包括手动分配和释放内存。

4. 平台依赖性：Java 被设计为平台无关的语言，可以在任何支持 Java 虚拟机（JVM）的平台上运行。C++ 的代码则需要在特定平台上进行编译和执行。

5. 异常处理：Java 引入了异常处理机制，强制开发者使用 try-catch 块来捕获和处理异常。C++ 也支持异常处理，但并不强制开发者使用。

6. 执行效率：由于 Java 使用解释执行和垃圾回收机制，相对于 C++ 来说，执行效率较低。C++ 是一种编译型语言，直接编译成机器代码，因此通常比 Java 执行效率更高。

7. 标准库：Java 提供了一个强大的标准库（Java API），包含了大量的类和方法，涵盖了各种常见的任务。C++ 的标准库（STL）同样提供了丰富的数据结构和算法，但相对来说更底层一些。

8. 开发工具：Java 使用开发工具包（JDK）作为开发环境，其中包含了编译器、调试器和其他工具。C++ 则可以使用多个编译器，如 GCC、Visual C++ 等。

 

二：什么是 Java 的平台无关性？

        Java 的平台无关性是指用 Java 编写的程序可以在不同的计算机平台上运行，而不需要针对特定平台进行修改。这是因为 Java 程序不是直接在特定平台的硬件上运行，而是在 Java 虚拟机（JVM）上运行，JVM 负责将 Java 字节码转换成特定平台的机器码。这种机制使得一次编写的 Java 程序可以在任何支持 Java 的平台上运行，大大提高了程序的可移植性和跨平台能力

 

三：什么是 JVM（Java 虚拟机）？

JVM（Java 虚拟机）是 Java 程序的运行环境，它是 Java 技术的核心组成部分之一。JVM 的主要功能是解释和执行 Java 字节码，并将其转换为特定平台的机器码，以便程序能够在不同的硬件和操作系统上运行。

JVM 的工作原理如下：

1. Java 编译器将 Java 源代码编译成字节码（即扩展名为 .class 的文件）。
2. JVM 将字节码加载到内存中，并对其进行解释和执行。
3. 在解释执行的同时，JVM 还会进行一些优化操作，如即时编译（Just-In-Time Compilation），将频繁执行的字节码转换为本地机器码，提高执行效率。
4. JVM 还负责管理程序的内存、垃圾回收、异常处理等方面的任务，确保程序的安全性和稳定性。

由于 JVM 的存在，Java 程序可以跨平台运行，只需在目标平台上安装适当版本的 JVM 即可执行相同的 Java 字节码，而无需修改程序代码。这种平台无关性是 Java 语言的重要特性之一，使得 Java 成为广泛应用于各种领域的编程语言

 

四：Java 中的基本数据类型有哪些？ 

         在 Java 中，基本数据类型分为两类：原始数据类型（Primitive Data Types）和引用数据类型（Reference Data Types）。原始数据类型是 Java 语言中最基本的数据类型，包括以下几种：

1. 整型（Integer Types）：

   • byte: 8 位有符号整数，取值范围为 -128 到 127。
   • short: 16 位有符号整数，取值范围为 -32,768 到 32,767。
   • int: 32 位有符号整数，取值范围为 -2^31 到 2^31-1。
   • long: 64 位有符号整数，取值范围为 -2^63 到 2^63-1。

2. 浮点型（Floating-Point Types）：

   • float: 32 位单精度浮点数，表示范围较大，但精度相对较低。
   • double: 64 位双精度浮点数，通常用于表示小数或需要更高精度的数据。

3. 字符型（Character Type）：

   • char: 16 位 Unicode 字符，用于表示单个字符。

4. 布尔型（Boolean Type）：

   • boolean: 只能取两个值之一，true 或 false，用于表示逻辑值。

 

五：这些基本数据类型在 Java 中用于存储不同类型的数据，并在程序中进行计算和操作。引用数据类型则是指对象类型（Object Types）、数组类型（Array Types）等，它们是由类或接口定义的数据类型

在 Java 中，自动装箱（Autoboxing）和拆箱（Unboxing）是指基本数据类型和对应的包装类之间的转换过程。

1. 自动装箱（Autoboxing）： 自动装箱是指将基本数据类型自动转换为对应的包装类对象。例如，将 int 类型的整数赋值给 Integer 对象时，编译器会自动进行装箱操作，将 int 转换为 Integer 对象

   int num = 10; Integer number = num; // 这里发生了自动装箱

2. 自动拆箱（Unboxing）： 自动拆箱是指将包装类对象自动转换为对应的基本数据类型。例如，将 Integer 对象赋值给 int 类型的变量时，编译器会自动进行拆箱操作，将 Integer 对象中的值取出来赋给 int 变量

   Integer number = new Integer(20); int num = number; // 这里发生了自动拆箱

自动装箱和拆箱使得基本数据类型和对应的包装类对象之间的转换更加方便，可以让开发者更轻松地在它们之间进行转换而不需要显式调用相应的方法。这些特性通常可以提高代码的可读性和简洁性

 

六： 什么是 Java 中的多态性？

         在面向对象编程中，多态性（Polymorphism）是指同一个方法或操作可以在不同的对象上产生不同的行为。在 Java 中，多态性是通过继承和方法重写实现的。

具体来说，Java 中的多态性包括两个关键概念：

1. 子类对象可以赋值给父类引用变量： 在 Java 中，可以将子类的对象赋值给父类的引用变量，这称为向上转型（Upcasting）。通过这种方式，可以利用父类的引用变量来引用子类对象，从而实现多态性

2. 方法重写（Override）： 子类可以重写父类的方法，即在子类中定义与父类相同名称、参数列表和返回类型的方法。当通过父类引用变量调用被子类重写的方法时，实际执行的是子类中的方法。

3. 多态性使得程序能够以统一的方式处理不同类型的对象，提高了代码的灵活性和可扩展性。通过使用多态性，可以编写出更通用、可重用的代码，并且便于在程序中引入新的子类或扩展现有的功能

 

七： 什么是方法的重载和重写？

        方法的重载（Overloading）是指在同一个类中，可以定义多个名称相同但参数列表不同的方法。重载的方法具有相同的名称，但是参数的类型、数量或顺序不同。

方法的重写（Overriding）是指在子类中重新定义父类中已经存在的方法，方法的名称和参数列表都必须与父类中的方法相同。通过重写，子类可以对继承自父类的方法进行自定义实现，使得子类可以根据自己的需要修改方法的行为。

总结来说，重载是在同一个类中定义多个方法，参数不同；而重写是在子类中重新定义父类中的方法，方法名和参数都必须相同。重载是编译时的静态绑定，而重写是运行时的动态绑定

 

  八：什么是异常处理？

         异常处理是编程中一种用于处理程序运行过程中可能出现的错误或异常情况的机制。在程序执行过程中，如果发生了异常情况（如除零错误、空指针引用、文件不存在等），系统会抛出异常。为了避免程序因异常而崩溃，可以通过异常处理机制来捕获和处理这些异常。

异常处理包括以下几个关键步骤：

1. 抛出异常（Throwing Exceptions）：当程序发生异常时，可以使用关键字 throw 来抛出一个异常对象。
2. 捕获异常（Catching Exceptions）：使用 try-catch 块来捕获可能抛出的异常。在 try 块中放置可能引发异常的代码，然后在 catch 块中处理异常情况。
3. 处理异常（Handling Exceptions）：在 catch 块中可以编写处理异常的代码，例如打印错误信息、记录日志、恢复程序状态等。
4. 抛出新异常（Throwing New Exceptions）：在处理异常时，也可以根据情况抛出新的异常，以便让调用者继续处理异常。

通过合理地使用异常处理机制，可以提高程序的稳定性和可靠性，确保程序在遇到异常情况时能够进行适当的处理而不会崩溃

九：什么是线程？如何创建和启动线程？

        当我们打开一个程序时，操作系统会为这个程序创建一个进程，一个进程可以包含多个线程。每个线程都有自己的执行路径，可以并发执行，同时共享进程的资源。

线程的创建和启动是由操作系统来完成的。在Java中，我们可以通过继承 Thread 类或实现 Runnable 接口来创建自己的线程。继承 Thread 类需要重写 run() 方法，实现 Runnable 接口需要实现 run() 方法。在 run() 方法中定义线程要执行的任务。

创建线程后，可以通过 start() 方法来启动线程，这会在后台创建一个新的线程，并在新的线程中调用 run() 方法。线程的生命周期包括以下几个状态：新建状态、就绪状态、运行状态、阻塞状态和死亡状态。线程的状态转换由操作系统管理。

多线程的编程需要注意线程安全性和协调问题，以避免出现竞态条件和死锁等情况。比如要保证多个线程同时访问共享资源时不会发生冲突，可以使用同步机制（如 synchronized 关键字）来限制同一时刻只有一个线程能够访问共享资源；要协调多个线程的执行顺序，可以使用 wait()、notify() 和 notifyAll() 等方法来实现线程间的通信

 

十： 什么是 Java 中的同步和异步？

        在Java中，同步和异步是用来描述程序执行模式的两种方式。

1. 同步（Synchronous）：同步指的是按顺序执行，一个任务的执行需要等待上一个任务的结束。在同步模式下，当一个任务开始执行时，程序会阻塞当前线程，直到该任务执行完成后才能继续执行下一个任务。同步通常用于处理顺序执行的逻辑或需要依赖上一个任务结果的情况。

2. 异步（Asynchronous）：异步指的是不按顺序执行，任务的执行可以并发进行，不需要等待上一个任务的结束。在异步模式下，一个任务的执行不会阻塞当前线程，而是通过回调、事件通知等机制来处理任务执行结果。异步通常用于处理并发执行的逻辑或需要非阻塞执行的情况。

在Java中，可以通过多线程编程来实现异步执行。比如使用线程池、CompletableFuture、Future 等机制来实现异步任务的执行。另外，在Java 8 中引入了 CompletableFuture 类，它提供了一种方便的方式来处理异步任务的执行和结果处理，支持链式调用和组合多个异步任务。

总之，同步和异步是描述程序执行模式的两种方式，选择合适的方式取决于具体的业务需求和性能优化考虑

 

十一： 什么是 Java 中的集合框架？

        Java 中的集合框架（Collection Framework）是一组用于存储和操作对象的类和接口的集合。这些类和接口提供了统一的方式来处理对象的集合，使得开发人员可以更方便地进行数据操作和管理。

Java 集合框架主要包括以下几个核心接口和类：

1. Collection 接口：Collection 接口是集合框架的根接口，它表示一组对象的集合。常见的子接口有 List、Set 和 Queue 等，分别代表列表、集合和队列。

2. List 接口：List 接口表示一个有序的集合，允许重复元素。常见的实现类有 ArrayList、LinkedList 和 Vector 等。

3. Set 接口：Set 接口表示一个不允许重复元素的集合。常见的实现类有 HashSet、LinkedHashSet 和 TreeSet 等。

4. Map 接口：Map 接口表示一种键值对的映射关系，每个键对应一个值，键不允许重复，但值可以重复。常见的实现类有 HashMap、LinkedHashMap、TreeMap 和 HashTable 等。

集合框架提供了丰富的方法和功能，如增删改查元素、遍历集合、排序、过滤等操作。使用集合框架可以简化代码编写，提高代码的可读性和可维护性。

在实际开发中，根据具体需求选择合适的集合类对数据进行存储和操作，以提高程序性能和效率。集合框架是 Java 编程中非常重要且常用的一部分，对于开发各种类型的应用程序都起着至关重要的作用

 

十二：ArrayList 和 LinkedList 的区别是什么

         ArrayList 和 LinkedList 是 Java 中常用的两种集合实现类，它们有一些重要的区别：

1. 内部实现：

   • ArrayList 内部是通过数组实现的，它可以动态增长和缩减，但在插入和删除元素时需要移动其他元素，因此对于频繁的插入和删除操作性能较差。
   • LinkedList 内部是通过双向链表实现的，插入和删除元素的性能比 ArrayList 要好，因为它只需要改变相邻节点的引用，不需要移动其他元素。但是访问特定位置的元素需要遍历链表，因此随机访问性能较差。

2. 访问元素的性能：

   • ArrayList 支持随机访问，由于内部使用数组实现，可以通过索引直接访问元素，因此访问元素的性能较好。
   • LinkedList 不支持随机访问，需要从头或尾开始遍历链表才能找到指定位置的元素，因此访问元素的性能较差。

3. 内存消耗：

   • ArrayList 在存储大量数据时会占用较多的内存空间，因为它需要预留一定的数组容量。
   • LinkedList 在存储大量数据时会占用更多的内存空间，因为它除了存储元素本身外还需要存储节点间的关联信息。

基于以上区别，可以根据具体的需求选择合适的集合类型。如果需要频繁进行随机访问操作，可以选择 ArrayList；如果需要频繁进行插入、删除操作，可以选择 LinkedList

 

 十三：HashMap 和 HashTable 的区别是什么？

        HashMap 和 HashTable 是 Java 中用于存储键值对的集合类，它们有以下几点区别：

1. 线程安全性：

   • HashMap 是非线程安全的，不保证并发访问时的线程安全性。如果多个线程同时操作同一个 HashMap 实例，可能会导致数据不一致或抛出异常。
   • HashTable 是线程安全的，使用同步机制保证了并发访问时的线程安全性。在多线程环境下，多个线程可以安全地访问和修改同一个 HashTable 实例。

2. Null 键和值：

   • HashMap 允许键和值为 null，即可以将 null 作为键或值存储到 HashMap 中。
   • HashTable 不允许键和值为 null，如果尝试存储 null 值，会抛出 NullPointerException。

3. 性能：

   • HashMap 的性能通常比 HashTable 更好。由于 HashTable 是线程安全的，对于单线程环境下的操作，HashTabe 需要进行额外的同步开销，而 HashMap 不需要。
   • 在高并发环境下，HashMap 的性能可能比 HashTable 更好，因为 HashTable 的同步机制可能会引入额外的竞争和排队，限制了并发性能。

4. 迭代器：

   • HashMap 的迭代器（Iterator）是快速失败的，即在迭代过程中，如果其他线程修改了 HashMap 的结构（添加、删除元素），会抛出 ConcurrentModificationException 异常。
   • HashTable 的迭代器不是快速失败的，不会检测并发的修改操作，可能会导致遍历过程中的不确定行为。

总体来说，HashMap 是常用的键值对集合，适用于单线程环境下的操作，并且允许 null 键和值。HashTable 是线程安全的，适用于多线程环境下的操作，但不允许 null 键和值。在性能要求较高的场景中，推荐使用 HashMap

 

十四：什么是迭代器（Iterator）？

        迭代器（Iterator）是 Java 集合框架中的一种接口，用于遍历集合中的元素并对其进行操作。通过迭代器，可以按顺序访问集合中的每个元素，而无需了解集合内部的实现细节。

迭代器提供了统一的方式来遍历不同类型的集合，如 List、Set、Map 等，使得程序员可以使用相同的方法来处理不同类型的集合数据。

迭代器通常包含以下几个常用方法：

1. hasNext()：判断是否还有下一个元素可以迭代。
2. next()：返回当前位置的元素，并将迭代器指针移动到下一个位置。
3. remove()：从集合中移除迭代器最后返回的元素（可选操作）。

使用迭代器可以避免直接使用索引或循环来遍历集合，这样做不仅简化了代码逻辑，还可以提高代码的可读性和可维护性。此外，迭代器还支持对集合的并发访问，即使在迭代过程中对集合进行修改也不会导致异常（除非是迭代器自身的 remove() 方法）。

在 Java 中，几乎所有的集合类都实现了 Iterator 接口，因此可以通过调用 iterator() 方法获取迭代器对象，然后使用迭代器来遍历集合中的元素。迭代器是 Java 集合框架中非常重要且常用的概念，它为集合的遍历操作提供了一种标准化的方式

 

十五：什么是 Java 中的反射（Reflection）？

        在 Java 中，反射（Reflection）是指在运行时检查、获取和操作类、接口、字段、方法等程序结构的能力。通过反射，可以在运行时动态地创建对象、调用方法、访问或修改字段等，而不需要在编译时就确定这些操作。

Java 的反射机制主要通过 java.lang.reflect 包中的类和接口来实现，包括 Class、Field、Method、Constructor 等。使用这些类和接口，可以进行如下操作：

• 获取类的信息：获取类的名称、修饰符、父类、接口、字段、方法等信息。
• 创建对象：通过反射可以动态地创建类的实例。
• 调用方法：可以通过反射调用类中的方法，包括公有方法、私有方法等。
• 访问和修改字段：可以通过反射访问和修改类中的字段，包括公有字段、私有字段等。

反射机制在某些情况下非常有用，比如在框架、库、工具等中经常会用到。但是需要注意的是，反射的使用可能会导致性能损失，并且降低代码的可读性和可维护性，因此在不是特别必要的情况下，应该谨慎使用反射。

总的来说，反射为 Java 提供了一种强大的机制，使得程序能够在运行时获取并操作类的信息，带来了更大的灵活性和扩展性，但也需要慎重考虑其使用场景和影响

 

十六： 什么是 Java 中的注解（Annotation）？

        在 Java 中，注解（Annotation）是一种元数据的形式，可以用于为代码添加额外的信息和标记。它们提供了一种结构化的方式来描述程序中的元素（类、方法、字段等），并可以在编译时、运行时或者在开发工具中使用这些注解。

注解以 @ 符号开头，放置在目标元素的前面，可以附加到类、方法、字段、参数等上。Java 提供了一些内置的注解，如 @Override、@Deprecated、@SuppressWarnings 等，同时也支持自定义注解。

注解的作用可以有以下几个方面：

1. 提供元数据：通过注解可以为代码添加元数据信息，用于指示某个元素的特性、用途或者约束。
2. 编译时检查：注解可以在编译过程中进行静态检查，从而发现潜在的错误或者提供警告信息。
3. 运行时处理：注解可以在运行时通过反射机制来处理，实现一些动态的逻辑或者行为。
4. 自动生成代码：注解可以被用于生成辅助代码，如自动化测试、数据库映射等。
5. 文档生成：注解可以用于生成文档或者其他形式的文档化描述。

自定义注解可以通过 @interface 关键字进行定义，注解的成员变量可以是任意合法的数据类型。注解还可以具有默认值，使得在使用注解时可以简化代码。

总之，注解是一种在 Java 中用于添加元数据和标记的机制，它为我们提供了一种灵活、可扩展的方式来描述和处理代码的特性和行为。通过注解，我们可以实现更加智能、可读性强、与开发工具集成的程序设计

 

十七：什么是 Java 中的序列化和反序列化？

        在 Java 中，序列化（Serialization）是指将对象转换为字节流的过程，以便将其保存到文件、数据库或者通过网络进行传输。反序列化（Deserialization）则是将字节流重新转换为对象的过程，使得可以恢复原始的对象状态。

通过序列化和反序列化，可以实现对象的持久化存储和跨平台数据传输。在 Java 中，实现序列化的类需要实现 java.io.Serializable 接口，该接口并没有任何方法，只是作为一个标记接口，表示该类是可序列化的。

要实现序列化，只需将对象写入输出流，而要实现反序列化，则是从输入流中读取字节并重建原始对象。Java 提供了 ObjectOutputStream 和 ObjectInputStream 来实现对象的序列化和反序列化操作。

序列化和反序列化的主要用途包括：

• 将对象保存到文件，实现持久化存储。
• 在分布式系统中通过网络传输对象。
• 实现深拷贝，即通过序列化再反序列化来实现对象的复制。

需要注意的是，虽然序列化提供了方便的方式来处理对象的持久化和传输，但在某些情况下可能会存在安全风险或者性能问题。因此，在设计可序列化类时，需要注意一些问题，如处理敏感数据、版本控制、性能优化等。

总的来说，序列化和反序列化是 Java 中重要的特性，通过它们可以实现对象的持久化和跨平台传输，为 Java 程序的开发和运行提供了更大的灵活性和便利性

 

十八： 什么是内部类（Inner Class）？

        在 Java 中，内部类（Inner Class）是定义在另一个类内部的类。内部类与外部类之间存在一种特殊的关系，内部类可以访问外部类的成员变量和方法，包括私有成员，而外部类也可以访问内部类的成员。

根据定义和使用方式的不同，内部类可以分为以下几种类型：

1. 成员内部类（Member Inner Class）：最普通的内部类，定义在类的内部且不是 static 类型的。成员内部类可以访问外部类的成员。
2. 静态内部类（Static Nested Class）：使用 static 关键字修饰的内部类，相当于一个静态成员。静态内部类不能直接访问外部类的非静态成员，但可以访问外部类的静态成员。
3. 方法局部内部类（Method Local Inner Class）：定义在方法内部的类，作用范围仅限于该方法内部。
4. 匿名内部类（Anonymous Inner Class）：没有命名的内部类，通常用于实现接口或继承父类。

使用内部类的好处包括：

• 内部类可以轻松访问外部类的私有成员。
• 内部类可以将代码逻辑封装在外部类中，使代码更加清晰和模块化。
• 内部类可以避免命名冲突，使代码更具可读性。

然而，内部类也可能增加代码复杂性，因此在使用内部类时需要慎重考虑。通常来说，如果内部类只在外部类内部使用，并且与外部类具有密切关联，那么使用内部类是合理的选择。

总的来说，内部类是 Java 中一种特殊的类形式，能够帮助实现更灵活、清晰的代码结构，并提供了一种在类内部实现逻辑关联的机制

十九：什么是 Java 中的 Lambda 表达式？

在 Java 中，Lambda 表达式是一种匿名函数的形式，它允许我们将函数作为一个方法参数传递给另一个方法或者作为函数式接口的实例。Lambda 表达式的引入使得 Java 的函数式编程更加简洁和灵活。

Lambda 表达式的基本语法如下：

(parameters) -> expression 或者 (parameters) -> { statements; }

其中，parameters 表示参数列表，-> 为 Lambda 操作符，expression 或 { statements; } 表示函数体。Lambda 表达式可以推断出参数类型，也可以显式指定参数类型。

Lambda 表达式通常与函数式接口（Functional Interface）一起使用，函数式接口是只有一个抽象方法的接口。Lambda 表达式可以用来表示该抽象方法的实现，从而可以通过 Lambda 表达式来创建函数式接口的实例。

Lambda 表达式的主要优点包括：

1. 简洁性：Lambda 表达式可以大大减少冗余代码，使代码更加简洁清晰。
2. 易读性：Lambda 表达式可以使代码更具可读性，特别是对于简单的函数式操作。
3. 函数式编程：Lambda 表达式的引入让 Java 更加支持函数式编程风格。

Lambda 表达式在集合框架、多线程编程、事件处理等方面有着广泛的应用，能够帮助简化代码并提高编程效率。

需要注意的是，在使用 Lambda 表达式时，需要遵循一些规则，比如 Lambda 表达式的参数类型可以省略，但如果省略了一个参数的类型，则所有的参数类型都必须省略；Lambda 表达式中访问的变量必须是 final 或者事实上 final 的；Lambda 表达式中可以访问外部变量，但要谨慎处理并避免造成并发安全问题等。

总的来说，Lambda 表达式是 Java 中一种重要的特性，它使得函数式编程更加容易和优雅，为 Java 编程带来了更多的可能性

二十：什么是函数式接口（Functional Interface）？

在 Java 中，函数式接口（Functional Interface）是指只包含一个抽象方法的接口。函数式接口是支持函数式编程的基础，它可以被Lambda表达式所支持，Lambda表达式可以用来表示函数式接口的实例。

函数式接口的特点包括：

1. 只有一个抽象方法：函数式接口中只能包含一个抽象方法，但可以包含多个默认方法（default methods）、静态方法（static methods）或Object类的方法（如equals、hashCode等）。
2. 可以使用@FunctionalInterface注解：使用@FunctionalInterface注解可以显式声明一个接口为函数式接口，当接口不符合函数式接口的定义时，编译器会报错。
3. 支持Lambda表达式：函数式接口可以通过Lambda表达式来创建接口的实例，从而实现函数式编程的功能。

函数式接口在Java中的应用非常广泛，特别是在Java 8引入Lambda表达式之后。一些常用的函数式接口包括：

• java.lang.Runnable：表示一个没有参数和返回值的操作。
• java.util.function.Consumer<T>：表示接受一个参数并且不返回任何结果的操作。
• java.util.function.Supplier<T>：表示一个供给型接口，不接受参数但返回结果。
• java.util.function.Predicate<T>：表示接受一个参数并返回boolean类型结果的操作。
• java.util.function.Function<T, R>：表示接受一个参数并返回结果的操作。

通过使用函数式接口和Lambda表达式，Java程序员可以更加方便地实现函数式编程的思想，简化代码结构，提高代码的可读性和可维护性。函数式接口是Java 8引入的重要特性，也是支持Java函数式编程的基础之一