配合 try-catch 使用

  • 使用 BufferedReader 从文件中逐行读取文本
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        String fileName = "example.txt"; // 假设要读取的文件名为 example.txt

        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line); // 逐行输出文本内容
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • 使用 BufferedReader 从 System.in（标准输入流）读取输入
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println("You entered: " + line); // 输出读入的内容
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

二、数组

1. 数组的定义

静态初始化数组

在声明数组的同时，为数组元素指定初始值。可以使用花括号 {} 来包含初始值，并用逗号分隔各个元素。示例如下：

// 声明并初始化一个整数数组
int[] numbers = {1, 2, 3, 4, 5};

// 声明并初始化一个字符串数组
String[] names = {"Alice", "Bob", "Charlie"};

在静态初始化数组时，编译器会根据提供的初始值自动确定数组的长度。

动态初始化数组

在声明数组时，先指定数组的类型和长度，然后使用 new 关键字创建数组对象。示例如下：

// 声明一个整数数组，并指定长度为 5
int[] numbers = new int[5];

// 声明一个字符串数组，并指定长度为 3
String[] names = new String[3];

//先声明数组，再 new 分配空间
double scores[] ; //声明数组， 这时 scores 是 null
scores = new double[5]; // 分配内存空间，可以存放数据

动态初始化数组时，所有元素都会被自动初始化为默认值（例如，整数数组的元素默认为 0，字符串数组的元素默认为 null）。

多维数组

Java 中还支持多维数组，即数组的元素也可以是数组。可以使用多组方括号 [] 来表示多维数组的维度。示例如下：

// 声明并初始化一个二维整数数组
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

// 声明一个三维字符串数组，并指定长度
String[][][] cube = new String[3][4][2];

多维数组的初始化方式与一维数组类似，可以使用静态初始化或动态初始化。

需要注意的是，数组的索引从 0 开始，因此可以通过索引访问数组中的元素。例如，numbers[0] 表示整数数组 numbers 的第一个元素。

此外，Java 还提供了一些数组相关的方法和属性，例如 length 属性用于获取数组的长度。可以使用点运算符 . 来访问数组的属性和调用方法。

int[] numbers = {1, 2, 3, 4, 5};
int length = numbers.length; // 获取数组的长度，结果为 5

2. 数组赋值机制

  1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。
int n1 = 2; int n2 = n1;
  1. 数组在默认情况下是引用传递，赋的值是地址。
//代码 ArrayAssign.java
int[] arr1 = {1,2,3};
int[] arr2 = arr1;

java输入数据到字符串数组 java 输入字符串数组_java输入数据到字符串数组

3. 数组拷贝

使用循环逐元素拷贝

可以使用循环遍历源数组的每个元素，并逐个将其复制到目标数组中。示例代码如下：

int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];

for (int i = 0; i < sourceArray.length; i++) {
    targetArray[i] = sourceArray[i];
}

通过循环逐个复制元素，实现了源数组到目标数组的拷贝。

使用 System.arraycopy() 方法

Java 提供了 System.arraycopy() 方法，可以方便地进行数组拷贝。该方法接受源数组、源数组的起始位置、目标数组、目标数组的起始位置以及要拷贝的元素数量作为参数。示例代码如下：

int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];

System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);

通过调用 System.arraycopy() 方法，将源数组的元素拷贝到目标数组中。

使用 Arrays.copyOf() 方法

import java.util.Arrays;

Arrays 类提供了 copyOf() 方法，可以用于拷贝数组。该方法接受源数组和目标数组的长度作为参数，并返回一个新的目标数组，其中包含源数组的元素。示例代码如下：

import java.util.Arrays;
...
int[] sourceArray = {1, 2, 3, 4, 5};
int[] targetArray = Arrays.copyOf(sourceArray, sourceArray.length);

通过调用 Arrays.copyOf() 方法，将源数组的元素拷贝到目标数组中。

4. 数组排序

使用Arrays类中的 sort() 方法来对数组进行排序

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 4, 1};
        
        // 对数组进行排序
        Arrays.sort(numbers);
        
        // 打印排序后的数组
        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }
}

使用lambda表达式来调整 sort() 方法的比较规则

import java.util.Arrays;

public class test1 {
    public static void main(String[] args) {
        int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5};
        System.out.println("Original array: " + Arrays.toString(arr));
        Arrays.sort(arr, (a, b) -> b - a);
        System.out.println("Sorted array: " + Arrays.toString(arr));
    }
}

// Original array: [3, 1, 4, 1, 5, 9, 2, 6, 5]
// Sorted array: [9, 6, 5, 5, 4, 3, 2, 1, 1]
public class test1 {
    public static void main(String[] args) {
        int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5};
        System.out.println("Original array: " + Arrays.toString(arr));
        Arrays.sort(arr, (a, b) -> {
            return a - b;
        });
        System.out.println("Sorted array: " + Arrays.toString(arr));
    }
}

// Original array: [3, 1, 4, 1, 5, 9, 2, 6, 5]
// Sorted array: [1, 1, 2, 3, 4, 5, 5, 6, 9]

5. 数组合并

import java.util.Arrays;

public class test1 {
    public static void main(String[] args) {
        int[] arr1 = {3, 2, 1};
        int[] arr2 = {6, 5, 4};
        int length = arr1.length + arr2.length;
        int[] res = new int[length];
        System.arraycopy(arr1, 0, res, 0, arr1.length);
        System.arraycopy(arr2, 0, res, arr1.length, arr2.length);
        Arrays.sort(res);
        int[] arr = Arrays.copyOf(res, length);
        for (int i = 0; i < arr.length; ++i) {
            System.out.print(arr[i] + " ");
        }
    }
}

6. 数组翻转

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        
        System.out.println("Original array: " + Arrays.toString(arr));
        
        // Reverse the array
        Arrays.reverse(arr);
        
        System.out.println("Reversed array: " + Arrays.toString(arr));
    }
}

// Original array: [1, 2, 3, 4, 5]
// Reversed array: [5, 4, 3, 2, 1]

7. 基于范围的 for 循环

从 Java 5 开始，引入了基于范围的 for 循环（也称为增强型 for 循环或 foreach 循环），用于遍历数组、集合等可迭代对象。基于范围的 for 循环可以更简洁地遍历集合或数组中的元素，无需显式地使用索引。

for (elementType element : collection) {
    // 在此处处理每个元素
}
  • elementType 是集合中元素的类型。
  • collection 是要遍历的集合或数组。
  • element 是一个变量，用于迭代遍历集合中的每个元素。

例如，遍历一个整数数组：

### 最后

> 由于细节内容实在太多了，为了不影响文章的观赏性，只截出了一部分知识点大致的介绍一下，每个小节点里面都有更细化的内容！

![]()

**小编准备了一份Java进阶学习路线图（Xmind）以及来年金三银四必备的一份《Java面试必备指南》**

![]()

lementType element : collection) {
    // 在此处处理每个元素
}
  • elementType 是集合中元素的类型。
  • collection 是要遍历的集合或数组。
  • element 是一个变量，用于迭代遍历集合中的每个元素。

例如，遍历一个整数数组：