Java常用类库详解

# 第一章：String类和StringBuilder类

## 1.1 String类的常见用法

在Java中，String类是一个非常常用的类，用于表示字符串对象。它提供了丰富的方法来操作字符串，包括字符串的拼接、截取、比较等操作。下面是一个简单的示例，展示了String类的常见用法：

public class StringExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "World";
        
        // 字符串拼接
        String result = str1 + " " + str2;
        System.out.println(result); // 输出：Hello World
        
        // 获取字符串长度
        int length = result.length();
        System.out.println("Length: " + length); // 输出：Length: 11
        
        // 字符串比较
        boolean isEqual = str1.equals(str2);
        System.out.println("Is equal: " + isEqual); // 输出：Is equal: false
        
        // 字符串截取
        String subStr = result.substring(6);
        System.out.println(subStr); // 输出：World
    }
}

通过上述代码，我们可以看到String类提供了丰富的方法来操作字符串，包括拼接、获取长度、比较、截取等功能。这些方法在实际开发中非常常用。

## 1.2 StringBuilder类的使用和性能优化

除了String类外，Java还提供了StringBuilder类来处理可变的字符串。相对于String类的不可变特性，StringBuilder类可以有效地进行字符串拼接和修改，同时具有更好的性能。下面是一个使用StringBuilder的示例：

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder();
        
        // 字符串拼接
        builder.append("Hello");
        builder.append(" ");
        builder.append("World");
        String result = builder.toString();
        System.out.println(result); // 输出：Hello World
        
        // 字符串插入
        builder.insert(5, "Beautiful ");
        System.out.println(builder.toString()); // 输出：Hello Beautiful World
        
        // 字符串反转
        System.out.println(builder.reverse().toString()); // 输出：dlroW lufituaeB olleH
    }
}

通过上述示例，我们可以看到StringBuilder类可以灵活地进行字符串拼接、插入和反转操作，并且具有良好的性能表现。在需要频繁进行字符串操作时，建议使用StringBuilder来提升性能。

### 第二章：集合类

集合类是Java编程中非常常用的一部分，它包括了ArrayList、LinkedList、HashMap和HashSet等常见的数据结构，下面将详细介绍它们的原理和使用。

#### 2.1 ArrayList和LinkedList的比较及应用场景

在Java中，ArrayList和LinkedList是两种常用的集合类，它们分别基于数组和链表实现。ArrayList提供了动态数组的功能，它可以根据需要动态增加或减少大小。而LinkedList则是基于双向链表实现的，因此在插入和删除操作时具有更好的性能。

应用场景的选择取决于不同的需求。如果需要大量的随机访问元素，那么ArrayList会更加高效；而如果需要频繁地执行插入和删除操作，LinkedList会更加合适。

下面是使用ArrayList和LinkedList的示例代码：

import java.util.ArrayList;
import java.util.LinkedList;

public class ListExample {
    public static void main(String[] args) {
        // 使用ArrayList
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("A");
        arrayList.add("B");
        arrayList.add("C");
        
        // 使用LinkedList
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("X");
        linkedList.add("Y");
        linkedList.add("Z");
    }
}

从上面的示例可以看出，ArrayList和LinkedList的使用方式基本相同，只是在内部实现上有所不同。在具体选择时，需要根据实际需求进行权衡利弊。

#### 2.2 HashMap和HashSet的原理和使用

HashMap和HashSet是Java中用于存储键值对和唯一元素的集合类。HashMap基于哈希表实现，它通过计算键的哈希码来快速定位值；而HashSet则是基于HashMap实现的，它通过HashMap的键来存储唯一的元素。

下面是使用HashMap和HashSet的示例代码：

import java.util.HashMap;
import java.util.HashSet;

public class MapSetExample {
    public static void main(String[] args) {
        // 使用HashMap
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("A", 1);
        hashMap.put("B", 2);
        hashMap.put("C", 3);
        
        // 使用HashSet
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("X");
        hashSet.add("Y");
        hashSet.add("Z");
    }
}

在实际使用中，HashMap和HashSet可以高效地进行元素的查找、插入和删除操作，因此在处理大量数据时非常有用。

### 第三章：日期时间类

#### 3.1 Date类和Calendar类的基本用法

在Java中，日期时间的处理通常会涉及到Date类和Calendar类。Date类代表特定的时间点，而Calendar类则提供了对日期时间进行操作的功能。下面我们将介绍它们的基本用法。

// 使用Date类获取当前时间
Date currentDate = new Date();
System.out.println("当前时间：" + currentDate);

// 使用Calendar类获取当前时间
Calendar calendar = Calendar.getInstance();
System.out.println("当前时间：" + calendar.getTime());

上面的代码中，我们首先使用Date类和Calendar类分别获取了当前时间，并输出到控制台上。

#### 3.2 SimpleDateFormat类的格式化和解析

SimpleDateFormat类可以用来将Date对象进行格式化为指定格式的字符串，也可以将字符串解析为Date对象。下面是一个简单的示例：

// 格式化日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String formattedDate = sdf.format(currentDate);
System.out.println("格式化后的日期：" + formattedDate);

// 解析日期字符串
String dateString = "2022-05-15 14:30:00";
Date parsedDate = sdf.parse(dateString);
System.out.println("解析后的日期：" + parsedDate);

通过SimpleDateFormat类，我们可以方便地实现日期时间的格式化和解析操作。

## 第四章：输入输出类

### 4.1 File类的文件操作

File类是Java中用于表示文件或目录的类，可以进行文件的创建、删除、重命名、查看属性等操作。下面是一个File类的基本应用示例：

import java.io.File;

public class FileExample {
    public static void main(String[] args) {
        // 创建File对象
        File file = new File("test.txt");

        // 判断文件是否存在
        if (file.exists()) {
            System.out.println("文件已存在");
        } else {
            System.out.println("文件不存在");
        }

        // 创建新文件
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (Exception e) {
            System.out.println("文件创建失败：" + e.getMessage());
        }

        // 删除文件
        if (file.delete()) {
            System.out.println("文件删除成功");
        } else {
            System.out.println("文件删除失败");
        }
    }
}

代码执行结果：

文件不存在
文件创建成功
文件删除成功

在这个示例中，我们使用File类进行了文件的创建和删除操作，展示了File类的基本用法。

### 4.2 InputStream和OutputStream的使用

在Java中，InputStream和OutputStream是用于字节流操作的类，可以进行文件的读取和写入操作。下面是一个简单的示例：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileIOExample {
    public static void main(String[] args) {
        try {
            // 使用FileInputStream读取文件
            FileInputStream in = new FileInputStream("input.txt");
            int data;
            while ((data = in.read()) != -1) {
                System.out.print((char) data);
            }
            in.close();

            // 使用FileOutputStream写入文件
            FileOutputStream out = new FileOutputStream("output.txt");
            out.write("Hello, World!".getBytes());
            out.close();
        } catch (IOException e) {
            System.out.println("文件操作异常：" + e.getMessage());
        }
    }
}

代码执行结果：

This is the content of input.txt

在这个示例中，我们使用了FileInputStream读取文件内容，并使用FileOutputStream写入文件内容，展示了InputStream和OutputStream的基本用法。
### 第五章：异常处理类

异常处理是Java程序中非常重要的一部分，能够帮助我们更好地处理可能出现的错误情况，提高程序的稳定性和可靠性。在本章节中，我们将介绍异常处理的基础知识和如何自定义异常类的编写和使用。

#### 5.1 异常处理基础

在Java中，异常是指在程序执行过程中发生的意外情况，如空指针引用、除以零等。异常处理的基础是使用try...catch语句块捕获和处理异常。以下是一个简单的异常处理示例：

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;  // 除以零，会抛出ArithmeticException异常
        } catch (ArithmeticException e) {
            System.out.println("除数不能为零");
        }
    }
}

在上面的示例中，我们使用try块来包裹可能抛出异常的代码，在catch块中捕获并处理ArithmeticException异常。

#### 5.2 自定义异常类的编写和使用

除了Java提供的异常类外，我们还可以通过继承Exception类或其子类来创建自定义异常。下面是一个自定义异常类的示例：

public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

public class CustomExceptionDemo {
    public static void main(String[] args) {
        try {
            throw new CustomException("自定义异常信息");
        } catch (CustomException e) {
            System.out.println(e.getMessage());
        }
    }
}

在上面的示例中，我们创建了一个CustomException类，继承自Exception类，并在main方法中抛出并捕获了自定义异常。这样我们可以根据实际情况定义自己的异常类，用于特定的错误情形。

### 第六章：多线程类

#### 6.1 线程的基本概念
在Java中，线程是一种轻量级的子进程，是程序执行流的最小单元。多线程允许同时执行多个任务，提高了程序的性能和响应速度。

##### 场景：
假设我们需要同时下载多个文件，使用多线程可以让每个文件分配一个线程进行下载，从而提高下载效率。

##### 代码示例：

public class BasicThreadConcept {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new DownloadTask("File1"));
        Thread thread2 = new Thread(new DownloadTask("File2"));
        
        thread1.start();
        thread2.start();
    }
}

class DownloadTask implements Runnable {
    private String fileName;
    
    public DownloadTask(String fileName) {
        this.fileName = fileName;
    }
    
    @Override
    public void run() {
        System.out.println("Downloading " + fileName + "...");
        // 实现文件下载的逻辑
        System.out.println(fileName + " downloaded successfully.");
    }
}

##### 代码总结：
- 使用Thread类和Runnable接口创建了两个线程
- 每个线程执行了一个文件下载任务
- 通过多线程实现了并行下载，提高了下载效率

##### 结果说明：
通过运行上述代码，可以看到两个文件会同时开始下载，并且下载完成的顺序不确定，演示了多线程并行执行任务的效果。

#### 6.2 使用Thread类和Runnable接口创建线程
在Java中，创建线程主要有两种方式：继承Thread类和实现Runnable接口。继承Thread类适合在较为简单的场景下使用，而实现Runnable接口更灵活，适合多线程共享资源的情况。

##### 场景：
假设我们需要实现一个简单的计数器，可以使用Thread类或Runnable接口创建多个线程并发执行计数任务。

##### 代码示例：

public class CreateThreadExample {
    public static void main(String[] args) {
        Thread thread1 = new MyThread("Thread 1");
        Thread thread2 = new Thread(new MyRunnable(), "Thread 2");
        
        thread1.start();
        thread2.start();
    }
}

class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

##### 代码总结：
- 分别使用Thread类和Runnable接口创建了两个线程
- 线程执行了简单的计数任务
- 展示了使用不同方式创建线程的方法

##### 结果说明：
运行上述代码，可以看到两个线程会同时执行计数任务，展示了使用Thread类和Runnable接口创建线程的效果。