基础知识 - 分类 - 咔咔不太卡的博客

Java 泛型详解

咔咔 — Sun, 12 Apr 2026 15:00:00 +0800

泛型概述

泛型（Generics）是 Java 5 引入的参数化类型机制，允许在定义类、接口和方法时使用类型参数，从而实现代码的复用和类型安全。

泛型类

        
        
        
    
// 定义泛型类
public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

// 使用
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");
String value = stringBox.getContent(); // 无需强制类型转换

泛型方法

        
        
        
    
public class Util {
    // 泛型方法
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    // 有界类型参数
    public static <T extends Comparable<T>> T findMax(T a, T b) {
        return a.compareTo(b) > 0 ? a : b;
    }
}

通配符

无边界的通配符

        
List unknownList = new ArrayList<String>();
// 可以读取，但不能添加（除 null 外）
Object obj = unknownList.get(0);
// unknownList.add("test"); // 编译错误

上界通配符

        
        
        
    
// 可以读取 Number 及其子类
public double sum(List extends Number> numbers) {
    double total = 0;
    for (Number num : numbers) {
        total += num.doubleValue();
    }
    return total;
}

// 使用
sum(Arrays.asList(1, 2, 3));      // Integer
sum(Arrays.asList(1.5, 2.5));     // Double

下界通配符

        
        
        
    
// 可以添加 Integer 及其父类
public void addNumbers(List super Integer> list) {
    list.add(1);
    list.add(2);
    list.add(3);
}

// 使用
List<Number> numbers = new ArrayList<>();
addNumbers(numbers);

PECS 原则

Producer Extends, Consumer Super

Java 核心特性详解：从基础到进阶

咔咔 — Fri, 10 Apr 2026 16:30:00 +0800

Java 作为一门历经二十余年依然活跃的编程语言，其设计理念和技术特性值得每一位开发者深入理解。本文将从核心特性出发，详细解析 Java 的技术优势与实现原理。

Java 异常处理机制详解

咔咔 — Thu, 09 Apr 2026 15:00:00 +0800

异常概述

异常（Exception）是程序运行过程中发生的不正常事件，中断了程序的正常执行流程。

异常体系结构

        
        
        
    
Throwable
├── Error（严重错误，不应捕获）
│   ├── OutOfMemoryError
│   ├── StackOverflowError
│   └── ...
└── Exception（程序可处理）
    ├── RuntimeException（运行时异常）
    │   ├── NullPointerException
    │   ├── ArrayIndexOutOfBoundsException
    │   ├── IllegalArgumentException
    │   └── ...
    └── 其他异常（受检异常）
        ├── IOException
        ├── SQLException
        ├── ClassNotFoundException
        └── ...

异常分类

1. 受检异常（Checked Exception）

编译时检查
必须处理或声明抛出
继承自 Exception 但不是 RuntimeException

        
// 必须处理
public void readFile() throws IOException {
    FileReader reader = new FileReader("file.txt");
}

2. 非受检异常（Unchecked Exception）

运行时检查
不强制处理
继承自 RuntimeException

        
// 不强制处理，但应该避免
public void divide(int a, int b) {
    int result = a / b;  // 可能抛出 ArithmeticException
}

异常处理

try-catch

        
        
        
    
try {
    // 可能抛出异常的代码
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // 处理异常
    System.out.println("除数不能为0");
}

多个 catch

        
        
        
    
try {
    // 可能抛出多种异常
    int[] arr = new int[5];
    arr[10] = 100;
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("数组越界");
} catch (Exception e) {
    System.out.println("其他异常");
}

注意：子类异常在前，父类异常在后。

Java Stream API 详解

咔咔 — Thu, 09 Apr 2026 13:00:00 +0800

什么是 Stream

Stream 是 Java 8 引入的函数式编程特性，用于对集合数据进行高效、声明式的操作。

特点：

链式操作，代码简洁
支持并行处理
惰性求值，性能优化
不修改原数据源

创建 Stream

        
        
        
    
import java.util.stream.*;
import java.util.*;

// 1. 从集合创建
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream1 = list.stream();
Stream<String> parallelStream = list.parallelStream();

// 2. 从数组创建
Stream<String> stream2 = Arrays.stream(new String[]{"a", "b", "c"});

// 3. 使用 Stream.of
Stream<String> stream3 = Stream.of("a", "b", "c");

// 4. 无限流
Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2).limit(10);
Stream<Double> randomStream = Stream.generate(Math::random).limit(5);

// 5. 从文件创建（IO流）
Stream<String> lines = Files.lines(Paths.get("file.txt"));

// 6. 空流
Stream<String> emptyStream = Stream.empty();

中间操作（Intermediate Operations）

中间操作返回新的 Stream，可以链式调用。

Java 集合框架详解

咔咔 — Thu, 09 Apr 2026 10:00:00 +0800

概述

Java 集合框架（Java Collections Framework）是 Java 提供的一套用于存储和操作一组数据的类和接口。它是 Java 编程中最常用的工具之一。

集合体系结构

        
        
        
    
Collection
├── List（有序、可重复）
│   ├── ArrayList
│   ├── LinkedList
│   └── Vector
│       └── Stack
├── Set（无序、不可重复）
│   ├── HashSet
│   │   └── LinkedHashSet
│   └── TreeSet
└── Queue（队列）
    ├── LinkedList
    ├── PriorityQueue
    └── Deque
        ├── ArrayDeque
        └── LinkedList

Map（键值对）
├── HashMap
│   └── LinkedHashMap
├── TreeMap
├── Hashtable
│   └── Properties
└── ConcurrentHashMap

List 详解

ArrayList vs LinkedList

ArrayList

基于动态数组实现，查询快、插入删除慢。