Java高级内容
Java数据结构
Java数据结构是存储和管理数据的方式，能够有效地组织数据以实现高效的访问和修改。Java 提供了内置的基础数据结构，以及通过集合框架提供的更复杂的数据结构，如列表、集合、队列、映射等。
基本数据结构
1. 数组（Array）
- 定义：数组是固定大小的连续内存块，用于存储相同类型的元素。它们提供了快速的随机访问，但插入和删除操作较慢，尤其是在中间位置进行操作时。
- 特点：
- 索引从
0开始。 - 访问时间复杂度为
O(1)，插入和删除平均时间复杂度为O(n)。
- 索引从
int[] numbers = new int[5];
numbers[0] = 10;
int first = numbers[0];2. 链表（Linked List）
- 定义：链表是一种线性数据结构，每个节点包含数据和指向下一个节点的指针。常见的链表类型有单向链表和双向链表。
- 特点：
- 插入和删除操作效率高（
O(1)），但随机访问效率低（O(n)）。 - 不要求连续内存块，适合频繁插入和删除操作。
- 插入和删除操作效率高（
class Node {
int data;
Node next;
Node(int data) {
this.data = data;
}
}
Node head = new Node(1);
head.next = new Node(2);Java集合框架中的数据结构
1. 列表（List）
List 是一种有序的、可以包含重复元素的集合。Java 中常见的 List 实现包括 ArrayList 和 LinkedList。
ArrayList：基于动态数组实现，提供了快速的随机访问，但在中间插入和删除元素时效率较低。LinkedList：基于双向链表实现，插入和删除元素效率高，尤其是在列表中间操作时。
List<String> arrayList = new ArrayList<>();
arrayList.add("A");
arrayList.add("B");
List<String> linkedList = new LinkedList<>();
linkedList.add("X");
linkedList.add("Y");2. 集合（Set）
Set 是一种不允许重复元素的集合，Java中常见的 Set 实现包括 HashSet、LinkedHashSet 和 TreeSet。
HashSet：基于哈希表实现，元素无序，允许一个null元素，插入和查找操作速度快。LinkedHashSet：HashSet的子类，保留插入顺序。TreeSet：基于红黑树实现，元素按自然顺序或指定的比较器排序。
Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
Set<String> treeSet = new TreeSet<>();
treeSet.add("Cherry");
treeSet.add("Date");3. 队列（Queue）
Queue 是一种先进先出（FIFO）的数据结构，常用于任务调度、缓冲区等场景。常见的 Queue 实现包括 LinkedList 和 PriorityQueue。
LinkedList：实现了Queue接口，适合作为普通队列和双端队列（Deque）。PriorityQueue：基于堆实现，元素按优先级顺序出队。
Queue<String> queue = new LinkedList<>();
queue.add("Task1");
queue.add("Task2");
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.add(30);
priorityQueue.add(20);4. 映射（Map）
Map 是一种键值对（key-value）数据结构，用于存储和快速查找数据。常见的 Map 实现包括 HashMap、LinkedHashMap 和 TreeMap。
HashMap：基于哈希表实现，键无序，允许一个null键和多个null值。LinkedHashMap：HashMap的子类，保留插入顺序。TreeMap：基于红黑树实现，键按自然顺序或比较器排序。
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("One", 1);
hashMap.put("Two", 2);
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Apple", 3);
treeMap.put("Banana", 4);特殊数据结构
1. 栈（Stack）
栈是后进先出（LIFO）的数据结构，常用于递归算法、表达式求值等场景。Java中可以使用Stack类或Deque接口来实现栈。
Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.push(20);
int top = stack.pop(); // 202. 堆（Heap）
堆是一种特殊的二叉树，用于实现优先队列。Java中通过PriorityQueue类实现堆结构。
PriorityQueue<Integer> heap = new PriorityQueue<>();
heap.add(15);
heap.add(10);
heap.add(20);3. 图（Graph）
图是由节点和边组成的复杂数据结构，广泛应用于网络、路径规划等领域。Java中没有直接的图类，但可以通过Map和List等类来自行实现图结构。
Map<String, List<String>> graph = new HashMap<>();
graph.put("A", Arrays.asList("B", "C"));
graph.put("B", Arrays.asList("A", "D"));自定义数据结构
除了Java提供的内置数据结构，你也可以根据具体需求自定义数据结构。例如，实现一个平衡二叉树、跳表、Trie树等。
Java中的数据结构是编程中非常重要的基础，掌握这些数据结构可以帮助你更高效地解决各种问题，并优化程序的性能。
Java集合类
Java 集合类（Collections）提供了一组处理对象集合的接口和类，用于存储、检索和操作数据。集合类主要位于 java.util 包中，支持的数据结构包括列表、集合、队列、映射等。
集合框架的核心接口
Java 集合框架由几个核心接口组成，每个接口定义了一组通用操作。主要接口包括：
Collection<E>：最基本的集合接口，定义了一组对象的操作。子接口包括List、Set和Queue。List<E>：有序集合，可以包含重复元素。常见实现类有ArrayList、LinkedList、Vector。Set<E>：不允许包含重复元素的集合。常见实现类有HashSet、LinkedHashSet、TreeSet。Queue<E>：用于按特定顺序保存一组待处理元素，通常用于实现队列结构。常见实现类有LinkedList、PriorityQueue。Map<K, V>：键值对的集合，不允许重复的键。常见实现类有HashMap、TreeMap、LinkedHashMap。
常见集合类
1. List<E> 接口及其实现类
ArrayList<E>：基于数组实现的动态列表，支持快速随机访问，适合频繁读取操作。List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("C");LinkedList<E>：基于链表实现，适合频繁插入和删除操作。List<String> linkedList = new LinkedList<>(); linkedList.add("X"); linkedList.add("Y");Vector<E>：类似ArrayList，但线程安全，性能较低。Stack是Vector的子类，表示后进先出（LIFO）堆栈。Vector<String> vector = new Vector<>(); vector.add("1"); vector.add("2");
2. Set<E> 接口及其实现类
HashSet<E>：基于哈希表实现，不保证顺序，允许null元素，插入、删除、查找操作效率高。Set<String> set = new HashSet<>(); set.add("Apple"); set.add("Banana");LinkedHashSet<E>：HashSet的子类，保留元素的插入顺序。Set<String> linkedSet = new LinkedHashSet<>(); linkedSet.add("First"); linkedSet.add("Second");TreeSet<E>：基于TreeMap实现，元素按自然顺序或指定的比较器排序，不允许null元素。Set<String> treeSet = new TreeSet<>(); treeSet.add("Alpha"); treeSet.add("Beta");
3. Queue<E> 接口及其实现类
LinkedList<E>：双向链表实现的队列，既可以作为Queue使用，也可以作为Deque（双端队列）使用。Queue<String> queue = new LinkedList<>(); queue.add("Task1"); queue.add("Task2");PriorityQueue<E>：基于优先级堆的队列，元素按优先级顺序出队。Queue<Integer> priorityQueue = new PriorityQueue<>(); priorityQueue.add(10); priorityQueue.add(20);
4. Map<K, V> 接口及其实现类
HashMap<K, V>：基于哈希表实现的键值对集合，不保证顺序，允许null键和值，适合快速插入和查找。Map<String, Integer> hashMap = new HashMap<>(); hashMap.put("One", 1); hashMap.put("Two", 2);LinkedHashMap<K, V>：HashMap的子类，保留插入顺序或访问顺序。Map<String, Integer> linkedHashMap = new LinkedHashMap<>(); linkedHashMap.put("First", 1); linkedHashMap.put("Second", 2);TreeMap<K, V>：基于红黑树的实现，键按自然顺序或指定的比较器排序，不允许null键。Map<String, Integer> treeMap = new TreeMap<>(); treeMap.put("Key1", 100); treeMap.put("Key2", 200);
集合工具类
Java 提供了 Collections 工具类，提供了许多静态方法来操作集合，如排序、查找、同步化、不可变集合创建等。
- 排序：
Collections.sort(list)，对List进行自然排序。 - 查找：
Collections.binarySearch(list, key)，在排序列表中二分查找元素。 - 同步化：
Collections.synchronizedList(new ArrayList<>())，返回一个同步的集合。
集合与线程安全
- 同步集合：如
Vector、Hashtable等集合类本身是线程安全的。 - 非同步集合：如
ArrayList、HashMap等，通常需要通过Collections.synchronizedList()等方法进行同步包装。 - 并发集合：Java 还提供了
java.util.concurrent包中的并发集合类，如ConcurrentHashMap、CopyOnWriteArrayList，适合高并发环境下使用。
Java 集合框架是 Java 核心库中最常用的部分之一，提供了丰富的数据结构和操作方法，是进行高效数据管理的基础。
List
在 Java 中，List 是一种有序的集合（Collection），它允许存储重复的元素。List 是一个接口，它继承自 Collection 接口，并提供了许多操作列表元素的方法。Java 提供了多个类来实现 List 接口，其中最常用的是 ArrayList 和 LinkedList。
一、List 接口的基本概念
List 是一种数据结构，具有以下特点：
- 有序性：
List中的元素是按插入顺序排序的。 - 允许重复元素：
List可以包含重复的元素。 - 基于索引：
List提供了基于索引（从 0 开始）的操作，可以通过索引来访问、更新或删除元素。
二、List 接口常用方法
List 接口定义了许多常用的方法，包括但不限于以下这些：
add(E e)：在列表的末尾添加指定的元素。add(int index, E element)：在指定的索引位置插入指定的元素。remove(Object o)：移除列表中第一次出现的指定元素。remove(int index)：移除指定索引位置的元素。get(int index)：返回指定索引位置的元素。set(int index, E element)：用指定的元素替换指定索引位置的元素。size()：返回列表中的元素数量。isEmpty()：如果列表不包含元素，则返回true。contains(Object o)：如果列表包含指定的元素，则返回true。indexOf(Object o)：返回列表中第一次出现的指定元素的索引；如果列表不包含该元素，则返回 -1。
三、ArrayList 类
ArrayList 是 List 接口的一个常用实现类，它基于数组实现，适合频繁读取数据的场景。ArrayList 是非同步的（即线程不安全），如果需要在多线程环境中使用 ArrayList，则需要手动同步。
1. ArrayList 的特点
- 动态数组：
ArrayList是一个可动态增长和缩减的数组。它会根据需要自动调整容量。 - 随机访问：由于底层是数组，
ArrayList提供了快速的随机访问（通过索引访问元素）。 - 插入和删除操作效率低：在中间插入或删除元素时，需要移动后续元素，效率较低。
2. 示例：使用 ArrayList
import java.util.ArrayList;
import java.util.List;
public class ArrayListExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
// 添加元素
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 输出列表
System.out.println("List: " + list);
// 插入元素
list.add(1, "Grapes");
System.out.println("After inserting at index 1: " + list);
// 获取元素
String fruit = list.get(2);
System.out.println("Element at index 2: " + fruit);
// 替换元素
list.set(2, "Mango");
System.out.println("After replacing element at index 2: " + list);
// 删除元素
list.remove("Apple");
System.out.println("After removing 'Apple': " + list);
// 判断是否包含元素
boolean containsBanana = list.contains("Banana");
System.out.println("Contains 'Banana': " + containsBanana);
// 列表大小
int size = list.size();
System.out.println("List size: " + size);
}
}四、LinkedList 类
LinkedList 是 List 接口的另一个实现类，它基于双向链表实现，适合频繁插入和删除数据的场景。LinkedList 也是非同步的（线程不安全）。
1. LinkedList 的特点
- 双向链表：
LinkedList底层是一个双向链表结构。 - 插入和删除操作效率高：由于链表结构的特性，在列表的中间位置插入或删除元素时，不需要移动后续元素。
- 随机访问效率低：由于没有索引，必须从头开始遍历链表来查找某个元素，效率较低。
- 可以作为队列和双端队列（Deque）使用：
LinkedList还实现了Deque接口，支持先进先出（FIFO）队列操作和双端队列操作。
2. 示例：使用 LinkedList
import java.util.LinkedList;
import java.util.List;
public class LinkedListExample {
public static void main(String[] args) {
List<String> list = new LinkedList<>();
// 添加元素
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 输出列表
System.out.println("List: " + list);
// 插入元素
list.add(1, "Grapes");
System.out.println("After inserting at index 1: " + list);
// 获取元素
String fruit = list.get(2);
System.out.println("Element at index 2: " + fruit);
// 替换元素
list.set(2, "Mango");
System.out.println("After replacing element at index 2: " + list);
// 删除元素
list.remove("Apple");
System.out.println("After removing 'Apple': " + list);
// 判断是否包含元素
boolean containsBanana = list.contains("Banana");
System.out.println("Contains 'Banana': " + containsBanana);
// 列表大小
int size = list.size();
System.out.println("List size: " + size);
}
}五、ArrayList 与 LinkedList 的对比
| 特性 | ArrayList | LinkedList |
|---|---|---|
| 底层实现 | 动态数组 | 双向链表 |
| 是否允许随机访问 | 是 | 否 |
| 插入/删除效率 | 低（需要移动元素） | 高（只需调整链表指针） |
| 内存消耗 | 相对较低，额外内存仅用于存储元素 | 相对较高，需要存储额外的节点信息（指针） |
| 线程安全性 | 非同步（需手动同步） | 非同步（需手动同步） |
| 适用场景 | 频繁读取操作 | 频繁插入和删除操作 |
六、CopyOnWriteArrayList 类
CopyOnWriteArrayList 是一个线程安全的 List 实现，适用于读操作远多于写操作的场景。它基于写时复制（Copy-on-Write）机制，写操作时会创建一个新的副本来进行修改，修改完成后再将引用指向新副本。
示例：使用 CopyOnWriteArrayList
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class CopyOnWriteArrayListExample {
public static void main(String[] args) {
List<String> list = new CopyOnWriteArrayList<>();
// 添加元素
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 遍历列表
for (String fruit : list) {
System.out.println(fruit);
}
// 在遍历期间修改列表
list.add("Grapes");
System.out.println("After adding 'Grapes': " + list);
}
}七、总结
Java 提供了多种 List 的实现类，以满足不同场景下的需求：
ArrayList：适合频繁读取数据的场景，提供快速的随机访问。LinkedList：适合频繁插入和删除数据的场景，插入和删除效率高。CopyOnWriteArrayList：适合多线程环境下读操作多于写操作的场景，提供线程安全的List实现。
通过选择合适的 List 实现类，可以提高程序的性能和稳定性。在实际应用中，根据需求选择合适的数据结构是编写高效代码的关键。
Queue
在 Java 中，Queue 是一种数据结构，用于存储需要按特定顺序处理的元素。Queue 接口是 Java 集合框架的一部分，位于 java.util 包中。Queue 主要用于按顺序访问元素，通常遵循先进先出（FIFO，First-In-First-Out）原则。
一、Queue 接口的基本概念
Queue 是一种有序的集合，它支持在一端插入元素，在另一端删除元素的操作。它常用于任务调度、消息传递、请求处理等场景。
1. Queue 的特点
- 先进先出（FIFO）：元素按照插入的顺序处理，第一个插入的元素最先被处理。
- 不允许随机访问：只能通过队列的操作来访问队首或队尾的元素。
- 可以为空：
Queue允许为空，调用poll()方法返回null，调用remove()方法则抛出异常。
2. Queue 的常用方法
add(E e)：将指定的元素插入到队列中，如果成功则返回true，如果队列已满，则抛出异常。offer(E e)：将指定的元素插入到队列中，如果成功则返回true，否则返回false。remove()：移除并返回队列的头元素，如果队列为空则抛出异常。poll()：移除并返回队列的头元素，如果队列为空则返回null。element()：返回队列的头元素但不移除它，如果队列为空则抛出异常。peek()：返回队列的头元素但不移除它，如果队列为空则返回null。
二、Queue 的实现类
Java 提供了多种 Queue 的实现类，可以满足不同的需求，包括：
LinkedList：常用的Queue实现类，基于双向链表实现。PriorityQueue：一种基于优先级堆的队列，元素会按照自然顺序或指定的比较器排序。ArrayDeque：基于可变数组实现的双端队列，提供更高效的插入、删除操作。ConcurrentLinkedQueue：线程安全的队列，适用于高并发环境。BlockingQueue：支持阻塞操作的队列接口，适用于多线程环境中的生产者-消费者问题。
三、LinkedList 作为 Queue 的实现
LinkedList 类不仅可以作为 List 使用，还实现了 Queue 接口，因此可以作为队列使用。
示例：使用 LinkedList 实现 Queue
import java.util.LinkedList;
import java.util.Queue;
public class LinkedListQueueExample {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
// 添加元素到队列
queue.offer("Apple");
queue.offer("Banana");
queue.offer("Orange");
// 查看队列头部元素
System.out.println("Head of queue: " + queue.peek());
// 取出并移除队列头部元素
System.out.println("Removed from queue: " + queue.poll());
// 再次查看队列头部元素
System.out.println("Head of queue after removal: " + queue.peek());
// 打印队列中的所有元素
System.out.println("Remaining elements in queue: " + queue);
}
}四、PriorityQueue 类
PriorityQueue 是一个基于优先级堆的队列，元素按照自然顺序或提供的比较器顺序进行排序。默认情况下，它不保证插入顺序，但每次检索或移除操作将返回优先级最高的元素。
示例：使用 PriorityQueue
import java.util.PriorityQueue;
import java.util.Queue;
public class PriorityQueueExample {
public static void main(String[] args) {
Queue<Integer> priorityQueue = new PriorityQueue<>();
// 添加元素
priorityQueue.offer(10);
priorityQueue.offer(5);
priorityQueue.offer(15);
// 打印队列中的元素（按优先级顺序）
System.out.println("PriorityQueue: " + priorityQueue);
// 取出并移除优先级最高的元素
System.out.println("Removed element: " + priorityQueue.poll());
// 打印剩余元素
System.out.println("Remaining elements: " + priorityQueue);
}
}五、ArrayDeque 类
ArrayDeque 是一个基于数组的双端队列（Deque），可以作为栈和队列使用。它没有容量限制，可以根据需要动态扩展。ArrayDeque 提供了比 LinkedList 更高效的插入和删除操作。
示例：使用 ArrayDeque 实现 Queue
import java.util.ArrayDeque;
import java.util.Queue;
public class ArrayDequeExample {
public static void main(String[] args) {
Queue<String> deque = new ArrayDeque<>();
// 添加元素到队列
deque.offer("Apple");
deque.offer("Banana");
deque.offer("Orange");
// 查看队列头部元素
System.out.println("Head of queue: " + deque.peek());
// 取出并移除队列头部元素
System.out.println("Removed from queue: " + deque.poll());
// 打印剩余元素
System.out.println("Remaining elements in queue: " + deque);
}
}六、BlockingQueue 接口
BlockingQueue 是一个支持线程安全操作的队列接口。它提供了阻塞的 put 和 take 操作，适用于多线程环境下的生产者-消费者模式。常见的实现类包括：
ArrayBlockingQueue：一个有界的阻塞队列，基于数组实现。LinkedBlockingQueue：一个可选边界的阻塞队列，基于链表实现。PriorityBlockingQueue：一个基于优先级的阻塞队列。DelayQueue：一个延迟获取元素的阻塞队列，适用于任务调度。
示例：使用 LinkedBlockingQueue
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class BlockingQueueExample {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(3);
// 向队列中添加元素
blockingQueue.put("Apple");
blockingQueue.put("Banana");
blockingQueue.put("Orange");
System.out.println("BlockingQueue after adding elements: " + blockingQueue);
// 取出并移除队列头部元素
System.out.println("Removed element: " + blockingQueue.take());
// 打印剩余元素
System.out.println("Remaining elements in BlockingQueue: " + blockingQueue);
}
}七、总结
Java 提供了丰富的 Queue 实现来满足不同的需求。常见的 Queue 实现类包括：
LinkedList：通用队列实现，适合简单队列操作。PriorityQueue：适合需要优先级排序的场景。ArrayDeque：高效的双端队列实现，适合栈和队列操作。ConcurrentLinkedQueue：线程安全的无界非阻塞队列。BlockingQueue实现类（如ArrayBlockingQueue、LinkedBlockingQueue等）：适合多线程环境下的任务调度和生产者-消费者模式。
通过选择适合的队列实现类，可以根据实际需求实现更高效的应用程序。
Stack
在 Java 中，Stack 是一种用于存储和操作数据的线性数据结构，遵循后进先出（LIFO，Last-In-First-Out）原则。Java 提供了 Stack 类作为栈的实现，它继承自 Vector 类，位于 java.util 包中。
一、Stack 类的基本概念
Stack 是一种数据结构，它的特性是新插入的元素位于栈顶，最先被移除的元素也是栈顶元素。栈通常用于解决递归、回溯、表达式求值等问题。
1. Stack 的特点
- 后进先出（LIFO）：最近添加的元素最先被移除。
- 基于数组的实现：
Stack类继承自Vector，底层使用动态数组来存储元素。 - 线程安全：
Stack类是同步的，因此可以在多线程环境中安全使用。
2. Stack 类的常用方法
push(E item)：将元素推入栈顶。pop()：移除并返回栈顶元素，如果栈为空则抛出EmptyStackException。peek()：返回栈顶元素但不移除它，如果栈为空则抛出EmptyStackException。empty()：如果栈为空则返回true，否则返回false。search(Object o)：返回对象在栈中的位置（从 1 开始计数），如果不在栈中则返回 -1。
二、Stack 类的使用示例
import java.util.Stack;
public class StackExample {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
// 将元素推入栈
stack.push(10);
stack.push(20);
stack.push(30);
System.out.println("Stack after pushes: " + stack);
// 查看栈顶元素
System.out.println("Top element is: " + stack.peek());
// 从栈中移除元素
System.out.println("Popped element: " + stack.pop());
// 查看栈的当前状态
System.out.println("Stack after pop: " + stack);
// 判断栈是否为空
System.out.println("Is stack empty? " + stack.empty());
// 查找元素的位置
int position = stack.search(10);
System.out.println("Position of element '10' in stack: " + position);
}
}三、Stack 的应用场景
- 表达式求值：用于中缀表达式到后缀表达式的转换，以及后缀表达式的求值。
- 括号匹配：用于检查表达式中的括号是否正确匹配。
- 回溯算法：用于实现回溯算法，如深度优先搜索（DFS）。
- 递归消除：用于将递归算法转换为迭代算法。
四、Deque 作为栈的替代
虽然 Stack 类在 Java 中被广泛使用，但由于其继承自 Vector 并且是同步的，它在某些情况下性能可能不够理想。Java 提供了更现代的替代方案，如 Deque 接口及其实现类 ArrayDeque。Deque（双端队列）可以用作栈，因为它支持在两端插入和删除元素。
ArrayDeque 作为栈的实现，具有更好的性能，因为它没有 Stack 类的同步开销。
示例：使用 ArrayDeque 作为栈
import java.util.ArrayDeque;
import java.util.Deque;
public class ArrayDequeAsStackExample {
public static void main(String[] args) {
Deque<Integer> stack = new ArrayDeque<>();
// 将元素推入栈
stack.push(10);
stack.push(20);
stack.push(30);
System.out.println("Stack after pushes: " + stack);
// 查看栈顶元素
System.out.println("Top element is: " + stack.peek());
// 从栈中移除元素
System.out.println("Popped element: " + stack.pop());
// 查看栈的当前状态
System.out.println("Stack after pop: " + stack);
// 判断栈是否为空
System.out.println("Is stack empty? " + stack.isEmpty());
}
}五、Stack 与 ArrayDeque 的对比
| 特性 | Stack | ArrayDeque |
|---|---|---|
| 底层实现 | 基于 Vector（动态数组） | 基于动态数组 |
| 是否同步 | 是（线程安全） | 否（非线程安全） |
| 性能 | 同步开销较大，性能稍差 | 无同步开销，性能更高 |
| 适用场景 | 需要线程安全的场景 | 性能敏感的单线程场景 |
| 常用方法 | push(), pop(), peek() | push(), pop(), peek() |
六、总结
Java 提供了多种实现栈数据结构的方法，最常用的是 Stack 类和 ArrayDeque 类。虽然 Stack 类是经典的栈实现，但由于其同步性开销较大，在单线程环境中，ArrayDeque 通常是更好的选择。通过根据应用场景选择合适的栈实现，可以实现更高效和更简洁的代码。
Set
在 Java 中，Set 是一种不允许存储重复元素的集合接口。Set 接口是 Java 集合框架（Java Collections Framework）的一部分，位于 java.util 包中。Set 不保证元素的顺序，可以根据不同的实现类选择不同的排序策略。
一、Set 接口的基本概念
Set 接口继承自 Collection 接口，表示不包含重复元素的集合。它主要用于快速查找、去重、集合操作（如交集、并集、差集）等场景。
1. Set 的特点
- 不允许重复元素：
Set不允许存储重复的元素。如果尝试添加重复元素，则集合会保持不变。 - 不保证元素顺序：不同的
Set实现类对元素顺序有不同的处理方式，如HashSet不保证顺序，LinkedHashSet按照插入顺序排序，TreeSet按照元素的自然顺序排序。 - 基于哈希表、红黑树或链表的实现：不同的
Set实现类有不同的底层数据结构。
2. Set 接口的常用方法
Set 继承了 Collection 接口中的方法，因此提供了许多常用的集合操作方法，如：
add(E e)：将元素添加到集合中，如果集合中不存在该元素则返回true。remove(Object o)：从集合中移除指定元素，如果存在则返回true。contains(Object o)：判断集合中是否包含指定的元素。size()：返回集合中的元素个数。isEmpty()：判断集合是否为空。clear()：清空集合中的所有元素。iterator()：返回集合的迭代器，用于遍历集合中的元素。
二、Set 的实现类
Java 提供了多个 Set 接口的实现类，每个实现类都有其独特的特性和适用场景：
HashSet：基于哈希表的实现，允许null值，不保证元素的顺序，操作速度最快。LinkedHashSet：继承自HashSet，但使用双向链表维护元素的插入顺序。TreeSet：基于红黑树的实现，元素按自然顺序排序（或根据提供的比较器排序），不允许null值。EnumSet：专门用于枚举类型的集合，所有元素必须是枚举类型。
三、HashSet 类
HashSet 是最常用的 Set 实现类，基于哈希表实现。它不保证元素的顺序，允许存储一个 null 元素。HashSet 的基本操作（如 add、remove、contains）的时间复杂度为 O(1)。
示例：使用 HashSet
import java.util.HashSet;
import java.util.Set;
public class HashSetExample {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
// 添加元素
set.add("Apple");
set.add("Banana");
set.add("Orange");
set.add("Apple"); // 重复元素，不会添加
System.out.println("HashSet: " + set);
// 判断集合中是否包含某个元素
System.out.println("Contains 'Apple': " + set.contains("Apple"));
// 移除元素
set.remove("Banana");
System.out.println("HashSet after removing 'Banana': " + set);
// 遍历集合
for (String item : set) {
System.out.println("Item: " + item);
}
}
}四、LinkedHashSet 类
LinkedHashSet 是 HashSet 的子类，使用双向链表维护元素的插入顺序。它的性能稍慢于 HashSet，但在需要维持插入顺序的场景中非常有用。
示例：使用 LinkedHashSet
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetExample {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
// 添加元素
set.add("Apple");
set.add("Banana");
set.add("Orange");
set.add("Apple"); // 重复元素，不会添加
System.out.println("LinkedHashSet: " + set);
// 遍历集合
for (String item : set) {
System.out.println("Item: " + item);
}
}
}五、TreeSet 类
TreeSet 是基于红黑树的实现，保证元素按照自然顺序或指定的比较器顺序排序。由于 TreeSet 需要维护顺序，因此它的操作（如 add、remove、contains）的时间复杂度为 O(log n)。
示例：使用 TreeSet
import java.util.Set;
import java.util.TreeSet;
public class TreeSetExample {
public static void main(String[] args) {
Set<String> set = new TreeSet<>();
// 添加元素
set.add("Banana");
set.add("Apple");
set.add("Orange");
System.out.println("TreeSet (sorted): " + set);
// 判断集合中是否包含某个元素
System.out.println("Contains 'Apple': " + set.contains("Apple"));
// 移除元素
set.remove("Banana");
System.out.println("TreeSet after removing 'Banana': " + set);
// 遍历集合
for (String item : set) {
System.out.println("Item: " + item);
}
}
}六、EnumSet 类
EnumSet 是一个专门用于枚举类型的集合，它的所有元素必须是同一个枚举类型。EnumSet 的性能非常高效，因为它内部使用位向量表示。
示例：使用 EnumSet
import java.util.EnumSet;
import java.util.Set;
enum Fruit {
APPLE, BANANA, ORANGE, PEAR
}
public class EnumSetExample {
public static void main(String[] args) {
Set<Fruit> set = EnumSet.of(Fruit.APPLE, Fruit.BANANA);
// 添加元素
set.add(Fruit.ORANGE);
System.out.println("EnumSet: " + set);
// 判断集合中是否包含某个元素
System.out.println("Contains APPLE: " + set.contains(Fruit.APPLE));
// 移除元素
set.remove(Fruit.BANANA);
System.out.println("EnumSet after removing BANANA: " + set);
}
}七、Set 的常见操作和应用
- 集合操作：
Set接口的实现类可以用于各种集合操作，例如并集、交集和差集。 - 去重操作：在需要去除重复数据的场景下，使用
Set非常方便。 - 快速查找：
HashSet提供了高效的查找操作，适用于需要快速查找的场景。
八、总结
Set 接口是 Java 集合框架中一个重要的接口，用于存储不允许重复的元素集合。根据不同的场景和需求，Java 提供了不同的 Set 实现类，如 HashSet、LinkedHashSet、TreeSet 和 EnumSet。理解和使用这些实现类，可以更好地管理和操作数据集合，提高程序的性能和可维护性。
Map
在 Java 中，Map 接口表示一个键值对映射的集合，它提供了一种存储和操作键值对的方式。Map 不属于 Java Collection 框架的子接口，它是独立的接口，但同样位于 java.util 包中。Map 是一个非常常用的数据结构，适用于需要根据键快速查找、插入或删除值的场景。
一、Map 接口的基本概念
Map 是一种键值对（Key-Value Pair）映射的集合，其中键（Key）是唯一的，不能重复，而值（Value）则可以重复。Map 接口提供了很多方法用于基本的集合操作，如插入、删除、查找等。
1. Map 的特点
- 键唯一，值可重复：
Map中的每个键（Key）必须是唯一的，但对应的值（Value）可以重复。 - 键不能为
null（部分实现类允许null）：在某些实现中（如HashMap），允许键为null，而在其他实现（如TreeMap）中则不允许。 - 不保证顺序：大多数
Map实现类不保证键值对的顺序，但也有一些实现（如LinkedHashMap）可以维护插入顺序或访问顺序。
2. Map 接口的常用方法
put(K key, V value)：将指定的键值对插入到映射中，如果键已存在，则替换旧值。get(Object key)：返回与指定键关联的值，如果映射中不包含该键，则返回null。remove(Object key)：移除指定键对应的键值对。containsKey(Object key)：判断映射中是否包含指定的键。containsValue(Object value)：判断映射中是否包含一个或多个指定的值。keySet()：返回映射中所有键的Set视图。values()：返回映射中所有值的Collection视图。entrySet()：返回映射中所有键值对的Set视图。size()：返回映射中键值对的数量。isEmpty()：判断映射是否为空。clear()：清空映射中的所有键值对。
二、Map 的实现类
Java 提供了多个 Map 接口的实现类，每个实现类都有其独特的特性和适用场景：
HashMap：基于哈希表的实现，允许一个null键和多个null值，不保证键值对的顺序。LinkedHashMap：继承自HashMap，使用双向链表维护元素的插入顺序（或访问顺序）。TreeMap：基于红黑树的实现，键值对按键的自然顺序或指定的比较器顺序排序，不允许null键。Hashtable：基于哈希表的实现，线程安全，不允许null键或值。ConcurrentHashMap：线程安全的HashMap实现，支持并发操作，分段锁机制。
三、HashMap 类
HashMap 是最常用的 Map 实现类，基于哈希表实现，允许一个 null 键和多个 null 值，不保证键值对的顺序。HashMap 的基本操作（如 put、get、remove）的时间复杂度为 O(1)。
示例：使用 HashMap
import java.util.HashMap;
import java.util.Map;
public class HashMapExample {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
// 添加键值对
map.put("Apple", 10);
map.put("Banana", 20);
map.put("Orange", 30);
map.put("Apple", 40); // 键 "Apple" 的值将被替换
// 打印整个映射
System.out.println("HashMap: " + map);
// 获取键对应的值
int value = map.get("Apple");
System.out.println("Value for key 'Apple': " + value);
// 移除键值对
map.remove("Banana");
System.out.println("HashMap after removing 'Banana': " + map);
// 遍历键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
}
}四、LinkedHashMap 类
LinkedHashMap 是 HashMap 的子类，使用双向链表维护键值对的插入顺序（或访问顺序）。它的性能稍慢于 HashMap，但在需要维持顺序的场景中非常有用。
示例：使用 LinkedHashMap
import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapExample {
public static void main(String[] args) {
Map<String, Integer> map = new LinkedHashMap<>();
// 添加键值对
map.put("Apple", 10);
map.put("Banana", 20);
map.put("Orange", 30);
System.out.println("LinkedHashMap: " + map);
// 遍历键值对（按插入顺序）
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
}
}五、TreeMap 类
TreeMap 是基于红黑树的实现，键值对按键的自然顺序或指定的比较器顺序排序。由于 TreeMap 需要维护顺序，其操作（如 put、get、remove）的时间复杂度为 O(log n)。
示例：使用 TreeMap
import java.util.Map;
import java.util.TreeMap;
public class TreeMapExample {
public static void main(String[] args) {
Map<String, Integer> map = new TreeMap<>();
// 添加键值对
map.put("Banana", 20);
map.put("Apple", 10);
map.put("Orange", 30);
System.out.println("TreeMap (sorted): " + map);
// 遍历键值对（按自然顺序）
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
}
}六、Hashtable 类
Hashtable 是一个线程安全的 Map 实现类，它不允许 null 键或 null 值。由于其线程安全性，Hashtable 的性能相比 HashMap 较低。
示例：使用 Hashtable
import java.util.Hashtable;
import java.util.Map;
public class HashtableExample {
public static void main(String[] args) {
Map<String, Integer> map = new Hashtable<>();
// 添加键值对
map.put("Apple", 10);
map.put("Banana", 20);
map.put("Orange", 30);
System.out.println("Hashtable: " + map);
// 遍历键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
}
}七、ConcurrentHashMap 类
ConcurrentHashMap 是线程安全的 HashMap 实现类，支持高效的并发操作，采用分段锁机制来提高性能。它不允许 null 键或 null 值。
示例：使用 ConcurrentHashMap
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentHashMapExample {
public static void main(String[] args) {
Map<String, Integer> map = new ConcurrentHashMap<>();
// 添加键值对
map.put("Apple", 10);
map.put("Banana", 20);
map.put("Orange", 30);
System.out.println("ConcurrentHashMap: " + map);
// 遍历键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
}
}八、总结
Map 接口在 Java 集合框架中用于键值对的映射操作。不同的 Map 实现类（如 HashMap、LinkedHashMap、TreeMap、Hashtable、ConcurrentHashMap）提供了不同的功能和特性，适用于各种场景。选择适合的 Map` 实现类可以大大提高程序的性能和效率。
Iterator
在 Java 中，生成器（Generator） 的概念并不像 Python 中那样明确，但 Java 提供了一种机制来实现类似生成器的功能。迭代器（Iterator） 是 Java 集合框架中的一个重要接口，提供了一种遍历集合元素的统一方式。
一、Java 中的迭代器（Iterator）
Iterator 是 Java 集合框架中用于遍历集合元素的接口，它位于 java.util 包中。几乎所有的 Java 集合类（如 List、Set 等）都实现了 Iterable 接口，该接口提供了一个 iterator() 方法，用于返回一个 Iterator 对象。
1. Iterator 接口的基本方法
Iterator 接口定义了一些方法，用于遍历和操作集合中的元素：
boolean hasNext()：如果仍有元素可以迭代，则返回true。E next()：返回下一个元素。void remove()：从集合中移除上一次调用next()方法返回的元素（可选操作）。
2. 示例：使用 Iterator 遍历集合
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 获取 Iterator 对象
Iterator<String> iterator = list.iterator();
// 使用 Iterator 遍历集合
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);
// 可选：移除元素
if ("Banana".equals(element)) {
iterator.remove(); // 从列表中移除 "Banana"
}
}
System.out.println("List after removal: " + list);
}
}3. for-each 循环与迭代器
Java 的增强型 for 循环（for-each）实际上是基于 Iterator 实现的。所有实现了 Iterable 接口的类都可以使用 for-each 进行迭代。
for (String item : list) {
System.out.println(item);
}二、Java 中的生成器（Generator）
Java 中没有像 Python 那样的原生生成器（即使用 yield 关键字的函数），但我们可以通过 实现 Iterator 接口 和 使用 Stream API 实现类似生成器的功能。
1. 使用 Iterator 接口模拟生成器
我们可以创建一个类实现 Iterator 接口，通过自定义逻辑生成序列元素，类似于生成器的行为。
示例：创建一个生成斐波那契数列的生成器
import java.util.Iterator;
public class FibonacciGenerator implements Iterator<Integer> {
private int limit; // 生成多少个斐波那契数
private int count; // 当前生成的个数
private int prev1; // 上一个数
private int prev2; // 上上一个数
public FibonacciGenerator(int limit) {
this.limit = limit;
this.count = 0;
this.prev1 = 0;
this.prev2 = 1;
}
@Override
public boolean hasNext() {
return count < limit;
}
@Override
public Integer next() {
if (!hasNext()) {
throw new IllegalStateException("No more elements");
}
int current = prev1;
prev1 = prev2;
prev2 = prev1 + current;
count++;
return current;
}
public static void main(String[] args) {
FibonacciGenerator generator = new FibonacciGenerator(10);
while (generator.hasNext()) {
System.out.print(generator.next() + " ");
}
}
}2. 使用 Stream API 实现生成器
Java 8 引入的 Stream API 提供了一个新的方式来生成序列。Stream 可以是无限的，可以通过 limit 或其他方法来控制生成多少元素。
示例：使用 Stream 生成斐波那契数列
import java.util.stream.Stream;
public class StreamGeneratorExample {
public static void main(String[] args) {
Stream.iterate(new int[]{0, 1}, arr -> new int[]{arr[1], arr[0] + arr[1]})
.limit(10)
.map(arr -> arr[0])
.forEach(System.out::println);
}
}在上面的示例中，Stream.iterate() 方法接受一个种子值（初始值）和一个生成函数来生成序列。map() 方法将生成的数组转换为单个整数，然后使用 forEach() 方法输出每个元素。
三、ListIterator 接口
除了 Iterator，Java 还提供了一个更加强大的迭代器接口 ListIterator，它支持在双向遍历 List 集合中的元素。
1. ListIterator 的基本方法
boolean hasNext()：如果向前遍历仍有元素可迭代，则返回true。E next()：返回下一个元素。boolean hasPrevious()：如果向后遍历仍有元素可迭代，则返回true。E previous()：返回前一个元素。void add(E e)：在当前迭代位置添加一个元素。void set(E e)：更新最近一次next()或previous()返回的元素。
2. 示例：使用 ListIterator 遍历集合
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 获取 ListIterator 对象
ListIterator<String> iterator = list.listIterator();
System.out.println("Forward iteration:");
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);
}
System.out.println("Backward iteration:");
while (iterator.hasPrevious()) {
String element = iterator.previous();
System.out.println(element);
}
}
}四、总结
- 迭代器（Iterator） 是 Java 集合框架中的一个重要接口，用于遍历集合元素。
Iterator提供了统一的方式来遍历List、Set等集合。 - 生成器（Generator） 在 Java 中没有直接的概念，但可以通过实现
Iterator接口或使用StreamAPI 来实现类似生成器的功能。 ListIterator是一个增强版的迭代器接口，提供了双向遍历和元素添加、更新等功能。
通过熟练使用迭代器和类似生成器的工具，Java 开发者可以更高效地管理和处理集合中的数据。
反射
Java 反射（Reflection）是一种强大的特性，允许程序在运行时检查和操作类、方法、字段等的属性。通过反射，你可以动态地创建对象、调用方法、访问和修改字段等，这些操作在编译时是未知的。
反射的基本概念
反射的核心是 Java 的 java.lang.reflect 包，它提供了类和接口来访问类的内部结构，包括：
Class<T>：表示一个类或接口的运行时类型。Field：表示类的字段（成员变量）。Method：表示类的方法。Constructor<T>：表示类的构造方法。
获取 Class 对象
要使用反射，首先需要获取一个 Class 对象，代表某个类的运行时类型。可以通过以下几种方式获得：
使用
Class.forName()：Class<?> clazz = Class.forName("com.example.MyClass");使用
ClassName.class：Class<MyClass> clazz = MyClass.class;使用对象的
getClass()方法：MyClass obj = new MyClass(); Class<?> clazz = obj.getClass();
动态创建对象
通过反射，你可以在运行时动态创建类的实例：
Class<MyClass> clazz = MyClass.class;
MyClass obj = clazz.newInstance(); // 调用无参构造方法如果类没有无参构造方法，或者你想使用特定的构造方法，可以使用 Constructor 类：
Constructor<MyClass> constructor = clazz.getConstructor(String.class);
MyClass obj = constructor.newInstance("Hello");访问和修改字段
反射允许你访问和修改对象的字段，包括私有字段：
Class<MyClass> clazz = MyClass.class;
MyClass obj = clazz.newInstance();
Field field = clazz.getDeclaredField("name");
field.setAccessible(true); // 允许访问私有字段
field.set(obj, "John"); // 设置字段的值
String value = (String) field.get(obj); // 获取字段的值调用方法
你可以通过反射调用对象的方法，包括私有方法：
Class<MyClass> clazz = MyClass.class;
MyClass obj = clazz.newInstance();
Method method = clazz.getDeclaredMethod("sayHello", String.class);
method.setAccessible(true); // 允许访问私有方法
method.invoke(obj, "John"); // 调用方法示例：使用反射获取类的信息
以下示例展示了如何使用反射获取类的所有字段、方法和构造方法的信息：
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionExample {
public static void main(String[] args) throws Exception {
Class<MyClass> clazz = MyClass.class;
// 获取所有字段
System.out.println("Fields:");
for (Field field : clazz.getDeclaredFields()) {
System.out.println(" " + field);
}
// 获取所有方法
System.out.println("Methods:");
for (Method method : clazz.getDeclaredMethods()) {
System.out.println(" " + method);
}
// 获取所有构造方法
System.out.println("Constructors:");
for (Constructor<?> constructor : clazz.getDeclaredConstructors()) {
System.out.println(" " + constructor);
}
}
}
class MyClass {
private String name;
private int age;
public MyClass() {}
public MyClass(String name) {
this.name = name;
}
public void sayHello(String greeting) {
System.out.println(greeting + ", " + name);
}
}反射的用途
- 框架和库：许多 Java 框架和库（如 Spring、Hibernate）大量使用反射来实现依赖注入、对象关系映射等功能。
- 动态代理：通过反射，Java 可以动态创建代理对象，用于 AOP（面向切面编程）等技术。
- 测试框架：像 JUnit 这样的测试框架使用反射来调用测试方法。
- 工具类：反射用于开发通用工具类，能够处理各种类型的对象，而无需预先了解对象的类型。
反射的局限性和注意事项
- 性能开销：反射相比直接调用方法或访问字段要慢，特别是在频繁调用时，这种性能差异更加明显。
- 安全性：反射可以绕过访问控制，访问私有字段和方法，这可能导致安全问题。
- 类型安全：反射操作通常
泛型
Java 泛型（Generics）是Java编程语言中一种强大的功能，允许你在编写代码时使用类型参数。它可以使代码更加通用和灵活，同时提高类型安全性。
基本概念
- 泛型类：定义类时使用泛型参数，这样类可以处理不同类型的数据，而不必在类的每个具体实例中指定特定的数据类型。
- 泛型方法：定义方法时使用泛型参数，使方法可以处理不同类型的参数，而无需编写多个方法来处理不同类型的数据。
- 泛型接口：接口也可以定义泛型参数，允许接口的实现类具有不同的类型参数。
语法
使用尖括号 <> 来定义泛型参数，常见的泛型参数符号包括：
T（Type）E（Element）K（Key）V（Value）
// 泛型类
public class Box<T> {
private T t;
public void set(T t) {
this.t = t;
}
public T get() {
return t;
}
}
// 泛型方法
public <U> void print(U u) {
System.out.println(u);
}常见用途
- 集合框架：Java的集合框架广泛使用泛型，如
List<T>、Map<K, V>等。 - 类型安全：泛型确保在编译时检查类型，而不是在运行时抛出
ClassCastException。 - 减少冗余代码：使用泛型可以避免编写重复的代码，同时处理多种数据类型。
限定泛型
你可以对泛型参数设置上限或下限。例如，<T extends Number> 限制 T 必须是 Number 或其子类。
public <T extends Number> void processNumber(T number) {
System.out.println(number.doubleValue());
}通配符
通配符 ? 用于表示不确定的类型，可以用于方法参数、返回类型或局部变量中。
public void printList(List<?> list) {
for (Object elem : list) {
System.out.println(elem);
}
}通配符还可以限定上下限，例如 <? extends Number> 表示某个类型是 Number 或其子类，<? super Integer> 表示某个类型是 Integer 或其父类。
注意事项
- 类型擦除：在运行时，所有的泛型信息都会被擦除，泛型类型会被替换为其边界类型（默认是
Object）。因此，不能直接在运行时检查泛型类型，如if (obj instanceof T)是非法的。 - 静态成员：泛型类的静态成员不能使用泛型参数。
泛型在Java中是非常重要的，它提高了代码的重用性、类型安全性和可读性。
注解
Java 注解（Annotations）是一种为代码提供元数据的机制。注解不会直接影响程序的逻辑，但它们可以用于给编译器、开发工具、框架或运行时环境提供指示。
基本概念
- 元数据：注解是附加在代码上的数据，用于描述代码的属性或行为。
- 不会改变代码行为：注解不会改变编译后的代码行为，但它们可以用于生成代码、编译时检查、运行时处理等。
- 注解类型：注解本质上是一个特殊的接口，方法名对应注解的元素，返回值对应元素的类型。
常见的内置注解
Java提供了一些内置注解，用于基本的编译时检查和指示：
@Override：表示当前方法覆盖了父类或接口中的方法。编译器会检查方法签名是否正确。@Override public String toString() { return "Example"; }@Deprecated：标记一个方法、类或字段已过时，建议不再使用。使用时编译器会给出警告。@Deprecated public void oldMethod() { // ... }@SuppressWarnings：用于抑制编译器警告。@SuppressWarnings("unchecked") public void someMethod() { List list = new ArrayList(); // unchecked warning suppressed }@SafeVarargs：用于抑制使用泛型可变参数方法的警告。@SafeVarargs public final void method(T... args) { // ... }@FunctionalInterface：表示该接口是一个函数式接口，编译器会检查该接口是否符合要求（只有一个抽象方法）。@FunctionalInterface public interface MyFunctionalInterface { void doSomething(); }
自定义注解
你可以创建自己的注解，类似于定义接口：
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
// 定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
String value() default "default value";
}
// 使用注解
public class MyClass {
@MyAnnotation(value = "custom value")
public void myMethod() {
// ...
}
}注解的元注解
注解可以使用元注解来控制它们的行为。常见的元注解包括：
@Retention：定义注解的生命周期。RetentionPolicy.SOURCE：只在源码中保留，编译时会被忽略。RetentionPolicy.CLASS：在字节码中保留，但运行时不可见（默认）。RetentionPolicy.RUNTIME：在运行时保留，可以通过反射获取。
@Target：定义注解可以使用的地方，如类、方法、字段等。ElementType.TYPE：类、接口（包括注解类型）、枚举。ElementType.METHOD：方法。ElementType.FIELD：字段。
@Inherited：允许子类继承父类的注解。@Documented：表明注解应当被包含在 javadoc 中。
处理注解
注解可以在运行时通过反射进行处理：
import java.lang.reflect.Method;
public class AnnotationProcessor {
public static void main(String[] args) throws Exception {
Method method = MyClass.class.getMethod("myMethod");
MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
if (annotation != null) {
System.out.println("Value: " + annotation.value());
}
}
}注解的应用场景
- 框架：如Spring、Hibernate使用注解配置Bean、事务等。
- 测试：如JUnit中的
@Test注解。 - 依赖注入：通过注解配置依赖关系。
- 代码生成和处理：如APT（Annotation Processing Tool）用于在编译时生成代码。
Java注解是一种灵活且强大的工具，广泛应用于现代Java开发中，为代码提供了更多的可读性和扩展性。
单元测试
Java单元测试是用于验证代码中的单个方法或类是否按照预期工作的一种技术。它通过编写小的、可独立执行的测试代码来检测代码中的错误，并在代码更改后确保现有功能不被破坏。
1. 什么是单元测试
单元测试（Unit Testing）是软件测试的一部分，专注于测试软件的最小可测试单元（通常是一个类中的方法）。通过编写单元测试，可以确保每个单元功能正常，减少代码中的bug，提高代码质量和可维护性。
2. Java 单元测试框架
Java有几个流行的单元测试框架，最常用的是JUnit和TestNG。
2.1 JUnit
JUnit是Java平台最流行的单元测试框架之一。JUnit 4和5都是常用版本，其中JUnit 5是最新版本，提供了更强大的功能和灵活性。
添加JUnit依赖： 如果你使用Maven构建工具，可以在pom.xml文件中添加以下依赖：
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.10.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>5.10.0</version>
<scope>test</scope>
</dependency>
</dependencies>3. 编写JUnit测试用例
在JUnit中，测试用例通常是一个包含测试方法的类。每个测试方法用于测试一个特定的功能或方法。
3.1 基本测试用例
示例：
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
class CalculatorTest {
@Test
void testAdd() {
Calculator calculator = new Calculator();
int result = calculator.add(2, 3);
assertEquals(5, result, "The addition result should be 5");
}
}在这个例子中：
@Test：标记一个方法为测试方法。assertEquals(expected, actual)：断言expected值和actual值是否相等。
3.2 运行测试
可以通过IDE（如IntelliJ IDEA或Eclipse）或Maven命令运行测试。测试成功通过时，框架将显示绿色的进度条，表示所有测试都通过；如果有测试失败，将显示红色，并提供详细的错误信息。
4. 测试常用注解
@BeforeEach：在每个测试方法执行前运行，通常用于初始化。@AfterEach：在每个测试方法执行后运行，通常用于清理。@BeforeAll：在所有测试方法执行前运行，仅运行一次，通常用于一次性初始化。@AfterAll：在所有测试方法执行后运行，仅运行一次，通常用于一次性清理。@Disabled：标记测试方法为忽略，暂时不运行。
示例：
import org.junit.jupiter.api.*;
class CalculatorTest {
private Calculator calculator;
@BeforeEach
void setUp() {
calculator = new Calculator();
}
@AfterEach
void tearDown() {
calculator = null;
}
@Test
void testAdd() {
assertEquals(5, calculator.add(2, 3));
}
@Test
@Disabled("Disabled until bug #123 is fixed")
void testSubtract() {
assertEquals(1, calculator.subtract(3, 2));
}
}5. 断言（Assertions）
断言是单元测试中用于验证测试结果是否符合预期的语句。JUnit提供了许多常用的断言方法：
assertEquals(expected, actual)：验证两个值是否相等。assertNotEquals(unexpected, actual)：验证两个值是否不相等。assertTrue(condition)：验证条件是否为真。assertFalse(condition)：验证条件是否为假。assertNull(object)：验证对象是否为null。assertNotNull(object)：验证对象是否不为null。assertThrows(expectedType, executable)：验证执行代码是否抛出指定的异常类型。
示例：
@Test
void testDivide() {
ArithmeticException exception = assertThrows(ArithmeticException.class, () -> {
calculator.divide(10, 0);
});
assertEquals("/ by zero", exception.getMessage());
}6. 参数化测试
参数化测试允许使用不同的参数多次运行同一个测试方法。在JUnit 5中，使用@ParameterizedTest注解可以实现参数化测试。
示例：
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
class CalculatorTest {
@ParameterizedTest
@ValueSource(ints = { 1, 2, 3, 4, 5 })
void testIsPositive(int number) {
assertTrue(calculator.isPositive(number));
}
}7. Mocking 测试
在单元测试中，有时需要对依赖项进行模拟，以隔离被测试的单元。Mockito是Java中最流行的Mocking框架之一，用于创建和管理模拟对象。
添加Mockito依赖：
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>4.0.0</version>
<scope>test</scope>
</dependency>示例：
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
class UserServiceTest {
@Test
void testGetUserById() {
UserRepository userRepository = Mockito.mock(UserRepository.class);
UserService userService = new UserService(userRepository);
User mockUser = new User("John", "Doe");
Mockito.when(userRepository.findById(1)).thenReturn(mockUser);
User user = userService.getUserById(1);
assertEquals("John", user.getFirstName());
}
}总结
Java单元测试是确保代码质量的重要手段。通过使用JUnit框架，可以轻松编写、运行和管理测试用例，从而有效地发现和修复代码中的问题。掌握JUnit的常用功能和工具（如Mocking、参数化测试）将有助于编写健壮且可维护的单元测试，提高整个项目的稳定性和可靠性。
序列化
Java 序列化（Serialization）是将对象的状态转换为字节流的过程，这个字节流可以保存到文件、数据库或者通过网络传输。反序列化（Deserialization）是将字节流恢复为对象的过程。
序列化的用途
- 持久化：将对象的状态保存到硬盘中，便于以后恢复。
- 传输：在分布式系统中，通过网络传输对象的状态。
- 缓存：将对象序列化后存储到缓存中，减少重新计算的时间。
序列化的基本要求
实现
Serializable接口：要序列化的类必须实现java.io.Serializable接口。该接口是一个标记接口，不包含任何方法。serialVersionUID：每个可序列化类建议都定义一个serialVersionUID字段，用于标识类的版本。如果类的定义发生变化，而没有相应地修改serialVersionUID，则在反序列化时可能会发生InvalidClassException。public class MyClass implements Serializable { private static final long serialVersionUID = 1L; private String name; private int age; // Constructors, getters, setters }
序列化和反序列化
- 序列化：使用
ObjectOutputStream类的writeObject()方法。 - 反序列化：使用
ObjectInputStream类的readObject()方法。
import java.io.*;
public class SerializationExample {
public static void main(String[] args) {
MyClass obj = new MyClass("John", 30);
// 序列化
try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("object.ser"))) {
out.writeObject(obj);
} catch (IOException e) {
e.printStackTrace();
}
// 反序列化
try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("object.ser"))) {
MyClass deserializedObj = (MyClass) in.readObject();
System.out.println("Name: " + deserializedObj.getName());
System.out.println("Age: " + deserializedObj.getAge());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class MyClass implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
public MyClass(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}transient 关键字
在序列化过程中，标记为 transient 的字段不会被序列化。这对于那些不需要或不能被序列化的字段非常有用，例如密码或其他敏感数据。
public class MyClass implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private transient int age; // 这个字段不会被序列化
// Constructors, getters, setters
}Externalizable 接口
Externalizable 接口提供了更细粒度的控制，可以通过实现 writeExternal() 和 readExternal() 方法来自定义序列化和反序列化过程。
import java.io.*;
public class MyExternalizableClass implements Externalizable {
private String name;
private int age;
public MyExternalizableClass() {
// No-arg constructor is required for Externalizable
}
public MyExternalizableClass(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(name);
out.writeInt(age);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
name = (String) in.readObject();
age = in.readInt();
}
// Getters, setters
}序列化的注意事项
- 对象图：在序列化一个对象时，所有可达的对象（引用的对象）也会被序列化。这被称为对象图。
serialVersionUID：如果没有显式声明，JVM 会自动生成一个，但建议手动声明以避免潜在的问题。- 版本兼容性：在反序列化时，类的版本必须兼容，否则会抛出异常。
- 安全性：序列化和反序列化存在安全风险，特别是在反序列化未受信任的数据时，可能导致反序列化漏洞。
Java 序列化是一个功能强大但也需要谨慎使用的机制，尤其在涉及安全和版本兼容性时。
IO流
Java IO（输入输出）流是 Java 中用于处理输入和输出操作的一套 API。它支持读写文件、读取用户输入、网络通信等多种场景。Java IO 流分为字节流和字符流，每种流都有输入流和输出流。理解 Java 的 IO 流机制是进行 Java 编程的基础。
一、Java IO 流的分类
Java IO 流主要分为以下几类：
按数据单位划分：
- 字节流（Byte Stream）：以字节（8 位）为单位进行输入输出操作，通常用于处理二进制数据（如图片、音频、视频等）。
- 输入流：
InputStream及其子类 - 输出流：
OutputStream及其子类
- 输入流：
- 字符流（Character Stream）：以字符（16 位 Unicode）为单位进行输入输出操作，通常用于处理文本数据。
- 输入流：
Reader及其子类 - 输出流：
Writer及其子类
- 输入流：
- 字节流（Byte Stream）：以字节（8 位）为单位进行输入输出操作，通常用于处理二进制数据（如图片、音频、视频等）。
按流的方向划分：
- 输入流（Input Stream/Reader）：用于读取数据
- 输出流（Output Stream/Writer）：用于写入数据
按功能划分：
- 节点流（Node Stream）：直接与数据源或数据目的地相连的流，如
FileInputStream、FileOutputStream。 - 处理流（Processing Stream）：对节点流进行包装，提供更高效或便捷的输入输出功能，如
BufferedInputStream、BufferedReader。
- 节点流（Node Stream）：直接与数据源或数据目的地相连的流，如
二、字节流（Byte Streams）
字节流用于处理所有类型的二进制数据。在 Java 中，所有的字节流类都是 InputStream 和 OutputStream 类的子类。
1. 字节输入流（InputStream）
InputStream：字节输入流的抽象基类，用于读取字节数据。常用子类包括：FileInputStream：从文件中读取字节流。ByteArrayInputStream：从字节数组中读取字节流。BufferedInputStream：为其他输入流提供缓冲功能，提高读取效率。
示例：读取文件中的字节数据
import java.io.FileInputStream;
import java.io.IOException;
public class ByteInputExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("example.txt")) {
int data;
while ((data = fis.read()) != -1) { // 读取字节数据
System.out.print((char) data); // 将字节转换为字符
}
} catch (IOException e) {
e.printStackTrace();
}
}
}2. 字节输出流（OutputStream）
OutputStream：字节输出流的抽象基类，用于写入字节数据。常用子类包括：FileOutputStream：将字节数据写入文件。ByteArrayOutputStream：将字节数据写入字节数组。BufferedOutputStream：为其他输出流提供缓冲功能，提高写入效率。
示例：将字节数据写入文件
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteOutputExample {
public static void main(String[] args) {
String content = "Hello, World!";
try (FileOutputStream fos = new FileOutputStream("output.txt")) {
fos.write(content.getBytes()); // 写入字节数据
} catch (IOException e) {
e.printStackTrace();
}
}
}三、字符流（Character Streams）
字符流用于处理文本数据（字符）。在 Java 中，所有的字符流类都是 Reader 和 Writer 类的子类。
1. 字符输入流（Reader）
Reader：字符输入流的抽象基类，用于读取字符数据。常用子类包括：FileReader：从文件中读取字符流。CharArrayReader：从字符数组中读取字符流。BufferedReader：为其他字符输入流提供缓冲功能，支持按行读取。
示例：使用 BufferedReader 读取文件中的文本数据
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class CharInputExample {
public static void main(String[] args) {
try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
String line;
while ((line = br.readLine()) != null) { // 读取每一行
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}2. 字符输出流（Writer）
Writer：字符输出流的抽象基类，用于写入字符数据。常用子类包括：FileWriter：将字符数据写入文件。CharArrayWriter：将字符数据写入字符数组。BufferedWriter：为其他字符输出流提供缓冲功能，支持按行写入。
示例：使用 BufferedWriter 写入文本数据到文件
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class CharOutputExample {
public static void main(String[] args) {
String content = "Hello, World!";
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
bw.write(content); // 写入字符数据
bw.newLine(); // 写入一个换行符
} catch (IOException e) {
e.printStackTrace();
}
}
}四、常用的 IO 流类
以下是 Java 中一些常用的 IO 流类：
| 类 | 描述 |
|---|---|
FileInputStream | 从文件中读取字节数据。 |
FileOutputStream | 将字节数据写入文件。 |
BufferedInputStream | 提供缓冲机制的字节输入流。 |
BufferedOutputStream | 提供缓冲机制的字节输出流。 |
FileReader | 从文件中读取字符数据。 |
FileWriter | 将字符数据写入文件。 |
BufferedReader | 提供缓冲机制的字符输入流，支持按行读取。 |
BufferedWriter | 提供缓冲机制的字符输出流，支持按行写入。 |
PrintWriter | 提供打印格式化数据的字符输出流。 |
ObjectInputStream | 反序列化对象的字节输入流。 |
ObjectOutputStream | 序列化对象的字节输出流。 |
五、序列化与反序列化
- 序列化：将对象转换为字节流的过程，以便存储或传输。
- 反序列化：将字节流转换为对象的过程。
在 Java 中，序列化和反序列化通常使用 ObjectOutputStream 和 ObjectInputStream 类来实现。类需要实现 Serializable 接口才能序列化。
import java.io.*;
// Serializable 类示例
class Person implements Serializable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + '}';
}
}
public class SerializationExample {
public static void main(String[] args) {
Person person = new Person("John", 30);
// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
oos.writeObject(person); // 将对象写入文件
} catch (IOException e) {
e.printStackTrace();
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
Person deserializedPerson = (Person) ois.readObject(); // 从文件读取对象
System.out.println(deserializedPerson);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}六、文件流与缓冲流的区别
- 文件流（File Stream）：直接操作文件，速度较慢。
- 缓冲流（Buffered Stream）：对文件流进行包装，提供缓冲区来提高读写效率。
七、Java NIO（New IO）
Java NIO（Non-blocking IO）是 Java 1.4 引入的一套新的 IO API，相比传统的 IO（BIO，Blocking IO），NIO 更加高效，支持非阻塞模式和多路复用。Java NIO
包含 Channel、Buffer、Selector 等核心组件，适用于高性能的网络编程和文件操作。
八、总结
Java IO 提供了多种流类来满足不同的输入输出需求，字节流适合处理二进制数据，而字符流适合处理文本数据。Java 中的 IO 流设计遵循装饰器模式，通过处理流来增强基本流的功能。掌握这些 IO 基础对于构建 Java 应用程序至关重要。
Java NIO
Java NIO（New Input/Output）是 Java 1.4 中引入的一套新的 IO API，与传统的 Java IO（即“Old IO”或“Blocking IO”）相比，Java NIO 提供了更高效的 IO 操作方式，支持非阻塞 IO（Non-blocking IO）和多路复用。它适用于需要处理大量数据的高性能服务器、网络应用等场景。
一、Java NIO 的主要组件
Java NIO 的核心组件包括：
- Channel（通道）：负责数据的传输。
- Buffer（缓冲区）：用于存储数据。
- Selector（选择器）：用于管理多个通道的 I/O 操作。
二、Channel（通道）
通道（Channel）是 Java NIO 中的核心概念之一。它类似于传统 IO 中的流（Stream），但与流不同的是，通道是双向的，既可以用于读操作，也可以用于写操作。通道的常用实现类有：
FileChannel：用于读取、写入、映射和操作文件的通道。DatagramChannel：用于通过 UDP 读取和写入网络中的数据。SocketChannel：用于通过 TCP 读取和写入网络中的数据。ServerSocketChannel：可以监听新进来的 TCP 连接，像传统的服务器套接字。
创建 FileChannel 示例
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.ByteBuffer;
public class FileChannelExample {
public static void main(String[] args) throws Exception {
RandomAccessFile file = new RandomAccessFile("example.txt", "rw");
FileChannel fileChannel = file.getChannel(); // 获取 FileChannel
// 创建一个容量为 48 字节的缓冲区
ByteBuffer buffer = ByteBuffer.allocate(48);
// 从通道读取数据到缓冲区
int bytesRead = fileChannel.read(buffer);
while (bytesRead != -1) {
buffer.flip(); // 切换缓冲区为读取模式
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get()); // 逐字节读取
}
buffer.clear(); // 清空缓冲区，准备下一次读取
bytesRead = fileChannel.read(buffer);
}
file.close();
}
}三、Buffer（缓冲区）
缓冲区（Buffer） 是一个对象，它包含一些要写入或要读出的数据。NIO 的所有数据都是用缓冲区处理的，数据是从通道读入到缓冲区中，或者从缓冲区写入到通道中的。
缓冲区本质上是一个数组，它是一个包含数据的连续块，可以通过各种方式来操作这些数据。常用的缓冲区类型有：
ByteBuffer：字节缓冲区。CharBuffer：字符缓冲区。IntBuffer：整数缓冲区。FloatBuffer：浮点缓冲区。DoubleBuffer：双精度浮点缓冲区。LongBuffer：长整数缓冲区。ShortBuffer：短整数缓冲区。
Buffer 的基本操作
Buffer 的核心属性和方法包括：
capacity：缓冲区的容量，缓冲区能够容纳的最大数据量。position：当前读写位置。limit：表示缓冲区的可操作数据的大小，不能对limit之外的数据进行读写操作。
缓冲区的常用方法有：
flip()：将缓冲区从写模式切换到读模式。clear()：清空缓冲区，准备写入数据。rewind()：重绕缓冲区，从头开始读取数据。mark()和reset()：标记和重置缓冲区到特定位置。
四、Selector（选择器）
选择器（Selector） 是 Java NIO 中的一个对象，它用于检查一个或多个通道的状态，看是否有事件发生。Selector 是实现非阻塞 IO 的关键组件。通过 Selector，单个线程可以监视多个通道的 IO 状态，极大地提高了 IO 操作的效率。
Selector 的使用步骤
创建 Selector：
Selector selector = Selector.open();注册通道到 Selector： 将一个通道（如
SocketChannel）注册到 Selector 上，并指定感兴趣的操作（如 OP_READ、OP_WRITE 等）。SocketChannel socketChannel = SocketChannel.open(); socketChannel.configureBlocking(false); // 设置为非阻塞模式 socketChannel.register(selector, SelectionKey.OP_READ); // 注册到 Selector 并指定感兴趣的操作轮询通道的状态： 使用
select()方法阻塞等待，直到至少有一个通道准备好进行 IO 操作。while (true) { selector.select(); // 阻塞，直到至少有一个通道准备好 Set<SelectionKey> selectedKeys = selector.selectedKeys(); Iterator<SelectionKey> iterator = selectedKeys.iterator(); while (iterator.hasNext()) { SelectionKey key = iterator.next(); if (key.isReadable()) { // 处理读取操作 } else if (key.isWritable()) { // 处理写入操作 } iterator.remove(); // 移除已处理的键 } }
五、Java NIO 的非阻塞模式
Java NIO 的一个重要特性是支持非阻塞 IO。传统的 IO 操作是阻塞的，也就是说，当一个线程执行 IO 操作时，它会被阻塞，直到操作完成。而在 NIO 中，可以让一个线程发起一个 IO 操作，然后继续处理其他事情，直到 IO 操作完成。
六、Java NIO 实现网络通信的示例
以下是一个使用 Java NIO 实现简单的服务器和客户端的示例：
1. NIO 服务器
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
public class NioServer {
public static void main(String[] args) {
try {
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(8080));
serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式
System.out.println("服务器已启动，等待客户端连接...");
while (true) {
SocketChannel socketChannel = serverSocketChannel.accept(); // 非阻塞模式，不会阻塞
if (socketChannel != null) {
System.out.println("客户端已连接：" + socketChannel.getRemoteAddress());
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("Hello from server!".getBytes());
buffer.flip();
socketChannel.write(buffer); // 发送数据到客户端
socketChannel.close();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}2. NIO 客户端
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class NioClient {
public static void main(String[] args) {
try {
SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("localhost", 8080));
ByteBuffer buffer = ByteBuffer.allocate(1024);
socketChannel.read(buffer);
buffer.flip();
System.out.println("从服务器收到消息: " + new String(buffer.array(), 0, buffer.limit()));
socketChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}七、Java NIO 与传统 IO 的对比
| 特性 | Java NIO | 传统 IO |
|---|---|---|
| IO 模型 | 非阻塞 IO，支持多路复用 | 阻塞 IO |
| 数据处理方式 | 基于缓冲区（Buffer）处理数据 | 基于流（Stream）处理数据 |
| IO 方向 | 双向（Channel） | 单向（InputStream 或 OutputStream） |
| 多线程支持 | 支持单线程处理多个通道，提高效率 | 一个线程处理一个流，效率较低 |
| 适用场景 | 高性能、大规模并发的网络应用 | 简单的文件读写或少量数据处理 |
八、总结
Java NIO 提供了比传统 IO 更高效和灵活的 API，适用于高性能、高并发的网络编程场景。它通过 Channel、Buffer 和 Selector 等组件，使开发者能够编写出高效、非阻塞的 IO 代码。掌握 Java NIO 是构建高性能网络应用的重要技能。
异常处理
Java 的异常处理机制是一种处理程序运行期间可能出现的错误或异常情况的方式。它使得代码在出现错误时不会立即崩溃，而是可以捕获并处理异常，提供更可靠的程序运行方式。
一、什么是异常？
异常（Exception）是程序运行时出现的非正常情况或错误。Java 中的异常是通过类来表示的，所有异常类都是从 java.lang.Throwable 类派生的。Throwable 类有两个主要的子类：
Error：错误，表示系统级别的严重问题，通常程序无法恢复（如OutOfMemoryError）。Error类及其子类不需要处理，程序通常无法捕获它们。Exception：异常，表示程序级别的异常情况，可以由程序本身处理，分为以下两类：- 受检异常（Checked Exception）：编译时异常，必须显式地捕获或声明抛出，例如
IOException、SQLException。 - 非受检异常（Unchecked Exception）：运行时异常，程序员的逻辑错误导致的异常，例如
NullPointerException、ArrayIndexOutOfBoundsException。
- 受检异常（Checked Exception）：编译时异常，必须显式地捕获或声明抛出，例如
二、异常的继承体系
Java 异常类的层次结构如下所示：
java.lang.Object
└── java.lang.Throwable
├── java.lang.Error
└── java.lang.Exception
├── java.lang.RuntimeException
└── 其他异常类（如 IOException、SQLException 等）三、异常处理的关键字
Java 使用 5 个关键字来处理异常：
try：用于包裹可能会引发异常的代码块。catch：用于捕获异常，并处理异常。finally：无论是否发生异常，都会执行的代码块，通常用于释放资源。throw：显式抛出一个异常。throws：用于声明一个方法可能抛出的异常。
四、基本的异常处理机制
在 Java 中，异常处理通常使用 try-catch-finally 结构。以下是一个简单的示例：
public class ExceptionExample {
public static void main(String[] args) {
try {
// 可能会引发异常的代码
int result = 10 / 0; // 这会引发 ArithmeticException
} catch (ArithmeticException e) {
// 捕获并处理异常
System.out.println("捕获到异常: " + e.getMessage());
} finally {
// 无论是否发生异常，都会执行
System.out.println("执行 finally 代码块");
}
}
}输出：
捕获到异常: / by zero
执行 finally 代码块五、异常处理的工作流程
- 当程序在
try块中执行时，遇到异常情况（如除以零）。 - 异常被引发（即“抛出”），Java 运行时系统（JVM）查找能够处理该异常的
catch块。 - 如果找到匹配的
catch块，则执行它。 - 如果没有找到匹配的
catch块，程序会终止，并且异常信息会被打印到控制台。 - 无论异常是否被捕获，
finally块都会执行（除非 JVM 退出或线程被中断）。
六、多个 catch 块
一个 try 块可以跟多个 catch 块，每个 catch 块处理不同类型的异常。异常处理按照从上到下的顺序进行，如果某个 catch 块匹配了异常类型，则执行该块，其后的 catch 块将被忽略。
public class MultipleCatchExample {
public static void main(String[] args) {
try {
int[] arr = new int[5];
arr[5] = 30 / 0; // 可能会引发 ArithmeticException 或 ArrayIndexOutOfBoundsException
} catch (ArithmeticException e) {
System.out.println("捕获到算术异常: " + e.getMessage());
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("捕获到数组索引越界异常: " + e.getMessage());
} catch (Exception e) {
System.out.println("捕获到异常: " + e.getMessage());
}
}
}输出：
捕获到算术异常: / by zero七、使用 finally 块
finally 块用于在代码执行后进行清理操作，例如关闭文件、释放资源、断开数据库连接等。finally 块总是会执行，无论是否发生异常，除非 JVM 退出或线程被中断。
public class FinallyExample {
public static void main(String[] args) {
try {
int data = 50 / 0; // 这会引发 ArithmeticException
} catch (ArithmeticException e) {
System.out.println("异常被捕获: " + e.getMessage());
} finally {
System.out.println("finally 块始终会执行");
}
}
}输出：
异常被捕获: / by zero
finally 块始终会执行八、throw 和 throws
throw：用于显式地抛出一个异常，通常用于自定义异常处理。throws：用于声明一个方法可能抛出的异常类型，表示方法可能不会捕获这些异常，需要调用方处理。
使用 throw 抛出异常
public class ThrowExample {
public static void validateAge(int age) {
if (age < 18) {
throw new IllegalArgumentException("年龄必须大于或等于18岁");
}
}
public static void main(String[] args) {
try {
validateAge(15);
} catch (IllegalArgumentException e) {
System.out.println("异常: " + e.getMessage());
}
}
}输出：
异常: 年龄必须大于或等于18岁使用 throws 声明异常
import java.io.IOException;
public class ThrowsExample {
public static void readFile() throws IOException {
throw new IOException("文件未找到");
}
public static void main(String[] args) {
try {
readFile();
} catch (IOException e) {
System.out.println("捕获到异常: " + e.getMessage());
}
}
}九、自定义异常
Java 允许创建自定义异常，继承自 Exception 或 RuntimeException 类。以下是一个自定义异常的示例：
// 自定义异常类
class MyCustomException extends Exception {
public MyCustomException(String message) {
super(message);
}
}
public class CustomExceptionExample {
public static void main(String[] args) {
try {
// 手动抛出自定义异常
throw new MyCustomException("这是一个自定义异常");
} catch (MyCustomException e) {
System.out.println("捕获到自定义异常: " + e.getMessage());
}
}
}十、最佳实践
- 捕获特定异常：避免使用通用的
Exception类来捕获所有异常，优先捕获特定的异常类型。 - 异常信息明确：提供有意义的异常信息，以便更好地调试和排查问题。
- 使用
finally块进行资源清理：确保无论是否发生异常，都会正确释放资源。 - 避免在循环中使用异常控制流：异常处理机制较为昂贵，应避免将其用作正常的控制流机制。
- 使用自定义异常：当需要提供更具体的错误信息时，考虑使用自定义异常。
- 记录异常日志：在处理异常时，通常需要记录异常日志，以便后续分析。
十一、总结
Java 异常处理机制提供了一种强大的方式来处理程序运行时的错误和异常情况。通过正确使用 try-catch-finally 结构、throw 和 throws 关键字，以及自定义异常，开发者可以编写健壮、稳定且易于调试的代码。
日志
Java 日志（Logging）是一种用于记录应用程序运行时信息的机制。日志是调试和监控应用程序的重要工具，它可以帮助开发人员发现问题、分析错误和记录重要的操作过程。
一、Java 日志的重要性
日志在应用程序开发和维护中有以下几个重要作用：
- 调试和排查问题：记录程序运行过程中的关键信息，帮助快速定位和解决问题。
- 监控和审计：记录用户行为、系统事件等信息，便于监控系统状态和进行安全审计。
- 数据分析：日志数据可以用于分析系统性能和用户行为，帮助改进系统设计。
二、Java 常用的日志框架
Java 生态中有多种日志框架，它们提供了不同的功能和灵活性。常用的日志框架有：
- Java 内置日志框架（
java.util.logging，简称 JUL）：Java 提供的内置日志工具，功能简单，适合入门使用。 - Apache Log4j：一个功能强大的日志记录框架，支持多种日志输出方式和配置。
- Log4j 2：Log4j 的升级版本，提供了更好的性能和更多功能。
- SLF4J（Simple Logging Facade for Java）：一个日志门面（Facade）框架，不提供日志实现本身，而是与其他日志框架（如 Log4j、JUL 等）结合使用。
- Logback：由 Log4j 的原作者设计，作为 Log4j 的继任者，功能强大，性能优越。
三、Java 内置日志框架（java.util.logging）
java.util.logging（JUL）是 Java 的内置日志框架，它无需额外引入第三方依赖，适合简单的日志记录需求。下面是 JUL 的基本用法。
1. Logger 类
Logger 是 Java 内置日志框架的核心类。它负责记录日志信息，并将日志发送到 Handler 进行输出。
2. 日志级别
日志级别定义了日志的严重性，常见的日志级别有（从低到高）：
SEVERE（最高级别，表示严重错误）WARNING（警告信息）INFO（一般信息）CONFIG（配置信息）FINE（详细信息）FINER（更详细的信息）FINEST（最低级别，最详细的信息）
3. 创建 Logger 示例
以下是一个简单的使用 Java 内置日志框架的示例：
import java.util.logging.Level;
import java.util.logging.Logger;
public class JULExample {
private static final Logger logger = Logger.getLogger(JULExample.class.getName());
public static void main(String[] args) {
logger.setLevel(Level.ALL); // 设置日志级别为所有
logger.severe("这是一个 SEVERE 级别的日志消息");
logger.warning("这是一个 WARNING 级别的日志消息");
logger.info("这是一个 INFO 级别的日志消息");
logger.config("这是一个 CONFIG 级别的日志消息");
logger.fine("这是一个 FINE 级别的日志消息");
logger.finer("这是一个 FINER 级别的日志消息");
logger.finest("这是一个 FINEST 级别的日志消息");
}
}四、Log4j 2
Log4j 2 是一个流行的 Java 日志框架，它是对 Log4j 的重大升级，提供了更好的性能和更灵活的配置。
1. 引入依赖
使用 Log4j 2 需要在项目中添加相应的依赖。如果你使用 Maven 项目，可以在 pom.xml 文件中添加以下依赖：
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.17.1</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.17.1</version>
</dependency>2. 配置文件
Log4j 2 支持多种配置格式（如 XML、JSON、YAML）。下面是一个简单的 XML 配置示例（log4j2.xml）：
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
<Appenders>
<Console name="Console" target="SYSTEM_OUT">
<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss} [%t] %-5level %logger{36} - %msg%n"/>
</Console>
</Appenders>
<Loggers>
<Root level="debug">
<AppenderRef ref="Console"/>
</Root>
</Loggers>
</Configuration>3. 使用 Log4j 2 记录日志
以下是使用 Log4j 2 记录日志的示例：
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class Log4j2Example {
private static final Logger logger = LogManager.getLogger(Log4j2Example.class);
public static void main(String[] args) {
logger.trace("This is a TRACE level log message");
logger.debug("This is a DEBUG level log message");
logger.info("This is an INFO level log message");
logger.warn("This is a WARN level log message");
logger.error("This is an ERROR level log message");
logger.fatal("This is a FATAL level log message");
}
}五、SLF4J 和 Logback
SLF4J（Simple Logging Facade for Java） 是一个为各种日志框架提供统一接口的日志门面，常与 Logback 配合使用。Logback 是由 Log4j 的原作者开发的，作为 Log4j 的继任者，性能和功能更佳。
1. 引入依赖
如果你使用 SLF4J 和 Logback，可以在 pom.xml 中添加以下依赖：
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.11</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.36</version>
</dependency>2. 配置文件
Logback 使用 logback.xml 文件进行配置，以下是一个简单的配置示例：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level [%thread] %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<root level="debug">
<appender-ref ref="STDOUT" />
</root>
</configuration>3. 使用 SLF4J 和 Logback 记录日志
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SLF4JLogbackExample {
private static final Logger logger = LoggerFactory.getLogger(SLF4JLogbackExample.class);
public static void main(String[] args) {
logger.info("This is an INFO level log message");
logger.debug("This is a DEBUG level log message");
logger.warn("This is a WARN level log message");
logger.error("This is an ERROR level log message");
}
}六、日志最佳实践
选择合适的日志级别：根据不同的场景选择合适的日志级别（如 DEBUG、INFO、WARN、ERROR），避免过多或过少的日志信息。
使用参数化日志：避免在日志语句中进行字符串拼接，而是使用参数化的日志语句，提升性能。
logger.info("User {} has logged in", username);合理配置日志输出：根据需要配置日志的输出位置（控制台、文件、远程服务器等）和日志文件的滚动策略。
避免记录敏感信息：不要在日志中记录密码、密钥等敏感信息。
统一日志格式：使用一致的日志格式，便于后续的日志分析和监控。
七、总结
Java 提供了多种日志框架供开发者选择，从内置的 java.util.logging 到功能强大的 Log4j、Logback 等。在实际项目中，根据需求和项目规模选择合适的日志框架，并遵循日志的最佳实践，可以帮助提高应用程序的可维护性和稳定性。
网络编程
Java 网络编程主要涉及如何在网络上建立通信，处理网络协议，以及如何编写客户端和服务器端程序。Java 提供了丰富的类库和 API 来支持网络编程，尤其是基于 TCP/IP 协议的编程。主要的类和接口位于 java.net 包中。
一、Java 网络编程的基本概念
- IP 地址：互联网上每台计算机都有一个唯一的 IP 地址，用于标识网络中的计算机。
- 端口（Port）：每台计算机有 0 到 65535 之间的端口，每个端口对应一个特定的服务。
- 协议（Protocol）：定义了网络通信的规则和格式。常见的协议有 TCP（传输控制协议）和 UDP（用户数据报协议）。
- URL（Uniform Resource Locator）：统一资源定位符，用于表示互联网上资源的位置。
二、Java 网络编程核心类和接口
java.net 包提供了以下核心类和接口，用于实现 Java 网络编程：
InetAddress：表示 IP 地址。URL和URLConnection：用于处理 URL 和与其相关的连接。Socket和ServerSocket：用于实现基于 TCP 的客户端-服务器通信。DatagramSocket和DatagramPacket：用于实现基于 UDP 的通信。
三、使用 InetAddress 类处理 IP 地址
InetAddress 类用于表示 IP 地址，可以是 IPv4 或 IPv6。它提供了一些静态方法来获取主机的 IP 地址和主机名。
示例：获取主机的 IP 地址和主机名
import java.net.InetAddress;
import java.net.UnknownHostException;
public class InetAddressExample {
public static void main(String[] args) {
try {
// 获取本地主机的 IP 地址
InetAddress localHost = InetAddress.getLocalHost();
System.out.println("本地主机名: " + localHost.getHostName());
System.out.println("本地主机地址: " + localHost.getHostAddress());
// 获取指定主机的 IP 地址
InetAddress googleHost = InetAddress.getByName("www.google.com");
System.out.println("Google 主机名: " + googleHost.getHostName());
System.out.println("Google IP 地址: " + googleHost.getHostAddress());
// 获取所有 IP 地址
InetAddress[] allAddresses = InetAddress.getAllByName("www.google.com");
for (InetAddress address : allAddresses) {
System.out.println("Google IP 地址（多地址）: " + address.getHostAddress());
}
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}四、基于 TCP 的网络编程
TCP（传输控制协议） 是一种面向连接的、可靠的、基于字节流的协议。Java 提供了 Socket 类用于实现 TCP 客户端，ServerSocket 类用于实现 TCP 服务器端。
1. 实现 TCP 客户端
Socket 类用于创建一个客户端，并连接到指定主机和端口。客户端通过 OutputStream 向服务器发送数据，通过 InputStream 接收服务器的数据。
import java.io.*;
import java.net.Socket;
public class TCPClient {
public static void main(String[] args) {
String serverAddress = "localhost";
int port = 12345;
try (Socket socket = new Socket(serverAddress, port);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
// 向服务器发送请求
out.println("Hello, Server!");
// 接收服务器的响应
String response = in.readLine();
System.out.println("来自服务器的响应: " + response);
} catch (IOException e) {
e.printStackTrace();
}
}
}2. 实现 TCP 服务器端
ServerSocket 类用于创建一个服务器端 socket，监听来自客户端的连接请求。服务器通过 accept() 方法接受客户端的连接，返回一个与客户端通信的 Socket 对象。
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServer {
public static void main(String[] args) {
int port = 12345;
try (ServerSocket serverSocket = new ServerSocket(port)) {
System.out.println("服务器启动，正在监听端口: " + port);
while (true) {
// 接受客户端连接
Socket clientSocket = serverSocket.accept();
System.out.println("新客户端连接: " + clientSocket.getInetAddress().getHostAddress());
// 处理客户端请求
try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
String request = in.readLine();
System.out.println("接收到客户端请求: " + request);
// 响应客户端
out.println("Hello, Client!");
} catch (IOException e) {
e.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}五、基于 UDP 的网络编程
UDP（用户数据报协议） 是一种无连接的、不可靠的协议，适用于对速度要求高而对可靠性要求低的场合。Java 提供了 DatagramSocket 和 DatagramPacket 类来实现 UDP 编程。
1. 实现 UDP 客户端
DatagramSocket 类用于创建一个 UDP 套接字，DatagramPacket 用于发送和接收数据报文。
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UDPClient {
public static void main(String[] args) {
String serverAddress = "localhost";
int port = 12345;
String message = "Hello, Server!";
try (DatagramSocket socket = new DatagramSocket()) {
byte[] sendBuffer = message.getBytes();
InetAddress serverInetAddress = InetAddress.getByName(serverAddress);
DatagramPacket sendPacket = new DatagramPacket(sendBuffer, sendBuffer.length, serverInetAddress, port);
// 发送数据报文
socket.send(sendPacket);
System.out.println("已发送消息到服务器: " + message);
// 接收服务器的响应
byte[] receiveBuffer = new byte[1024];
DatagramPacket receivePacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);
socket.receive(receivePacket);
String response = new String(receivePacket.getData(), 0, receivePacket.getLength());
System.out.println("来自服务器的响应: " + response);
} catch (Exception e) {
e.printStackTrace();
}
}
}2. 实现 UDP 服务器端
DatagramSocket 类用于在指定的端口上创建一个 UDP 套接字，用于接收客户端的请求。
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class UDPServer {
public static void main(String[] args) {
int port = 12345;
try (DatagramSocket socket = new DatagramSocket(port)) {
System.out.println("UDP 服务器已启动，正在监听端口: " + port);
byte[] receiveBuffer = new byte[1024];
while (true) {
DatagramPacket receivePacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);
socket.receive(receivePacket);
String request = new String(receivePacket.getData(), 0, receivePacket.getLength());
System.out.println("接收到客户端请求: " + request);
// 响应客户端
String response = "Hello, Client!";
byte[] sendBuffer = response.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendBuffer, sendBuffer.length, receivePacket.getAddress(), receivePacket.getPort());
socket.send(sendPacket);
System.out.println("已发送响应到客户端: " + response);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}六、使用 URL 和 URLConnection 进行网络编程
Java 提供了 URL 和 URLConnection 类，用于处理 HTTP、FTP 等协议。URL 类表示一个统一资源定位符，而 URLConnection 类表示与 URL 的通信链接。
1. 使用 URL 类
URL 类可以用来创建一个 URL 对象，并获取 URL 的相关信息。
import java.net.URL;
public class URLExample {
public static void main(String[] args) {
try {
URL url = new URL("https://www.example.com:443/path/to/resource?query=123#fragment");
System.out.println("协议: " + url.getProtocol());
System.out.println("主机名: " + url.getHost());
System.out.println("端口号: " + url.getPort());
System.out.println("路径: " + url.getPath());
System.out.println("查询字符串: " + url.getQuery());
System.out.println("片段: " + url.getRef());
} catch (
Exception e) {
e.printStackTrace();
}
}
}2. 使用 URLConnection 类
URLConnection 类用于读取或写入数据到指定的 URL。
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
public class URLConnectionExample {
public static void main(String[] args) {
try {
URL url = new URL("https://www.example.com");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String inputLine;
StringBuilder response = new StringBuilder();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println("响应内容: " + response.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
}七、Java 网络编程的高级特性
- 多线程服务器：使用多线程来处理多个客户端的连接请求，提高服务器的性能。
- NIO（New Input/Output）：提供了非阻塞 I/O 和更高效的 I/O 操作，适用于高并发的网络应用。
- Java WebSockets：用于在客户端和服务器之间建立全双工通信通道，适合实时通信应用。
八、总结
Java 网络编程提供了丰富的类库和 API，可以方便地开发基于 TCP 和 UDP 协议的网络应用。掌握 Java 的网络编程知识，可以帮助开发者编写高效、可靠的网络应用程序。通过结合使用线程、NIO 和高级并发工具类，可以构建更强大和高效的网络系统。
正则表达式
Java 正则表达式是一种强大的文本处理工具，它允许开发者用一种简洁的方式来搜索、匹配和操作字符串。正则表达式在文本解析、数据验证、替换和格式化等方面非常有用。
一、Java 正则表达式的基础
Java 提供了 java.util.regex 包来处理正则表达式，主要有两个核心类：
Pattern类：表示编译后的正则表达式。使用Pattern.compile()方法创建Pattern对象。Matcher类：表示对输入字符串进行解释和匹配的引擎。通过Pattern.matcher()方法创建Matcher对象。
二、Java 正则表达式的语法
正则表达式由一些特殊字符和字符序列组成，它们定义了一个搜索模式。以下是 Java 中常见的正则表达式语法：
| 正则表达式 | 描述 |
|---|---|
. | 匹配除换行符外的任何字符 |
^ | 匹配字符串的开始 |
$ | 匹配字符串的结束 |
\d | 匹配一个数字字符（0-9） |
\D | 匹配一个非数字字符 |
\w | 匹配一个字母、数字或下划线字符 |
\W | 匹配一个非字母、数字或下划线字符 |
\s | 匹配任何空白字符（空格、制表符等） |
\S | 匹配任何非空白字符 |
* | 匹配前面的字符 0 次或多次 |
+ | 匹配前面的字符 1 次或多次 |
? | 匹配前面的字符 0 次或 1 次 |
{n} | 匹配前面的字符恰好 n 次 |
{n,} | 匹配前面的字符至少 n 次 |
{n,m} | 匹配前面的字符至少 n 次，至多 m 次 |
[] | 匹配括号内的任意一个字符 |
[^] | 匹配不在括号内的任意字符 |
| `(a | b)` |
(…) | 捕获组 |
(?:...) | 非捕获组 |
\ | 转义字符，匹配特殊字符本身（如 \. 匹配点） |
三、基本使用示例
1. 匹配和查找
以下是一个简单的 Java 正则表达式使用示例，用于匹配和查找字符串中的模式。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexExample {
public static void main(String[] args) {
String text = "This is a sample text with 123 and more numbers like 456.";
// 定义正则表达式
String regex = "\\d+";
// 创建 Pattern 对象
Pattern pattern = Pattern.compile(regex);
// 创建 Matcher 对象
Matcher matcher = pattern.matcher(text);
// 查找并输出所有匹配的子串
while (matcher.find()) {
System.out.println("找到的数字: " + matcher.group());
}
}
}输出：
找到的数字: 123
找到的数字: 4562. 验证字符串格式
以下示例使用正则表达式验证一个输入的字符串是否是一个有效的电子邮件地址：
public class EmailValidation {
public static void main(String[] args) {
String email = "example@domain.com";
String regex = "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$";
if (email.matches(regex)) {
System.out.println("有效的电子邮件地址");
} else {
System.out.println("无效的电子邮件地址");
}
}
}四、使用 Pattern 和 Matcher 类的常用方法
Pattern类的常用方法：Pattern.compile(String regex)：编译正则表达式，返回Pattern对象。Pattern.compile(String regex, int flags)：编译带有标志的正则表达式。
Matcher类的常用方法：boolean matches()：整个输入序列是否匹配正则表达式。boolean find()：是否找到与正则表达式匹配的子字符串。String group()：返回上一次匹配操作中匹配的子字符串。int start()：返回上一次匹配操作中匹配的子字符串的开始索引。int end()：返回上一次匹配操作中匹配的子字符串的结束索引。String replaceAll(String replacement)：将所有匹配的子字符串替换为给定的字符串。
替换示例
使用正则表达式替换字符串中的所有非数字字符：
public class RegexReplaceExample {
public static void main(String[] args) {
String text = "Hello123World456";
String regex = "\\D"; // 匹配非数字字符
// 将非数字字符替换为空字符串
String result = text.replaceAll(regex, "");
System.out.println(result); // 输出：123456
}
}五、正则表达式的标志（Flags）
在 Java 中，可以通过 Pattern 类的 compile() 方法中的第二个参数来指定正则表达式的标志。常见的标志有：
Pattern.CASE_INSENSITIVE：忽略大小写匹配。Pattern.MULTILINE：启用多行模式。Pattern.DOTALL：使.匹配包括换行符在内的所有字符。Pattern.UNICODE_CASE：在匹配时考虑 Unicode 大小写。Pattern.COMMENTS：忽略正则表达式中的空白和注释。
示例：忽略大小写匹配
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexFlagExample {
public static void main(String[] args) {
String text = "Java is fun. JAVA is powerful.";
String regex = "java";
// 使用 CASE_INSENSITIVE 标志
Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(text);
while (matcher.find()) {
System.out.println("匹配到: " + matcher.group());
}
}
}输出：
匹配到: Java
匹配到: JAVA六、分组与捕获
正则表达式支持使用圆括号 () 来分组和捕获匹配的子模式。捕获组可以在匹配后用于提取信息。
示例：捕获组
public class RegexGroupExample {
public static void main(String[] args) {
String text = "John Doe, 30 years old";
String regex = "(\\w+) (\\w+), (\\d+) years old";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(text);
if (matcher.find()) {
System.out.println("名字: " + matcher.group(1)); // John
System.out.println("姓氏: " + matcher.group(2)); // Doe
System.out.println("年龄: " + matcher.group(3)); // 30
}
}
}七、总结
Java 正则表达式提供了强大的文本处理功能，通过 Pattern 和 Matcher 类，可以方便地对字符串进行搜索、匹配和操作。掌握正则表达式语法和使用方法，有助于开发人员编写更加灵活和高效的 Java 应用程序。在实际应用中，正则表达式广泛用于数据验证、日志分析、字符串替换等场景。
多线程
Java 多线程编程是开发高性能和响应迅速应用程序的关键技术之一。通过多线程，程序可以同时执行多个任务，从而提高效率、改善用户体验。Java 提供了强大的多线程支持，主要通过 java.lang.Thread 类和 java.util.concurrent 包来实现。
一、什么是线程？
- 线程（Thread） 是操作系统能够调度的最小执行单元。一个进程可以包含多个线程，这些线程共享进程的资源（如内存、文件句柄等）。
- 多线程 是指在一个程序中同时运行多个线程。每个线程执行一个独立的任务，可以与其他线程并发执行。
二、Java 多线程的实现方式
Java 中有两种创建线程的主要方式：
- 继承
Thread类。 - 实现
Runnable接口。
此外，还有使用 Callable 和 Future 接口的方式，这种方式支持返回结果和抛出异常。
1. 继承 Thread 类
通过继承 Thread 类，可以创建一个新的线程类，并重写 run() 方法。
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " 正在执行: " + i);
}
}
}
public class ThreadExample {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.start(); // 启动线程
thread2.start(); // 启动线程
}
}2. 实现 Runnable 接口
实现 Runnable 接口是更常用的方法，因为 Java 不支持多重继承，通过实现接口的方式可以避免类继承的限制。
class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " 正在执行: " + i);
}
}
}
public class RunnableExample {
public static void main(String[] args) {
Thread thread1 = new Thread(new MyRunnable());
Thread thread2 = new Thread(new MyRunnable());
thread1.start(); // 启动线程
thread2.start(); // 启动线程
}
}3. 使用 Callable 和 Future 接口
Runnable 接口不返回结果，也不能抛出异常，而 Callable 接口可以做到。Callable 使用 call() 方法，返回一个结果并允许抛出异常。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += i;
System.out.println(Thread.currentThread().getName() + " 计算中: " + sum);
}
return sum;
}
}
public class CallableExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
Future<Integer> future1 = executor.submit(new MyCallable());
Future<Integer> future2 = executor.submit(new MyCallable());
try {
System.out.println("Future1 结果: " + future1.get());
System.out.println("Future2 结果: " + future2.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
executor.shutdown();
}
}三、线程的生命周期
Java 中的线程有五个基本状态：
- 新建（New）：线程对象被创建但尚未启动。
- 就绪（Runnable）：线程已启动并等待调度器分配 CPU 时间。
- 运行（Running）：线程正在执行。
- 阻塞（Blocked）：线程正在等待资源（如 I/O 操作）或者被另一个线程锁定。
- 终止（Terminated）：线程执行完毕或者异常退出。
线程的状态转换如下图所示：
New -> Runnable -> Running -> Blocked -> Runnable -> Running -> Terminated四、线程控制方法
Java 提供了一些控制线程的方法，用于管理线程的生命周期和行为。
start()：启动线程，使其进入就绪状态。run()：线程执行的入口方法，不直接调用run()方法，使用start()方法来启动线程。sleep(long millis)：使当前线程进入休眠状态millis毫秒。join()：等待调用join()方法的线程执行完毕。yield()：让出当前 CPU 使用权，线程从运行状态变为就绪状态。interrupt()：中断线程，设置线程的中断状态标志。isAlive()：检查线程是否处于活动状态。
示例：使用 sleep() 和 join() 方法
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " 正在执行: " + i);
try {
Thread.sleep(1000); // 线程休眠 1 秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ThreadControlExample {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.start();
try {
thread1.join(); // 主线程等待 thread1 完成
} catch (InterruptedException e) {
e.printStackTrace();
}
thread2.start();
}
}五、线程同步
当多个线程同时访问共享资源时，可能会引起数据不一致问题。线程同步是解决这一问题的常用方式。
1. 使用 synchronized 关键字
Synchronized 关键字可以修饰方法或代码块，确保同一时间只有一个线程可以访问这些资源。
- 同步方法：在方法声明中使用
synchronized关键字。
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}- 同步代码块：在方法内部使用
synchronized关键字。
class Counter {
private int count = 0;
public void increment() {
synchronized (this) {
count++;
}
}
public int getCount() {
return count;
}
}2. 使用 ReentrantLock 类
ReentrantLock 是 Java 提供的一种显示锁机制，比 synchronized 更灵活。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Counter {
private int count = 0;
private final Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
return count;
}
}六、线程间通信
Java 提供了 wait()、notify() 和 notifyAll() 方法，用于在多个线程之间进行通信，通常与同步代码块或方法一起使用。
wait()：使当前线程等待，直到另一个线程调用notify()或notifyAll()。notify()：唤醒等待的单个线程。notifyAll()：唤醒等待的所有线程。
class Message {
private String message;
public synchronized void write(String message) {
this.message = message;
notify(); // 唤醒等待的读取线程
}
public synchronized String read() {
try {
wait(); // 等待写入线程调用 notify()
} catch (InterruptedException e) {
e.printStackTrace();
}
return message;
}
}
public class ThreadCommunicationExample {
public static void main(String[] args) {
Message message = new Message();
// 写入线程
new Thread(() -> {
try {
Thread.sleep(1000);
message.write("你好，线程间通信！");
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
// 读取线程
new Thread(() -> {
System.out.println("读取消息: " + message.read());
}).start();
}
}七、Java 并发工具类
Java 提供了 java.util.concurrent 包，包含了一些更高级的并发工具类：
ExecutorService：用于管理线程池。CountDownLatch：允许一个或多个线程等待其他线程完成操作
。
CyclicBarrier：允许一组线程互相等待，直到所有线程都到达屏障点。Semaphore：控制对资源的访问。BlockingQueue：支持阻塞操作的线程安全队列。
八、总结
Java 的多线程编程为开发者提供了丰富的工具和 API，帮助解决并发问题，提高应用程序的性能和响应速度。通过正确使用线程同步、线程间通信和并发工具类，可以有效避免线程安全问题，确保程序的稳定性和高效性。
JDBC
Java JDBC（Java Database Connectivity） 是 Java 用于连接和操作数据库的标准 API。JDBC 提供了一种统一的方式来访问不同类型的关系型数据库，使开发人员可以编写独立于数据库的应用程序。
一、JDBC 简介
JDBC 是一种用于执行 SQL 语句的 Java API，可以与各种数据库（如 MySQL、PostgreSQL、Oracle、SQL Server 等）进行交互。通过 JDBC，开发人员可以执行 SQL 查询、更新语句，调用存储过程，处理结果集等操作。JDBC 的核心组件包括 DriverManager、Connection、Statement、PreparedStatement、ResultSet 等。
二、JDBC 架构
JDBC 的架构主要包括两层：
- JDBC API 层：为应用程序提供标准的接口。
- JDBC Driver 层：负责将 JDBC API 调用转换为特定数据库的操作。驱动程序可以是原生的、网络协议的、数据库协议的等。
三、JDBC 的基本操作步骤
使用 JDBC 操作数据库的步骤通常包括以下几个步骤：
- 加载数据库驱动程序。
- 建立数据库连接。
- 创建 SQL 语句对象。
- 执行 SQL 语句。
- 处理结果集（如果是查询操作）。
- 关闭连接。
四、JDBC 代码示例
以下是一个使用 JDBC 连接 MySQL 数据库的示例代码。
1. 加载数据库驱动程序
要使用 JDBC 连接数据库，首先需要加载数据库驱动程序。驱动程序通常由数据库供应商提供（例如 MySQL 的 mysql-connector-java）。Java 提供了 Class.forName() 方法来加载驱动程序类。
try {
Class.forName("com.mysql.cj.jdbc.Driver"); // 加载 MySQL JDBC 驱动程序
} catch (ClassNotFoundException e) {
e.printStackTrace();
}2. 建立数据库连接
使用 DriverManager.getConnection() 方法建立与数据库的连接。该方法需要传递数据库 URL、用户名和密码。
String url = "jdbc:mysql://localhost:3306/testdb"; // 数据库 URL
String user = "root"; // 数据库用户名
String password = "password"; // 数据库密码
Connection connection = null;
try {
connection = DriverManager.getConnection(url, user, password); // 建立连接
System.out.println("数据库连接成功！");
} catch (SQLException e) {
e.printStackTrace();
}3. 创建 SQL 语句对象
使用 Connection 对象的 createStatement() 方法创建 Statement 对象，该对象用于发送 SQL 语句到数据库。
Statement statement = null;
try {
statement = connection.createStatement(); // 创建 Statement 对象
} catch (SQLException e) {
e.printStackTrace();
}4. 执行 SQL 语句
使用 Statement 对象的 executeQuery() 方法执行 SQL 查询语句，或使用 executeUpdate() 方法执行插入、更新或删除操作。
try {
// 查询操作
String query = "SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(query); // 执行查询并返回结果集
// 插入操作
String insertQuery = "INSERT INTO users (name, age) VALUES ('John Doe', 30)";
int rowsAffected = statement.executeUpdate(insertQuery); // 执行插入操作
System.out.println("影响的行数: " + rowsAffected);
} catch (SQLException e) {
e.printStackTrace();
}5. 处理结果集
当执行查询操作时，会返回一个 ResultSet 对象，包含查询的结果数据。可以使用 ResultSet 对象的各种方法来访问结果集中的数据。
try {
ResultSet resultSet = statement.executeQuery("SELECT * FROM users");
while (resultSet.next()) { // 遍历结果集
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
int age = resultSet.getInt("age");
System.out.println("ID: " + id + ", Name: " + name + ", Age: " + age);
}
} catch (SQLException e) {
e.printStackTrace();
}6. 关闭连接
为了防止资源泄露，必须关闭 ResultSet、Statement 和 Connection 对象。通常在 finally 块中执行这些操作。
try {
if (resultSet != null) resultSet.close();
if (statement != null) statement.close();
if (connection != null) connection.close();
} catch (SQLException e) {
e.printStackTrace();
}五、使用 PreparedStatement 进行查询和更新
PreparedStatement 是 Statement 的子接口，提供了预编译的 SQL 语句，有效地防止了 SQL 注入攻击并提高了性能。推荐在任何数据库查询和更新中使用 PreparedStatement。
String query = "SELECT * FROM users WHERE age > ?";
PreparedStatement preparedStatement = connection.prepareStatement(query);
preparedStatement.setInt(1, 25); // 设置第一个参数的值
ResultSet resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
System.out.println("Name: " + resultSet.getString("name"));
}六、事务管理
在 JDBC 中，可以使用 Connection 对象的 setAutoCommit(false) 方法来开启事务，并在需要时使用 commit() 或 rollback() 方法提交或回滚事务。
try {
connection.setAutoCommit(false); // 关闭自动提交，开启事务
String updateQuery1 = "UPDATE accounts SET balance = balance - 100 WHERE id = 1";
statement.executeUpdate(updateQuery1);
String updateQuery2 = "UPDATE accounts SET balance = balance + 100 WHERE id = 2";
statement.executeUpdate(updateQuery2);
connection.commit(); // 提交事务
} catch (SQLException e) {
connection.rollback(); // 回滚事务
e.printStackTrace();
}七、JDBC 驱动类型
JDBC 驱动分为四种类型：
- 类型 1（JDBC-ODBC 桥驱动）：使用 ODBC 驱动与数据库进行通信。
- 类型 2（本地 API 驱动）：通过 Java 本地接口（JNI）调用数据库的本地客户端库。
- 类型 3（网络协议驱动）：客户端使用 JDBC 驱动连接中间件，中间件再连接数据库。
- 类型 4（本地协议驱动）：纯 Java 驱动程序，直接使用数据库的原生协议与数据库进行通信。推荐使用类型 4 驱动，因为它不依赖于本地库。
八、总结
JDBC 是 Java 应用程序与数据库交互的标准 API，具有跨平台、可移植性和数据库无关性。通过 JDBC，可以方便地执行 SQL 语句，处理结果集，管理数据库连接等操作。掌握 JDBC 是学习 Java 企业级开发和数据库编程的基础。
Java8新特性
Java 8 是 Java 语言的一个重要版本，带来了许多新的特性和改进，使得Java编程更加简洁、灵活和高效。以下是Java 8中一些主要的新特性：
1. Lambda 表达式
Lambda表达式是Java 8最重要的特性之一，它使得可以以更简洁的方式来表达函数或匿名类。
示例：
// 使用Lambda表达式代替匿名内部类
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// 使用Lambda表达式进行排序
names.sort((s1, s2) -> s1.compareTo(s2));
// 另一种写法：使用方法引用
names.sort(String::compareTo);Lambda表达式的语法形式如下：
(parameters) -> expression
// 或
(parameters) -> { statements; }2. 函数式接口
函数式接口是仅有一个抽象方法的接口，通常用于Lambda表达式。Java 8引入了@FunctionalInterface注解来标识函数式接口，并提供了几个常用的函数式接口，如 Function、Predicate、Consumer、Supplier 等。
示例：
@FunctionalInterface
interface MyFunctionalInterface {
void myMethod();
}
// 使用Lambda表达式来实现接口方法
MyFunctionalInterface func = () -> System.out.println("Hello, Lambda!");
func.myMethod();3. 方法引用
方法引用是一种简洁的Lambda表达式写法，主要用于简化Lambda表达式的定义。方法引用的主要类型有：
- 静态方法引用：
ClassName::methodName - 实例方法引用：
instance::methodName - 构造方法引用：
ClassName::new
示例：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// 使用静态方法引用
names.forEach(System.out::println);4. Stream API
Stream API 是用于处理集合的强大工具，支持声明性的数据处理，类似于SQL查询语句。通过Stream API，开发者可以以一种流式操作的方式来处理集合数据，如过滤、排序、映射、规约等。
示例：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
// 使用Stream API进行数据处理
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println(evenNumbers); // 输出 [2, 4, 6]5. 默认方法和静态方法
Java 8允许在接口中定义默认方法和静态方法。默认方法可以有方法体，实现类可以选择性地重写它们，而静态方法则只能通过接口调用。
示例：
interface MyInterface {
// 默认方法
default void defaultMethod() {
System.out.println("This is a default method.");
}
// 静态方法
static void staticMethod() {
System.out.println("This is a static method.");
}
}
class MyClass implements MyInterface {
// 可以选择性地重写默认方法
}
public class Main {
public static void main(String[] args) {
MyClass myClass = new MyClass();
myClass.defaultMethod(); // 调用默认方法
MyInterface.staticMethod(); // 调用静态方法
}
}6. 新的日期和时间 API (java.time)
Java 8 引入了全新的日期和时间API，位于java.time包下，它解决了java.util.Date和java.util.Calendar的许多问题。新API是不可变且线程安全的，设计更加合理和易用。
示例：
LocalDate date = LocalDate.now();
LocalDate specificDate = LocalDate.of(2023, Month.AUGUST, 28);
LocalTime time = LocalTime.now();
LocalDateTime dateTime = LocalDateTime.of(date, time);
System.out.println("Current date: " + date);
System.out.println("Current time: " + time);
System.out.println("Current datetime: " + dateTime);7. Optional 类
Optional 是一个容器类，用于表示可能为空的值。通过Optional，可以更优雅地处理null值，避免出现NullPointerException。
示例：
Optional<String> optional = Optional.ofNullable("Hello");
if (optional.isPresent()) {
System.out.println(optional.get());
}
// 使用orElse提供默认值
String result = optional.orElse("Default Value");
System.out.println(result);8. Nashorn JavaScript 引擎
Java 8引入了一个新的JavaScript引擎——Nashorn，它允许开发者在Java代码中直接嵌入和执行JavaScript代码。
示例：
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class Main {
public static void main(String[] args) throws ScriptException {
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("nashorn");
engine.eval("print('Hello, Nashorn');");
}
}9. 其它改进
- Base64 API：提供了对Base64编码和解码的支持。
- JavaFX：Java 8 将 JavaFX 集成到了JDK中，成为标准UI工具包。
- 并行数组：引入了一些新的并行处理数组的工具，如
Arrays.parallelSort()。
总结
Java 8 带来了许多新的特性和改进，使得Java开发更加高效和灵活。Lambda表达式和Stream API是最受欢迎的特性，它们极大地简化了集合的处理和函数式编程。此外，新的日期和时间API、Optional类和默认方法等功能，增强了Java语言的表达能力，改进了代码的可读性和安全性。
文档注释
在Java中，文档注释（Documentation Comments）是一种特殊的注释类型，用于生成程序的API文档。Java提供了一个工具称为javadoc，它能够解析源代码中的文档注释并生成HTML格式的文档。
1. 什么是文档注释
文档注释是以 /** 开头，*/ 结尾的注释块，通常用于类、方法、字段、构造函数等声明之前。文档注释支持使用HTML标签、javadoc特定的标签来描述代码的功能、参数、返回值、异常等。
示例：
/**
* The `Calculator` class provides methods to perform
* basic arithmetic operations such as addition, subtraction,
* multiplication, and division.
*
* @author YourName
* @version 1.0
*/
public class Calculator {
/**
* Adds two numbers together.
*
* @param a the first number
* @param b the second number
* @return the sum of a and b
*/
public int add(int a, int b) {
return a + b;
}
/**
* Divides one number by another.
*
* @param a the numerator
* @param b the denominator
* @return the result of division
* @throws ArithmeticException if b is zero
*/
public int divide(int a, int b) throws ArithmeticException {
if (b == 0) {
throw new ArithmeticException("Division by zero");
}
return a / b;
}
}2. 常用的Javadoc标签
以下是一些常用的Javadoc标签，它们通常用于文档注释中，帮助生成更详细的API文档：
@author：指定类或接口的作者。@version：指定类或接口的版本信息。@param：描述方法的参数，格式为@param 参数名 描述。@return：描述方法的返回值，适用于非void返回类型的方法。@throws或@exception：描述方法可能抛出的异常。@see：提供一个链接到相关类或方法的参考。@since：指定该功能从哪个版本开始可用。@deprecated：标记已废弃的类、方法或字段，并提供替代方案的说明。
示例：
/**
* Calculates the square root of a number.
*
* @param x the number to calculate the square root of
* @return the square root of x
* @throws IllegalArgumentException if x is negative
* @see Math#sqrt(double)
* @since 1.0
*/
public double sqrt(double x) {
if (x < 0) {
throw new IllegalArgumentException("Cannot calculate the square root of a negative number");
}
return Math.sqrt(x);
}3. 使用javadoc工具生成文档
使用javadoc工具可以自动生成HTML格式的API文档。通常在命令行中使用以下命令：
javadoc -d doc_directory YourClass.java-d doc_directory：指定生成文档的输出目录。YourClass.java：包含文档注释的Java源文件。
生成的文档通常包含类的说明、方法的详细描述、参数和返回值的信息等，是开发人员之间传递代码信息的重要工具。
4. 文档注释的最佳实践
- 简洁明了：文档注释应简洁明了，准确描述类、方法或字段的用途和行为。
- 覆盖全面：为每个公开的类、接口、方法、构造函数和字段添加文档注释，确保用户能够全面理解API。
- 更新及时：随着代码的更新，及时更新文档注释，保持文档与代码一致。
- 遵循标准格式：使用标准的Javadoc标签和格式，确保生成的文档清晰、易读。
总结
Java的文档注释是一种强大的工具，帮助开发人员生成易于理解的API文档。通过使用Javadoc注释和javadoc工具，开发人员可以提供详细的代码说明，提高代码的可维护性和可读性。
设计模式
单例模式
单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供全局访问点来访问该实例。单例模式在需要一个类只存在一个对象（如数据库连接、配置管理器、线程池等）的情况下非常有用。
1. 单例模式的关键点
- 唯一实例：单例模式通过限制实例化次数，确保一个类只有一个实例存在。
- 全局访问：单例模式提供一个全局访问点，通过该访问点可以获取唯一的实例。
2. 实现单例模式的几种方法
单例模式在Java中有多种实现方式，主要包括以下几种：
2.1 饿汉式（Eager Initialization）
饿汉式单例在类加载时就创建了实例，因此线程安全，且无需同步。
示例：
public class Singleton {
// 在类加载时就创建实例
private static final Singleton instance = new Singleton();
// 私有构造函数，防止外部实例化
private Singleton() {}
// 提供全局访问点
public static Singleton getInstance() {
return instance;
}
}优点：
- 实现简单，线程安全。
缺点：
- 如果单例实例占用资源较多，但始终未被使用，会造成资源浪费。
2.2 懒汉式（Lazy Initialization）
懒汉式单例在第一次调用getInstance()方法时才创建实例，节约资源。
示例：
public class Singleton {
// 初始时不创建实例
private static Singleton instance;
// 私有构造函数
private Singleton() {}
// 提供全局访问点，并在第一次使用时创建实例
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}优点：
- 实例在需要时才创建，节约资源。
缺点：
- 在多线程环境下不安全，可能会创建多个实例。
2.3 线程安全的懒汉式（Synchronized Method）
为了解决懒汉式的线程安全问题，可以对getInstance()方法进行同步。
示例：
public class Singleton {
private static Singleton instance;
private Singleton() {}
// 使用 synchronized 关键字保证线程安全
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}优点：
- 线程安全。
缺点：
synchronized带来一定的性能开销，特别是在频繁调用时。
2.4 双重检查锁（Double-Checked Locking）
双重检查锁在确保线程安全的同时，减少了同步的开销。
示例：
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}优点：
- 线程安全，且性能较好。
缺点：
- 实现稍微复杂，容易出错。
2.5 静态内部类（Bill Pugh Singleton）
静态内部类方式利用了类加载的特性，只有在实际使用内部类时，才会加载和创建实例，线程安全且实现简单。
示例：
public class Singleton {
private Singleton() {}
// 静态内部类，只有在调用 getInstance() 时才会加载
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}优点：
- 实现简单，线程安全，且延迟加载实例。
缺点：
- 无明显缺点，是一种推荐的单例实现方式。
2.6 枚举单例（Enum Singleton）
使用枚举实现单例是一种极为简洁的方式，且天然支持序列化和线程安全。
示例：
public enum Singleton {
INSTANCE;
public void someMethod() {
// 方法实现
}
}优点：
- 实现最简单，线程安全，防止反序列化创建新的对象。
缺点：
- 灵活性较差，枚举的写法不适合懒加载。
3. 单例模式的优缺点
优点：
- 内存节省：避免创建多余的对象，节省内存。
- 全局访问：提供一个全局访问点，方便使用。
- 可控实例化：集中控制实例化过程，避免重复创建。
缺点：
- 扩展困难：单例类较难扩展，因为它的结构决定了只有一个实例。
- 隐藏依赖：单例的全局访问可能导致不良的依赖关系，增加代码的耦合度。
4. 单例模式的应用场景
- 资源管理器：如线程池、数据库连接池等，确保资源唯一且被全局访问。
- 配置管理器：读取配置文件并在应用程序中共享配置数据。
- 日志记录器：确保整个应用程序中的日志输出统一管理。
总结
单例模式是一种常用的设计模式，通过确保类只有一个实例，可以避免重复创建对象带来的资源浪费。实现单例模式有多种方式，各有优缺点，开发者应根据具体场景选择合适的实现方式。枚举单例被认为是最简洁和推荐的方式，特别是在涉及序列化和反射攻击的情况下。
GUI
Java GUI（图形用户界面）编程主要使用两大库：AWT（Abstract Window Toolkit） 和 Swing，其中 Swing 是 AWT 的扩展和增强，提供了更丰富的组件和更好的跨平台支持。
一、Java GUI 编程概述
- AWT：Java 的早期 GUI 工具包，依赖于本地操作系统的 GUI 实现，使用重量级组件。AWT 的组件通常与操作系统的原生窗口小部件一一对应，因此其外观和行为依赖于操作系统。
- Swing：基于 AWT 的轻量级 GUI 工具包，提供更丰富的 UI 组件（如按钮、文本框、表格等）和更好的可移植性。Swing 独立于操作系统，可以跨平台运行，并且有自己的绘图机制来渲染组件。
在实际开发中，Swing 是最常用的 Java GUI 框架，它为构建桌面应用程序提供了强大的工具。
二、Swing 编程基础
Swing 是 Java 基础类库（JFC，Java Foundation Classes）的一部分，提供了丰富的组件和容器类。所有 Swing 组件都位于 javax.swing 包中。
1. Swing 的核心类
JFrame：顶层容器，代表一个窗口。JPanel：中间容器，用于组织和布局组件。JButton、JLabel、JTextField、JTextArea：基本组件，分别表示按钮、标签、文本框和多行文本区。JMenuBar、JMenu、JMenuItem：用于创建菜单栏和菜单项。
2. 创建一个简单的 Swing 应用程序
下面是一个简单的 Java Swing 应用程序，它创建了一个窗口，并在窗口中添加了一个按钮：
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class SimpleSwingApp {
public static void main(String[] args) {
// 创建一个 JFrame 窗口
JFrame frame = new JFrame("简单的 Swing 应用程序");
frame.setSize(400, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLayout(null); // 使用绝对布局
// 创建一个按钮
JButton button = new JButton("点击我");
button.setBounds(150, 100, 100, 50); // 设置按钮位置和大小
// 添加按钮点击事件监听器
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(frame, "按钮被点击了！");
}
});
// 将按钮添加到 JFrame 中
frame.add(button);
// 显示窗口
frame.setVisible(true);
}
}代码说明：
JFrame：创建一个窗口对象，并设置其大小、标题和关闭操作。JButton：创建一个按钮组件，并通过setBounds()方法设置其在窗口中的位置和大小。ActionListener：添加按钮的点击事件监听器，当按钮被点击时，会弹出一个消息对话框。
三、Swing 组件和布局管理器
Swing 提供了丰富的 GUI 组件和布局管理器，用于构建复杂的用户界面。
1. 常用 Swing 组件
JButton：按钮。JLabel：标签，用于显示文本或图像。JTextField：单行文本输入框。JTextArea：多行文本输入框。JCheckBox：复选框。JRadioButton：单选按钮。JComboBox：下拉列表。JList：列表。JTable：表格。JTree：树形结构。JProgressBar：进度条。
2. 布局管理器
布局管理器负责管理组件在容器中的排列方式。Swing 提供了多种布局管理器，如下所示：
FlowLayout：按顺序从左到右排列组件，默认情况下在 JPanel 中使用。BorderLayout：将容器分为东南西北中五个区域，每个区域最多只能添加一个组件，默认在 JFrame 中使用。GridLayout：将容器划分为网格，每个单元格大小相同。BoxLayout：按水平或垂直方向排列组件。GridBagLayout：最复杂和最强大的布局管理器，允许精确控制组件的布局。
布局管理示例：FlowLayout
import javax.swing.JButton;
import javax.swing.JFrame;
import java.awt.FlowLayout;
public class FlowLayoutExample {
public static void main(String[] args) {
JFrame frame = new JFrame("FlowLayout 示例");
frame.setSize(300, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// 设置布局管理器为 FlowLayout
frame.setLayout(new FlowLayout());
// 添加按钮
frame.add(new JButton("按钮 1"));
frame.add(new JButton("按钮 2"));
frame.add(new JButton("按钮 3"));
// 显示窗口
frame.setVisible(true);
}
}布局管理示例：BorderLayout
import javax.swing.JButton;
import javax.swing.JFrame;
import java.awt.BorderLayout;
public class BorderLayoutExample {
public static void main(String[] args) {
JFrame frame = new JFrame("BorderLayout 示例");
frame.setSize(400, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// 设置布局管理器为 BorderLayout
frame.setLayout(new BorderLayout());
// 添加按钮到不同区域
frame.add(new JButton("北"), BorderLayout.NORTH);
frame.add(new JButton("南"), BorderLayout.SOUTH);
frame.add(new JButton("东"), BorderLayout.EAST);
frame.add(new JButton("西"), BorderLayout.WEST);
frame.add(new JButton("中"), BorderLayout.CENTER);
// 显示窗口
frame.setVisible(true);
}
}四、事件处理
Java 使用事件驱动机制来处理 GUI 组件的用户交互。每个 GUI 组件都有相应的事件监听器接口来处理特定的用户事件。
1. 常见事件监听器接口
ActionListener：用于处理按钮、菜单项等组件的点击事件。MouseListener：用于处理鼠标点击、进入、退出等事件。KeyListener：用于处理键盘按键事件。WindowListener：用于处理窗口事件（如窗口关闭、最小化等）。
2. 添加事件监听器
通过调用组件的 addXXXListener() 方法来注册事件监听器，如 addActionListener() 注册按钮点击事件监听器。
JButton button = new JButton("点击我");
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("按钮被点击了！");
}
});五、JavaFX：Java 的现代 GUI 框架
尽管 Swing 仍然被广泛使用，但 JavaFX 是 Java 的现代 GUI 框架，提供了更丰富的 GUI 组件、动画支持和更强大的样式功能（CSS）。JavaFX 已成为构建现代 Java 桌面应用程序的首选工具。
示例：JavaFX 简单应用
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
public class JavaFXExample extends Application {
@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("JavaFX 示例");
Button button = new Button("点击我");
button.setOnAction(e -> System.out.println("按钮被点击了！"));
StackPane root = new StackPane();
root.getChildren().add(button);
Scene scene = new Scene(root, 300, 250);
primaryStage.setScene(scene);
primaryStage.show();
}
public static void main(String[] args) {
launch(args);
}
}六、总结
Java 提供了多种 GUI 编程工具和框架。Swing 是经典的 GUI 框架，适用于构建跨平台的桌面应用程序，而 JavaFX 提供了更现代的 GUI 设计和更强大的功能。根据需求和项目特点，选择合适的框架进行开发。
Java 常用类和API
Java 提供了丰富的类库和 API，涵盖了各种常用功能和工具类。这些类库和 API 是 Java 开发的基础，帮助开发者完成诸如字符串处理、集合操作、日期时间处理、文件 I/O 操作、网络编程等各种任务。下面将详细介绍一些 Java 常用的类和 API。
一、Java 核心类库
Java 核心类库主要位于 java.lang、java.util、java.io、java.net、java.time 等包中，这些类库提供了基本的编程功能。
1. java.lang 包
java.lang 包是 Java 语言的基础包，包含了 Java 语言的核心类，如 Object、String、Math 等。
Object类：所有 Java 类的超类，提供了equals()、hashCode()、toString()、clone()等方法。String类：不可变的字符串类，用于表示和操作字符串。常用方法有substring()、indexOf()、replace()、split()、toUpperCase()等。StringBuilder和StringBuffer类：用于可变字符串的操作。StringBuilder非线程安全，性能更高；StringBuffer线程安全，适用于多线程环境。Math类：提供数学运算方法，如abs()、max()、min()、pow()、sqrt()、sin()、cos()、random()等。System类：提供系统相关功能，如标准输入输出、环境变量、系统属性等。常用方法有System.out.println()、System.currentTimeMillis()、System.arraycopy()等。Thread类：用于多线程编程，提供了创建和管理线程的功能。
2. java.util 包
java.util 包包含了集合框架、日期时间、随机数生成器等实用工具类。
- 集合框架：
List接口及其实现类：如ArrayList、LinkedList，用于存储有序的元素集合。Set接口及其实现类：如HashSet、LinkedHashSet、TreeSet，用于存储无序且唯一的元素集合。Map接口及其实现类：如HashMap、LinkedHashMap、TreeMap，用于存储键值对。Queue接口及其实现类：如LinkedList（双端队列）、PriorityQueue，用于存储按照某种顺序进行处理的元素集合。
- 日期时间类：
Date类：表示特定的瞬间（已过时，不推荐使用）。Calendar类：用于操作日期时间（已过时，不推荐使用）。TimeZone类：用于表示时区。Locale类：用于表示地区、语言环境。
- 工具类：
Random类：用于生成随机数。Collections类：包含用于操作集合（如排序、查找、线程安全等）的静态方法。Arrays类：包含用于操作数组（如排序、查找等）的静态方法。
3. java.io 包
java.io 包提供了输入输出（I/O）相关的类，支持文件 I/O、网络 I/O、序列化等功能。
- 输入流和输出流：
- 字节流：
InputStream、OutputStream及其子类（如FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream）。 - 字符流：
Reader、Writer及其子类（如FileReader、FileWriter、BufferedReader、BufferedWriter）。
- 字节流：
- 文件操作类：
File类：用于表示文件和目录，提供了创建、删除、重命名文件等功能。FileReader和FileWriter类：用于读取和写入字符文件。BufferedReader和BufferedWriter类：用于高效读取和写入字符文件。
- 序列化：
Serializable接口：用于表示一个类的对象可以序列化（将对象转换为字节流）。ObjectInputStream和ObjectOutputStream类：用于对象的序列化和反序列化。
4. java.net 包
java.net 包提供了进行网络编程的类，支持 TCP、UDP、HTTP 等协议。
URL类：表示一个统一资源定位符（Uniform Resource Locator），用于访问网络资源。URLConnection类：表示一个到 URL 所引用的远程对象的通信链接。Socket类：实现客户端的套接字，支持 TCP 网络通信。ServerSocket类：实现服务器端的套接字，支持 TCP 网络通信。DatagramSocket类：实现无连接的 UDP 网络通信。
5. java.time 包
java.time 包是 Java 8 引入的用于处理日期和时间的类库，替代了过时的 java.util.Date 和 java.util.Calendar 类。
LocalDate类：表示一个没有时间的日期。LocalTime类：表示一个不带日期的时间。LocalDateTime类：表示一个日期时间。ZonedDateTime类：表示带有时区的日期时间。Period类：表示日期的差异。Duration类：表示时间的差异。DateTimeFormatter类：用于格式化和解析日期时间。
二、Java 常用工具类和 API
1. java.util.regex 包
java.util.regex 包提供了正则表达式 API，用于模式匹配和文本操作。
Pattern类：表示编译后的正则表达式。Matcher类：用于在输入字符串中匹配正则表达式。PatternSyntaxException类：表示正则表达式的语法错误。
2. java.util.concurrent 包
java.util.concurrent 包提供了线程安全的集合、执行器框架、同步工具和原子变量等，用于并发编程。
- 线程池：
Executor、ExecutorService、ScheduledExecutorService、ThreadPoolExecutor等。 - 同步工具：
CountDownLatch、CyclicBarrier、Semaphore、Exchanger等。 - 原子变量：
AtomicInteger、AtomicLong、AtomicReference等。 - 并发集合：
ConcurrentHashMap、CopyOnWriteArrayList、CopyOnWriteArraySet等。
3. java.security 包
java.security 包提供了加密、数字签名、密钥生成和验证、消息摘要等安全功能。
- 消息摘要：
MessageDigest类用于计算消息的摘要（如 SHA-256）。 - 密钥生成：
KeyGenerator类用于生成对称加密密钥。 - 数字签名：
Signature类用于生成和验证数字签名。 - 加密/解密：
Cipher类用于加密和解密数据。
三、示例代码
示例：使用 LocalDate 和 LocalDateTime
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class DateTimeExample {
public static void main(String[] args) {
// 获取当前日期
LocalDate date = LocalDate.now();
System.out.println("Current Date: " + date);
// 获取当前日期时间
LocalDateTime dateTime = LocalDateTime.now();
System.out.println("Current DateTime: " + dateTime);
// 自定义格式化日期时间
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDateTime = dateTime.format(formatter);
System.out.println("Formatted DateTime: " + formattedDateTime);
}
}示例：使用 Pattern 和 Matcher 进行正则表达式匹配
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexExample {
public static void main(String[] args) {
String text = "The quick brown fox jumps over the lazy dog.";
String patternString = "\\b[a-zA-Z]{4}\\b"; // 匹配长度为4的单词
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(text);
while (matcher.find()) {
System.out.println
("Found: " + matcher.group());
}
}
}四、总结
Java 提供了广泛的类库和 API，涵盖了几乎所有常见的编程需求。掌握这些类和 API 是成为 Java 开发者的基础，通过熟悉它们可以提高开发效率和代码质量。建议在实际开发中多加练习和应用这些类库，深入理解其工作原理和最佳实践。