Java的一些常见类【万字介绍】

欢迎来到Cefler的博客
博客主页：那个传说中的man的主页
个人专栏：题目解析
推荐文章：题目大解析（3）

---

输入输出

Scanner类

Scanner类是Java标准库中常用的输入处理类，它提供了一种方便的方式来从控制台、文件或其他输入源读取基本类型和字符串。

要使用Scanner类，首先需要在Java代码的开头添加引用：

import java.util.Scanner;

然后，可以创建Scanner对象，并将其关联到特定的输入源。以下是一些常见的用法示例：

1. 从控制台读取输入：

Scanner scanner = new Scanner(System.in);

这样就创建了一个Scanner对象，它将从标准输入（键盘）读取数据。

2. 从文件读取输入：

File file = new File("input.txt");
Scanner scanner = new Scanner(file);

这样就创建了一个Scanner对象，并将其关联到名为"input.txt"的文件。

3. 读取不同类型的输入：
   Scanner类提供了一系列的方法来读取不同类型的数据，如nextInt()、nextDouble()、nextLine()等。以下是一些示例：

int num = scanner.nextInt(); // 读取一个整数
double decimal = scanner.nextDouble(); // 读取一个浮点数
String str = scanner.nextLine(); // 读取一行字符串

4. 循环读取输入：
   可以通过循环结构来连续读取输入，直到满足某个结束条件为止。例如：

while (scanner.hasNext()) {
    String data = scanner.nextLine();
    // 处理输入数据
}

上述代码会持续从输入源获取数据，直到没有更多的数据可读时结束循环。

需要注意的是，在使用完Scanner对象后，应该调用其close()方法来释放资源：

scanner.close();

输出

Java提供了多种输出类来将数据输出到不同的目标，比较常用的有以下几种：

1. System.out：
   System.out是Java中的标准输出流，它是PrintStream类的对象，默认情况下将数据输出到控制台。可以使用System.out.print()和System.out.println()方法来输出数据。示例代码如下：

System.out.print("Hello "); // 不换行输出
System.out.println("World!"); // 换行输出

2. System.err：
   System.err是Java中的标准错误流，它也是PrintStream类的对象，默认情况下将数据输出到控制台。与System.out相比，System.err主要用于输出错误信息或异常信息。同样可以使用System.err.print()和System.err.println()方法来输出数据。

System.err.println("Error occurred!"); // 输出错误信息，并换行

3. PrintWriter类：
   PrintWriter类是一个便捷的输出类，它可以将数据输出到文件或其他输出源。示例代码如下：

try {
    PrintWriter writer = new PrintWriter("output.txt");
    writer.println("Hello World!");
    writer.close();
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

上述代码将字符串"Hello World!"输出到名为"output.txt"的文件中。

4. FileWriter类：
   FileWriter类是用于向文件写入字符数据的输出类。示例代码如下：

try {
    FileWriter writer = new FileWriter("output.txt");
    writer.write("Hello World!");
    writer.close();
} catch (IOException e) {
    e.printStackTrace();
}

上述代码将字符串"Hello World!"写入到名为"output.txt"的文件中。

输出浮点数时怎么控制输出小数位？

要控制输出浮点数的小数位数，可以使用 DecimalFormat 类或者 String.format() 方法来格式化输出。

下面是两种实现方式的示例代码：

1. 使用 DecimalFormat 类：

import java.text.DecimalFormat;

double number = 3.1415926;

// 创建 DecimalFormat 对象，指定小数位数为两位
DecimalFormat decimalFormat = new DecimalFormat("#0.00");

// 格式化输出
String formattedNumber = decimalFormat.format(number);

System.out.println(formattedNumber);   // 输出：3.14

2. 使用 String.format() 方法：

double number = 3.1415926;

// 使用 String.format() 方法指定小数位数为两位
String formattedNumber = String.format("%.2f", number);

System.out.println(formattedNumber);   // 输出：3.14

在示例代码中，我们将浮点数 number 格式化为保留两位小数的字符串并进行输出。其中 "#0.00" 或 "%.2f" 控制了小数位的显示格式，其中 0 表示有数字则显示，没有则补0，# 表示有数字则显示，没有则不显示。

数组

在Java中，数组是一种用于存储固定数量元素的数据结构。它可以存储相同类型的元素，并且具有固定的长度。以下是关于Java数组的一些重要概念和操作：

1. 声明数组：
   要声明一个数组，需要指定数组的类型和名称，并使用方括号来表示数组的维度。以下是一些示例：

int[] numbers; // 声明一个整型数组
double[] values; // 声明一个双精度浮点型数组
String[] names; // 声明一个字符串数组

2. 创建数组：
   在声明数组之后，需要使用new关键字来创建数组对象，并指定数组的长度。以下是一些示例：

numbers = new int[5]; // 创建包含5个元素的整型数组
values = new double[10]; // 创建包含10个元素的双精度浮点型数组
names = new String[3]; // 创建包含3个元素的字符串数组

也可以在声明数组的同时进行创建：

int[] numbers = new int[5]; // 声明并创建一个包含5个元素的整型数组

3. 访问数组元素：
   可以使用索引（从0开始）来访问数组中的元素。以下是一些示例：

numbers[0] = 10; // 设置第一个元素为10
int x = numbers[1]; // 读取第二个元素的值

4. 数组长度：
   使用length属性可以获取数组的长度，表示数组中元素的个数。例如：

int length = numbers.length; // 获取numbers数组的长度

5. 遍历数组：
   可以使用循环结构（如for循环）来遍历数组中的所有元素。以下是一个示例：

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]); // 输出每个元素的值
}

6. 多维数组：
   Java还支持多维数组，它是指包含多个维度的数组。例如，可以创建二维数组或三维数组。以下是一个示例：

int[][] matrix = new int[3][3]; // 创建一个3x3的二维整型数组
matrix[0][0] = 1; // 设置第一个元素的值
int value = matrix[1][2]; // 读取第二行第三列的元素值

数组的一些其它初始化方法

当声明数组时，可以使用以下方式进行初始化。

1. 直接初始化。在声明数组的同时，使用花括号{}括起来并用逗号分隔的方式指定初始值。

int[] numbers = {10, 20, 30, 40, 50};

2. 动态初始化。先声明数组，再使用赋值语句为每个元素赋初值。可以使用循环结构来实现批量赋值。

int[] numbers = new int[5];
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;

int[] numbers = new int[5];
for (int i = 0; i < 5; i++) {
    numbers[i] = i + 1;
}

3. 默认初始化。如果在声明数组时没有为数组元素指定初始值，则默认会根据其类型自动为每个元素初始化一个默认值。

int[] numbers = new int[5];
// 数组元素默认值为0

同时，Java中还存在一种匿名数组的方式，这种方式通常用于传递参数等需要创建临时数组的场合。

public class Example {
    public static void main(String[] args) {
        printArray(new int[]{10, 20, 30}); // 输出数组元素
    }
 
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

String类

在Java中，String类是一个非常重要且广泛使用的类，用于表示和操作字符串。它属于Java的核心类库，提供了各种方法来处理字符串。下面是关于String类的一些重要信息：

1. 创建字符串对象：
   可以使用以下方式创建字符串对象：

String str1 = "Hello"; // 直接赋值创建字符串对象
String str2 = new String("World"); // 使用构造函数创建字符串对象

2. 字符串长度：
   使用length()方法可以获取字符串的长度，即字符数（包括空格和标点符号）。

String str = "Hello World";
int length = str.length(); // 获取字符串长度

3. 字符串连接：
   使用+运算符或concat()方法可以将两个字符串连接起来。

String str1 = "Hello";
String str2 = "World";
String result1 = str1 + " " + str2; // 使用+运算符连接字符串
String result2 = str1.concat(" ").concat(str2); // 使用concat()方法连接字符串

4. 字符串比较：
   字符串比较可以使用equals()方法或equalsIgnoreCase()方法进行，返回一个布尔值。

String str1 = "Hello";
String str2 = "World";
boolean isEqual = str1.equals(str2); // 比较两个字符串是否相等

5. 字符串查找：
   可以使用indexOf()方法或lastIndexOf()方法来查找指定字符或子字符串在字符串中的位置。

String str = "Hello World";
int index1 = str.indexOf('o'); // 查找字符'o'在字符串中的第一次出现位置
int index2 = str.lastIndexOf("Wo"); // 查找子字符串"Wo"在字符串中的最后一次出现位置

6. 字符串切割：
   可以使用split()方法将字符串按照指定的分隔符切割为子字符串，并返回一个字符串数组。

String str = "Hello,World";
String[] parts = str.split(","); // 将字符串按逗号分隔为子字符串数组

7. 字符串替换：
   使用replace()方法可以将字符串中的指定字符或子字符串替换为新的字符或子字符串。

String str = "Hello World";
String newStr = str.replace('o', 'a'); // 将字符'o'替换为'a'

8. 字符串转换：
   String类提供了用于将字符串转换为其他数据类型的方法，例如parseInt()、parseFloat()等。

String numberStr = "123";
int number = Integer.parseInt(numberStr); // 将字符串转换为整数

怎么访问string类对象的元素？

在Java中，String类是不可变的，意味着一旦创建了一个String对象，它的值就不能被改变。因此，我们无法直接通过索引来访问字符串对象的元素。但是，可以使用以下方式访问字符串的元素：

1. 通过索引访问字符：
   字符串中的每个字符都有一个对应的索引，从0开始到长度减1。可以使用charAt()方法来获取指定索引位置的字符。

String str = "Hello";
char ch = str.charAt(0); // 获取字符串中索引为0的字符（即'H'）

2. 使用循环遍历字符串：
   可以使用循环结构（如for循环）以及字符串的长度属性和charAt()方法来逐个访问字符串中的字符。

String str = "Hello";
for (int i = 0; i < str.length(); i++) {
    char ch = str.charAt(i); // 获取字符串中每个索引位置的字符
    System.out.println(ch);
}

3. 转换为字符数组：
   可以使用toCharArray()方法将字符串转换为字符数组，然后直接访问字符数组中的元素。

String str = "Hello";
char[] chars = str.toCharArray(); // 将字符串转换为字符数组
char ch = chars[0]; // 获取字符数组中索引为0的字符（即'H'）

需要注意的是，由于String对象是不可变的，每次对字符串的操作都会创建一个新的字符串对象。因此，在频繁对字符串进行操作时，最好使用StringBuilder类或StringBuffer类，它们提供了可变的字符串操作功能。

StringBuilder类

在Java中，StringBuilder类表示一个可变的字符序列，可以用于构建字符串。与String类不同，StringBuilder对象是可变的，可以进行添加、删除、插入和替换操作，而不会创建新的字符串对象，因此在需要频繁修改字符串时，使用StringBuilder类可以提高效率。
下面是StringBuilder类的一些常用方法：

1. 创建StringBuilder对象：
   可以使用以下方式创建StringBuilder对象：

StringBuilder strBuilder = new StringBuilder(); // 创建一个空的StringBuilder对象
StringBuilder strBuilder2 = new StringBuilder("Hello"); // 使用指定字符串创建一个StringBuilder对象

2. 添加字符串：
   可以使用append()方法向StringBuilder对象中添加字符串。

StringBuilder strBuilder = new StringBuilder("Hello");
strBuilder.append(" World"); // 添加字符串" World"

3. 插入字符串：
   可以使用insert()方法将指定字符串插入到StringBuilder对象的指定位置。

StringBuilder strBuilder = new StringBuilder("Hello");
strBuilder.insert(2, "llo"); // 在索引为2的位置插入字符串"llo"

4. 删除字符串：
   可以使用delete()方法从StringBuilder对象中删除指定范围内的字符。

StringBuilder strBuilder = new StringBuilder("Hello World");
strBuilder.delete(5, 11); // 删除索引5到11之间的字符（包括索引5，但不包括索引11）

5. 替换字符串：
   可以使用replace()方法将StringBuilder对象中指定范围内的字符替换为指定字符串。

StringBuilder strBuilder = new StringBuilder("Hello World");
strBuilder.replace(6, 11, "Java"); // 将索引6到11之间的字符替换为字符串"Java"

6. 转换为字符串：
   可以使用toString()方法将StringBuilder对象转换为一个字符串对象。

StringBuilder strBuilder = new StringBuilder("Hello");
String str = strBuilder.toString(); // 将StringBuilder对象转换为一个字符串对象

7. 获取字符串长度：
   可以使用 length() 方法获取 StringBuilder 对象中当前字符串的长度。

   StringBuilder strBuilder = new StringBuilder("Hello");
   int length = strBuilder.length(); // 获取字符串长度
   

8. 获取指定索引位置的字符：
   使用 charAt() 方法可以获取 StringBuilder 对象中指定索引位置的字符。

   StringBuilder strBuilder = new StringBuilder("Hello");
   char ch = strBuilder.charAt(2); // 获取索引为 2 的字符（即 'l'）
   

9. 反转字符串：
   可以使用 reverse() 方法将 StringBuilder 对象中的字符串进行反转。

   StringBuilder strBuilder = new StringBuilder("Hello");
   strBuilder.reverse(); // 反转字符串
   

10. 删除指定位置的字符：
    使用 deleteCharAt() 方法可以删除 StringBuilder 对象中指定索引位置的字符。

    StringBuilder strBuilder = new StringBuilder("Hello");
    strBuilder.deleteCharAt(2); // 删除索引为 2 的字符
    

11. 替换指定范围内的字符序列：
    使用 replace() 方法可以将 StringBuilder 对象中指定范围内的字符序列替换为另一个字符串。

    StringBuilder strBuilder = new StringBuilder("Hello World");
    strBuilder.replace(6, 11, "Java"); // 将索引 6 到 11 之间的字符序列替换为 "Java"
    

12. 清空字符串：
    可以使用 setLength() 方法将 StringBuilder 对象的长度设置为 0，从而清空字符串。

    StringBuilder strBuilder = new StringBuilder("Hello");
    strBuilder.setLength(0); // 清空字符串
    

stringbuilder类怎么访问对象元素？

在 StringBuilder 类中，可以通过索引访问和修改对象的元素（字符）。使用 charAt() 方法可以获取指定索引位置的字符，使用 setCharAt() 方法可以修改指定索引位置的字符。下面是具体的示例：

StringBuilder strBuilder = new StringBuilder("Hello");

// 访问指定索引位置的字符
char ch = strBuilder.charAt(2); // 获取索引为 2 的字符（即 'l'）
System.out.println(ch); // 输出：l

// 修改指定索引位置的字符
strBuilder.setCharAt(2, 'L'); // 将索引为 2 的字符修改为 'L'
System.out.println(strBuilder.toString()); // 输出：HeLlo

在上面的示例中，我们首先使用 charAt() 方法获取索引为 2 的字符，并将其存储在变量 ch 中。然后，使用 setCharAt() 方法将索引为 2 的字符修改为 ‘L’。最后，通过 toString() 方法将 StringBuilder 对象转换为字符串并进行打印。

需要注意的是，索引从0开始，即第一个字符的索引是0，第二个字符的索引是1，以此类推。

小tips

如果要将 StringBuilder 对象的内容打印出来或传递给需要字符串类型参数的方法，通常需要使用 toString() 方法将其转换为 String 类型。

StringBuffer类

当然，下面是关于 StringBuffer 类的一些介绍和常用方法的示例：

StringBuffer 类是 Java 中可变字符串的线程安全版本，它与 StringBuilder 类相似，但有一些区别。主要区别在于 StringBuffer 的方法被声明为synchronized，从而保证了多线程环境下的安全性，但性能相对较低。

以下是 StringBuffer 类的一些常用方法示例：

1. 构造方法：
   StringBuffer 可以通过多种构造方法进行实例化，例如：

   StringBuffer strBuffer1 = new StringBuffer(); // 创建一个空的 StringBuffer 对象
   StringBuffer strBuffer2 = new StringBuffer("Hello"); // 创建一个包含初始内容的 StringBuffer 对象
   

2. 添加字符串：
   使用 append() 方法可以向 StringBuffer 对象中追加字符串。

   StringBuffer strBuffer = new StringBuffer("Hello");
   strBuffer.append(" World"); // 向末尾添加字符串
   

3. 插入字符串：
   使用 insert() 方法可以在指定位置插入字符串。

   StringBuffer strBuffer = new StringBuffer("Hello");
   strBuffer.insert(2, "Java"); // 在索引 2 处插入字符串
   

4. 删除指定范围内的字符串：
   使用 delete() 方法可以删除 StringBuffer 对象中指定范围内的字符串。

   StringBuffer strBuffer = new StringBuffer("Hello World");
   strBuffer.delete(6, 11); // 删除索引 6 到 11 之间的字符串
   

5. 反转字符串：
   使用 reverse() 方法可以将 StringBuffer 对象中的字符串进行反转。

   StringBuffer strBuffer = new StringBuffer("Hello");
   strBuffer.reverse(); // 反转字符串
   

6. 获取字符串长度：
   可以使用 length() 方法获取 StringBuffer 对象中当前字符串的长度。

   StringBuffer strBuffer = new StringBuffer("Hello");
   int length = strBuffer.length(); // 获取字符串长度
   

7. 获取指定索引位置的字符：
   使用 charAt() 方法可以获取 StringBuffer 对象中指定索引位置的字符。

   StringBuffer strBuffer = new StringBuffer("Hello");
   char ch = strBuffer.charAt(2); // 获取索引为 2 的字符（即 'l'）
   

8. 删除指定位置的字符：
   使用 deleteCharAt() 方法可以删除 StringBuffer 对象中指定索引位置的字符。

   StringBuffer strBuffer = new StringBuffer("Hello");
   strBuffer.deleteCharAt(2); // 删除索引为 2 的字符
   

9. 替换指定范围内的字符序列：
   使用 replace() 方法可以将 StringBuffer 对象中指定范围内的字符序列替换为另一个字符串。

   StringBuffer strBuffer = new StringBuffer("Hello World");
   strBuffer.replace(6, 11, "Java"); // 将索引 6 到 11 之间的字符序列替换为 "Java"
   

10. 清空字符串：
    可以使用 setLength() 方法将 StringBuffer 对象的长度设置为 0，从而清空字符串。

    StringBuffer strBuffer = new StringBuffer("Hello");
    strBuffer.setLength(0); // 清空字符串
    

11. 获取容量：
    使用 capacity() 方法可以获取 StringBuffer 对象当前的容量（内部字符数组的大小）。

    StringBuffer strBuffer = new StringBuffer("Hello");
    int capacity = strBuffer.capacity(); // 获取容量
    

12. 转换为 String 类型：
    使用 toString() 方法可以将 StringBuffer 对象转换为 String 类型。

    StringBuffer strBuffer = new StringBuffer("Hello");
    String str = strBuffer.toString(); // 转换为 String 类型
    

StringBuffer 类与 String 类和 StringBuilder 类的主要区别在于线程安全性。StringBuffer 是线程安全的，适用于多线程环境，但性能相对较低。而 StringBuilder 是非线程安全的，适用于单线程环境，但性能较高。

另外，StringBuffer 和 StringBuilder 类都提供了可变字符串的操作方法，而 String 类是不可变的，意味着每次对字符串进行操作时都会创建一个新的字符串对象。

java提供的一些排序、swap方法

Java 中也提供了许多用于排序和数组操作的类和方法。下面是一些常用的 Java 排序和数组操作类和方法：

1. Arrays 类：提供了一些静态方法，如 sort()、binarySearch()、copyOf() 等，可以对数组进行排序、二分查找、复制等操作。

int[] numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
Arrays.sort(numbers); // 对整个数组进行排序
int index = Arrays.binarySearch(numbers, 5); // 在已排序数组中查找元素（返回值为下标，若未找到则返回负数）
int[] copy = Arrays.copyOf(numbers, numbers.length); // 复制整个数组

2. Collections 类：提供了一些静态方法，如 sort()、binarySearch()、swap() 等，可以对集合进行排序、二分查找、交换元素等操作。

List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3));
Collections.sort(list); // 对列表进行排序
int index = Collections.binarySearch(list, 5); // 在已排序列表中查找元素（返回值为下标，若未找到则返回负数）
Collections.swap(list, 0, 1); // 交换列表中指定位置的元素

需要注意的是，Java 中的排序和数组操作方法通常是稳定的、通用的和安全的，但可能在性能方面不如 C++ 中的算法库。如果需要进行复杂的算法操作或者对性能有很高要求，可以考虑使用其他第三方库或自行实现。

Integer类

Integer 是 Java 中的一个类，用于表示整数类型的数据。它是 java.lang.Integer 类的封装类，提供了许多方法来操作和处理整数。

Integer 类具有以下特点：

1. 封装功能：Integer 类将基本数据类型 int 封装成对象。这样可以在需要使用对象的场景中操作和处理整数。
2. 不可变性：Integer 对象创建后，其值不可更改。如果需要修改值，只能创建一个新的 Integer 对象。
3. 装箱和拆箱：Java 自动支持 int 和 Integer 之间的自动转换，称为装箱和拆箱。装箱是指将基本数据类型 int 包装为 Integer 对象，而拆箱则是指将 Integer 对象转换为 int 值。
4. 提供常用方法：Integer 类中提供了许多方法，如 parseInt()、valueOf()、toString()等，用于解析字符串、转换为字符串、比较大小等操作。

下面是一些使用 Integer 类的示例：

int num = 10;
Integer integerObj1 = new Integer(num); // 装箱，将 int 转换为 Integer 对象
Integer integerObj2 = Integer.valueOf(20); // 装箱，另一种方式
int value1 = integerObj1.intValue(); // 拆箱，将 Integer 对象转换为 int 值
int value2 = integerObj2; // 拆箱，另一种方式
String str = integerObj1.toString(); // 将 Integer 对象转换为字符串

int sum = integerObj1 + integerObj2; // 自动拆箱后进行运算

值得注意的是，从 Java 5 开始，引入了自动装箱和拆箱的特性，使得在 Integer 类与 int 类型之间的转换更加方便。

List类

当提到 “List”，通常指的是Java中的接口 java.util.List。List 是 Java 中最常用的集合类之一，它允许存储一组有序的元素，并且允许重复元素存在。

List 接口的实现类有许多，常见的包括 ArrayList、LinkedList 和 Vector 等。

下面是 List 的一些特点和常用操作：

1. 有序性：List 中的元素按照它们被插入的顺序进行存储，并且可以根据索引位置访问和操作元素。
2. 元素重复：List 允许存储重复的元素，同一个元素可以出现多次。
3. 大小可变：List 的大小是可变的，可以随时添加、删除或修改元素。
4. 常用方法：List 提供了一系列常用的方法，如 add() 用于添加元素，get() 用于获取指定位置的元素，remove() 用于移除指定位置或指定元素等。

以下是一个使用 ArrayList 的示例：

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

public class ListExample {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();

        // 添加元素
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("orange");

        // 获取元素
        String firstFruit = fruits.get(0);
        System.out.println("第一个水果：" + firstFruit);

        // 修改元素
        fruits.set(1, "grape");

        // 删除元素
        fruits.remove(2);

        // 遍历元素
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 判断是否包含某个元素
        boolean containsOrange = fruits.contains("orange");
        System.out.println("是否包含橙子：" + containsOrange);

        // 获取列表长度
        int size = fruits.size();
        System.out.println("水果列表长度：" + size);
    }
}

输出结果：

第一个水果：apple
apple
grape
是否包含橙子：false
水果列表长度：2

foreach循环遍历

Java 从SE5（也就是J2SE 5.0）开始支持了增强型 for 循环（也称为 foreach 循环）语法，可以用于遍历实现了 Iterable 接口的对象，包括 List、Set、Map等集合类。

在使用增强型 for 循环时，不需要进行索引的控制，语法非常简洁。下面是一个示例代码：

List<String> listOfFruits = Arrays.asList("apple", "banana", "orange");
for (String fruit : listOfFruits) {
    System.out.println(fruit);
}

以上代码就使用了增强型 for 循环，将 listOfFruits 中的元素逐个输出。

需要注意的是，增强型 for 循环不能对数组进行操作，因为数组没有实现 Iterable 接口，但是可以使用传统的 for 循环通过索引来访问数组元素。例如：

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

对于 String 类和 StringBuilder 类，它们都不是实现了 Iterable 接口，因此不能直接使用增强型 for 循环进行遍历。

但是，可以通过一些方式将它们转换为可迭代的对象来实现类似的效果。例如，可以将字符串拆分为字符数组，然后使用增强型 for 循环遍历字符数组。示例如下：

String str = "Hello";
for (char c : str.toCharArray()) {
    System.out.println(c);
}

对于 StringBuffer 类，它实现了 CharSequence 接口，而 CharSequence 是 Iterable 的子接口，因此 StringBuffer 对象可以直接使用增强型 for 循环进行遍历。示例如下：

StringBuffer sb = new StringBuffer("Hello");
for (char c : sb) {
    System.out.println(c);
}

需要注意的是，StringBuilder 类与 StringBuffer 类非常相似，但不是实现了 CharSequence 接口，因此不能直接使用增强型 for 循环遍历。如果希望使用增强型 for 循环遍历 StringBuilder 对象中的字符，请先将其转换为字符数组或字符串。

Date类

当涉及日期和时间的操作时，Java 中常用的类是 Date 类。Date 类提供了对日期和时间的处理方法，包括获取当前日期和时间、比较日期、格式化日期、解析日期等。

以下是一些常用的 Date 类方法：

1. 构造方法：

   • Date()：创建一个表示当前日期和时间的 Date 对象。
   • Date(long milliseconds)：根据给定的毫秒数创建一个 Date 对象。

2. 获取日期和时间的方法：

   • getTime()：返回自 1970 年 1 月 1 日午夜以来的毫秒数。

3. 比较日期和时间的方法：

   • before(Date when)：检查一个日期是否在另一个日期之前。
   • after(Date when)：检查一个日期是否在另一个日期之后。
   • compareTo(Date anotherDate)：将此日期与另一个日期进行比较。

4. 格式化和解析日期的方法：

   • toString()：将日期对象转换为字符串表示。
   • SimpleDateFormat 类：用于将日期对象格式化为指定的字符串，或将字符串解析为日期对象。

5. 其他方法：

   • setTime(long time)：设置日期对象的毫秒数。
   • clone()：创建并返回此日期对象的副本。

需要注意的是，Date 类存在一些问题，因为它在设计之初并不考虑国际化和时区的问题。在 Java 8 中，引入了新的日期和时间 API java.time，其中包含了更强大和易用的日期和时间处理功能。

Random类

当需要生成伪随机数时，Java 中常用的类是 Random 类。Random 类提供了生成伪随机数的方法，可以用于各种需要随机性的场景。

以下是 Random 类的一些常用方法和示例代码：

1. 生成随机整数：

import java.util.Random;

// 创建 Random 对象
Random random = new Random();

// 生成 0 到 9 之间（包括 0 和 9）的随机整数
int randomNumber = random.nextInt(10);

System.out.println(randomNumber);

2. 生成随机浮点数：

import java.util.Random;

// 创建 Random 对象
Random random = new Random();

// 生成 0.0 到 1.0 之间的随机浮点数
double randomDouble = random.nextDouble();

System.out.println(randomDouble);

3. 生成随机布尔值：

import java.util.Random;

// 创建 Random 对象
Random random = new Random();

// 生成随机布尔值
boolean randomBoolean = random.nextBoolean();

System.out.println(randomBoolean);

4. 生成随机字节数组：

import java.util.Random;

// 创建 Random 对象
Random random = new Random();

// 创建字节数组
byte[] randomBytes = new byte[10];

// 填充字节数组为随机值
random.nextBytes(randomBytes);

System.out.println(Arrays.toString(randomBytes));

需要注意的是，Random 类生成的是伪随机数，即看起来像随机的数值，但实际上是通过算法计算得出的。如果需要更安全和更随机的随机数生成方式，请使用 java.security.SecureRandom 类。

Math类

Math 类是 Java 中提供数学计算方法的一个内置类。它包含了许多用于执行常见数学运算的静态方法，如取绝对值、求平方根、三角函数等。

以下是 Math 类的一些常用方法和示例代码：

1. 取整数部分：

double number = 3.14;

// 向下取整
int floorValue = (int) Math.floor(number);

// 向上取整
int ceilValue = (int) Math.ceil(number);

// 四舍五入
int roundValue = (int) Math.round(number);

System.out.println(floorValue);    // 输出：3
System.out.println(ceilValue);     // 输出：4
System.out.println(roundValue);    // 输出：3

2. 求最大值和最小值：

int a = 5;
int b = 3;

// 求最大值
int max = Math.max(a, b);

// 求最小值
int min = Math.min(a, b);

System.out.println(max);   // 输出：5
System.out.println(min);   // 输出：3

3. 求绝对值和随机数：

int x = -7;

// 求绝对值
int absValue = Math.abs(x);

// 生成 0 到 1 之间的随机浮点数
double randomValue = Math.random();

System.out.println(absValue);       // 输出：7
System.out.println(randomValue);    // 输出：随机浮点数

4. 数学运算：

double angle = 45.0;

// 求正弦值
double sinValue = Math.sin(Math.toRadians(angle));

// 求余弦值
double cosValue = Math.cos(Math.toRadians(angle));

// 求正切值
double tanValue = Math.tan(Math.toRadians(angle));

System.out.println(sinValue);   // 输出：0.7071067811865475
System.out.println(cosValue);   // 输出：0.7071067811865476
System.out.println(tanValue);   // 输出：0.9999999999999999

5.求平方根：

double number = 16;

// 求平方根
double squareRoot = Math.sqrt(number);

System.out.println(squareRoot);   // 输出：4.0

6.求幂（pow）

double base = 2;
double exponent = 3;

// 求幂
double powerResult = Math.pow(base, exponent);

System.out.println(powerResult);   // 输出：8.0

需要注意的是，Math 类的方法都是静态方法，可以直接通过 Math.方法名() 的方式调用。另外，Math 类还包含其他一些数学计算的方法，如幂运算、对数运算、指数运算等。

java中常见的一些包

Java提供了众多常见且常用的包，这些包包含了各种功能和工具类。以下是一些常见的Java包及其主要功能：

1. java.lang：提供了Java语言的核心类，例如基本数据类型的包装类、字符串处理、异常处理等。

2. java.util：提供了各种实用工具类，如集合框架、日期时间处理、随机数生成、输入输出、正则表达式等。

3. java.io：提供了用于处理输入输出的类和接口，如文件操作、流操作、序列化等。

4. java.math：提供了处理大数运算的类和方法，如高精度计算、大整数操作、大浮点数操作等。

5. java.net：提供了进行网络编程的类和接口，如Socket编程、URL处理、HTTP通信等。

6. java.sql：提供了进行数据库操作的类和接口，如连接数据库、执行SQL语句、事务处理等。

7. java.awt：提供了创建图形用户界面（GUI）的类和接口，如窗口、按钮、文本框、绘图等。

8. javax.swing：在java.awt的基础上进一步扩展，提供了更丰富的GUI组件，如对话框、表格、列表等。

java.lang

在java.lang包中，有一些常见且常用的类，这些类在Java编程中非常有用。以下是其中一些常见类的介绍：

1. Object：是所有类的父类，定义了一些通用方法，如equals()、hashCode()、toString()等。

2. String：用于表示字符串，提供了字符串操作的各种方法，如拼接、截取、替换、判断相等等。

3. StringBuilder和StringBuffer：用于高效地进行字符串拼接和修改操作，可避免频繁创建新字符串。

4. Boolean、Character、Byte、Short、Integer、Long、Float、Double：这些是基本数据类型对应的包装类，用于在对象中封装基本类型值，提供了许多有用的方法。

5. Enum：用于定义枚举类型，可以枚举固定的常量项。

6. Throwable、Exception和Error：用于异常处理，Throwable是异常处理的根类，Exception是普通异常的父类，Error是严重错误的父类。

7. Thread：用于创建和管理线程，实现多线程并发操作。

除了以上列举的类之外，java.lang包还包含了其他一些类，如Math（提供数学运算方法）、System（提供与系统交互的方法）、Runtime（与运行时环境进行交互的类）等。

需要注意的是，java.lang包中的类在Java程序中默认可直接使用，无需显式导入。

java.util

在java.util包中，有许多常见且有用的类，提供了各种数据结构和工具类。以下是其中一些常见类的介绍：

1. ArrayList：动态数组实现的列表，可以根据需要自动扩容。

2. LinkedList：双向链表实现的列表，对于插入和删除操作效率较高。

3. HashMap：基于哈希表实现的键值对映射集合，通过键快速查找值。

4. HashSet：基于哈希表实现的无序集合，用于存储唯一元素。

5. TreeMap：基于红黑树实现的有序键值对映射集合，根据键进行排序。

6. TreeSet：基于红黑树实现的有序集合，保持元素的自然排序。

7. Queue接口及其实现类，如LinkedList：用于表示队列数据结构，按照先进先出（FIFO）的方式进行元素操作。

8. Deque接口及其实现类，如ArrayDeque：双端队列，可以在两端插入和删除元素。

9. Iterator：用于遍历集合中的元素，提供了统一的迭代器模式。

10. Date和Calendar：用于处理日期和时间相关操作。

11. Random：用于生成伪随机数。

12. Collections：提供了一系列静态方法，用于对集合进行常见操作，如排序、查找、反转等。

除了以上列举的类之外，java.util包还包含了其他许多有用的类和接口，如Scanner（用于从输入流中读取数据）、Arrays（提供数组操作的方法）、Stack（栈数据结构）、PriorityQueue（优先级队列）等。

---

如上便是本期的所有内容了，如果喜欢并觉得有帮助的话，希望可以博个点赞+收藏+关注❤️ ,学海无涯苦作舟,愿与君一起共勉成长