java学习笔记下

1
BufferedReader reader = null;
2
try {
3
    reader = new BufferedReader(new FileReader("file.txt"));
4
    String line = reader.readLine();
5
    System.out.println(line);
6
} catch (IOException e) {
7
    System.out.println("IOException: " + e.getMessage());
8
} finally {
9
    // 确保资源被释放
10
    if (reader != null) {
11
        try {
12
            reader.close();
13
        } catch (IOException e) {
14
            System.out.println("Error closing reader: " + e.getMessage());
15
        }
16
    }
17
}

1
import java.io.BufferedReader;
2
import java.io.FileReader;
3
import java.io.IOException;
4

5
public class TryWithResourcesExample {
6
    public static void main(String[] args) {
7
        try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
8
            String line = reader.readLine();
9
            System.out.println(line);
10
        } catch (IOException e) {
11
            System.out.println("IOException: " + e.getMessage());
12
        }
13
        // 无需显式关闭 reader，Java 会自动处理
14
    }
15
}

1
public class Example {
2
  public static void main(String[] args) {
3
    try {
4
      testAge(-1);
5
    } catch(AgeOutOfRangeException e) {
6
      System.out.println(e.getMessage());
7
    }
8
  }
9

10
  public static void testAge(int age)  {
11
    if(age < 0) {
12
      throw new AgeOutOfRangeException("年龄要大于或等于0岁");
13
    }
14
  }
15
}
16

17
class AgeOutOfRangeException extends RuntimeException {
18
  public AgeOutOfRangeException(String message) {
19
    super(message);
20
  }
21

22
  public AgeOutOfRangeException(String message, Throwable cause) {
23
    super(message, cause);
24
  }
25
}

1
import java.io.BufferedReader;
2
import java.io.FileReader;
3
import java.io.IOException;
4

5
public class ThrowsExample {
6

7
    public static void main(String[] args) {
8
        try {
9
            readFile("nonexistentfile.txt");
10
        } catch (IOException e) {
11
            System.out.println("文件未找到: " + e.getMessage());
12
        }
13
    }
14

15
    public static void readFile(String fileName) throws IOException {
16
        BufferedReader reader = new BufferedReader(new FileReader(fileName));
17
        String line = reader.readLine();
18
        System.out.println(line);
19
        reader.close();
20
    }
21
}

1
class SuperClass {
2
  public void foo() throws Exception {
3
    int res = 1 / 0;
4
  }
5
}
6

7
class SubClass1 extends SuperClass {
8
  @Override
9
  public void foo() { // 不抛出异常
10
    try{
11
      int res = 1 / 0;
12
    } catch(ArithmeticException e) {
13
      System.out.println(e.getMessage());
14
    }
15
  }
16
}
17

18
class SubClass2 extends SuperClass {
19
  @Override
20
  public void foo() throws Exception { // 抛出父类异常同类型异常
21
    int res = 1 / 0;
22
  }
23
}
24

25
class SubClass3 extends SuperClass {
26
  @Override
27
  public void foo() throws ArithmeticException { // 抛出父类方法抛出异常的子类异常
28
    int res = 1 / 0;
29
  }
30
}

1
public class Example {
2
  public static void main(String[] args) {
3
    String str1 = new String("Hello");
4
    String str2 = new String("World");
5

6
    String str = str1 + str2;
7
        // 这里是上面字符串创建方式提到的第三种创建方式
8
        // 间接使用构造器创建，所以这里的str指向的是一个堆区的
9
        // 字符串对象，而且常量池中没有与str内容一样的字符串常量
10

11
    System.out.println(str == str.intern()); // true
12
    // 这里由于str指向的是一个新的在堆区的String对象，内容为"HelloWorld"
13
    // 而在常量池中没有与"HelloWorld"内容一样的字符串常量，所以，str的引用会被放入到常量池中，然后被返回，所以这里str.intern()返回的还是str，所以
14
    // 这里会输出true
15
  }
16
}

1
public class Example {
2
  public static void main(String[] args) {
3
    String a = "123";
4
    // a指向常量池的"123"
5
    String b = new String("123");
6
    // b指向堆区的String对象，
7
    // String对象的value指向常量池的"123"
8

9
    System.out.println(a.equals(b)); // true
10
    System.out.println(a == b); // false
11
    System.out.println(a == b.intern()); // true
12
        // 由于常量池中已经有了"123"常量，所以返回的是这个常量的引用，
13
        // 而a的引用就是这个常量的引用，所以这里结果为true
14
    System.out.println(b == b.intern()); // false
15
        // 这里b.intern()返回的是常量池中的"123"常量，对于b指向的则是堆区中的
16
        // 对象，所以这里是结果false
17
  }
18
}

1
//生成特定范围的随机浮点数
2
double min = 5.0; // 最小值
3
double max = 10.0; // 最大值
4
double randomValue = min + (Math.random() * (max - min));
5
//生成特定范围的随机整数
6
int min = 5; // 最小值
7
int max = 10; // 最大值
8
int randomInt = min + (int)(Math.random() * (max - min + 1));
9
//生成随机布尔值
10
boolean randomBoolean = Math.random() < 0.5;
11
//生成随机字符（例如：小写字母
12
char randomChar = (char)('a' + Math.random() * 26);
13
//生成指定长度的随机字符串
14
StringBuilder randomString = new StringBuilder();
15
int length = 10; // 指定字符串长度
16
for (int i = 0; i < length; i++) {
17
    char randomChar = (char)('a' + Math.random() * 26); // 生成小写字母
18
    randomString.append(randomChar);
19
}

1
    public static String toString(int[] a) {
2
        if (a == null) // 判断 a 是否为空引用，如果为空引用，则返回 "null" 字符串
3
            return "null";
4
        int iMax = a.length - 1;
5
        if (iMax == -1) // 判断数组内容是否为空，如果内容为空，则返回 "[]" 字符串
6
            return "[]";
7

8
        StringBuilder b = new StringBuilder();
9
        b.append('[');
10
        for (int i = 0; ; i++) {
11
            b.append(a[i]); // 依次将数组的元素追加到字符串中
12
            if (i == iMax) // 判断是否为最后一个元素，如果是最后一个元素，则返回最终的字符串
13
                return b.append(']').toString();
14
            b.append(", ");
15
        }
16
    }

1
import java.util.Arrays;
2

3
public class Example {
4
  public static void main(String[] args) {
5
    // 原始数组
6
    int[] originalArray = {1, 2, 3, 4, 5};
7

8
    // 复制数组，指定新数组的长度
9
    // 新数组长度小于原数组长度
10
    int[] newArray1 = Arrays.copyOf(originalArray, 3);
11
    System.out.println("新数组1: " + Arrays.toString(newArray1)); // 输出: [1, 2, 3]
12

13
    // 新数组长度大于原数组长度
14
    int[] newArray2 = Arrays.copyOf(originalArray, 8);
15
    System.out.println("新数组2: " + Arrays.toString(newArray2)); // 输出: [1, 2, 3, 4, 5, 0, 0, 0]
16

17
    // 新数组长度等于原数组长度
18
    int[] newArray3 = Arrays.copyOf(originalArray, originalArray.length);
19
    System.out.println("新数组3: " + Arrays.toString(newArray3)); // 输出: [1, 2, 3, 4, 5]
20
  }
21
}
22
//第一个参数是源数组，第二个参数是从源数组中复制多少个元素到新数组中，如果第二个参数大于了源数组的大小，则新数组中大于源数组大小的部分的元素都是类型默认值。

1
import java.util.Arrays;
2
import java.util.Comparator;
3

4
public class Example {
5
  public static void main(String[] args) {
6
    Integer[] arr = {11, 33, 99, 22, 88, 44, 55, 66, 77};
7
        // 这里要使用 Integer 包装类
8

9
    Arrays.sort(arr, new Comparator<Integer>() {
10
      @Override
11
      public int compare(Integer o1, Integer o2) {
12
        return o2 - o1;
13
      }
14
    });
15
    System.out.println(Arrays.toString(arr));
16
  }
17
}

1
import java.util.Arrays;
2

3
public class Example {
4
  public static void main(String[] args) {
5
    int[] array1 = {1, 2, 3};
6
    int[] array2 = {1, 2, 3};
7
    int[] array3 = {1, 2, 4};
8

9
    // 比较相同的数组
10
    boolean isEqual1 = Arrays.equals(array1, array2);
11
    System.out.println("array1 和 array2 相等? " + isEqual1); // 输出: true
12

13
    // 比较不同的数组
14
    boolean isEqual2 = Arrays.equals(array1, array3);
15
    System.out.println("array1 和 array3 相等? " + isEqual2); // 输出: false
16
  }
17
}

1
import java.util.Arrays;
2

3
public class Example {
4
  public static void main(String[] args) {
5
    int[][] array1 = {{1, 2, 3}, {4, 5, 6}};
6
    int[][] array2 = {{1, 2, 3}, {4, 5, 6}};
7
    int[][] array3 = {{1, 2, 3}, {4, 5, 7}};
8

9
    // 比较相同的二维数组
10
    boolean isEqual1 = Arrays.deepEquals(array1, array2);
11
    System.out.println("array1 和 array2 相等? " + isEqual1); // 输出: true
12

13
    // 比较不同的二维数组
14
    boolean isEqual2 = Arrays.deepEquals(array1, array3);
15
    System.out.println("array1 和 array3 相等? " + isEqual2); // 输出: false
16
  }
17
}

1
import java.util.Arrays;
2
import java.util.List;
3

4
public class Example {
5
  public static void main(String[] args) {
6
    Integer[] numbersArray = {1, 2, 3, 4, 5};
7

8
    // 转换为列表
9
    List<Integer> numbersList = Arrays.asList(numbersArray);
10

11
    // 修改列表中的元素
12
    numbersList.set(0, 10);
13

14
    // 打印修改后的列表和数组
15
    System.out.println("修改后的列表: " + numbersList); // 输出: 修改后的列表: [10, 2, 3, 4, 5]
16
    System.out.println("修改后的数组: " + Arrays.toString(numbersArray)); // 输出: 修改后的数组: [10, 2, 3, 4, 5]
17
  }
18
}

1
import java.util.Arrays;
2
import java.util.List;
3

4
public class Example {
5
  public static void main(String[] args) {
6
    String[] colorsArray = {"Red", "Green", "Blue"};
7

8
    // 转换为列表
9
    List<String> colorsList = Arrays.asList(colorsArray);
10

11
    // 尝试添加新元素（会抛出 UnsupportedOperationException）
12
    try {
13
      colorsList.add("Yellow");
14
    } catch (UnsupportedOperationException e) {
15
      System.out.println("无法添加元素到列表: " + e.getMessage());
16
    }
17
  }
18
}
19
//固定大小：返回的 List 的大小是固定的，因为原数组的大小是固定的。换句话说，您不能向该列表中添加或删除元素，因为这会导致列表的大小发生变化。当尝试调用 add() 或 remove() 方法来修改列表的大小时，会抛出 UnsupportedOperationException

1
import java.util.ArrayList;
2
import java.util.List;
3

4
public class ArrayListDemo {
5
    public static void main(String[] args) {
6
        // 1. 创建ArrayList（存储字符串）
7
        List<String> list = new ArrayList<>();
8

9
        // 2. 添加元素（有序、可重复）
10
        list.add("Java");
11
        list.add("Python");
12
        list.add("Java"); // 允许重复元素
13
        System.out.println("添加后：" + list); // 输出：[Java, Python, Java]
14

15
        // 3. 按索引访问元素
16
        String element = list.get(1);
17
        System.out.println("索引1的元素：" + element); // 输出：Python
18

19
        // 4. 按索引修改元素
20
        list.set(2, "C++");
21
        System.out.println("修改后：" + list); // 输出：[Java, Python, C++]
22

23
        // 5. 按索引删除元素
24
        list.remove(1);
25
        System.out.println("删除后：" + list); // 输出：[Java, C++]
26

27
        // 6. 遍历元素（三种方式）
28
        // 方式1：普通for循环（适合需要索引的场景）
29
        for (int i = 0; i < list.size(); i++) {
30
            System.out.print(list.get(i) + " ");
31
        }
32
        System.out.println();
33

34
        // 方式2：增强for循环（简洁）
35
        for (String s : list) {
36
            System.out.print(s + " ");
37
        }
38
        System.out.println();
39

40
        // 方式3：迭代器（支持遍历中删除元素）
41
        java.util.Iterator<String> iterator = list.iterator();
42
        while (iterator.hasNext()) {
43
            String s = iterator.next();
44
            if (s.equals("Java")) {
45
                iterator.remove(); // 安全删除，不会触发ConcurrentModificationException
46
            }
47
        }
48
        System.out.println("迭代器删除后：" + list); // 输出：[C++]
49
    }
50
}