Java常用API学习日志#

1
// 字符串创建
2
String str1 = "Hello";
3
String str2 = new String("World");
4
String str3 = String.valueOf(123);
5

6
// 基本操作
7
String str = "Hello World";
8
int length = str.length();           // 获取长度
9
char ch = str.charAt(0);            // 获取字符
10
String sub = str.substring(0, 5);   // 截取子串
11
String upper = str.toUpperCase();    // 转大写
12
String lower = str.toLowerCase();    // 转小写
13

14
// 输出结果
15
System.out.println("str1: " + str1);           // 输出: str1: Hello
16
System.out.println("str2: " + str2);           // 输出: str2: World
17
System.out.println("str3: " + str3);           // 输出: str3: 123
18
System.out.println("length: " + length);       // 输出: length: 11
19
System.out.println("ch: " + ch);               // 输出: ch: H
20
System.out.println("sub: " + sub);             // 输出: sub: Hello
21
System.out.println("upper: " + upper);         // 输出: upper: HELLO WORLD
22
System.out.println("lower: " + lower);         // 输出: lower: hello world

1
String str = "Hello World";
2
boolean contains = str.contains("World");    // 是否包含
3
int index = str.indexOf("o");               // 查找字符位置
4
int lastIndex = str.lastIndexOf("o");       // 从后查找
5
String replaced = str.replace("World", "Java"); // 替换
6
String[] parts = str.split(" ");            // 分割
7

8
// 输出结果
9
System.out.println("contains: " + contains);     // 输出: contains: true
10
System.out.println("index: " + index);           // 输出: index: 4
11
System.out.println("lastIndex: " + lastIndex);   // 输出: lastIndex: 7
12
System.out.println("replaced: " + replaced);     // 输出: replaced: Hello Java
13
System.out.println("parts[0]: " + parts[0]);     // 输出: parts[0]: Hello
14
System.out.println("parts[1]: " + parts[1]);     // 输出: parts[1]: World

1
String s1 = "Hello";
2
String s2 = "hello";
3
boolean equals = s1.equals(s2);             // 内容比较
4
boolean ignoreCase = s1.equalsIgnoreCase(s2); // 忽略大小写比较
5
int compare = s1.compareTo(s2);             // 字典序比较
6

7
// 输出结果
8
System.out.println("equals: " + equals);           // 输出: equals: false
9
System.out.println("ignoreCase: " + ignoreCase);   // 输出: ignoreCase: true
10
System.out.println("compare: " + compare);         // 输出: compare: -32 (H的ASCII码比h小32)

1
StringBuilder sb = new StringBuilder();
2
sb.append("Hello");
3
sb.append(" ");
4
sb.append("World");
5
String result = sb.toString();
6

7
// 链式调用
8
StringBuilder sb2 = new StringBuilder()
9
    .append("Hello")
10
    .append(" ")
11
    .append("World");
12

13
// 输出结果
14
System.out.println("result: " + result);           // 输出: result: Hello World
15
System.out.println("sb2: " + sb2.toString());      // 输出: sb2: Hello World

1
StringBuffer buffer = new StringBuffer();
2
buffer.append("Hello");
3
buffer.append(" ");
4
buffer.append("World");
5
String result = buffer.toString();
6

7
// 输出结果
8
System.out.println("result: " + result);           // 输出: result: Hello World

1
StringBuilder sb = new StringBuilder("Hello");
2
sb.insert(5, " World");     // 插入
3
System.out.println("insert: " + sb);               // 输出: insert: Hello World
4

5
sb.delete(5, 11);           // 删除
6
System.out.println("delete: " + sb);               // 输出: delete: Hello
7

8
sb.reverse();               // 反转
9
System.out.println("reverse: " + sb);              // 输出: reverse: olleH
10

11
sb.setCharAt(0, 'h');      // 设置字符
12
System.out.println("setCharAt: " + sb);            // 输出: setCharAt: hlleH

1
StringJoiner joiner = new StringJoiner(", ", "[", "]");
2
joiner.add("Apple");
3
joiner.add("Banana");
4
joiner.add("Orange");
5
String result = joiner.toString();
6

7
// 输出结果
8
System.out.println("result: " + result);           // 输出: result: [Apple, Banana, Orange]

1
String[] names = {"Alice", "Bob", "Charlie"};
2
String result = String.join(", ", names);
3

4
// 输出结果
5
System.out.println("result: " + result);           // 输出: result: Alice, Bob, Charlie

1
List<String> list = new ArrayList<>();
2
list.add("Apple");
3
list.add("Banana");
4
list.add("Orange");
5

6
// 遍历方式
7
System.out.println("=== 遍历方式 ===");
8
for (String item : list) {
9
    System.out.println(item);
10
}
11
// 输出:
12
// Apple
13
// Banana
14
// Orange
15

16
list.forEach(System.out::println);
17
// 输出:
18
// Apple
19
// Banana
20
// Orange
21

22
// 常用操作
23
String first = list.get(0);                    // 获取元素
24
list.set(0, "Grape");                         // 设置元素
25
boolean contains = list.contains("Apple");     // 是否包含
26
int size = list.size();                       // 大小
27

28
// 输出结果
29
System.out.println("first: " + first);         // 输出: first: Apple
30
System.out.println("contains Apple: " + contains); // 输出: contains Apple: false
31
System.out.println("size: " + size);           // 输出: size: 3
32
System.out.println("list after set: " + list); // 输出: list after set: [Grape, Banana, Orange]

1
LinkedList<String> linkedList = new LinkedList<>();
2
linkedList.addFirst("First");   // 头部添加
3
linkedList.addLast("Last");     // 尾部添加
4
linkedList.add("Middle");       // 中间添加
5

6
// 输出结果
7
System.out.println("linkedList: " + linkedList); // 输出: linkedList: [First, Middle, Last]
8

9
String first = linkedList.removeFirst();       // 头部删除
10
String last = linkedList.removeLast();        // 尾部删除
11
String peek = linkedList.peek();              // 查看头部元素
12

13
// 输出结果
14
System.out.println("removed first: " + first); // 输出: removed first: First
15
System.out.println("removed last: " + last);   // 输出: removed last: Last
16
System.out.println("peek: " + peek);           // 输出: peek: Middle
17
System.out.println("final list: " + linkedList); // 输出: final list: [Middle]

1
Set<String> set = new HashSet<>();
2
set.add("Apple");
3
set.add("Banana");
4
set.add("Apple"); // 重复元素不会添加
5

6
// 遍历
7
System.out.println("=== HashSet遍历 ===");
8
set.forEach(System.out::println);
9
// 输出:
10
// Apple
11
// Banana
12

13
// 常用操作
14
boolean contains = set.contains("Apple");          // 是否包含
15
boolean removed = set.remove("Apple");            // 删除
16
int size = set.size();                            // 大小
17

18
// 输出结果
19
System.out.println("contains Apple: " + contains); // 输出: contains Apple: true
20
System.out.println("removed Apple: " + removed);   // 输出: removed Apple: true
21
System.out.println("size: " + size);               // 输出: size: 1
22
System.out.println("final set: " + set);           // 输出: final set: [Banana]

1
TreeSet<String> treeSet = new TreeSet<>();
2
treeSet.add("Zebra");
3
treeSet.add("Apple");
4
treeSet.add("Banana");
5
// 自动排序：Apple, Banana, Zebra
6

7
// 输出结果
8
System.out.println("treeSet: " + treeSet); // 输出: treeSet: [Apple, Banana, Zebra]
9

10
// 获取第一个和最后一个
11
String first = treeSet.first();
12
String last = treeSet.last();
13

14
// 输出结果
15
System.out.println("first: " + first); // 输出: first: Apple
16
System.out.println("last: " + last);   // 输出: last: Zebra

1
Map<String, Integer> map = new HashMap<>();
2
map.put("Apple", 1);
3
map.put("Banana", 2);
4
map.put("Orange", 3);
5

6
// 遍历方式
7
System.out.println("=== HashMap遍历 ===");
8
map.forEach((key, value) ->
9
    System.out.println(key + ": " + value));
10
// 输出:
11
// Apple: 1
12
// Banana: 2
13
// Orange: 3
14

15
for (Map.Entry<String, Integer> entry : map.entrySet()) {
16
    System.out.println(entry.getKey() + " -> " + entry.getValue());
17
}
18
// 输出:
19
// Apple -> 1
20
// Banana -> 2
21
// Orange -> 3
22

23
// 常用操作
24
Integer appleValue = map.get("Apple");              // 获取值
25
boolean containsKey = map.containsKey("Apple");     // 是否包含键
26
boolean containsValue = map.containsValue(1);       // 是否包含值
27
Integer removed = map.remove("Apple");              // 删除
28

29
// 输出结果
30
System.out.println("appleValue: " + appleValue);           // 输出: appleValue: 1
31
System.out.println("containsKey Apple: " + containsKey);   // 输出: containsKey Apple: true
32
System.out.println("containsValue 1: " + containsValue);   // 输出: containsValue 1: true
33
System.out.println("removed: " + removed);                 // 输出: removed: 1
34
System.out.println("final map: " + map);                   // 输出: final map: {Banana=2, Orange=3}

1
TreeMap<String, Integer> treeMap = new TreeMap<>();
2
treeMap.put("Zebra", 3);
3
treeMap.put("Apple", 1);
4
treeMap.put("Banana", 2);
5
// 按键自动排序
6

7
// 输出结果
8
System.out.println("treeMap: " + treeMap); // 输出: treeMap: {Apple=1, Banana=2, Zebra=3}
9

10
// 获取第一个和最后一个
11
Map.Entry<String, Integer> first = treeMap.firstEntry();
12
Map.Entry<String, Integer> last = treeMap.lastEntry();
13

14
// 输出结果
15
System.out.println("first: " + first.getKey() + "=" + first.getValue()); // 输出: first: Apple=1
16
System.out.println("last: " + last.getKey() + "=" + last.getValue());   // 输出: last: Zebra=3

1
try (FileInputStream fis = new FileInputStream("input.txt")) {
2
    byte[] buffer = new byte[1024];
3
    int bytesRead;
4
    while ((bytesRead = fis.read(buffer)) != -1) {
5
        // 处理读取的数据
6
        System.out.write(buffer, 0, bytesRead);
7
    }
8
} catch (IOException e) {
9
    e.printStackTrace();
10
}

1
try (FileOutputStream fos = new FileOutputStream("output.txt")) {
2
    String data = "Hello World";
3
    fos.write(data.getBytes());
4
} catch (IOException e) {
5
    e.printStackTrace();
6
}

1
try (FileReader reader = new FileReader("input.txt")) {
2
    char[] buffer = new char[1024];
3
    int charsRead;
4
    while ((charsRead = reader.read(buffer)) != -1) {
5
        System.out.print(new String(buffer, 0, charsRead));
6
    }
7
} catch (IOException e) {
8
    e.printStackTrace();
9
}

1
try (FileWriter writer = new FileWriter("output.txt")) {
2
    writer.write("Hello World");
3
} catch (IOException e) {
4
    e.printStackTrace();
5
}

1
try (BufferedReader reader = new BufferedReader(
2
        new FileReader("input.txt"))) {
3
    String line;
4
    while ((line = reader.readLine()) != null) {
5
        System.out.println(line);
6
    }
7
} catch (IOException e) {
8
    e.printStackTrace();
9
}

1
try (BufferedWriter writer = new BufferedWriter(
2
        new FileWriter("output.txt"))) {
3
    writer.write("Line 1");
4
    writer.newLine();
5
    writer.write("Line 2");
6
} catch (IOException e) {
7
    e.printStackTrace();
8
}

1
class MyThread extends Thread {
2
    @Override
3
    public void run() {
4
        System.out.println("Thread running: " + Thread.currentThread().getName());
5
    }
6
}
7

8
// 使用
9
MyThread thread = new MyThread();
10
thread.start();

1
class MyRunnable implements Runnable {
2
    @Override
3
    public void run() {
4
        System.out.println("Runnable running: " + Thread.currentThread().getName());
5
    }
6
}
7

8
// 使用
9
Thread thread = new Thread(new MyRunnable());
10
thread.start();

1
Thread thread = new Thread(() -> {
2
    System.out.println("Lambda thread running");
3
});
4
thread.start();

1
Thread thread = new Thread(() -> {
2
    for (int i = 0; i < 5; i++) {
3
        System.out.println("Count: " + i);
4
        try {
5
            Thread.sleep(1000); // 休眠1秒
6
        } catch (InterruptedException e) {
7
            e.printStackTrace();
8
        }
9
    }
10
});
11

12
thread.start();
13
thread.join(); // 等待线程结束

1
Thread thread = new Thread(() -> {
2
    // 线程任务
3
});
4

5
System.out.println("State: " + thread.getState()); // NEW
6
thread.start();
7
System.out.println("State: " + thread.getState()); // RUNNABLE

1
class Counter {
2
    private int count = 0;
3

4
    public synchronized void increment() {
5
        count++;
6
    }
7

8
    public synchronized int getCount() {
9
        return count;
10
    }
11
}

1
import java.util.concurrent.locks.ReentrantLock;
2

3
class Counter {
4
    private int count = 0;
5
    private ReentrantLock lock = new ReentrantLock();
6

7
    public void increment() {
8
        lock.lock();
9
        try {
10
            count++;
11
        } finally {
12
            lock.unlock();
13
        }
14
    }
15
}

1
// 方式1：通过类名
2
Class<?> clazz1 = String.class;
3

4
// 方式2：通过对象
5
String str = "Hello";
6
Class<?> clazz2 = str.getClass();
7

8
// 方式3：通过全限定名
9
try {
10
    Class<?> clazz3 = Class.forName("java.lang.String");
11
} catch (ClassNotFoundException e) {
12
    e.printStackTrace();
13
}

1
Class<?> clazz = String.class;
2

3
// 获取所有公共构造方法
4
Constructor<?>[] constructors = clazz.getConstructors();
5

6
// 获取指定构造方法
7
try {
8
    Constructor<?> constructor = clazz.getConstructor(String.class);
9
    String obj = (String) constructor.newInstance("Hello");
10
} catch (Exception e) {
11
    e.printStackTrace();
12
}

1
Class<?> clazz = String.class;
2

3
// 获取所有公共方法
4
Method[] methods = clazz.getMethods();
5

6
// 获取指定方法
7
try {
8
    Method method = clazz.getMethod("length");
9
    String str = "Hello";
10
    int length = (int) method.invoke(str);
11
    System.out.println("Length: " + length);
12
} catch (Exception e) {
13
    e.printStackTrace();
14
}

1
class Person {
2
    private String name;
3
    public int age;
4
}
5

6
Class<?> clazz = Person.class;
7

8
// 获取所有公共字段
9
Field[] fields = clazz.getFields();
10

11
// 获取所有字段（包括私有）
12
Field[] allFields = clazz.getDeclaredFields();
13

14
// 访问私有字段
15
try {
16
    Field nameField = clazz.getDeclaredField("name");
17
    nameField.setAccessible(true); // 设置可访问
18
    Person person = new Person();
19
    nameField.set(person, "Alice");
20
    String name = (String) nameField.get(person);
21
} catch (Exception e) {
22
    e.printStackTrace();
23
}

1
import java.lang.annotation.*;
2

3
@Target(ElementType.METHOD)
4
@Retention(RetentionPolicy.RUNTIME)
5
@Documented
6
public @interface MyAnnotation {
7
    String value() default "";
8
    int count() default 1;
9
}

1
class TestClass {
2
    @MyAnnotation(value = "test", count = 3)
3
    public void testMethod() {
4
        System.out.println("Test method");
5
    }
6
}

1
Class<?> clazz = TestClass.class;
2
Method[] methods = clazz.getMethods();
3

4
for (Method method : methods) {
5
    if (method.isAnnotationPresent(MyAnnotation.class)) {
6
        MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
7
        System.out.println("Value: " + annotation.value());
8
        System.out.println("Count: " + annotation.count());
9
    }
10
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3

4
LocalDate today = LocalDate.now();
5
LocalDate specificDate = LocalDate.of(2025, 5, 15);
6

7
// 日期操作
8
LocalDate tomorrow = today.plusDays(1);
9
LocalDate yesterday = today.minusDays(1);
10
LocalDate nextMonth = today.plusMonths(1);
11

12
// 格式化
13
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
14
String formatted = today.format(formatter);
15
LocalDate parsed = LocalDate.parse("2025-05-15", formatter);

1
import java.time.LocalTime;
2

3
LocalTime now = LocalTime.now();
4
LocalTime specificTime = LocalTime.of(14, 30, 45);
5

6
// 时间操作
7
LocalTime plusHours = now.plusHours(2);
8
LocalTime minusMinutes = now.minusMinutes(30);
9

10
// 格式化
11
DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");
12
String formatted = now.format(timeFormatter);

1
import java.time.LocalDateTime;
2

3
LocalDateTime now = LocalDateTime.now();
4
LocalDateTime specific = LocalDateTime.of(2025, 5, 15, 14, 30, 45);
5

6
// 日期时间操作
7
LocalDateTime plusDays = now.plusDays(1);
8
LocalDateTime minusHours = now.minusHours(2);
9

10
// 格式化
11
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
12
String formatted = now.format(formatter);

1
import java.util.Date;
2
import java.text.SimpleDateFormat;
3

4
Date now = new Date();
5
Date specific = new Date(2025 - 1900, 4, 15); // 月份从0开始
6

7
// 格式化
8
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
9
String formatted = sdf.format(now);
10

11
// 解析
12
try {
13
    Date parsed = sdf.parse("2025-05-15 14:30:45");
14
} catch (ParseException e) {
15
    e.printStackTrace();
16
}

1
import java.util.Calendar;
2

3
Calendar cal = Calendar.getInstance();
4
cal.set(2025, Calendar.MAY, 15); // 月份从0开始
5

6
// 获取字段
7
int year = cal.get(Calendar.YEAR);
8
int month = cal.get(Calendar.MONTH);
9
int day = cal.get(Calendar.DAY_OF_MONTH);
10

11
// 操作
12
cal.add(Calendar.DAY_OF_MONTH, 1); // 加一天
13
cal.add(Calendar.MONTH, 1);        // 加一月

1
import java.util.Arrays;
2

3
int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
4

5
// 排序
6
Arrays.sort(arr);
7
System.out.println("sorted: " + Arrays.toString(arr)); // 输出: sorted: [1, 1, 2, 3, 4, 5, 6, 9]
8

9
// 二分查找（需要先排序）
10
int index = Arrays.binarySearch(arr, 5);
11
System.out.println("index of 5: " + index); // 输出: index of 5: 5
12

13
// 填充
14
Arrays.fill(arr, 0);
15
System.out.println("filled: " + Arrays.toString(arr)); // 输出: filled: [0, 0, 0, 0, 0, 0, 0, 0]
16

17
// 复制
18
int[] original = {1, 2, 3, 4, 5};
19
int[] copy = Arrays.copyOf(original, original.length);
20
System.out.println("copy: " + Arrays.toString(copy)); // 输出: copy: [1, 2, 3, 4, 5]
21

22
// 比较
23
boolean equals = Arrays.equals(original, copy);
24
System.out.println("equals: " + equals); // 输出: equals: true
25

26
// 转换为字符串
27
String str = Arrays.toString(original);
28
System.out.println("string: " + str); // 输出: string: [1, 2, 3, 4, 5]

1
import java.util.*;
2

3
List<String> list = Arrays.asList("Apple", "Banana", "Orange");
4

5
// 排序
6
Collections.sort(list);
7
System.out.println("sorted: " + list); // 输出: sorted: [Apple, Banana, Orange]
8

9
// 反转
10
Collections.reverse(list);
11
System.out.println("reversed: " + list); // 输出: reversed: [Orange, Banana, Apple]
12

13
// 随机打乱
14
Collections.shuffle(list);
15
System.out.println("shuffled: " + list); // 输出: shuffled: [Banana, Apple, Orange] (顺序随机)
16

17
// 查找最大最小值
18
String max = Collections.max(list);
19
String min = Collections.min(list);
20
System.out.println("max: " + max); // 输出: max: Orange
21
System.out.println("min: " + min); // 输出: min: Apple
22

23
// 替换
24
Collections.replaceAll(list, "Apple", "Grape");
25
System.out.println("replaced: " + list); // 输出: replaced: [Banana, Grape, Orange]
26

27
// 频率统计
28
int frequency = Collections.frequency(list, "Banana");
29
System.out.println("frequency of Banana: " + frequency); // 输出: frequency of Banana: 1

1
import java.util.Objects;
2

3
String str = null;
4

5
// 空值检查
6
boolean isNull = Objects.isNull(str);
7
boolean nonNull = Objects.nonNull(str);
8
System.out.println("isNull: " + isNull);     // 输出: isNull: true
9
System.out.println("nonNull: " + nonNull);   // 输出: nonNull: false
10

11
// 相等性比较
12
boolean equals = Objects.equals("Hello", "Hello");
13
boolean equalsNull = Objects.equals(null, null);
14
System.out.println("equals: " + equals);         // 输出: equals: true
15
System.out.println("equalsNull: " + equalsNull); // 输出: equalsNull: true
16

17
// 哈希码
18
int hashCode = Objects.hash("Hello", "World");
19
System.out.println("hashCode: " + hashCode); // 输出: hashCode: 123456789 (具体值可能不同)
20

21
// 要求非空
22
try {
23
    String result = Objects.requireNonNull(str, "String cannot be null");
24
} catch (NullPointerException e) {
25
    System.out.println("Exception: " + e.getMessage()); // 输出: Exception: String cannot be null
26
}

1
import java.util.Optional;
2

3
String str = "Hello";
4
Optional<String> optional = Optional.of(str);
5

6
// 安全获取值
7
String value = optional.orElse("Default");
8
System.out.println("value: " + value); // 输出: value: Hello
9

10
// 条件处理
11
optional.ifPresent(System.out::println); // 输出: Hello
12

13
// 链式操作
14
Optional<String> result = optional
15
    .map(s -> s.toUpperCase())
16
    .filter(s -> s.length() > 3);
17
System.out.println("result: " + result.get()); // 输出: result: HELLO
18

19
// 创建Optional
20
Optional<String> empty = Optional.empty();
21
Optional<String> ofNullable = Optional.ofNullable(str);
22

23
// 处理空Optional
24
String emptyValue = empty.orElse("Empty");
25
System.out.println("emptyValue: " + emptyValue); // 输出: emptyValue: Empty

1
import java.lang.Math;
2

3
// 基本数学运算
4
double abs = Math.abs(-5.5);        // 绝对值
5
double ceil = Math.ceil(5.3);       // 向上取整
6
double floor = Math.floor(5.7);     // 向下取整
7
double round = Math.round(5.5);     // 四舍五入
8
double max = Math.max(10, 20);      // 最大值
9
double min = Math.min(10, 20);      // 最小值
10

11
// 输出结果
12
System.out.println("abs(-5.5): " + abs);     // 输出: abs(-5.5): 5.5
13
System.out.println("ceil(5.3): " + ceil);    // 输出: ceil(5.3): 6.0
14
System.out.println("floor(5.7): " + floor);  // 输出: floor(5.7): 5.0
15
System.out.println("round(5.5): " + round);  // 输出: round(5.5): 6.0
16
System.out.println("max(10,20): " + max);    // 输出: max(10,20): 20.0
17
System.out.println("min(10,20): " + min);    // 输出: min(10,20): 10.0
18

19
// 幂运算
20
double pow = Math.pow(2, 3);        // 2的3次方
21
double sqrt = Math.sqrt(16);        // 平方根
22
double cbrt = Math.cbrt(27);        // 立方根
23

24
// 输出结果
25
System.out.println("pow(2,3): " + pow);   // 输出: pow(2,3): 8.0
26
System.out.println("sqrt(16): " + sqrt);  // 输出: sqrt(16): 4.0
27
System.out.println("cbrt(27): " + cbrt);  // 输出: cbrt(27): 3.0
28

29
// 三角函数（参数为弧度）
30
double sin = Math.sin(Math.PI / 2); // 正弦
31
double cos = Math.cos(0);           // 余弦
32
double tan = Math.tan(Math.PI / 4); // 正切
33

34
// 输出结果
35
System.out.println("sin(π/2): " + sin);   // 输出: sin(π/2): 1.0
36
System.out.println("cos(0): " + cos);     // 输出: cos(0): 1.0
37
System.out.println("tan(π/4): " + tan);   // 输出: tan(π/4): 1.0
38

39
// 反三角函数
40
double asin = Math.asin(1.0);       // 反正弦
41
double acos = Math.acos(1.0);       // 反余弦
42
double atan = Math.atan(1.0);       // 反正切
43

44
// 角度与弧度转换
45
double toRadians = Math.toRadians(180); // 角度转弧度
46
double toDegrees = Math.toDegrees(Math.PI); // 弧度转角度
47

48
// 对数函数
49
double log = Math.log(Math.E);      // 自然对数
50
double log10 = Math.log10(100);     // 常用对数
51

52
// 随机数
53
double random = Math.random();       // 0.0到1.0之间的随机数
54
int randomInt = (int)(Math.random() * 100); // 0到99的随机整数
55

56
// 输出结果
57
System.out.println("random: " + random);     // 输出: random: 0.123456789 (具体值随机)
58
System.out.println("randomInt: " + randomInt); // 输出: randomInt: 45 (具体值随机)
59

60
// 常量
61
double pi = Math.PI;                // 圆周率
62
double e = Math.E;                  // 自然对数的底
63

64
// 输出结果
65
System.out.println("π: " + pi);     // 输出: π: 3.141592653589793
66
System.out.println("e: " + e);      // 输出: e: 2.718281828459045

1
// 生成指定范围的随机数
2
public static int randomRange(int min, int max) {
3
    return (int)(Math.random() * (max - min + 1)) + min;
4
}
5

6
// 计算两点间距离
7
public static double distance(double x1, double y1, double x2, double y2) {
8
    return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
9
}
10

11
// 判断是否为素数
12
public static boolean isPrime(int n) {
13
    if (n <= 1) return false;
14
    if (n <= 3) return true;
15
    if (n % 2 == 0 || n % 3 == 0) return false;
16

17
    int sqrt = (int)Math.sqrt(n);
18
    for (int i = 5; i <= sqrt; i += 6) {
19
        if (n % i == 0 || n % (i + 2) == 0) return false;
20
    }
21
    return true;
22
}
23

24
// 计算圆的面积
25
public static double circleArea(double radius) {
26
    return Math.PI * Math.pow(radius, 2);
27
}
28

29
// 计算球的体积
30
public static double sphereVolume(double radius) {
31
    return (4.0 / 3.0) * Math.PI * Math.pow(radius, 3);
32
}

1
import java.lang.System;
2

3
// 获取当前时间戳
4
long currentTime = System.currentTimeMillis();  // 毫秒时间戳
5
long nanoTime = System.nanoTime();              // 纳秒时间戳
6

7
// 输出结果
8
System.out.println("currentTime: " + currentTime); // 输出: currentTime: 1640995200000 (具体值不同)
9
System.out.println("nanoTime: " + nanoTime);       // 输出: nanoTime: 1234567890123456789 (具体值不同)
10

11
// 系统属性
12
String osName = System.getProperty("os.name");           // 操作系统名称
13
String javaVersion = System.getProperty("java.version"); // Java版本
14
String userHome = System.getProperty("user.home");       // 用户主目录
15

16
// 输出结果
17
System.out.println("osName: " + osName);         // 输出: osName: Windows 10 (或Linux、macOS等)
18
System.out.println("javaVersion: " + javaVersion); // 输出: javaVersion: 17.0.1 (具体版本不同)
19
System.out.println("userHome: " + userHome);     // 输出: userHome: C:\Users\username (具体路径不同)
20

21
// 数组复制
22
int[] source = {1, 2, 3, 4, 5};
23
int[] dest = new int[5];
24
System.arraycopy(source, 0, dest, 0, source.length);
25
System.out.println("dest: " + Arrays.toString(dest)); // 输出: dest: [1, 2, 3, 4, 5]
26

27
// 垃圾回收
28
System.gc();  // 建议进行垃圾回收
29

30
// 程序退出
31
// System.exit(0);  // 正常退出
32
// System.exit(1);  // 异常退出
33

34
// 安全检查
35
SecurityManager sm = System.getSecurityManager();

1
// 标准输出
2
System.out.println("Hello World");                    // 输出: Hello World
3
System.out.print("不换行输出");                        // 输出: 不换行输出
4
System.out.printf("格式化输出: %s, %d", "字符串", 123); // 输出: 格式化输出: 字符串, 123
5

6
// 输出格式控制
7
System.out.printf("整数: %d%n", 100);                 // 输出: 整数: 100
8
System.out.printf("浮点数: %.2f%n", 3.14159);         // 输出: 浮点数: 3.14
9
System.out.printf("字符串: %s%n", "Java");            // 输出: 字符串: Java
10
System.out.printf("字符: %c%n", 'A');                 // 输出: 字符: A
11
System.out.printf("布尔值: %b%n", true);              // 输出: 布尔值: true
12
System.out.printf("十六进制: %x%n", 255);             // 输出: 十六进制: ff
13
System.out.printf("八进制: %o%n", 255);               // 输出: 八进制: 377
14

15
// 重定向输出流
16
PrintStream originalOut = System.out;
17
try {
18
    // 重定向到文件
19
    PrintStream fileOut = new PrintStream("output.txt");
20
    System.setOut(fileOut);
21
    System.out.println("这条消息会写入文件");
22
} finally {
23
    // 恢复原始输出流
24
    System.setOut(originalOut);
25
}

1
// 标准输入
2
Scanner scanner = new Scanner(System.in);
3
System.out.print("请输入姓名: ");  // 输出: 请输入姓名:
4
String name = scanner.nextLine();  // 等待用户输入
5
System.out.print("请输入年龄: ");  // 输出: 请输入年龄:
6
int age = scanner.nextInt();       // 等待用户输入
7

8
// 输出结果
9
System.out.println("姓名: " + name); // 输出: 姓名: 张三 (用户输入的内容)
10
System.out.println("年龄: " + age);  // 输出: 年龄: 25 (用户输入的内容)
11

12
// 直接读取字节
13
try {
14
    System.out.print("请输入一个字符: "); // 输出: 请输入一个字符:
15
    int ch = System.in.read();
16
    System.out.println("输入的字符: " + (char)ch); // 输出: 输入的字符: A (用户输入的内容)
17
} catch (IOException e) {
18
    e.printStackTrace();
19
}
20

21
// 重定向输入流
22
try {
23
    // 从文件读取输入
24
    FileInputStream fileIn = new FileInputStream("input.txt");
25
    System.setIn(fileIn);
26
    Scanner fileScanner = new Scanner(System.in);
27
    while (fileScanner.hasNextLine()) {
28
        String line = fileScanner.nextLine();
29
        System.out.println("从文件读取: " + line); // 输出: 从文件读取: 文件内容
30
    }
31
} catch (FileNotFoundException e) {
32
    e.printStackTrace();
33
}

1
// 错误输出
2
System.err.println("这是一个错误消息");                    // 输出: 这是一个错误消息 (红色错误输出)
3
System.err.print("错误信息不换行");                        // 输出: 错误信息不换行 (红色错误输出)
4

5
// 格式化错误输出
6
System.err.printf("错误代码: %d, 错误信息: %s%n", 404, "页面未找到");
7
// 输出: 错误代码: 404, 错误信息: 页面未找到 (红色错误输出)
8

9
// 重定向错误流
10
PrintStream originalErr = System.err;
11
try {
12
    PrintStream errorFile = new PrintStream("error.log");
13
    System.setErr(errorFile);
14
    System.err.println("错误日志会写入文件");
15
} finally {
16
    System.setErr(originalErr);
17
}