先序: 学习编程语言要先学个轮廓，刚开始只用学核心的部分，一些细节、不常用的内容先放着，现用现查即可；把常用的东西弄熟练了在慢慢补充。

1. Java 概述

Java 是一种面向对象的编程语言，由 Sun Microsystems（现在的 Oracle）在 1995 年推出。Java 程序可以在任何支持 Java 虚拟机 (JVM) 的设备上运行。Java 的核心理念是“一次编写，到处运行”。

2. 基本语法

2.1 Java 程序结构

每个 Java 程序都由类 (class) 和方法 (method) 组成。以下是一个简单的 Java 程序示例：

<code>public class HelloWorld {

public static void main(String[] args) {

System.out.println("Hello, World!");

}

}

• public class HelloWorld：定义一个名为 HelloWorld 的公共类。
• public static void main(String[] args)：主方法，是程序的入口点。
• System.out.println("Hello, World!");：打印一行文本到控制台。

2.2 注释

Java 支持三种类型的注释：

• 单行注释：使用 //
• 多行注释：使用 /* ... */
• 文档注释：使用 /** ... */

3. 数据类型

Java 的数据类型分为两大类：基本数据类型 (primitive types) 和引用数据类型 (reference types)。

3.1 基本数据类型

• 整型：byte, short, int, long
• 浮点型：float, double
• 字符型：char
• 布尔型：boolean

int number = 10;

float pi = 3.14f;

char letter = 'A';

boolean isJavaFun = true;

3.2 引用数据类型

引用数据类型包括类 (class), 接口 (interface), 数组 (array)，以及枚举 (enum)。

4. 运算符

Java 提供了丰富的运算符，包括：

• 算术运算符：+, -, *, /, %
• 赋值运算符：=, +=, -=, *=, /=, %=
• 比较运算符：==, !=, >, <, >=, <=
• 逻辑运算符：&&, ||, !
• 位运算符：&, |, ^, ~, <<, >>, >>>

int a = 5;

int b = 10;

int sum = a + b; // 加法

boolean isEqual = (a == b); // 比较

5. 判断和循环

5.1 条件语句

• if 语句：用于条件判断
• switch 语句：用于多分支选择

if (a > b) {

System.out.println("a is greater than b");

} else if (a < b) {

System.out.println("a is less than b");

} else {

System.out.println("a is equal to b");

}

switch (a) {

case 1:

System.out.println("a is 1");

break;

case 2:

System.out.println("a is 2");

break;

default:

System.out.println("a is not 1 or 2");

}

5.2 循环语句

• for 循环：用于固定次数的循环
• while 循环：用于条件控制的循环
• do-while 循环：至少执行一次的循环

for (int i = 0; i < 5; i++) {

System.out.println(i);

}

int j = 0;

while (j < 5) {

System.out.println(j);

j++;

}

int k = 0;

do {

System.out.println(k);

k++;

} while (k < 5);

5.3 常用遍历方法

在 Java 中，遍历数组和字符串是常见的操作。下面详细介绍几种常用的遍历方法。

1. 遍历数组的方法

1.1 使用 for 循环

传统的 for 循环是遍历数组的常见方法：

int[] numbers = {1, 2, 3, 4, 5};

for (int i = 0; i < numbers.length; i++) {

System.out.println(numbers[i]);

}

这里的 i 是数组的索引，通过 numbers[i] 获取数组元素。

1.2 使用增强型 for 循环（for-each 循环）

增强型 for 循环简化了数组的遍历，不需要使用索引：

int[] numbers = {1, 2, 3, 4, 5};

for (int number : numbers) {

System.out.println(number);

}

这种方法直接获取数组中的每个元素，语法简洁。

2. 遍历字符串的方法

2.1 使用 for 循环

字符串可以看作是字符数组，可以用 for 循环逐个字符地遍历：

String text = "Hello";

for (int i = 0; i < text.length(); i++) {

System.out.println(text.charAt(i));

}

charAt(i) 方法返回字符串中第 i 个字符。

2.2 使用增强型 for 循环（for-each 循环）

虽然增强型 for 循环不能直接用于 String，但可以将字符串转换为字符数组后进行遍历：

String text = "Hello";

for (char ch : text.toCharArray()) {

System.out.println(ch);

}

toCharArray() 方法将字符串转换为字符数组，然后进行遍历。

2.3 使用 Stream API

同样地，可以使用 Stream API 来遍历字符串：

String text = "Hello";

text.chars().forEach(c -> System.out.println((char) c));

chars() 方法返回一个包含字符的 IntStream，需要将 int 类型转换为 char 类型。

3. 其他的遍历方法

3.1 使用迭代器（Iterator）

对于集合类（如 List、Set 等），可以使用 Iterator 进行遍历：

List<String> list = Arrays.asList("A", "B", "C");

Iterator<String> iterator = list.iterator();

while (iterator.hasNext()) {

System.out.println(iterator.next());

}

Iterator 提供了 hasNext() 和 next() 方法，用于顺序访问集合中的元素。

3.2 使用 forEach 方法

Java 8 引入的 forEach 方法可以直接用于遍历集合和 Map：

List<String> list = Arrays.asList("A", "B", "C");

list.forEach(System.out::println);

Map<Integer, String> map = new HashMap<>();

map.put(1, "One");

map.put(2, "Two");

map.forEach((key, value) -> System.out.println(key + " = " + value));

这种方法语法简洁，尤其适合使用 Lambda 表达式进行处理。

6. 数组

数组是相同数据类型的集合，可以存储固定大小的元素。

int[] numbers = new int[5];

numbers[0] = 1;

numbers[1] = 2;

// 其他元素初始化

int[] primes = {2, 3, 5, 7, 11};

System.out.println(primes[0]); // 输出第一个元素

7. 面向对象编程

面向对象编程 (OOP) 是 Java 的核心概念，以下是几个重要的面向对象概念：

7.1 接口

接口是一种抽象类型，定义了类必须实现的方法。接口中的所有方法默认都是抽象的（没有方法体），且所有字段默认都是 public static final。

interface Animal {

void eat();

void sleep();

}

class Dog implements Animal {

@Override

public void eat() {

System.out.println("Dog eats");

}

@Override

public void sleep() {

System.out.println("Dog sleeps");

}

}

public class Main {

public static void main(String[] args) {

Dog dog = new Dog();

dog.eat();

dog.sleep();

}

}

7.2 抽象类

抽象类是不能被实例化的类，可以包含抽象方法和具体方法。抽象方法必须在子类中实现。

abstract class Animal {

abstract void makeSound();

public void sleep() {

System.out.println("Sleeping...");

}

}

class Dog extends Animal {

@Override

public void makeSound() {

System.out.println("Bark");

}

}

public class Main {

public static void main(String[] args) {

Dog dog = new Dog();

dog.makeSound();

dog.sleep();

}

}

7.3 继承

继承是指一个类（子类）继承另一个类（父类）的属性和方法。子类可以扩展或重写父类的方法。

class Animal {

public void eat() {

System.out.println("Animal eats");

}

}

class Dog extends Animal {

@Override

public void eat() {

System.out.println("Dog eats");

}

}

public class Main {

public static void main(String[] args) {

Dog dog = new Dog();

dog.eat();

}

}

7.4 多态

多态允许同一个接口在不同的实现中表现出不同的行为。它是通过方法重载和方法重写实现的。

class Animal {

public void makeSound() {

System.out.println("Some sound");

}

}

class Dog extends Animal {

@Override

public void makeSound() {

System.out.println("Bark");

}

}

class Cat extends Animal {

@Override

public void makeSound() {

System.out.println("Meow");

}

}

public class Main {

public static void main(String[] args) {

Animal myDog = new Dog();

Animal myCat = new Cat();

myDog.makeSound();

myCat.makeSound();

}

}

8. 输入输出 (I/O)

Java 的 I/O 库提供了丰富的类和接口，用于文件操作、数据流操作、网络通信等。

Scanner 类

Scanner 类是 Java 5 引入的，用于从各种输入源读取数据，例如控制台输入、文件、字符串等。它提供了一系列方便的方法来解析基本类型和字符串。

下面给的示例代码都是从控制台获取输入

import java.util.Scanner;

public class ScannerExample {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.print("请输入您的名字: ");

String name = scanner.nextLine(); // 读取整行输入

System.out.println("你好, " + name + "!");

System.out.print("请输入您的年龄: ");

int age = scanner.nextInt(); // 读取整数输入

System.out.println("您 " + age + " 岁了!");

scanner.close(); // 关闭 Scanner

}

}

常用方法：

• nextLine(): 读取一整行输入，返回一个字符串。
• nextLine().charAt(0): 读取一行字符串中的第一个，一般用这个读取char类型变量。
• nextInt(): 读取一个整数。
• nextDouble(): 读取一个双精度浮点数。
• nextBoolean(): 读取一个布尔值。
• hasNext(): 检查是否有下一个输入。
• hasNextLine(): 检查是否有下一行输入。
• close(): 关闭 Scanner。

BufferedReader 类

BufferedReader 类用于从字符输入流中读取文本，提供了缓冲功能以提高读取效率。它通常与 InputStreamReader 一起使用，从标准输入或文件读取数据。

使用 BufferedReader 从终端读取数据

示例代码：

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class BufferedReaderExample {

public static void main(String[] args) throws IOException {

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

System.out.print("请输入您的名字: ");

String name = reader.readLine(); // 读取整行输入

System.out.println("你好, " + name + "!");

System.out.print("请输入您的年龄: ");

int age = Integer.parseInt(reader.readLine()); // 读取整行输入并解析为整数

System.out.println("您 " + age + " 岁了!");

reader.close(); // 关闭 BufferedReader

}

}

常用方法：

• readLine(): 读取一整行输入，返回一个字符串。
• close(): 关闭 BufferedReader。

对比 Scanner 和 BufferedReader

相同点：

1. 都可以用于从终端、文件等源读取输入。
2. 都提供了读取整行输入的方法：nextLine() 和 readLine()。

不同点：

1. 功能：

   • Scanner 提供了更多解析输入数据的方法，如 nextInt(), nextDouble() 等，可以直接读取基本类型数据。
   • BufferedReader 主要用于读取字符串，需要手动解析基本类型数据。

2. 性能：

   • BufferedReader 通常性能更高，因为它使用缓冲机制，适合读取大量文本数据。
   • Scanner 在方便性上有优势，但性能可能稍逊色。

3. 使用场景：

   • Scanner 更适合处理交互式的终端输入，或者需要解析各种基本类型数据的场景。
   • BufferedReader 更适合读取大量文本数据，或者需要更高效的输入操作的场景。

8.2 文件操作

Java 提供了多种文件操作类，如 FileReader, FileWriter, BufferedReader, BufferedWriter。

读取文件

使用 BufferedReader 从文件中读取数据。

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

public class FileRead {

public static void main(String[] args) {

try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {

String line;

while ((line = br.readLine()) != null) {

System.out.println(line);

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

写入文件

使用 BufferedWriter 将数据写入文件。

import java.io.BufferedWriter;

import java.io.FileWriter;

import java.io.IOException;

public class FileWrite {

public static void main(String[] args) {

try (BufferedWriter bw = new BufferedWriter(new FileWriter("test.txt"))) {

bw.write("Hello, World!");

} catch (IOException e) {

e.printStackTrace();

}

}

}

8.3 输出

将数据输出到控制台。

1. System.out.print()

• 示例:

  // 输出内容到控制台，末尾没有换行

  System.out.print("Hello");

  System.out.print("World");

  输出:

  HelloWorld

2. System.out.println()

• 示例:

  // 输出内容到控制台，并在内容后自动添加换行符。

  System.out.println("Hello");

  System.out.println("World");

• 输出:

  Hello

  World

3. System.out.printf()

• 用法: System.out.printf(formatString, arguments);
• 示例:

  // 使用格式化字符串输出内容，类似于 C 语言中的 `printf`。允许你使用格式说明符控制输出的格式。

  int age = 25;

  double height = 1.75;

  System.out.printf("Age: %d years\n", age);

  System.out.printf("Height: %.2f meters\n", height);

  输出:

  Age: 25 years

  Height: 1.75 meters

常用格式说明符

• 整数:
  • %d: 十进制整数
  • %x: 十六进制整数
• 浮点数:
  • %f: 浮点数
  • %.2f: 浮点数，保留两位小数
• 字符串:
  • %s: 字符串
• 字符:
  • %c: 单个字符
• 百分比:
  • %%: 输出百分号 %

总结

• System.out.print(): 用于输出内容，不换行。
• System.out.println(): 用于输出内容并换行。
• System.out.printf(): 用于格式化输出内容。

9、Java 集合框架

String常用方法

1. 创建与初始化

• String()：创建一个空字符串。
• String(String original)：创建一个新的字符串，内容为指定的 String。

2. 字符串操作

• concat(String str)：连接指定字符串到当前字符串末尾。
• substring(int beginIndex)：从指定索引开始，返回子字符串。
• substring(int beginIndex, int endIndex)：返回从 beginIndex 到 endIndex 之间的子字符串。

3. 查找与比较

• indexOf(String str)：返回指定子字符串第一次出现的索引。
• lastIndexOf(String str)：返回指定子字符串最后一次出现的索引。
• contains(CharSequence sequence)：判断当前字符串是否包含指定字符序列。
• equals(Object anObject)：比较两个字符串的内容是否相等。
• equalsIgnoreCase(String anotherString)：忽略大小写比较两个字符串的内容是否相等。
• compareTo(String anotherString)：按字典顺序比较两个字符串。

4. 替换与转换

• replace(char oldChar, char newChar)：替换字符串中的所有指定字符为新字符。
• replaceAll(String regex, String replacement)：用正则表达式匹配并替换匹配的部分。
• toLowerCase()：将字符串转换为小写。
• toUpperCase()：将字符串转换为大写.
• trim()：去除字符串首尾的空白字符。

5. 分割与连接

• split(String regex)：根据正则表达式分割字符串，返回字符串数组。
• join(CharSequence delimiter, CharSequence... elements)：使用指定的分隔符连接多个字符序列。

6. 其他

• charAt(int index)：返回指定索引处的字符。java的String不可以通过str[0]这样的方式访问
• length()：返回字符串的长度。
• isEmpty()：判断字符串是否为空（长度为0）。
• toCharArray()：将字符串转换为字符数组。
• startsWith(String prefix)：判断字符串是否以指定的前缀开始。
• endsWith(String suffix)：判断字符串是否以指定的后缀结束。
• matches(String regex)：判断字符串是否匹配给定的正则表达式。

List 接口

List 是一个有序的集合，可以包含重复元素。常用实现类有 ArrayList 和 LinkedList。

ArrayList

ArrayList 是一个基于动态数组的数据结构，提供了快速的随机访问能力。它的主要特点是：

• 动态调整数组大小：当元素超过数组容量时，ArrayList 会自动扩展。
• 访问元素速度快：由于底层是数组，通过索引访问元素的时间复杂度为 O(1)。
• 插入和删除操作相对较慢：插入或删除元素时，可能需要移动数组中的其他元素，时间复杂度为 O(n)。

常用方法：

• add(E e): 添加元素到列表末尾。
• get(int index): 获取指定索引位置的元素。
• set(int index, E element): 替换指定索引位置的元素。
• remove(int index): 移除指定索引位置的元素。
• size(): 返回列表中元素的数量。

示例代码：

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("Cherry");

System.out.println("List: " + list);

System.out.println("Element at index 1: " + list.get(1));

list.set(1, "Blueberry");

System.out.println("Updated List: " + list);

list.remove(0);

System.out.println("List after removal: " + list);

}

}

LinkedList

LinkedList 是一个基于双向链表的数据结构，提供了高效的插入和删除操作。它的主要特点是：

• 链表节点：每个元素都是一个节点，包含元素值以及指向前一个和后一个节点的指针。
• 插入和删除速度快：插入和删除元素时只需调整指针，时间复杂度为 O(1)。
• 访问元素速度慢：由于需要从头开始遍历链表，通过索引访问元素的时间复杂度为 O(n)。

常用方法：

• add(E e): 添加元素到列表末尾。
• get(int index): 获取指定索引位置的元素。
• set(int index, E element): 替换指定索引位置的元素。
• remove(int index): 移除指定索引位置的元素。
• size(): 返回列表中元素的数量。

示例代码：

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("Cherry");

System.out.println("List: " + list);

System.out.println("Element at index 1: " + list.get(1));

list.set(1, "Blueberry");

System.out.println("Updated List: " + list);

list.remove(0);

System.out.println("List after removal: " + list);

}

}

Set 接口

Set 是一个不包含重复元素的集合。常用实现类有 HashSet 和 TreeSet。

HashSet

HashSet 基于哈希表实现，元素没有顺序。它的主要特点是：

• 无序集合：元素没有特定的顺序。
• 不允许重复元素：如果添加重复元素，HashSet 会忽略它。
• 高效的插入、删除和查找操作：时间复杂度为 O(1)。

常用方法：

• add(E e): 添加元素到集合中。
• remove(Object o): 从集合中移除指定元素。
• contains(Object o): 检查集合是否包含指定元素。
• size(): 返回集合中元素的数量。

示例代码：

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("Cherry");

set.add("Apple"); // 重复元素

System.out.println("Set: " + set);

System.out.println("Set contains 'Banana': " + set.contains("Banana"));

set.remove("Banana");

System.out.println("Set after removal: " + set);

}

}

TreeSet

TreeSet 基于红黑树实现，元素是有序的。它的主要特点是：

• 有序集合：元素按照自然顺序或自定义顺序排序。
• 不允许重复元素：如果添加重复元素，TreeSet 会忽略它。
• 较高的插入、删除和查找操作性能：时间复杂度为 O(log n)。

常用方法：

• add(E e): 添加元素到集合中。
• remove(Object o): 从集合中移除指定元素。
• contains(Object o): 检查集合是否包含指定元素。
• size(): 返回集合中元素的数量。

示例代码：

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("Cherry");

System.out.println("Set: " + set);

System.out.println("Set contains 'Banana': " + set.contains("Banana"));

set.remove("Banana");

System.out.println("Set after removal: " + set);

}

}

Map 接口

Map 是一个键值对的集合，每个键最多只能关联一个值。常用实现类有 HashMap 和 TreeMap。

HashMap

HashMap 基于哈希表实现，键值对没有顺序。它的主要特点是：

• 无序集合：键值对没有特定的顺序。
• 不允许重复键：如果添加重复键，HashMap 会覆盖旧值。
• 高效的插入、删除和查找操作：时间复杂度为 O(1)。

常用方法：

• put(K key, V value): 添加键值对到映射中。
• get(Object key): 获取指定键的值。
• remove(Object key): 从映射中移除指定键值对。
• containsKey(Object key): 检查映射是否包含指定键。
• size(): 返回映射中键值对的数量。

示例代码：

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", 1);

map.put("Banana", 2);

map.put("Cherry", 3);

System.out.println("Map: " + map);

System.out.println("Value for 'Banana': " + map.get("Banana"));

map.remove("Banana");

System.out.println("Map after removal: " + map);

}

}

TreeMap

TreeMap 基于红黑树实现，键值对是有序的。它的主要特点是：

• 有序集合：键值对按照键的自然顺序或自定义顺序排序。
• 不允许重复键：如果添加重复键，TreeMap 会覆盖旧值。
• 较高的插入、删除和查找操作性能：时间复杂度为 O(log n)。

常用方法：

• put(K key, V value): 添加键值对到映射中。
• get(Object key): 获取指定键的值。
• remove(Object key): 从映射中移除指定键值对。
• containsKey(Object key): 检查映射是否包含指定键。
• size(): 返回映射中键值对的数量。

示例代码：

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", 2);

map.put("Apple", 1);

map.put("Cherry", 3);

System.out.println("Map: " + map);

System.out.println("Value for 'Banana': " + map.get("Banana"));

map.remove("Banana");

System.out.println("Map after removal: " + map);

}

}

Queue 接口

Queue 是一个先进先出的集合，常用实现类有 LinkedList 和 PriorityQueue。

LinkedList

LinkedList 实现了 Queue 接口，提供了基于链表的队列实现。它的主要特点是：

• 双向链表：可以作为队列（FIFO）和双端队列（Deque）使用。
• 高效的插入和删除操作：时间复杂度为 O(1)。

常用方法：

• add(E e): 将指定元素插入此队列的末尾。
• offer(E e): 将指定元素插入此队列的末尾，如果成功则返回 true，如果队列已满则返回 false（一般不检查队列是否满）。
• remove(): 检索并移除此队列的头部元素。
• poll(): 检索并移除此队列的头部元素，如果此队列为空，则返回 null。
• element(): 检索但不移除此队列的头部元素。
• peek(): 检索但不移除此队列的头部元素，如果此队列为空，则返回 null。

示例代码：

import java.util.LinkedList;

import java.util.Queue;

public class QueueExample {

public static void main(String[] args) {

Queue<String> queue = new LinkedList<>();

queue.add("Apple");

queue.offer("Banana");

queue.add("Cherry");

System.out.println("Queue: " + queue);

System.out.println("Head of the queue: " + queue.peek());

queue.remove();

System.out.println("Queue after removal: " + queue);

queue.poll();

System.out.println("Queue after poll: " + queue);

}

}

PriorityQueue

PriorityQueue 是一个基于优先级堆（最小堆或最大堆）的队列，元素按自然顺序或自定义顺序排序。它的主要特点是：

• 无界优先级队列：元素按照优先级排序，不一定是先进先出（FIFO）。
• 默认最小堆：自然顺序为最小堆，可自定义比较器实现最大堆。
• 高效的插入和删除操作：时间复杂度为 O(log n)。

常用方法与 LinkedList 类似：

• add(E e): 将指定元素插入此队列。
• offer(E e): 将指定元素插入此队列。
• remove(): 检索并移除此队列的头部元素。
• poll(): 检索并移除此队列的头部元素，如果此队列为空，则返回 null。
• element(): 检索但不移除此队列的头部元素。
• peek(): 检索但不移除此队列的头部元素，如果此队列为空，则返回 null。

示例代码：

import java.util.PriorityQueue;

import java.util.Queue;

public class PriorityQueueExample {

public static void main(String[] args) {

Queue<String> queue = new PriorityQueue<>();

queue.add("Banana");

queue.offer("Apple");

queue.add("Cherry");

System.out.println("PriorityQueue: " + queue);

System.out.println("Head of the queue: " + queue.peek());

queue.remove();

System.out.println("PriorityQueue after removal: " + queue);

queue.poll();

System.out.println("PriorityQueue after poll: " + queue);

}

}