Java学习九—常用包(类)之java.util包
一、关于java.util包
1.1简介
java.util 包是Java标准类库中的一个非常重要的组成部分，它提供了一系列对程序开发非常有用的类和接口。这个包主要包含集合框架、日期时间类、事件模型、随机数生成器以及其他实用工具类。
1.2常用类及接口
-
集合框架 - 集合框架是java.util包中最重要的部分之一，它提供了一系列的数据结构和算法，帮助开发者存储和操作数据集合。
- Collection - 集合框架的根接口，代表一组对象，这些对象称为元素。
- List - 有序集合，每个元素都有其在集合中的特定位置。
- Set - 不允许重复元素的集合。
- Map - 键值对的集合，也称为字典或哈希表。
- ArrayList - 实现了List接口的动态数组。
- LinkedList - 实现了List接口的双向链表。
- HashSet - 实现了Set接口的哈希表集合。
- LinkedHashSet - 继承自HashSet，维护元素插入顺序的集合。
- TreeSet - 实现了Set接口的基于红黑树的集合，元素按自然顺序或自定义顺序排序。
- HashMap - 实现了Map接口的哈希表。
- LinkedHashMap - 继承自HashMap，维护元素插入顺序或访问顺序的映射。
- TreeMap - 实现了Map接口的基于红黑树的映射，键按自然顺序或自定义顺序排序。
-
日期时间类 - 提供了操作日期和时间的类。
- Date - 表示特定的瞬间，精确到毫秒。
- Calendar - 可以用于日期的计算，比如添加或减少天数、获取星期等。
- TimeZone - 表示时区。
- Locale - 表示特定的语言、国家和区域的设置。
-
事件模型 - 用于处理事件和监听器模式。
- EventObject - 所有事件的超类。
- EventListener - 所有事件监听器接口的标记接口。
- EventSource - 能够生成事件的对象。
-
随机数生成器 - 提供随机数生成的功能。
- Random - 基于线性同余生成器的随机数生成器。
- java.security.SecureRandom - 提供更安全的随机数生成。
-
其他实用工具类 - 提供了一系列静态方法，用于执行各种任务。
- Arrays - 提供静态方法来操作数组，如排序、搜索等。
- Collections - 提供静态方法来操作集合，如排序、搜索等。
- Objects - 提供静态方法来操作对象，如空安全的比较、计算哈希码等。
- Timer - 可以调度任务在将来的某个时间点执行。
- UUID - 用于生成UUID（通用唯一标识符）。
1.3时间
1.3.1Date类
简介
java.util.Date 类在Java中用于表示特定的瞬间，精确到毫秒。
构造方法
Date类提供了多个构造方法，其中比较常用的有：
- Date(): 创建一个表示当前日期和时间的Date对象。
- Date(long date): 根据指定的毫秒数创建一个Date对象，该毫秒数表示自1970年1月1日00:00:00 GMT以来的毫秒数。
方法
- getTime(): 返回自1970年1月1日00:00:00 GMT以来的毫秒数。
- toString(): 将Date对象转换为String类型。
- before(Date when): 比较两个日期，如果当前日期早于参数日期，则返回true。
- after(Date when): 比较两个日期，如果当前日期晚于参数日期，则返回true。
示例
import java.util.Date; public class Main { public static void main(String[] args) { // 创建表示当前日期和时间的Date对象 Date currentDate = new Date(); System.out.println("当前日期和时间：" + currentDate); // 创建一个指定日期和时间的Date对象 Date specificDate = new Date(1630454400000L); // 对应2022年9月2日12:00:00 System.out.println("指定日期和时间：" + specificDate); // 判断日期先后 if (currentDate.after(specificDate)) { System.out.println("当前日期晚于指定日期"); } else { System.out.println("当前日期早于指定日期"); } } }
1.3.2TimeZone类
简介
在Java中，TimeZone类用于表示时区信息，并提供了对时区进行操作的方法。它可以帮助我们在处理日期和时间时，将时间转换为特定时区下的时间，并进行时区之间的转换。
构造方法
TimeZone类是一个抽象类，不能直接实例化，但它提供了一些静态方法来获取TimeZone对象：
- getTimeZone(String ID): 返回指定ID对应的TimeZone对象，例如：“GMT+08:00”。
- getDefault(): 返回默认的TimeZone对象，通常是系统默认的时区。
方法
TimeZone类提供了一些常用的方法，包括但不限于：
- getDisplayName(): 返回时区的名称。
- getID(): 返回时区的ID。
- getOffset(long date): 返回指定日期的偏移量，单位为毫秒。
- inDaylightTime(Date date): 判断指定日期是否在夏令时时段内。
- getAvailableIDs(): 返回所有可用的时区ID数组。
示例
import java.util.Date; import java.util.TimeZone; public class Main { public static void main(String[] args) { // 获取默认的时区 TimeZone defaultTimeZone = TimeZone.getDefault(); System.out.println("默认时区：" + defaultTimeZone.getDisplayName()); // 获取指定ID的时区 TimeZone gmt8TimeZone = TimeZone.getTimeZone("GMT+08:00"); System.out.println("GMT+08:00时区：" + gmt8TimeZone.getDisplayName()); // 进行时区转换 Date currentDate = new Date(); System.out.println("当前日期和时间：" + currentDate); System.out.println("当前日期和时间在GMT+08:00时区：" + formatDateInTimeZone(currentDate, gmt8TimeZone)); } // 将日期转换为指定时区下的日期 private static Date formatDateInTimeZone(Date date, TimeZone timeZone) { long timeInUTC = date.getTime() - timeZone.getRawOffset(); return new Date(timeInUTC); } }
1.4集合框架
集合框架 - 集合框架是java.util包中最重要的部分之一，它提供了一系列的数据结构和算法，帮助开发者存储和操作数据集合。
- Collection - 集合框架的根接口，代表一组对象，这些对象称为元素。
- List - 有序集合，每个元素都有其在集合中的特定位置。
- Set - 不允许重复元素的集合。
- Map - 键值对的集合，也称为字典或哈希表。
- ArrayList - 实现了List接口的动态数组。
- LinkedList - 实现了List接口的双向链表。
- HashSet - 实现了Set接口的哈希表集合。
- LinkedHashSet - 继承自HashSet，维护元素插入顺序的集合。
- TreeSet - 实现了Set接口的基于红黑树的集合，元素按自然顺序或自定义顺序排序。
- HashMap - 实现了Map接口的哈希表。
- LinkedHashMap - 继承自HashMap，维护元素插入顺序或访问顺序的映射。
- TreeMap - 实现了Map接口的基于红黑树的映射，键按自然顺序或自定义顺序排序。
在之前章节有详细介绍，这里不再赘述
1.5接口
1.5.1Comparator
简介
java.util.Comparator 接口是一个用于定义对象比较规则的接口。它允许开发者自定义对象比较逻辑，这在排序集合或者对对象进行排序操作时非常有用。Comparator 接口提供了一种灵活的比较机制，使得可以对任何对象进行排序，而不仅仅是实现了特定比较方法的对象。
方法
-
reversed(): 返回与当前比较器相反的比较器（逆序排列）。
-
thenComparing(): 返回一个复合比较器，用于对两个对象进行多重比较。
-
nullsFirst(): 返回一个可将null元素排在非null元素之前的比较器。
-
nullsLast(): 返回一个可将null元素排在非null元素之后的比较器。
-
compare(T o1, T o2) - 比较两个对象 o1 和 o2。返回值是一个整数，它表示第一个参数相对于第二个参数是小于、等于还是大于：
如果 o1 小于 o2，返回负整数；
如果 o1 等于 o2，返回零；
如果 o1 大于 o2，返回正整数。
示例
import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; class Student { private int id; private String name; public Student(int id, String name) { this.id = id; this.name = name; } public int getId() { return id; } public String getName() { return name; } } public class Main { public static void main(String[] args) { List studentList = new ArrayList(); studentList.add(new Student(1, "Alice")); studentList.add(new Student(2, "Bob")); studentList.add(new Student(3, "Charlie")); // 使用Comparator进行排序 Collections.sort(studentList, Comparator.comparing(Student::getName)); // 输出排序后的结果 for (Student student : studentList) { System.out.println("ID: " + student.getId() + ", Name: " + student.getName()); } } }在这个示例中，首先定义了一个Student类，然后创建了一个包含Student对象的列表studentList。接着，我们使用Comparator.comparing方法根据学生姓名对列表进行排序，最终输出排序后的结果。
1.5.2Iterator
简介
在Java中，Iterator接口提供了一种用于遍历集合元素的统一方式。通过实现Iterator接口，我们可以对集合中的元素进行迭代访问，而不需要了解集合的具体实现方式。
方法
- boolean hasNext(): 如果仍有元素可以迭代，则返回true，否则返回false。
- E next(): 返回迭代的下一个元素。
- void remove(): 从迭代器指向的集合中移除迭代器最后返回的元素（可选操作）。
示例
import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Main { public static void main(String[] args) { List names = new ArrayList(); names.add("Alice"); names.add("Bob"); names.add("Charlie"); // 获取Iterator对象并进行迭代 Iterator iterator = names.iterator(); while (iterator.hasNext()) { String name = iterator.next(); System.out.println(name); } } }在这个示例中，首先创建了一个包含字符串元素的ArrayList names。然后，我们通过调用names的iterator()方法获得了一个Iterator对象，并使用while循环和next()方法对集合进行迭代访问，最终输出了每个元素的值。这种方式能够适用于任何实现了Iterable接口的集合类，如List、Set等。
1.5.3EventListener
简介
在Java中，EventListener接口是用于实现事件监听器的接口，用于处理各种类型的事件。通过实现EventListener接口，可以创建自定义的事件监听器，用于监听和响应特定类型的事件。
方法
EventListener 接口本身不定义任何方法，但是它有很多子接口，这些子接口定义了事件处理方法。例如：
- ActionListener：用于处理动作事件，如按钮点击。
- ChangeListener：用于监听 ChangeEvent，当事件源的状态发生变化时触发。
- MouseListener：用于处理鼠标事件，如鼠标点击、移动等。
- MouseMotionListener：用于处理鼠标移动和拖动事件。
- KeyListener：用于处理键盘事件，如按键和释放。
示例
import java.awt.event.MouseEvent; import java.awt.event.MouseListener; public class MyMouseListener implements MouseListener { @Override public void mouseClicked(MouseEvent e) { System.out.println("Mouse Clicked at: (" + e.getX() + ", " + e.getY() + ")"); } @Override public void mousePressed(MouseEvent e) { // 实现鼠标按下时的处理逻辑 } @Override public void mouseReleased(MouseEvent e) { // 实现鼠标释放时的处理逻辑 } @Override public void mouseEntered(MouseEvent e) { // 实现鼠标进入组件时的处理逻辑 } @Override public void mouseExited(MouseEvent e) { // 实现鼠标退出组件时的处理逻辑 } }在这个示例中，创建了一个名为MyMouseListener的类，实现了MouseListener接口，该接口定义了处理鼠标事件的方法。我们重写了MouseListener接口中的几个方法，比如mouseClicked，在该方法中实现了鼠标点击事件发生时的逻辑。通过这种方式，我们可以自定义事件监听器来响应特定的事件。
1.6工具类
1.6.1UUID类
简介
java.util.UUID 类是用于生成通用唯一标识符（UUID）的工具类。UUID是一种标准化的32位字符格式，用于在分布式系统中唯一标识信息。UUID的设计目的是在所有计算机和系统上都能生成高度唯一的标识符，即使在不同的时间和空间中也是如此。
构造方法
UUID类提供了两种构造方法：
- UUID(long mostSignificantBits, long leastSignificantBits): 使用指定的最高有效位和最低有效位创建一个UUID对象。
- UUID(String name): 根据指定的字符串名称创建一个UUID对象。该字符串必须遵循UUID的标准格式，如 “550e8400-e29b-41d4-a716-446655440000”。
- UUID() - 生成一个随机生成的UUID。
UUID randomUUID = new UUID();
方法
- static UUID randomUUID(): 静态方法，用于生成一个随机的UUID。
- String toString(): 将UUID转换为字符串表示形式。
- int hashCode(): 返回此UUID的哈希码值。
- boolean equals(Object obj): 比较两个UUID对象是否相等。
示例
import java.util.UUID; public class Main { public static void main(String[] args) { // 生成一个随机的UUID UUID uuid = UUID.randomUUID(); // 将UUID转换为字符串表示形式 String uuidString = uuid.toString(); System.out.println("Random UUID: " + uuidString); } }在这个示例中，通过调用UUID.randomUUID()方法生成一个随机的UUID对象，然后通过调用toString()方法将其转换为字符串表示形式，并最终输出到控制台上。这样我们就可以生成一个唯一的标识符，用于在系统中标识对象或实体。
1.6.2Random类
简介
java.util.Random 类是Java标准库中提供的一个随机数生成器。它用于生成伪随机数流，这些随机数在足够长的时间内看起来是随机的，但实际上是可以重现的，因为它们是由一个初始种子值（seed）确定的。
构造方法
- Random(): 创建一个新的随机数生成器。
- Random(long seed): 使用指定的种子创建一个新的随机数生成器。使用相同的种子创建的Random对象将生成相同的随机数序列。
方法
- int nextInt(): 返回一个随机的int值。
- int nextInt(int bound): 返回一个大于等于0且小于bound的随机int值。
- double nextDouble(): 返回一个随机的double值。
- void nextBytes(byte[] bytes): 生成随机字节并将其放入提供的byte数组中。
- boolean nextBoolean(): 返回一个随机的boolean值。
示例
import java.util.Random; public class RandomExample { public static void main(String[] args) { // 使用默认构造方法创建Random对象 Random random = new Random(); // 生成一个随机整数 int randomInt = random.nextInt(); System.out.println("Random integer: " + randomInt); // 生成一个0到99之间的随机整数 int randomIntWithinRange = random.nextInt(100); System.out.println("Random integer within range (0-99): " + randomIntWithinRange); // 生成一个随机double值 double randomDouble = random.nextDouble(); System.out.println("Random double: " + randomDouble); // 生成一个随机float值 float randomFloat = random.nextFloat(); System.out.println("Random float: " + randomFloat); // 生成一个随机long值 long randomLong = random.nextLong(); System.out.println("Random long: " + randomLong); // 生成一个随机boolean值 boolean randomBoolean = random.nextBoolean(); System.out.println("Random boolean (true or false): " + randomBoolean); // 使用自定义种子值创建Random对象 Random randomWithSeed = new Random(123456L); // 再次生成随机整数，由于种子值相同，结果也将相同 int sameRandomInt = randomWithSeed.nextInt(); System.out.println("Same random integer with seed 123456: " + sameRandomInt); // 生成一个随机高斯分布值 double randomGaussian = random.nextGaussian(); System.out.println("Random Gaussian (normal distribution) value: " + randomGaussian); } }在这个示例中，首先创建了一个默认的 Random 对象，并使用它来生成不同类型的随机数。 接着，我们创建了一个带有自定义种子值的 Random 对象，并展示了如何通过指定种子值来重现相同的随机数序列。 最后，我们打印了生成的随机数，展示了 Random 类的各种用途。
1.6.3Scanner类
简介
在Java中，Scanner类是用于读取用户输入的一个方便的类，它可以从标准输入流（如键盘输入）、文件或字符串中获取输入数据。Scanner类提供了多种方法来解析基本数据类型和字符串。
构造方法
- Scanner(InputStream source): 通过指定输入流创建一个Scanner对象，通常用于从标准输入流（System.in）读取用户输入。
- Scanner(File source): 通过指定文件创建一个Scanner对象，用于从文件中读取数据。
- Scanner(String source): 通过指定字符串创建一个Scanner对象，用于从字符串中读取数据。
方法
- int nextInt(): 读取下一个输入项并将其解释为int类型。
- double nextDouble(): 读取下一个输入项并将其解释为double类型。
- String nextLine(): 读取下一行输入。
- boolean hasNext(): 检查是否还有输入项可读。
- void close(): 关闭Scanner对象。
示例
import java.util.Scanner; public class ScannerExample { public static void main(String[] args) { // 创建Scanner实例，使用System.in作为输入源 Scanner scanner = new Scanner(System.in); System.out.println("请输入一个整数："); int integer = scanner.nextInt(); System.out.println("您输入的整数是：" + integer); System.out.println("请输入一个浮点数："); double doubleValue = scanner.nextDouble(); System.out.println("您输入的浮点数是：" + doubleValue); System.out.println("请输入一个布尔值（true/false）："); boolean booleanValue = scanner.nextBoolean(); System.out.println("您输入的布尔值是：" + booleanValue); System.out.println("请输入一个字符串："); String string = scanner.nextLine(); System.out.println("您输入的字符串是：" + string); // 关闭Scanner实例 scanner.close(); } }在这个示例中，首先创建了一个 Scanner 实例，它默认使用 System.in 作为输入源。 接着，我们使用 nextInt()、nextDouble()、nextBoolean() 和 nextLine() 方法从用户那里读取不同类型的输入，并打印出来。 最后，我们调用 close() 方法关闭 Scanner 实例，释放与它关联的资源。
1.7java.util.concurrent包
1.7.1简介
java.util.concurrent 包提供了在并发编程中使用的工具类和框架。它包含了一系列用于处理并发任务的实用工具，使得在多线程环境中编写高效、安全的代码变得更加简单。
以下是 java.util.concurrent 包中一些常用的类和接口：
- Executor 框架：包括 Executor、ExecutorService 和 ScheduledExecutorService 接口，以及 Executors 工厂类。这些类允许你实现异步执行任务和控制执行过程。
- 线程安全集合：java.util.concurrent 包中提供了一系列线程安全的集合类，如 ConcurrentHashMap、CopyOnWriteArrayList、CopyOnWriteArraySet 等。这些集合类能够在多线程环境中安全地进行读写操作，避免了传统集合类在并发情况下可能出现的线程安全问题。
- 同步器和锁：该包中还包含了一些同步器和锁的实现，如 ReentrantLock、ReadWriteLock、Condition 等，它们提供了更灵活的锁机制，能够满足不同的并发控制需求。
- 并发工具类：java.util.concurrent 包还提供了一些并发编程中常用的工具类，比如 CountDownLatch、CyclicBarrier、Semaphore 等。这些工具类可以帮助协调多个线程之间的执行顺序和资源的访问。
总的来说，java.util.concurrent 包为 Java 程序员提供了丰富的并发编程工具，帮助开发者更加轻松地处理多线程编程中的挑战，提高了并发程序的性能和可靠性。通过合理地利用这些工具和框架，可以写出高效、可靠的并发程序。
1.7.2CompletableFuture类
简介
在Java中，CompletableFuture类提供了一种异步编程的方式，可以用于实现异步操作和构建复杂的异步流水线。它是Java 8引入的一个重要特性，用于简化并发编程。
java.util.concurrent 包中的 CompletableFuture 类是 Java 8 引入的一个类，用于支持异步编程和构建异步操作链。CompletableFuture 提供了一种简洁而强大的方式来处理异步任务的结果，以及对多个异步任务进行组合、串联和并发控制。
以下是 CompletableFuture 类的一些主要特点和用法：
- 异步操作：CompletableFuture 可以表示一个异步计算的结果，通过 CompletableFuture 的方法可以注册回调函数，在异步任务执行完成后自动触发回调函数处理结果。
- 组合操作：CompletableFuture 支持对多个 CompletableFuture 进行组合操作，包括 thenCombine、thenCompose、thenApplyAsync 等方法，可以串联多个异步任务，形成复杂的异步操作链。
- 异常处理：CompletableFuture 允许你通过 exceptionally 或 handle 方法来处理异步任务中产生的异常，使得异常处理变得更加灵活。
- 并发控制：CompletableFuture 提供了一些方法来实现并发控制，比如 allOf、anyOf 等，能够控制多个 CompletableFuture 的执行顺序和并发度。
- 超时处理：CompletableFuture 支持设置超时时间，并在超时时执行特定的操作，避免任务长时间阻塞。
使用 CompletableFuture 可以简化异步编程的复杂性，让开发者能够更加方便地处理异步任务的结果和操作。通过链式调用和组合不同的 CompletableFuture 对象，可以构建出复杂的异步任务流水线，实现高效的并发编程。
总的来说，CompletableFuture 是 Java 中处理异步编程的重要工具，它提供了丰富的方法和功能，使得异步任务的管理和处理变得更加简单和高效。
构造方法
CompletableFuture类有多个静态工厂方法来创建CompletableFuture对象，其中最常用的包括：
- static CompletableFuture runAsync(Runnable runnable): 异步执行指定的Runnable任务，并返回一个CompletableFuture对象。
- static CompletableFuture supplyAsync(Supplier supplier): 异步执行指定的Supplier任务，并返回一个CompletableFuture对象，该任务产生一个结果。
方法
- CompletableFuture thenApply(Function... cfs): 等待所有的CompletableFuture对象执行完毕。
示例
import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; public class Main { public static void main(String[] args) throws ExecutionException, InterruptedException { // 创建一个CompletableFuture对象，异步执行一个简单的任务 CompletableFuture future = CompletableFuture.runAsync(() -> { System.out.println("Async task running in the background..."); try { Thread.sleep(2000); // 模拟耗时操作 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Async task completed."); }); // 等待异步任务执行完毕 future.get(); // 这里会阻塞直到任务完成 System.out.println("Main thread continues to run..."); } }在这个示例中，首先使用CompletableFuture.runAsync()方法创建了一个CompletableFuture对象，异步执行一个简单的任务。然后使用get()方法等待异步任务执行完毕。在主线程中，我们打印了一条消息表明主线程继续执行。这样我们就可以利用CompletableFuture类方便地实现异步编程。
1.8java.util.stream包
1.8.1简介
java.util.stream 包是 Java 8 引入的用于支持流式处理（Stream API）的包。该包提供了一组类和接口，用于对集合数据进行函数式操作，以实现更简洁、可读性更强的代码。
以下是 java.util.stream 包中一些常用的类和接口：
- Stream：Stream 接口代表一个元素序列，可以支持各种操作来处理这个序列，如过滤、映射、归约等。
- Collectors：Collectors 类包含了一系列静态工厂方法，用于生成常见的收集器实例，例如将流元素收集到列表、集合、映射等数据结构中。
- IntStream, LongStream, DoubleStream：这些接口分别表示原始类型的流，提供了针对基本数据类型的特定操作。
- ParallelStream：ParallelStream 类支持并行流操作，可以加速处理大量数据的操作。
通过使用 java.util.stream 包中提供的类和接口，开发者可以利用流式处理来简化集合数据的操作、提高代码的可读性，并且能够更方便地进行并行处理以提升性能。这些功能使得 Java 编程变得更加灵活和强大。
1.8.2Collectors类
简介
Collectors 类是 Java 中 java.util.stream 包中的一个工具类，提供了一系列静态工厂方法，用于生成常见的收集器实例，以便在流式处理中对元素进行汇总和归约操作。
通过 Collectors 类，可以方便地将流中的元素收集到不同类型的数据结构中，比如集合（List、Set）、映射（Map）、字符串（joining）、统计信息（summarizingInt、summarizingDouble 等）等。这些收集器可以帮助简化代码，并支持并行处理以提高性能。
构造方法
在 Java 中，Collectors 类是一个工具类，它提供了一系列静态工厂方法来创建不同类型的收集器。因此，Collectors 类并没有公开的构造方法。相反，它提供了诸如 toList()、toSet()、toMap() 等静态方法，用于创建对应的收集器实例。
这些静态方法返回的是 Collector 接口的实例，Collector 接口定义了用于执行归约操作的方式，并可用于对输入的元素进行汇总。Collector 接口中有几个重要的方法，包括 supplier()、accumulator()、combiner() 和 finisher()，它们定义了收集器的行为和属性。
因此，我们通常不需要直接构造 Collectors 类的实例，而是通过调用其提供的静态工厂方法来获取特定类型的收集器。这样可以更方便地对流中的元素进行汇总和归约操作。
方法
一些常用的 Collectors 方法包括：
- toList(): 将流中的元素收集到一个 List 中。
- toSet(): 将流中的元素收集到一个 Set 中。
- toMap(keyMapper, valueMapper): 将流中的元素根据 keyMapper 和 valueMapper 转换为 Map。
- joining(): 将流中的元素连接成一个字符串。
- groupingBy(classifier): 根据分类函数对流中的元素进行分组。
- summarizingInt(), summarizingDouble(), summarizingLong(): 用于统计流中元素的汇总信息，如 count、sum、min、max、average 等。
- 将流中的元素收集到一个 List 中：
List words = Arrays.asList("apple", "banana", "orange", "grape"); List collectedList = words.stream() .collect(Collectors.toList()); System.out.println(collectedList);- 将流中的元素连接成一个字符串：
List words = Arrays.asList("apple", "banana", "orange", "grape"); String concatenatedString = words.stream() .collect(Collectors.joining(", ")); System.out.println(concatenatedString);- 根据字符串长度将元素分组：
List words = Arrays.asList("apple", "banana", "orange", "grape"); Map groupedByLength = words.stream() .collect(Collectors.groupingBy(String::length)); System.out.println(groupedByLength);- 计算元素的数量、总和、最小值、最大值和平均值：
List numbers = Arrays.asList(1, 2, 3, 4, 5); IntSummaryStatistics stats = numbers.stream() .collect(Collectors.summarizingInt(Integer::intValue)); System.out.println("Count: " + stats.getCount()); System.out.println("Sum: " + stats.getSum()); System.out.println("Min: " + stats.getMin()); System.out.println("Max: " + stats.getMax()); System.out.println("Average: " + stats.getAverage());这些示例展示了如何使用 Collectors 类中的一些常见方法来对流进行汇总操作。您可以根据具体的需求选择合适的收集器，并结合流操作来实现各种数据处理功能。
示例
import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { // 创建一个包含一些整数的List List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // 使用Collectors.toList()方法将Stream中的元素收集到List中 List evenNumbers = numbers.stream() .filter(num -> num % 2 == 0) .collect(Collectors.toList()); System.out.println("Even numbers: " + evenNumbers); // 使用Collectors.toSet()方法将Stream中的元素收集到Set中 Set oddNumbers = numbers.stream() .filter(num -> num % 2 != 0) .collect(Collectors.toSet()); System.out.println("Odd numbers: " + oddNumbers); // 使用Collectors.toMap()方法将Stream中的元素收集到Map中 Map numberMap = numbers.stream() .collect(Collectors.toMap( num -> num, num -> "Number: " + num )); System.out.println("Number map: " + numberMap); } }在这个示例中，首先创建了一个包含一些整数的List。然后使用Stream API对这个List进行操作，并利用Collectors类的方法将Stream中的元素收集到不同的数据结构中，包括List、Set和Map。最后我们打印出了收集到的结果。
1.8.3Stream类
简介
在 Java 中，Stream 是 Java 8 引入的一个全新的抽象概念，它提供了一种高效且功能强大的数据处理方式。Stream 可以让你以一种声明式的方式处理集合数据，这种方式更加简洁、灵活，并且可以充分利用多核处理器的优势。
简单来说，Stream 提供了一种对集合进行批量操作的高级抽象，它可以让你通过一系列的操作（如过滤、映射、排序、归约等）来处理集合中的元素，而无需写显式的循环。
构造方法
从集合创建
List list = Arrays.asList("a", "b", "c"); Stream streamFromList = list.stream(); // 从List创建Stream Stream parallelStreamFromList = list.parallelStream(); // 从List创建并行Stream从数组创建
String[] array = {"a", "b", "c"}; Stream streamFromArray = Arrays.stream(array); // 从数组创建Stream使用Stream.of()
Stream streamOfElements = Stream.of("a", "b", "c"); // 使用Stream.of()创建Stream使用Stream.iterate()
Stream streamIterate = Stream.iterate(0, n -> n + 2).limit(5); // 使用Stream.iterate()创建Stream
使用Stream.generate()
Stream streamGenerate = Stream.generate(Math::random).limit(3); // 使用Stream.generate()创建Stream
方法
Stream 类提供了丰富的方法来支持对集合数据的高级操作，这些方法可以分为中间操作和终端操作两种类型。中间操作用于构建 Stream 流水线，而终端操作则触发实际的处理过程并产生结果。以下是一些常用的 Stream 方法：
中间操作：
- filter(Predicate) ：根据给定的条件过滤元素。
- map(Function) ：将元素按照指定规则转换。
- flatMap(Function) ：将流中的每个元素都转换成另一个流，然后把所有流连接成一个流。
- distinct() ：去除流中重复的元素。
- sorted() ：对流进行排序。
- limit(long maxSize) ：截断流，使其最多只包含指定数量的元素。
- skip(long n) ：跳过指定数量的元素，返回剩余的元素。
终端操作：
- forEach(Consumer) ：对流中的每个元素执行指定操作。
- collect(Collector) ：将流中的元素累积成一个结果容器，如 List、Map 等。
- reduce(BinaryOperator) ：用指定的二元运算符对流中的元素进行归约操作，得到一个最终结果。
- count() ：返回流中元素的总个数。
- anyMatch(Predicate) ：检查流中是否至少有一个元素满足给定条件。
- allMatch(Predicate) ：检查流中是否所有元素都满足给定条件。
- noneMatch(Predicate) ：检查流中是否没有元素满足给定条件。
- findFirst() ：返回流中的第一个元素。
- findAny() ：返回流中的任意一个元素。
除了上述方法之外，Stream 还提供了很多其他的操作，这些方法可以根据具体的需求进行组合和使用，以实现对集合数据的灵活处理。
示例
import java.util.Arrays; import java.util.List; public class StreamExample { public static void main(String[] args) { List names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Emma"); // 创建一个 Stream 对象，并通过 filter 操作筛选出包含字母“a”的名字 names.stream() .filter(name -> name.contains("a")) .forEach(System.out::println); } }在这个示例中，首先创建了一个包含几个名字的 List。然后使用 stream() 方法将其转换为 Stream 对象，在 Stream 上调用 filter 方法，传入一个 Lambda 表达式作为条件，筛选出包含字母“a”的名字。最后，我们使用 forEach 方法打印筛选出的结果。
除了 filter 和 forEach 操作之外，Stream 还提供了很多其他的操作，如 map、reduce、sorted 等，通过这些操作，可以非常方便地进行数据处理和转换。
需要注意的是，Stream 的操作通常是惰性求值的，也就是说，在调用终结操作（如 forEach）之前，中间操作（如 filter、map）不会立即执行，而是等到终结操作触发时才会执行。这种特性使得 Stream 在处理大规模数据时更加高效。
-
