当前位置：首页 > news >正文

深圳营销型网站seo手机网站后台管理系统

news 2025/11/15 20:07:32

深圳营销型网站seo,手机网站后台管理系统,中企动力主要做什么的,wordpress怎么样建站内战目录一、给出代码逻辑优化的建议二、代码优化的例子（开发中） 1. 使用StringBuilder代替String拼接 2. 减少方法调用 3. 使用局部变量替代全局变量 4. 减少对象创建(使用对象池) 5. 选择高效数据结构和算法 6. 优化数据库访问 7. 使用Primitiv…

一、给出代码逻辑优化的建议

二、代码优化的例子（开发中）

1. 使用StringBuilder代替String拼接

2. 减少方法调用

3. 使用局部变量替代全局变量

4. 减少对象创建(使用对象池)

5. 选择高效数据结构和算法

6. 优化数据库访问

7. 使用Primitive类型替代Wrapper类型

8. 避免使用同步代码块（在可能的情况下）

9. 使用try-with-resources语句管理资源

10. 使用缓存机制

11. 并发编程优化

12.集合使用优化-使用ArrayList的get方法代替增强型for循环‌

13.并发编程优化-使用ConcurrentHashMap代替synchronized块‌

14. 避免在循环中重复调用list.size()

三、Java8 Lambda Stream流 etc

1、函数式接口

②、Consumer :

③、Supplier：

④、Function：

⑤、Predicate：

⑥、自定义函数式接口

2、Lambda表达式

3、方法引用

②、使用示例：

4、Option

②、创建 Optional 对象

③、Optional 常用方法及示例

1. 检查值是否存在

2. 获取值

3. 值存在时执行操作

4. 转换值(map/flatMap)

5. 过滤(filter)

④、实际应用示例

5、stream

①、Stream概述

②、Stream的创建

③、Stream的使用

3.1 遍历/匹配（foreach、find、match）

3.2 筛选（filter）

3.3 聚合（max、min、count）

3.4 映射（map、flatMap）

3.5 规约（reduce）

3.6 收集（collect）

3.6.1 归集（toList、toSet、toMap）

3.6.2 统计（count、averaging）

3.6.3 分组（partitioningBy、groupingBy）

3.6.4 接合（joining）

3.6.5 规约（reducing）

3.7 排序（sorted）

3.8 去重、合并（distinct、skip、limit）

一、给出代码逻辑优化的建议

‌①.消除死循环‌：
        确保所有的循环都有明确的终止条件。
        使用调试工具或日志记录来检测和定位潜在的死循环。
②.避免重复计算‌：
        对于重复使用的计算结果，使用局部变量或类成员变量进行缓存。
        在循环中避免进行不必要的重复计算。
‌③.优化数据结构和算法‌：
        根据问题的具体需求选择合适的数据结构，如ArrayList、LinkedList、HashMap等。
        使用高效的算法来减少时间复杂度。
④.减少不必要的对象创建和销毁‌：
        避免在循环中创建大量临时对象，尽量在循环外部创建对象并重用。
        使用对象池技术来重用已经创建过的对象。
‌⑤.利用并行和异步处理提高性能‌：
        对于可以并行处理的任务，使用Java的并发包（如java.util.concurrent）中的工具类来实现多线程处理。
        使用CompletableFuture等类来实现异步编程，提高程序的响应性。
⑥.避免过度使用同步机制‌：
        在多线程编程中，尽量减少同步代码块的范围。
        使用volatile、atomic变量等无锁机制来减少同步开销。
⑦.代码重构和模块化‌：
        将重复的代码封装成方法或类，提高代码的可重用性。
        将复杂的代码拆分成多个简单的模块，每个模块只负责一个具体的功能。
‌⑧.使用性能分析工具‌：
        使用Java的性能分析工具（如JProfiler、VisualVM等）来检测和分析程序的性能瓶颈。
        根据性能分析工具提供的报告和建议进行优化。
‌⑨.优化JVM参数‌：
        根据应用程序的需求调整JVM的启动参数，如堆大小、垃圾回收器等。
        使用JVM提供的性能监控工具（如JConsole、JMX等）来监控JVM的性能。
⑩.避免内存泄漏‌：
        确保在使用完对象后正确地释放资源，如关闭文件、数据库连接等。
        使用弱引用（WeakReference）等技术来避免内存泄漏。

二、代码优化的例子（开发中）

1. 使用StringBuilder代替String拼接

‌优化前‌：

String result = "";
for (int i = 0; i < 1000; i++) {result += i;
}

‌优化后‌：

StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {builder.append(i);
}
String result = builder.toString();

‌说明‌：String是不可变的，每次使用+进行拼接都会创建一个新的String对象。而StringBuilder是可变的，它允许在原有对象上进行修改，因此性能更高。

2. 减少方法调用

‌优化前‌：

public int calculateSum(int[] numbers) {int sum = 0;for (int i = 0; i < numbers.length; i++) {sum += getNumber(numbers[i]);}return sum;
}private int getNumber(int number) {return number;
}

‌优化后‌：

public int calculateSum(int[] numbers) {int sum = 0;for (int i = 0; i < numbers.length; i++) {sum += numbers[i];}return sum;
}

‌说明‌：减少了不必要的方法调用，直接访问数组元素。原因如下：

‌方法调用开销‌
每次方法调用都会产生额外的开销，包括：

栈帧的创建和销毁
参数压栈和返回值处理
程序计数器跳转
在优化前的例子中，getNumber()方法虽然只是简单返回参数，但每次循环都会产生这些开销。

‌数组访问效率‌
Java数组访问是高度优化的：

数组元素在内存中是连续存储的
JVM会编译为高效的机器指令（如直接内存访问）
现代CPU的缓存预取机制对连续内存访问特别有效

‌JIT优化限制‌
虽然JIT编译器会尝试内联简单方法，但：

方法调用可能阻碍其他优化
内联决策受方法大小和调用频率影响
直接访问消除了不确定性

‌示例性能对比‌
在示例代码中：

优化前：每次迭代需要1次数组访问+1次方法调用
优化后：仅需1次数组访问
实测在100万次迭代中，优化后版本可快2-3倍

‌可读性考量‌
当方法只是简单透传时（如示例中的getNumber()）：

直接访问使代码更简洁
减少不必要的抽象层级
更符合"不要为了封装而封装"的原则

3. 使用局部变量替代全局变量

‌优化前‌：

public class MyClass {private int globalVar;public void myMethod() {for (int i = 0; i < 1000; i++) {globalVar += i;}}
}

‌优化后‌：

public class MyClass {public void myMethod() {int localVar = 0;for (int i = 0; i < 1000; i++) {localVar += i;}// 可以选择将localVar赋值给某个全局变量，但仅在必要时}
}

‌说明‌：局部变量存储在栈中，访问速度比全局变量（存储在堆中）更快。原因如下：

‌性能优势‌
局部变量存储在栈内存中，访问速度比堆内存中的全局变量更快。每次访问全局变量需要通过对象引用查找，而局部变量直接通过索引访问。

‌内存管理优化‌
局部变量的生命周期与代码块绑定，执行完毕后自动释放内存，而全局变量需等待GC回收，可能造成内存泄漏。

‌作用域控制‌
局部变量作用域仅限于声明块内，可避免命名冲突和意外修改。例如：void method() {
int localVar = 10; // 仅限本方法可见
}

‌JIT编译器优化‌
局部变量更容易被JIT编译器优化，如内联和寄存器分配，而频繁访问全局变量会增加方法调用的开销。

‌线程安全性‌
局部变量天然线程安全，而全局变量在多线程环境下需要额外同步机制。

‌代码清晰度‌
局部变量能更清晰地表达代码意图，减少全局状态带来的耦合问题。例如：

void calculate() {
int sum = 0; // 明确作用域
for(int i=0; i<array.length; i++) {
sum += array[i];
}
return sum;
}

‌默认值差异‌
局部变量必须显式初始化，而全局变量有默认值（如0/null），使用局部变量可避免未初始化错误1。

‌现代Java特性支持‌
Java 10+的var类型推断适用于局部变量声明，进一步简化代码：

        void example() {
        var list = new ArrayList<>(); // 仅限局部变量
        }

4. 减少对象创建(使用对象池)

class MyObject {// 对象的状态private String someState;public void reset() {// 重置对象状态的方法this.someState = null;}// 其他方法...
}

‌优化前‌：

for (int i = 0; i < 1000; i++) {MyObject obj = new MyObject();// 使用obj进行一些操作
}

‌优化后‌：

MyObject obj = new MyObject();
for (int i = 0; i < 1000; i++) {// 重置obj并重新使用obj.reset();// 使用obj进行一些操作
}

‌说明‌：减少了对象的创建次数，降低了垃圾回收的频率和开销。
______________________________________________________________
使用对象池减少对象创建
以下是一个使用Apache Commons Pool库来实现Java对象池模式的示例。这个示例将涵盖ObjectPool接口的使用，以及如何通过PoolableObjectFactory来管理被池化对象的生命周期。

<dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId><version>2.11.1</version>
</dependency>

接下来，我们定义一个被池化的对象类，这个类需要实现PooledObject接口（尽管这不是强制的，但通常为了更好地管理对象，我们会这样做）。不过，在Apache Commons Pool 2中，更常见的是让工厂类实现PooledObjectFactory接口，而不是让对象本身实现PooledObject。因此，在这个示例中，我们将直接实现PooledObjectFactory。

import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.ObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPool;// 被池化的对象类
public class MyPooledObject {private String data;public MyPooledObject(String data) {this.data = data;}public String getData() {return data;}public void setData(String data) {this.data = data;}// 重写toString方法，方便打印@Overridepublic String toString() {return "MyPooledObject{data='" + data + "'}";}
}

// 被池化对象的工厂类
public class MyPooledObjectFactory implements PooledObjectFactory<MyPooledObject> {@Overridepublic MyPooledObject makeObject() throws Exception {// 创建并初始化被池化的对象return new MyPooledObject("Initial Data");}@Overridepublic void destroyObject(PooledObject<MyPooledObject> p) throws Exception {// 销毁被池化的对象，释放资源MyPooledObject obj = p.getObject();// 这里可以添加清理资源的代码，比如关闭连接等System.out.println("Destroying: " + obj);}@Overridepublic boolean validateObject(PooledObject<MyPooledObject> p) {// 验证被池化的对象是否有效MyPooledObject obj = p.getObject();// 这里可以添加验证对象有效性的逻辑return obj != null;}@Overridepublic void activateObject(PooledObject<MyPooledObject> p) throws Exception {// 激活被池化的对象，如果对象在空闲时需要做一些准备工作，可以在这里实现MyPooledObject obj = p.getObject();// 这里可以添加激活对象的代码System.out.println("Activating: " + obj);}@Overridepublic void passivateObject(PooledObject<MyPooledObject> p) throws Exception {// 挂起被池化的对象，如果对象在被归还到池中时需要做一些清理工作，可以在这里实现MyPooledObject obj = p.getObject();// 这里可以添加挂起对象的代码System.out.println("Passivating: " + obj);}
}

// 使用对象池的示例
public class ObjectPoolExample {public static void main(String[] args) {// 创建对象池，并指定工厂类ObjectPool<MyPooledObject> pool = new GenericObjectPool<>(new MyPooledObjectFactory());// 配置对象池（可选）// pool.setMaxTotal(10); // 设置对象池中的最大对象数// pool.setMaxIdle(5);   // 设置对象池中的最大空闲对象数// pool.setMinIdle(1);   // 设置对象池中的最小空闲对象数// 从对象池中获取对象try {MyPooledObject obj1 = pool.borrowObject();System.out.println("Borrowed: " + obj1);// 使用对象obj1.setData("Updated Data");// 归还对象到对象池pool.returnObject(obj1);System.out.println("Returned: " + obj1);// 再次从对象池中获取对象，可能是之前归还的那个MyPooledObject obj2 = pool.borrowObject();System.out.println("Borrowed again: " + obj2);} catch (Exception e) {e.printStackTrace();} finally {// 关闭对象池，释放资源（可选，但推荐在不再需要对象池时执行）pool.close();}}
}

代码解释:
‌被池化的对象类‌：MyPooledObject是一个简单的Java类，它有一个data字段和相应的getter/setter方法。
‌被池化对象的工厂类‌：MyPooledObjectFactory实现了PooledObjectFactory接口。这个类负责创建、销毁、验证、激活和挂起被池化的对象。
makeObject()方法用于创建新的被池化对象。
destroyObject()方法用于销毁被池化的对象，释放资源。
validateObject()方法用于验证被池化的对象是否有效。
activateObject()方法用于激活被池化的对象（如果需要的话）。
passivateObject()方法用于挂起被池化的对象（如果需要的话）。
‌使用对象池的示例‌：ObjectPoolExample类展示了如何使用对象池。
首先，创建一个GenericObjectPool对象，并传入MyPooledObjectFactory作为参数。
然后，从对象池中获取对象，使用它，并归还它。
最后，关闭对象池以释放资源。

对象池的工作原理:
‌借出对象‌：当调用pool.borrowObject()时，对象池会尝试从空闲对象集合中获取一个对象。如果空闲对象集合为空，对象池会调用工厂类的makeObject()方法创建一个新的对象。
‌归还对象‌：当调用pool.returnObject(obj)时，对象会被归还到空闲对象集合中，以便后续使用。
‌销毁对象‌：当对象池关闭或达到最大对象数时，对象池会调用工厂类的destroyObject()方法来销毁不再需要的对象。
‌验证对象‌：在借出或归还对象时，对象池可以调用工厂类的validateObject()方法来验证对象的有效性。如果对象无效，它可能会被销毁并重新创建。
这个示例展示了如何使用Apache Commons Pool库来实现Java对象池模式。通过对象池，我们可以有效地重用对象，减少内存分配和垃圾回收的开销，从而提高应用程序的性能。

5. 选择高效数据结构和算法

‌优化前‌（使用ArrayList进行查找）：

List<Integer> list = new ArrayList<>();
// 填充list
for (int i = 0; i < list.size(); i++) {if (list.get(i) == target) {// 找到目标值}
}

‌优化后‌（使用HashSet进行查找）：

Set<Integer> set = new HashSet<>();
// 填充set
if (set.contains(target)) {// 找到目标值
}

‌说明‌：HashSet在查找元素时的时间复杂度为O(1)，而ArrayList为O(n)。在需要频繁查找的场景下，HashSet更高效。

—————————————————————————————————————————
‌优化前‌：

List<String> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {list.add("item" + i);
}
// 假设需要从list中频繁查找元素
for (int i = 0; i < 1000; i++) {list.indexOf("item" + i); // List的indexOf方法性能较低
}

‌优化后‌：

Set<String> set = new HashSet<>();
for (int i = 0; i < 1000; i++) {set.add("item" + i);
}
// 使用Set的contains方法检查元素是否存在，性能更高
for (int i = 0; i < 1000; i++) {set.contains("item" + i); // Set的contains方法性能优于List的indexOf
}

‌优化点‌：在需要频繁查找元素的场景下，使用Set代替List可以提高性能，因为Set的contains方法通常比List的indexOf方法更高效。

6. 优化数据库访问

‌优化前‌（逐条插入数据）：

for (Entity entity : entities) {repository.save(entity);
}

‌优化后‌（批量插入数据）：

repository.saveAll(entities);

‌说明‌：批量操作减少了数据库交互次数，提高了数据库操作效率。

7. 使用Primitive类型替代Wrapper类型

‌优化前‌：

List<Integer> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {list.add(i);
}

‌优化后‌：

int[] array = new int[1000];
for (int i = 0; i < 1000; i++) {array[i] = i;
}

‌说明‌：在需要存储大量基本数据类型时，使用数组（Primitive类型数组）比使用List<Wrapper>类型更高效，因为Primitive类型数组在内存中的存储更加紧凑，且避免了自动装箱和拆箱的开销。
————————————————————————————————————————
‌优化前‌：

for (int i = 0; i < 1000; i++) {Integer num = new Integer(i); // 不必要的对象创建// 使用num进行一些操作
}

‌优化后‌：

for (int i = 0; i < 1000; i++) {int num = i; // 使用基本类型代替包装类型，避免对象创建// 使用num进行一些操作
}

‌优化点‌：在循环中避免不必要的对象创建，可以减少内存分配和垃圾回收的开销。在这个示例中，我们使用基本类型int代替包装类型Integer来存储数值。

8. 避免使用同步代码块（在可能的情况下）

‌优化前‌：

public class Counter {private int count = 0;public synchronized int getCount() {return count;}public synchronized void increment() {count++;}
}

‌优化后‌（使用AtomicInteger）：

import java.util.concurrent.atomic.AtomicInteger;
public class Counter {private AtomicInteger count = new AtomicInteger(0);public int getCount() {return count.get();}public void increment() {count.incrementAndGet();}
}

‌说明‌：在单例或多线程环境下，使用AtomicInteger等原子类可以避免使用同步代码块，从而提高性能。原子类内部使用了高效的CAS（Compare-And-Swap）操作来保证线程安全。

9. 使用try-with-resources语句管理资源

‌优化前‌：

BufferedReader reader = null;
try {reader = new BufferedReader(new FileReader("file.txt"));// 使用reader读取文件
} catch (IOException e) {e.printStackTrace();
} finally {if (reader != null) {try {reader.close();} catch (IOException e) {e.printStackTrace();}}
}

‌优化后‌：

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {// 使用reader读取文件
} catch (IOException e) {e.printStackTrace();
}

‌说明‌：try-with-resources语句可以自动管理资源（如文件、数据库连接等），在try块结束时自动关闭资源，避免了忘记关闭资源或异常处理导致的资源泄漏问题。

10. 使用缓存机制

‌优化前‌：

public String getDataFromDatabase(String query) {// 执行数据库查询并返回结果// 假设每次查询都会消耗大量时间和资源
}

‌优化后‌（使用ConcurrentHashMap作为缓存）：

import java.util.concurrent.ConcurrentHashMap;public class DataCache {private ConcurrentHashMap<String, String> cache = new ConcurrentHashMap<>();public String getData(String query) {// 先从缓存中获取数据String cachedData = cache.get(query);if (cachedData != null) {return cachedData;}// 如果缓存中没有数据，则从数据库中获取并更新缓存String newData = getDataFromDatabase(query);cache.put(query, newData);return newData;}private String getDataFromDatabase(String query) {// 执行数据库查询并返回结果}
}

‌说明‌：使用缓存机制可以减少对数据库等慢速资源的访问次数，从而提高性能。在这个示例中，我们使用ConcurrentHashMap作为缓存，它支持高效的并发访问。

（个人觉得这个例子数据有安全性问题，读取缓存的时候，数据库数据可能被更新了）

11. 并发编程优化

‌优化前‌：

public void processData(List<Data> dataList) {for (Data data : dataList) {processSingleData(data); // 同步处理数据，性能较低}
}

‌优化后‌：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public void processData(List<Data> dataList) {ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());for (Data data : dataList) {executor.submit(() -> processSingleData(data)); // 异步处理数据，提高性能}executor.shutdown();
}

‌优化点‌：使用线程池进行并发处理，可以充分利用多核CPU的性能，提高数据处理速度。在这个示例中，我们创建了一个固定大小的线程池，并提交任务给线程池进行异步处理。
——————————————————————————————————————————
合理使用线程池‌：

// 不推荐的方式：每次执行任务都创建新线程，导致线程创建和销毁开销大
for (int i = 0; i < 1000; i++) {new Thread(() -> {// 执行任务...}).start();
}

// 推荐的方式：使用线程池执行任务，减少线程创建和销毁开销
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 1000; i++) {executorService.submit(() -> {// 执行任务...});
}
executorService.shutdown();

‌优化点‌：使用线程池可以避免频繁创建和销毁线程带来的开销，提高系统的吞吐量和响应速度。

12.集合使用优化-使用ArrayList的get方法代替增强型for循环‌

List<Integer> list = new ArrayList<>();
// 填充list数据...// 不推荐的方式：使用增强型for循环遍历列表，可能导致迭代器开销
for (Integer item : list) {// 处理item...
}// 推荐的方式：使用索引访问集合元素，避免迭代器开销
for (int i = 0; i < list.size(); i++) {Integer item = list.get(i);// 处理item...
}

‌优化点‌：在已知集合大小的情况下，使用索引访问集合元素可以避免迭代器的额外开销，提高循环性能。

（个人测试10W、100W数据量时，效果不明显）

13.并发编程优化-使用ConcurrentHashMap代替synchronized块‌

// 不推荐的方式：使用synchronized块进行同步，可能导致线程阻塞和性能下降
Map<String, String> synchronizedMap = Collections.synchronizedMap(new HashMap<>());
synchronized (synchronizedMap) {synchronizedMap.put("key", "value");
}

// 推荐的方式：使用ConcurrentHashMap进行同步，提高并发性能
Map<String, String> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("key", "value");

‌优化点‌：ConcurrentHashMap已经针对多线程进行了优化，可以避免使用显式的synchronized块，从而提高并发性能。

14. 避免在循环中重复调用list.size()

for (int i = 0; i < list.size(); i++) {// 循环体
}
‌优化代码‌：
int size = list.size();
for (int i = 0; i < size; i++) {// 循环体
}
或者更好的方式：
for (String item : list) {// 循环体
}

‌优化点‌：
避免在循环中重复调用list.size()方法，可以减少不必要的开销。
使用增强型for循环（foreach循环）可以简化代码并提高可读性。

‌方法调用开销‌
每次调用size()方法都会产生额外的栈帧操作和可能的虚方法表查找（对于非final方法），即使现代JVM会内联简单方法，但重复调用仍可能阻碍其他优化。

‌潜在并发问题‌
对于非线程安全的集合（如ArrayList），在循环中多次调用size()可能导致不一致的结果，如果在迭代过程中有其他线程修改了集合大小。

‌JIT优化限制‌
虽然HotSpot会尝试将size()内联为直接访问字段（如ArrayList的size字段），但对于复杂集合（如ConcurrentHashMap），方法调用开销更大。

‌代码可读性‌
将size()结果存入局部变量能更明确地表达"固定循环次数"的意图：

for (int i = 0, n = list.size(); i < n; i++) { // 使用i和list.get(i) }

‌特殊集合的性能陷阱‌
某些集合的size()计算成本较高（如LinkedBlockingQueue需要遍历节点），重复调用会导致性能急剧下降。

例外情况：当集合可能在循环中被修改（如需要动态响应集合变化），此时必须每次调用size()。但在大多数固定次数的迭代场景中，缓存size()值是更优选择。

三、Java8 Lambda Stream流 etc

分为下面5个方面：在实际写代码时，可以使用这些新特性写出简约优雅的代码

①、函数式接口

②、Lambda表达式

③、方法引用

④、Option

⑤、stream

1、函数式接口

①、概念：

函数式接口是指只包含一个抽象方法的接口，可以用Lambda表达式或方法引用来实现。Java 8 通过@FunctionalInterface注解来标识函数式接口。虽然这个注解不是强制性的，但建议使用它来确保接口符合函数式接口的定义。

Java 8 提供了许多内置的函数式接口，其中最常用的四个是：

Consumer<T>：消费型接口
Supplier<T>：供给型接口
Function<T, R>：函数型接口

Predicate<T>：断言型接口

@FunctionalInterface
public interface MyFunctionalInterface {void doSomething(); // 只有一个抽象方法
}

为什么使用函数式接口？

函数式接口的主要目的是支持 Lambda 表达式和方法引用，从而简化代码，使代码更加简洁和易读。通过函数式接口，我们可以将行为（方法）作为参数传递，从而实现更灵活的编程。

②、Consumer<T> :

消费型接口

（1）、定义：Consumer<T> 表示接受一个输入参数并返回无结果的操作。它的抽象方法是：

void accept(T t);

（2）、使用场景：适用于需要对输入参数进行处理但不需要返回结果的场景，例如打印、修改对象状态等。

（3）、使用示例：

import java.util.function.Consumer;public class ConsumerExample {public static void main(String[] args) {// 使用 Lambda 表达式实现 ConsumerConsumer<String> printConsumer = (s) -> System.out.println(s);printConsumer.accept("Hello, Consumer!");  //输出： hello, consumer!// 使用方法引用实现 ConsumerConsumer<String> printConsumerRef = System.out::println;printConsumerRef.accept("Hello, Method Reference!"); // 输出：hello, Method Reference!}
}

（4）、其他方法：

andThen(Consumer<? super T> after)：组合多个Consumer，按顺序执行。

Consumer<String> first = (s) -> System.out.println("First: " + s);
Consumer<String> second = (s) -> System.out.println("Second: " + s);
first.andThen(second).accept("Hello");// 输出:first:hello
second:hello

`③、Supplier<T>`：

供给型接口

（1）、定义：Function<T, R> 表示接受一个输入参数并返回一个结果的函数。它的抽象方法是：

R apply(T t);

（2）、使用场景：适用于需要将一个值转换为另一个值的场景，例如数据转换、映射操作等。

（3）、使用示例：

import java.util.function.Supplier;public class SupplierExample {public static void main(String[] args) {// 使用 Lambda 表达式实现 SupplierSupplier<String> stringSupplier = () -> "Hello, Supplier!";System.out.println(stringSupplier.get());  //输出： hello, supplier!// 使用方法引用实现 Supplier// Supplier<Double> randomSupplier = ()-> Math.random();Supplier<Double> randomSupplier = Math::random;System.out.println(randomSupplier.get()); //输出：0.23149273619774136}
}

（4）、其他方法：无

④、`Function<T, R>`：

函数型接口

（1）、定义：Function<T, R> 表示接受一个输入参数并返回一个结果的函数。它的抽象方法是：

R apply(T t);

（2）、使用场景：适用于需要将一个值转换为另一个值的场景。例如数据转换、映射操作等

（3）、使用示例：

import java.util.function.Function;public class FunctionExample {public static void main(String[] args) {// 使用 Lambda 表达式实现 Function// Function<String, Integer> lengthFunction = (s) -> s.length();Function<String, Integer> lengthFunction = String::length;System.out.println(lengthFunction.apply("Hello, Function!")); //输出 16// 使用方法引用实现 FunctionFunction<String, String> upperCaseFunction = String::toUpperCase;System.out.println(upperCaseFunction.apply("hello"));  //输出： HELLO}
}

（4）、其他方法：

compose(Function<? super V, ? extends T> before)：组合多个Function，先执行before，再执行当前函数。（先执行后一个函数，再执行前一个函数，与andThen相反）

andThen(Function<? super R, ? extends V> after)：组合多个Function，先执行当前函数，再执行after。（按顺序先执行前一个函数，再执行后一个函数（参数中的函数））

Function<Integer, Integer> multiplyBy2 = x -> x * 2;
Function<Integer, Integer> add3 = x -> x + 3;// 先乘2再加3
Function<Integer, Integer> multiplyThenAdd = multiplyBy2.andThen(add3);
System.out.println(multiplyThenAdd.apply(5)); // 输出: 13 (5*2=10, 10+3=13)

Function<Integer, Integer> multiplyBy2 = x -> x * 2;
Function<Integer, Integer> add3 = x -> x + 3;// 先加3再乘2
Function<Integer, Integer> addThenMultiply = multiplyBy2.compose(add3);
System.out.println(addThenMultiply.apply(5)); // 输出: 16 (5+3=8, 8*2=16)

`⑤、Predicate<T>`：

断言型接口

（1）、定义：Predicate<T> 表示一个接受输入参数并返回布尔值的断言。它的抽象方法是：

boolean test(T t);

（2）、使用场景：适用于需要判断输入参数是否满足条件的场景，例如过滤、验证等。

（3）、使用示例：

import java.util.function.Predicate;public class PredicateExample {public static void main(String[] args) {// 使用 Lambda 表达式实现 PredicatePredicate<String> lengthPredicate = (s) -> s.length() > 5;System.out.println(lengthPredicate.test("Hello")); // falseSystem.out.println(lengthPredicate.test("Hello, Predicate!")); // true// 使用方法引用实现 Predicate// Predicate<String> isEmptyPredicate = (s)-> s.isEmpty();Predicate<String> isEmptyPredicate = String::isEmpty;System.out.println(isEmptyPredicate.test("")); // true}
}

（4）、其他方法：

and(Predicate<? super T> other)：逻辑与操作。

or(Predicate<? super T> other)：逻辑或操作。

negate()：逻辑非操作。

Predicate<String> lengthPredicate = (s) -> s.length() > 5;
Predicate<String> containsPredicate = (s) -> s.contains("china");
Predicate<String> comb1 = lengthPredicate.and(containsPredicate);
Predicate<String> comb2 = lengthPredicate.or(containsPredicate);
Predicate<String> comb3 = lengthPredicate.negate();
System.out.println(comb1.test("Hello, World!")); // false  =  true&false
System.out.println(comb2.test("Hello, World!")); // true  =  true|false
System.out.println(comb3.test("Hello, World!")); // false  =  !true

`⑥、自定义函数式接口`

@FunctionalInterface
interface MyFunctionalInterface {void myMethod();
}MyFunctionalInterface mfi = () -> System.out.println("My Method");
mfi.myMethod();

2、Lambda表达式

①、概念：

Lambda表达式是Java 8引入的一种简洁的匿名函数表示方式，它允许你将函数作为方法参数传递，或者将代码作为数据处理

语法：

(parameters) -> expression

或者

(parameters) -> { statements; }

parameters: 参数列表，可以为空或包含一个或多个参数。

->: Lambda 操作符，将参数和表达式或语句块分开。

expression: 单个表达式，Lambda 表达式会返回该表达式的结果。

{ statements; }: 语句块，可以包含多条语句，需要使用 return 语句返回值（如果有返回值）。

②、分类示例

（1）无参数的Lambda表达式

() -> System.out.println("Hello, World!");

（2）无参数的Lambda表达式

x -> x * x

（3）无参数的Lambda表达式

(x, y) -> x + y

（4）无参数的Lambda表达式

(x, y) -> {
int sum = x + y;
return sum;
}

③、使用场景

（1）、替代匿名内部类
Lambda 表达式常用于替代匿名内部类，尤其是在使用函数式接口时。

// 使用匿名内部类
Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("Hello, World!");}
};// 使用 Lambda 表达式
Runnable r2 = () -> System.out.println("Hello, World!");

（2）、集合操作
Lambda 表达式可以与 Java 8 引入的 Stream API 结合使用，简化集合操作。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");// 使用 Lambda 表达式遍历集合
names.forEach(name -> System.out.println(name));// 使用 Lambda 表达式过滤集合
List<String> filteredNames = names.stream().filter(name -> name.startsWith("A")).collect(Collectors.toList());

（3）、排序
Lambda 表达式可以简化排序操作。

List<String> names = Arrays.asList("Charlie", "Alice", "Bob");// 使用 Lambda 表达式排序
names.sort((a, b) -> a.compareTo(b));

（4）、函数式接口
Lambda 表达式通常与函数式接口一起使用。函数式接口是只包含一个抽象方法的接口。Java 8 提供了许多内置的函数式接口，如 Runnable、Callable、Comparator 等。

自定义函数式接口
你可以定义自己的函数式接口，然后使用表达式实现。

@FunctionalInterface
interface MyFunctionalInterface {void myMethod();
}MyFunctionalInterface mfi = () -> System.out.println("My Method");
mfi.myMethod();

常用内置函数式接口
Predicate<T>: 接受一个参数并返回一个布尔值。

Consumer<T>: 接受一个参数并执行操作，不返回任何结果。

Function<T, R>: 接受一个参数并返回一个结果。

Supplier<T>: 不接受参数，返回一个结果。

方法引用
方法引用是 Lambda 表达式的一种简化形式，用于直接引用已有方法。

// 静态方法引用
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.forEach(System.out::println);

// 实例方法引用
String str = "Hello";
Supplier<Integer> lengthSupplier = str::length;
System.out.println(lengthSupplier.get());

// 构造方法引用 
Supplier<List<String>> listSupplier = ArrayList::new;
List<String> list = listSupplier.get();

（5）、Lambda 表达式的变量作用域
Lambda 表达式可以访问外部的局部变量，但这些变量必须是 final 或事实上是 final 的（即不可变）。

int num = 10;
Runnable r = () -> System.out.println(num); 
// num 必须是 final 或事实上是 final

（6）、Lambda 表达式的限制
Lambda 表达式只能用于函数式接口。

Lambda 表达式不能包含 break 或 continue 语句。

Lambda 表达式不能抛出检查异常（除非函数式接口允许）。

3、方法引用

①、概念：

方法引用(Method Reference)是Java 8引入的一种简化Lambda表达式的语法特性，它允许你直接引用已有的方法或构造器，而不需要编写完整的Lambda表达式。实际上：方法引用是lambda表达式的一种特殊形式、是lambda表达式的一种语法糖。

使用方法：

方法引用使用一对冒号 :: 将类或对象与方法名进行连接，通常使用方式如下：

　　　　　　<1>　　对象的非静态方法引用　　ObjectName :: MethodName

　　　　　　<2>　　类的静态方法引用　　　　ClassName :: StaticMethodName

　　　　　　<3>　　类的非静态方法引用　　 ClassName :: MethodName

　　　　　　<4>　　构造器的引用　　　　　　 ClassName :: new

　　　　　　<5>　　数组的引用　　　　　　　 TypeName[] :: new

②、使用示例：


import java.util.Arrays;
import java.util.List;
import java.util.function.*;public class MethodReferenceDemo {public static void main(String[] args) {// 1. 静态方法引用  -  static int parseIntFunction<String, Integer> strToInt1 = s -> Integer.parseInt(s);Function<String, Integer> strToInt2 = Integer::parseInt;System.out.println("静态方法引用:");System.out.println("Lambda方式: " + strToInt1.apply("123"));System.out.println("方法引用: " + strToInt2.apply("456"));// 静态方法引用:// Lambda方式: 123// 方法引用: 456// 2. 实例方法引用 - String toUpperCase()String str = "Hello";Supplier<String> toUpper1 = () -> str.toUpperCase();Supplier<String> toUpper2 = str::toUpperCase;System.out.println("\n实例方法引用:");System.out.println("Lambda方式: " + toUpper1.get());System.out.println("方法引用: " + toUpper2.get());// 实例方法引用:// Lambda方式: HELLO// 方法引用: HELLO// 3. 类的任意对象方法引用BiPredicate<String, String> equals1 = (a, b) -> a.equals(b);BiPredicate<String, String> equals2 = String::equals;System.out.println("\n类的任意对象方法引用:");System.out.println("Lambda方式: " + equals1.test("Java", "Java"));System.out.println("方法引用: " + equals2.test("Java", "Python"));// 类的任意对象方法引用:// Lambda方式: true// 方法引用: false// 4. 构造方法引用  - public ArrayList() {.}Supplier<List<String>> listSupplier1 = () -> new ArrayList<>();Supplier<List<String>> listSupplier2 = ArrayList::new;System.out.println("\n构造方法引用:");System.out.println("Lambda方式创建列表大小: " + listSupplier1.get().size());System.out.println("方法引用创建列表大小: " + listSupplier2.get().size());// 构造方法引用:// Lambda方式创建列表大小: 0// 方法引用创建列表大小: 0// 综合应用示例List<String> names = Arrays.asList("Alice", "Bob", "Charlie");System.out.println("\n综合应用:");System.out.println("原始列表: " + names);names.sort(String::compareToIgnoreCase);System.out.println("排序后列表: " + names);// 综合应用:// 原始列表: [Alice, Bob, Charlie]// 排序后列表: [Alice, Bob, Charlie]}
}

4、Option

①、概念：

Optional 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

可以保存类型 T 的值或 null

提供多种方法避免显式 null 检查

强制开发者显式处理可能为空的情况

②、创建 Optional 对象

有三种创建 Optional 对象的方式：

// 1. 创建空的 Optional
Optional<String> empty = Optional.empty();// 2. 创建包含非空值的 Optional (如果值为null会抛出NPE)
Optional<String> nonNull = Optional.of("Hello");// 3. 创建可能为null的 Optional
Optional<String> nullable = Optional.ofNullable(getNullableValue());

③、Optional 常用方法及示例

1. 检查值是否存在

// 检查值是否存在
Optional<String> opt = Optional.of("Hello");
System.out.println(opt.isPresent());  // 输出: true
System.out.println(opt.isEmpty());    // 输出: false (Java 11+)Optional<String> s = Optional.of("");
System.out.println(s.isPresent());   // 输出: trueOptional<String> s = Optional.ofNullable("");
System.out.println(s.isPresent());  //输出： trueOptional<String> s = Optional.ofNullable(null);
System.out.println(s.isPresent());  //输出： false

2. 获取值

//示例1：
Optional<String> opt = Optional.of("Hello");
// 不安全获取(如果为空会抛出NoSuchElementException)
String value = opt.get();
// 安全获取方式
String value1 = opt.orElse("default");  // 为空时返回默认值
String value2 = opt.orElseGet(() -> "default");  // 使用Supplier提供默认值
String value3 = opt.orElseThrow(() -> new IllegalStateException());  // 为空时抛出异常//示例2：
Optional<String> opt = Optional.ofNullable(null);
// 安全获取方式
String value1 = opt.orElse("default");  // 为空时返回默认值
System.out.println(value1);
String value2 = opt.orElseGet(() -> "default");  // 使用Supplier提供默认值
System.out.println(value2);
String value3 = opt.orElseThrow(() -> new IllegalStateException());  // 为空时抛出异常
System.out.println(value3);       
// 不安全获取(如果为空会抛出NoSuchElementException)
String value = opt.get();
System.out.println(value);
//输出：
default
default
Exception in thread "main" java.lang.IllegalStateException at...//示例3：
Optional<String> opt = Optional.ofNullable("hello");
// 安全获取方式
String value1 = opt.orElse("default");  // 为空时返回默认值
System.out.println(value1);
String value2 = opt.orElseGet(() -> "default");  // 使用Supplier提供默认值
System.out.println(value2);
String value3 = opt.orElseThrow(() -> new IllegalStateException());  // 为空时抛出异常
System.out.println(value3);
// 不安全获取(如果为空会抛出NoSuchElementException)
String value = opt.get();
System.out.println(value);
//输出:
hello
hello
hello
hello

3. 值存在时执行操作

Optional<String> opt = Optional.of("Hello");// 值存在时执行操作
opt.ifPresent(v -> System.out.println("值为: " + v));  // 输出: 值为: Hello

4. 转换值(map/flatMap)

map(Function<T, R>)：对包装值应用转换函数，返回Optional<R>，适用于值到值的映射
flatMap(Function<T, Optional<R>>)：应用返回Optional的函数并展开结果，避免嵌套Optional，适用于值到 Optional的映射

// 传统多层null检查（命令式）
User user = getUser();
String email = null;
if (user != null) {Contact contact = user.getContact();if (contact != null) {email = contact.getEmail();}
}// Optional链式调用（声明式）
String email = Optional.ofNullable(getUser()).map(User::getContact).flatMap(Contact::getEmail).orElse("default@example.com");// map导致嵌套Optional（反例）
Optional<User> userOpt = Optional.of(new User());
Optional<Optional<String>> nestedEmail = userOpt.map(User::getContact)       // Optional<Contact>.map(Contact::getEmail);      // Optional<Optional<String>>// flatMap正确展开（正例）
Optional<String> emailOpt = userOpt.map(User::getContact)       // Optional<Contact>.flatMap(Contact::getEmail); // 直接展开为Optional<String>

Optional<String> opt = Optional.of("hello");// map转换
Optional<String> upper = opt.map(String::toUpperCase);
System.out.println(upper.get());  // 输出: HELLO// flatMap转换(用于嵌套Optional)
Optional<Optional<String>> nested = Optional.of(Optional.of("world"));
Optional<String> flat = nested.flatMap(Function.identity());
System.out.println(flat.get());  // 输出: world

5. 过滤(filter)

Optional<String> opt = Optional.of("hello");// 过滤
Optional<String> filtered = opt.filter(s -> s.length() > 3);
System.out.println(filtered.isPresent());  // 输出: trueOptional<String> filtered2 = opt.filter(s -> s.length() > 10);
System.out.println(filtered2.isPresent());  // 输出: false

④、实际应用示例

1. 替代多层 null 检查

// 传统方式
if (user != null) {Address address = user.getAddress();if (address != null) {Country country = address.getCountry();if (country != null) {String isocode = country.getIsocode();if (isocode != null) {isocode = isocode.toUpperCase();}}}
}// Optional方式
String result = Optional.ofNullable(user).map(User::getAddress).map(Address::getCountry).map(Country::getIsocode).map(String::toUpperCase).orElse("DEFAULT");

// 深度嵌套对象的安全访问
String address = Optional.ofNullable(order).map(Order::getCustomer).flatMap(Customer::getShippingInfo).map(ShippingInfo::getAddress).filter(a -> a.contains("China")).orElse("Unknown Address");

2. 方法返回值使用 Optional

public Optional<String> findUserEmail(Long userId) {// 模拟数据库查询if (userId == 1L) {return Optional.of("user@example.com");} else {return Optional.empty();}
}// 调用方式
Optional<String> email = findUserEmail(1L);
email.ifPresent(e -> System.out.println("发送邮件到: " + e));

Optional<User> userOpt = Optional.of(new User(17));
Optional<User> adultOpt = userOpt.filter(u -> u.getAge() > 18)  // 条件不满足，返回空Optional.map(u -> {System.out.println("This code won't execute");return u;});

// 将空值转换为业务异常
Integer userId = Optional.ofNullable(request.getParameter("userId")).filter(s -> s.matches("\\d+")).map(Integer::parseInt).orElseThrow(() -> new InvalidParamException("Invalid user ID"));

// 低效：对象装箱
Optional<Integer> boxedOpt = Optional.of(100);// 高效：基础类型特化
OptionalInt primitiveOpt = OptionalInt.of(100);
int value = primitiveOpt.orElse(0); // 直接获取int值，无装箱开销

public void test1() throws Exception {Student student = new Student(null, 3);if (student == null || isEmpty(student.getName())) {throw new Exception();}String name = student.getName();// 业务省略...// 使用Optional改造Optional.ofNullable(student).filter(s -> !isEmpty(s.getName())).orElseThrow(() -> new Exception());
}public static boolean isEmpty(CharSequence str) {return str == null || str.length() == 0;
}

int timeout = Optional.ofNullable(redisProperties.getTimeout()).map(x -> Long.valueOf(x.toMillis()).intValue()).orElse(10000);

Optional.ofNullable(props.getProperty(name)).flatMap(OptionalUtils::stringToInt).filter(i -> i>0).orElse(0);

public void test1() {Student student = new Student("李四", 3);Optional<Student> os1 = Optional.ofNullable(student);// 如果student对象不为空，就加一岁Optional<Student> emp = os1.map(e ->{e.setAge(e.getAge() + 1);return e;});}

⑤、注意事项

‌不要滥用 Optional‌：不应作为方法参数或类字段使用，主要用于返回值
‌避免直接调用 get()‌：除非确定值存在，否则优先使用 orElse/orElseGet
‌Optional 不是万能的‌：不能完全替代 null 检查，特别是对于集合(应使用空集合而非 Optional)
‌性能考虑‌：Optional 会创建额外对象，在性能敏感场景需谨慎使用

Optional 的正确使用可以显著提高代码可读性和健壮性，减少空指针异常的发生。

5、stream

①、Stream概述

java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的 Lambda ，给我们操作集合（Collection）提供了极大的便利。

那么什么是Stream？

Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。

Stream可以由数组或集合创建，对流的操作分为两种：

中间操作：每次返回一个新的流，可以有多个。（筛选filter、映射map、排序sorted、去重组合skip—limit）
终端操作：每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。（遍历foreach、匹配find–match、规约reduce、聚合max–min–count、收集collect）

另外，Stream有几个特性：

stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。

Stream与传统遍历相比
几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。例如：

import java.util.ArrayList;
import java.util.List;public class Demo1List {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("张无忌");list.add("周芷若");list.add("赵敏");list.add("小昭");list.add("殷离");list.add("张三");list.add("张三丰");List<String> listA = new ArrayList<>();for ( String s  : list) {if (s.startsWith("张"))listA.add(s);}List<String> listB = new ArrayList<>();for (String s: listA) {if (s.length() == 3)listB.add(s);}for (String s: listB) {System.out.println(s);}}
}

循环遍历的弊端

Java 8的Lambda更加专注于做什么（What），而不是怎么做（How），这点此前已经结合内部类进行了对比说明。现在，仔细体会一下上例代码，可以发现：

for循环的语法就是“怎么做”

for循环的循环体才是“做什么”

为什么使用循环？因为要进行遍历。但循环是遍历的唯一方式吗？遍历是指每一个元素逐一进行处理，而并不是从第一个到最后一个顺次处理的循环。前者是目的，后者是方式。

使用Stream写法

import java.util.ArrayList;
import java.util.List;public class Demo2Steam {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("张无忌");list.add("周芷若");list.add("赵敏");list.add("小昭");list.add("殷离");list.add("张三");list.add("张三丰");list.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3).forEach(name -> System.out.println(name));}
}

②、Stream的创建

Stream可以通过集合数组创建。

1、通过 java.util.Collection.stream() 方法用集合创建流

List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();

2、使用java.util.Arrays.stream(T[] array)方法用数组创建流

int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

3、使用Stream的静态方法：of()、iterate()、generate()

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println); // 0 3 6 9Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);
//输出：
0.7748471520653126
0.6071833509456785
0.7783126073723329

stream和parallelStream的简单区分：

stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。例如筛选集合中的奇数，两者的处理不同之处：

如果流中的数据量足够大，并行流可以加快处速度。

除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流：

Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();
List<Integer> list = Arrays.asList(1, 3, 6, 8, 12, 4);
Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();
System.out.println("使用Stream的静态方法generate：" + findFirst.get());

③、Stream的使用

在使用stream之前，先理解一个概念：Optional 。

Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

首先创建一个案例使用的员工类Person

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, "male", "New York"));
personList.add(new Person("Jack", 7000, "male", "Washington"));
personList.add(new Person("Lily", 7800, "female", "Washington"));
personList.add(new Person("Anni", 8200, "female", "New York"));
personList.add(new Person("Owen", 9500, "male", "New York"));
personList.add(new Person("Alisa", 7900, "female", "New York"));class Person {private String name;  // 姓名private int salary; // 薪资private int age; // 年龄private String sex; //性别private String area;  // 地区// 构造方法public Person(String name, int salary, int age,String sex,String area) {this.name = name;this.salary = salary;this.age = age;this.sex = sex;this.area = area;}// 省略了get和set，请自行添加}

3.1 遍历/匹配（foreach、find、match）

Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。

List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);// 遍历输出符合条件的元素
list.stream().filter(x -> x > 6).forEach(System.out::println);
// 匹配第一个
Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
// 匹配任意（适用于并行流）
Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
// 是否包含符合特定条件的元素
boolean anyMatch = list.stream().anyMatch(x -> x > 6);
System.out.println("匹配第一个值：" + findFirst.get());
System.out.println("匹配任意一个值：" + findAny.get());
System.out.println("是否存在大于6的值：" + anyMatch);

输出结果：

3.2 筛选（filter）

筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。

Stream<T> filter(Predicate<? super T> predicate);

案例一：筛选出Integer集合中大于7的元素，并打印出来


List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
Stream<Integer> stream = list.stream();
stream.filter(x -> x > 7).forEach(System.out::println);//输出： 
8
9

案例二：筛选员工中工资高于8000的人，并形成新的集合。形成新集合依赖collect（收集），后文有详细介绍。

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));List<String> fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());
System.out.print("高于8000的员工姓名：" + fiterList);

输出结果：

3.3 聚合（max、min、count）

max、min、count这些一定不陌生，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。

案例一：获取String集合中最长的元素。

List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");Optional<String> max = list.stream().max(Comparator.comparing(String::length));
System.out.println("最长的字符串：" + max.get());
//输出：    最长的字符串：weoujgsd

案例二：获取Integer集合中的最大值。

List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
// 自然排序
Optional<Integer> max = list.stream().max(Integer::compareTo);
// 自定义排序
Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
@Overridepublic int compare(Integer o1, Integer o2) {return o1.compareTo(o2);}});// 自定义缩写1：
//Optional<Integer> max2 = list.stream().max((o1, o2) -> o1.compareTo(o2));
// 自定义缩写2：
Optional<Integer> max2 = list.stream().max(Comparator.naturalOrder());System.out.println("自然排序的最大值：" + max.get()); // 11
System.out.println("自定义排序的最大值：" + max2.get());  // 11

案例三：获取员工工资最高的人。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();personList.add(new Person("Tom", 8900, 23, "male", "New York"));personList.add(new Person("Jack", 7000, 25, "male", "Washington"));personList.add(new Person("Lily", 7800, 21, "female", "Washington"));personList.add(new Person("Anni", 8200, 24, "female", "New York"));personList.add(new Person("Owen", 9500, 25, "male", "New York"));personList.add(new Person("Alisa", 7900, 26, "female", "New York"));Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));System.out.println("员工工资最大值：" + max.get().getSalary());}
}

案例四：计算Integer集合中大于6的元素的个数。

import java.util.Arrays;
import java.util.List;public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);long count = list.stream().filter(x -> x > 6).count();System.out.println("list中大于6的元素个数：" + count);}
}

3.4 映射（map、flatMap）

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：
map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

案例一：英文字符串数组的元素全部改为大写。整数数组每个元素+3。

public class StreamTest {public static void main(String[] args) {String[] strArr = { "abcd", "bcdd", "defde", "fTr" };List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());System.out.println("每个元素大写：" + strList);System.out.println("每个元素+3：" + intListNew);}
}

输出结果：

案例二：将员工的薪资全部增加1000。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();personList.add(new Person("Tom", 8900, 23, "male", "New York"));personList.add(new Person("Jack", 7000, 25, "male", "Washington"));personList.add(new Person("Lily", 7800, 21, "female", "Washington"));personList.add(new Person("Anni", 8200, 24, "female", "New York"));personList.add(new Person("Owen", 9500, 25, "male", "New York"));personList.add(new Person("Alisa", 7900, 26, "female", "New York"));// 不改变原来员工集合的方式List<Person> personListNew = personList.stream().map(person -> {Person personNew = new Person(person.getName(), 0, 0, null, null);personNew.setSalary(person.getSalary() + 10000);return personNew;}).collect(Collectors.toList());System.out.println("一次改动前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());System.out.println("一次改动后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());// 改变原来员工集合的方式List<Person> personListNew2 = personList.stream().map(person -> {person.setSalary(person.getSalary() + 10000);return person;}).collect(Collectors.toList());System.out.println("二次改动前：" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());System.out.println("二次改动后：" + personListNew2.get(0).getName() + "-->" + personListNew.get(0).getSalary());}
}

输出结果：

案例三：将两个字符数组合并成一个新的字符数组。

public class StreamTest {public static void main(String[] args) {List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");List<String> listNew = list.stream().flatMap(s -> {// 将每个元素转换成一个streamString[] split = s.split(",");Stream<String> s2 = Arrays.stream(split);return s2;}).collect(Collectors.toList());System.out.println("处理前的集合：" + list);System.out.println("处理后的集合：" + listNew);}
}

输出结果：

3.5 规约（reduce）

归约，也称缩减，顾名思义是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

   T reduce(T identity, BinaryOperator<T> accumulator);@Overridepublic final P_OUT reduce(final P_OUT identity, final BinaryOperator<P_OUT> accumulator)         {return evaluate(ReduceOps.makeRef(identity, accumulator, accumulator));}Optional<T> reduce(BinaryOperator<T> accumulator);@Overridepublic final Optional<P_OUT> reduce(BinaryOperator<P_OUT> accumulator) {return evaluate(ReduceOps.makeRef(accumulator));}<U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner);@Overridepublic final <R> R reduce(R identity, BiFunction<R, ? super P_OUT, R> accumulator, BinaryOperator<R> combiner) {return evaluate(ReduceOps.makeRef(identity, accumulator, combiner));}

Optional reduce(BinaryOperator accumulator)：第一次执行时，accumulator函数的第一个参数为流中的第一个元素，第二个参数为流中元素的第二个元素；第二次执行时，第一个参数为第一次函数执行的结果，第二个参数为流中的第三个元素；依次类推。

T reduce(T identity, BinaryOperator accumulator)：流程跟上面一样，只是第一次执行时，accumulator函数的第一个参数为identity，而第二个参数为流中的第一个元素。

案例一：求Integer集合的元素之和、乘积和最大值。

List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);// 求和方式1
Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
System.out.println(sum.get()); // 29// 求和方式2
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
System.out.println(sum2.get()); // 29// 求和方式3
Integer sum3 = list.stream().reduce(0, Integer::sum);
System.out.println(sum3); // 29, 这里的初始值是0，如果列表为空，则返回0// 求乘积
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
System.out.println("list求积：" + product.get()); // 2112 // 求最大值方式1
Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);  // 11// 求最大值写法2
// 初始值为1，初始值会与list中的最大值作比较，
// 11>1，显示为11， 如果初始值为12，则 12>11  显示12
Integer max2 = list.stream().reduce(1, Integer::max);

输出结果：

案例二：求所有员工的工资之和和最高工资。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();personList.add(new Person("Tom", 8900, 23, "male", "New York"));personList.add(new Person("Jack", 7000, 25, "male", "Washington"));personList.add(new Person("Lily", 7800, 21, "female", "Washington"));personList.add(new Person("Anni", 8200, 24, "female", "New York"));personList.add(new Person("Owen", 9500, 25, "male", "New York"));personList.add(new Person("Alisa", 7900, 26, "female", "New York"));// 求工资之和方式1：Optional<Integer> sumSalary = personList.stream().map(Person::getSalary).reduce(Integer::sum);// 求工资之和方式2：Integer sumSalary2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(),(sum1, sum2) -> sum1 + sum2);// 求工资之和方式3：Integer sumSalary3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);// 求最高工资方式1：Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),Integer::max);// 求最高工资方式2：Integer maxSalary2 = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),(max1, max2) -> max1 > max2 ? max1 : max2);System.out.println("工资之和：" + sumSalary.get() + "," + sumSalary2 + "," + sumSalary3);System.out.println("最高工资：" + maxSalary + "," + maxSalary2);}
}

输出结果：

3.6 收集（collect）

collect，收集，可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。

collect主要依赖java.util.stream.Collectors类内置的静态方法。

3.6.1 归集（toList、toSet、toMap）

因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。

下面用一个案例演示toList、toSet和toMap：

public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());List<Person> personList = new ArrayList<Person>();personList.add(new Person("Tom", 8900, 23, "male", "New York"));personList.add(new Person("Jack", 7000, 25, "male", "Washington"));personList.add(new Person("Lily", 7800, 21, "female", "Washington"));personList.add(new Person("Anni", 8200, 24, "female", "New York"));Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000).collect(Collectors.toMap(Person::getName, p -> p));System.out.println("toList:" + listNew);System.out.println("toSet:" + set);System.out.println("toMap:" + map);}
}

输出结果：

3.6.2 统计（count、averaging）

Collectors提供了一系列用于数据统计的静态方法：
计数：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
统计以上所有：summarizingInt、summarizingLong、summarizingDouble
案例：统计员工人数、平均工资、工资总额、最高工资。

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();personList.add(new Person("Tom", 8900, 23, "male", "New York"));personList.add(new Person("Jack", 7000, 25, "male", "Washington"));personList.add(new Person("Lily", 7800, 21, "female", "Washington"));// 求总数Long count = personList.stream().collect(Collectors.counting());// 求平均工资Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));// 求最高工资Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));// 求工资之和Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));// 一次性统计所有信息DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));System.out.println("员工总数：" + count);System.out.println("员工平均工资：" + average);System.out.println("员工工资总和：" + sum);System.out.println("员工工资所有统计：" + collect);}
}

输出结果：

3.6.3 分组（partitioningBy、groupingBy）

分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。

分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。

public static <T>Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate) {return partitioningBy(predicate, toList());}

public static <T, K> Collector<T, ?, Map<K, List<T>>>groupingBy(Function<? super T, ? extends K> classifier) {return groupingBy(classifier, toList());}

案例：将员工按薪资是否高于8000分为两部分；将员工按性别和地区分组

public class StreamTest {
public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();personList.add(new Person("Tom", 8900, "male", "New York"));personList.add(new Person("Jack", 7000, "male", "Washington"));personList.add(new Person("Lily", 7800, "female", "Washington"));personList.add(new Person("Anni", 8200, "female", "New York"));personList.add(new Person("Owen", 9500, "male", "New York"));personList.add(new Person("Alisa", 7900, "female", "New York"));// 将员工按薪资是否高于8000分组Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));// 将员工按性别分组Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));// 将员工先按性别分组，再按地区分组Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));System.out.println("员工按薪资是否大于8000分组情况：" + part);System.out.println("员工按性别分组情况：" + group);System.out.println("员工按性别、地区：" + group2);}
}

输出结果：

3.6.4 接合（joining）

joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。

public static Collector<CharSequence, ?, String> joining(CharSequence delimiter) {return joining(delimiter, "", "");}

案例：拼接字符串

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();personList.add(new Person("Tom", 8900, 23, "male", "New York"));personList.add(new Person("Jack", 7000, 25, "male", "Washington"));personList.add(new Person("Lily", 7800, 21, "female", "Washington"));String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));System.out.println("所有员工的姓名：" + names);List<String> list = Arrays.asList("A", "B", "C");String string = list.stream().collect(Collectors.joining("-"));System.out.println("拼接后的字符串：" + string);}
}

输出结果：

3.6.5 规约（reducing）

Collectors类提供的reducing方法，相比于stream本身的reduce方法，增加了对自定义归约的支持。

public static <T> Collector<T, ?, Optional<T>>reducing(BinaryOperator<T> op) {class OptionalBox implements Consumer<T> {T value = null;boolean present = false;@Overridepublic void accept(T t) {if (present) {value = op.apply(value, t);}else {value = t;present = true;}}}return new CollectorImpl<T, OptionalBox, Optional<T>>(OptionalBox::new, OptionalBox::accept,(a, b) -> { if (b.present) a.accept(b.value); return a; },a -> Optional.ofNullable(a.value), CH_NOID);}

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();personList.add(new Person("Tom", 8900, 23, "male", "New York"));personList.add(new Person("Jack", 7000, 25, "male", "Washington"));personList.add(new Person("Lily", 7800, 21, "female", "Washington"));// 每个员工减去起征点后的薪资之和（这个例子并不严谨，但一时没想到好的例子）Integer sum = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));System.out.println("员工扣税薪资总和：" + sum);// stream的reduceOptional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);System.out.println("员工薪资总和：" + sum2.get());}
}

输出结果：

3.7 排序（sorted）

sorted，中间操作。有两种排序：

sorted()：自然排序，流中元素需实现Comparable接口
sorted(Comparator com)：Comparator排序器自定义排序

   Stream<T> sorted();@Overridepublic final Stream<P_OUT> sorted() {return SortedOps.makeRef(this);}

	Stream<T> sorted(Comparator<? super T> comparator);@Overridepublic final Stream<P_OUT> sorted(Comparator<? super P_OUT> comparator) {return SortedOps.makeRef(this, comparator);}

案例：将员工按工资由高到低（工资一样则按年龄由大到小）排序

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();personList.add(new Person("Sherry", 9000, 24, "female", "New York"));personList.add(new Person("Tom", 8900, 22, "male", "Washington"));personList.add(new Person("Jack", 9000, 25, "male", "Washington"));personList.add(new Person("Lily", 8800, 26, "male", "New York"));personList.add(new Person("Alisa", 9000, 26, "female", "New York"));// 按工资升序排序（自然排序）List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName).collect(Collectors.toList());// 按工资倒序排序List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());// 先按工资再按年龄升序排序List<String> newList3 = personList.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName).collect(Collectors.toList());// 先按工资再按年龄自定义排序（降序）List<String> newList4 = personList.stream().sorted((p1, p2) -> {if (p1.getSalary() == p2.getSalary()) {return p2.getAge() - p1.getAge();} else {return p2.getSalary() - p1.getSalary();}}).map(Person::getName).collect(Collectors.toList());System.out.println("按工资升序排序：" + newList);System.out.println("按工资降序排序：" + newList2);System.out.println("先按工资再按年龄升序排序：" + newList3);System.out.println("先按工资再按年龄自定义降序排序：" + newList4);}
}

输出结果：

3.8 去重、合并（distinct、skip、limit）

流也可以进行合并、去重（distinct）、限制（limit）、跳过（skip）等操作

Stream<T> distinct();@Overridepublic final Stream<P_OUT> distinct() {return DistinctOps.makeRef(this);}

Stream<T> limit(long maxSize);@Overridepublic final Stream<P_OUT> limit(long maxSize) {if (maxSize < 0)throw new IllegalArgumentException(Long.toString(maxSize));return SliceOps.makeRef(this, 0, maxSize);}

Stream<T> skip(long n);@Overridepublic final Stream<P_OUT> skip(long n) {if (n < 0)throw new IllegalArgumentException(Long.toString(n));if (n == 0)return this;elsereturn SliceOps.makeRef(this, n, -1);}

案例：合并流、限制流、跳过流

public class StreamTest {public static void main(String[] args) {String[] arr1 = { "a", "b", "c", "d" };String[] arr2 = { "d", "e", "f", "g" };Stream<String> stream1 = Stream.of(arr1);Stream<String> stream2 = Stream.of(arr2);// concat:合并两个流 distinct：去重List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());// limit：限制从流中获得前n个数据List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());// skip：跳过前n个数据  这里的1代表把1代入后边的计算表达式List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());System.out.println("流合并：" + newList);System.out.println("limit：" + collect);System.out.println("skip：" + collect2);}
}

输出结果：