Java 核心知识点整理归纳

---

一、类中的代码块

类型	写法	执行时机	作用
静态代码块	static { }	类加载时执行，只执行一次	初始化静态资源
实例代码块	{ }	每次 new 对象 时，在构造方法之前执行	初始化实例资源

执行顺序（创建对象时）

静态代码块（类首次加载）
    ↓
实例代码块
    ↓
构造方法

示例

public class Demo {
    static {
        System.out.println("静态代码块");  // 类加载时执行 1 次
    }
    {
        System.out.println("实例代码块");  // 每次 new 都执行
    }
    public Demo() {
        System.out.println("构造方法");
    }
}

---

二、内部类

1. 成员内部类

• 定义在 类内部、方法外部
• 可以访问外部类的 私有成员
• 创建对象：外部类名.内部类名 对象 = 外部类对象.new 内部类();

public class Outer {
    private int x = 10;

    class Inner {
        void show() {
            System.out.println(x);  // 可访问外部类私有成员
        }
    }
}

// 使用
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

2. 匿名内部类

• 本质：一个没有名字的子类，同时也是该子类的 对象
• 写法：new 父类/接口() { 重写方法 }
• 用途：临时实现接口或继承类，只用一次的场景

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("匿名内部类");
    }
};

---

三、Lambda 表达式

1. 什么是函数式编程？有什么好处？

函数式编程：把 函数/行为 当作一等公民，强调 用函数描述“做什么”，而不是一步步描述“怎么做”。

好处：

• 代码更 简洁
• 可读性 更好
• 适合集合遍历、过滤、映射等场景
• 配合 Stream API 做链式数据处理

---

2. Lambda 是什么？有什么用？怎么写？

Lambda 是 JDK 8 新增的语法，代表 一个函数，用于 替代并简化函数式接口的匿名内部类。

语法格式：

(参数列表) -> { 方法体 }
(参数列表) -> 表达式          // 单行可省略 {} 和 return

对比：

// 匿名内部类
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("hello");
    }
};

// Lambda
Runnable r2 = () -> System.out.println("hello");

常见写法：

// 无参
() -> System.out.println("hi")

// 单参（可省略括号）
x -> x * 2

// 多参
(a, b) -> a + b

// 多行
(x, y) -> {
    int sum = x + y;
    return sum;
}

---

3. 什么是函数式接口？如何确保？

函数式接口：有且仅有 一个抽象方法 的接口（default、static 方法不算）。

如何确保：

@FunctionalInterface   // 编译期检查，不是函数式接口会报错
public interface MyFunc {
    void doSomething();
}

JDK 内置常见函数式接口：

接口	抽象方法	用途
Runnable	run()	无参无返回值
Supplier<T>	get()	无参有返回值
Consumer<T>	accept(T)	有参无返回值
Function<T,R>	apply(T)	有参有返回值
Predicate<T>	test(T)	判断 true/false

---

四、方法引用

方法引用是 Lambda 的 进一步简化，当 Lambda 只是 调用已有方法 时使用。

类型	写法	示例
静态方法引用	类名::静态方法	Integer::parseInt
实例方法引用	对象::实例方法	System.out::println
特定类型的实例方法	类名::实例方法	String::length
构造器引用	类名::new	ArrayList::new

// Lambda
list.forEach(s -> System.out.println(s));

// 方法引用（等价）
list.forEach(System.out::println);

---

五、String 常用 API

分类	方法	说明
长度/判空	length()	字符个数
	isEmpty()	是否为空串 ""
	isBlank() (JDK11+)	是否空白
查找	charAt(i)	取第 i 个字符
	indexOf(str)	首次出现位置，-1 表示没有
	contains(str)	是否包含
截取/替换	substring(begin, end)	截取子串
	replace(old, new)	替换
	trim()	去首尾空格
比较	equals(str)	内容比较（不要用 ==）
	equalsIgnoreCase(str)	忽略大小写比较
	compareTo(str)	字典序比较
转换	toUpperCase() / toLowerCase()	大小写
	split(regex)	按规则切割 → 数组
	valueOf(基本类型)	转成 String
拼接	+ 或 String.join(",", list)	字符串拼接

注意： String 是 不可变 的，每次修改都会创建新对象。频繁拼接用 StringBuilder。

---

六、数组 vs 集合

对比	数组	集合
长度	定义后 固定，不能变	可变，自动扩容
功能	基础，只有下标访问	丰富（增删改查、排序等）
类型	可存基本类型 + 引用类型	只能存 对象（基本类型用包装类）
使用场景	长度固定、性能敏感	开发中更常用

集合体系

Collection（单列）
├── List（有序、可重复）→ ArrayList、LinkedList
├── Set（无序、不重复）  → HashSet、TreeSet
└── Queue（队列）        → LinkedList、PriorityQueue

Map（键值对，双列）→ HashMap、TreeMap、Hashtable

---

七、ArrayList

特点

• 底层是 动态数组
• 查询快（按下标 O(1)）
• 增删慢（中间插入/删除需要移动元素）
• 有序、可重复、可存 null
• 线程不安全（多线程用 CopyOnWriteArrayList 或加锁）

常用 API

操作	方法
添加	add(e) / add(index, e)
删除	remove(index) / remove(Object)
修改	set(index, e)
查询	get(index) / size()
遍历	增强 for、forEach(Lambda)、迭代器
判断	contains(e) / isEmpty()
清空	clear()
转数组	toArray()

示例

ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add(0, "C");           // [C, A, B]

list.get(1);                // "A"
list.set(1, "D");           // [D, B]
list.remove("C");           // [D, B]

list.forEach(s -> System.out.println(s));  // Lambda 遍历

与 LinkedList 对比（常考）

	ArrayList	LinkedList
底层	数组	双向链表
查询	快	慢
增删（头尾）	一般	快
增删（中间）	慢	慢
内存	连续，开销小	节点指针，开销大
选用	查询多	增删多

---

八、知识脉络

类
├── 静态代码块 static{}     → 类加载时 1 次
├── 实例代码块 {}           → 每次 new 前
├── 内部类
│   ├── 成员内部类          → 外部类.new 内部类()
│   └── 匿名内部类          → new 接口/类(){}
└── Lambda                  → 简化函数式接口匿名类
    └── 方法引用 ::         → 进一步简化

数据容器
├── 数组                    → 长度固定
└── 集合
    └── ArrayList           → 动态数组，查询快，开发最常用