java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java java.util包

Java学习常用包(类)之java.util包详解

作者：qq_17153885

这篇文章主要介绍了Java学习常用包(类)之java.util包的相关资料,Java.util包是Java标准类库的重要组成部分,包含集合框架、日期时间类、事件模型、随机数生成器等实用工具类,集合框架提供了多种数据结构和算法,需要的朋友可以参考下

一、关于java.util包

1.1简介

java.util​ 包是Java标准类库中的一个非常重要的组成部分，它提供了一系列对程序开发非常有用的类和接口。这个包主要包含集合框架、日期时间类、事件模型、随机数生成器以及其他实用工具类。

1.2常用类及接口

1.3时间

1.3.1Date类

简介

java.util.Date​ 类在Java中用于表示特定的瞬间，精确到毫秒。

构造方法

Date类提供了多个构造方法，其中比较常用的有：

方法

示例

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对象：

方法

TimeZone类提供了一些常用的方法，包括但不限于：

示例

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​包中最重要的部分之一，它提供了一系列的数据结构和算法，帮助开发者存储和操作数据集合。

在之前章节有详细介绍，这里不再赘述

1.5接口

1.5.1Comparator

简介

java.util.Comparator​ 接口是一个用于定义对象比较规则的接口。它允许开发者自定义对象比较逻辑，这在排序集合或者对对象进行排序操作时非常有用。Comparator​ 接口提供了一种灵活的比较机制，使得可以对任何对象进行排序，而不仅仅是实现了特定比较方法的对象。‍

方法

示例

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<Student> 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接口，我们可以对集合中的元素进行迭代访问，而不需要了解集合的具体实现方式。‍

方法

示例

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        // 获取Iterator对象并进行迭代
        Iterator<String> 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​ 接口本身不定义任何方法，但是它有很多子接口，这些子接口定义了事件处理方法。例如：

示例

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 randomUUID = new 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）确定的。

构造方法

方法

示例

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类提供了多种方法来解析基本数据类型和字符串。

构造方法

方法

示例

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 包中一些常用的类和接口：

总的来说，java.util.concurrent 包为 Java 程序员提供了丰富的并发编程工具，帮助开发者更加轻松地处理多线程编程中的挑战，提高了并发程序的性能和可靠性。通过合理地利用这些工具和框架，可以写出高效、可靠的并发程序。

1.7.2CompletableFuture类

简介

在Java中，CompletableFuture类提供了一种异步编程的方式，可以用于实现异步操作和构建复杂的异步流水线。它是Java 8引入的一个重要特性，用于简化并发编程。‍

java.util.concurrent 包中的 CompletableFuture 类是 Java 8 引入的一个类，用于支持异步编程和构建异步操作链。CompletableFuture 提供了一种简洁而强大的方式来处理异步任务的结果，以及对多个异步任务进行组合、串联和并发控制。

以下是 CompletableFuture 类的一些主要特点和用法：

使用 CompletableFuture 可以简化异步编程的复杂性，让开发者能够更加方便地处理异步任务的结果和操作。通过链式调用和组合不同的 CompletableFuture 对象，可以构建出复杂的异步任务流水线，实现高效的并发编程。

总的来说，CompletableFuture 是 Java 中处理异步编程的重要工具，它提供了丰富的方法和功能，使得异步任务的管理和处理变得更加简单和高效。‍

构造方法

CompletableFuture类有多个静态工厂方法来创建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<Void> 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​ 包中一些常用的类和接口：

通过使用 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​ 方法包括：

List<String> words = Arrays.asList("apple", "banana", "orange", "grape");
List<String> collectedList = words.stream()
                                .collect(Collectors.toList());
System.out.println(collectedList);

List<String> words = Arrays.asList("apple", "banana", "orange", "grape");
String concatenatedString = words.stream()
                                .collect(Collectors.joining(", "));
System.out.println(concatenatedString);

List<String> words = Arrays.asList("apple", "banana", "orange", "grape");
Map<Integer, List<String>> groupedByLength = words.stream()
                                                .collect(Collectors.groupingBy(String::length));
System.out.println(groupedByLength);

List<Integer> 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<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用Collectors.toList()方法将Stream中的元素收集到List中
        List<Integer> evenNumbers = numbers.stream()
                .filter(num -> num % 2 == 0)
                .collect(Collectors.toList());
        System.out.println("Even numbers: " + evenNumbers);

        // 使用Collectors.toSet()方法将Stream中的元素收集到Set中
        Set<Integer> oddNumbers = numbers.stream()
                .filter(num -> num % 2 != 0)
                .collect(Collectors.toSet());
        System.out.println("Odd numbers: " + oddNumbers);

        // 使用Collectors.toMap()方法将Stream中的元素收集到Map中
        Map<Integer, String> 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<String> list = Arrays.asList("a", "b", "c");
Stream<String> streamFromList = list.stream(); // 从List创建Stream
Stream<String> parallelStreamFromList = list.parallelStream(); // 从List创建并行Stream

从数组创建

String[] array = {"a", "b", "c"};
Stream<String> streamFromArray = Arrays.stream(array); // 从数组创建Stream

使用Stream.of()

Stream<String> streamOfElements = Stream.of("a", "b", "c"); // 使用Stream.of()创建Stream

使用Stream.iterate()

Stream<Integer> streamIterate = Stream.iterate(0, n -> n + 2).limit(5); // 使用Stream.iterate()创建Stream

使用Stream.generate()

Stream<Double> streamGenerate = Stream.generate(Math::random).limit(3); // 使用Stream.generate()创建Stream

方法

Stream 类提供了丰富的方法来支持对集合数据的高级操作，这些方法可以分为中间操作和终端操作两种类型。中间操作用于构建 Stream 流水线，而终端操作则触发实际的处理过程并产生结果。以下是一些常用的 Stream 方法：

中间操作：

终端操作：

除了上述方法之外，Stream 还提供了很多其他的操作，这些方法可以根据具体的需求进行组合和使用，以实现对集合数据的灵活处理。

示例

import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<String> 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 在处理大规模数据时更加高效。

总结

到此这篇关于Java学习常用包(类)之java.util包详解的文章就介绍到这了,更多相关Java java.util包内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文