java 入门教程（非常详细！1.6w+ 文字）

先序: 学习编程语言要先学个表面，刚开始只用学焦点的部分，一些细节、不常用的内容先放着，现用现查即可；把常用的东西弄熟练了在慢慢补充。
1. Java 概述

Java 是一种面向对象的编程语言，由 Sun Microsystems（如今的 Oracle）在 1995 年推出。Java 程序可以在任何支持 Java 捏造机 (JVM) 的装备上运行。Java 的焦点理念是“一次编写，随处运行”。
2. 根本语法

2.1 Java 程序结构

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

1. public class Hello
2. World {
3.     public static void main(String[] args) {
4.         System.out.println("Hello, World!");
5.     }
6. }

复制代码

• public class Hello
  World：界说一个名为 Hello
  World 的公共类。
  
• 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
  

1. int number = 10;
2. float pi = 3.14f;
3. char letter = 'A';
4. boolean isJavaFun = true;

复制代码

3.2 引用数据范例

引用数据范例包罗类 (class), 接口 (interface), 数组 (array)，以及枚举 (enum)。
4. 运算符

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

• 算术运算符：+, -, *, /, %
  
• 赋值运算符：=, +=, -=, *=, /=, %=
  
• 比力运算符：==, !=, >, =, >>
  

1. int a = 5;
2. int b = 10;
3. int sum = a + b; // 加法
4. boolean isEqual = (a == b); // 比较

复制代码

5. 判定和循环

5.1 条件语句

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

1. if (a > b) {
2.     System.out.println("a is greater than b");
3. } else if (a < b) {
4.     System.out.println("a is less than b");
5. } else {
6.     System.out.println("a is equal to b");
7. }
9. switch (a) {
10.     case 1:
11.         System.out.println("a is 1");
12.         break;
13.     case 2:
14.         System.out.println("a is 2");
15.         break;
16.     default:
17.         System.out.println("a is not 1 or 2");
18. }

复制代码

5.2 循环语句

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

1. for (int i = 0; i < 5; i++) {
2.     System.out.println(i);
3. }
5. int j = 0;
6. while (j < 5) {
7.     System.out.println(j);
8.     j++;
9. }
11. int k = 0;
12. do {
13.     System.out.println(k);
14.     k++;
15. } while (k < 5);

复制代码

5.3 常用遍历方法

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

1.1 使用 for 循环

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

1. int[] numbers = {1, 2, 3, 4, 5};
2. for (int i = 0; i < numbers.length; i++) {
3.     System.out.println(numbers[i]);
4. }

复制代码

这里的 i 是数组的索引，通过 numbers 获取数组元素。
1.2 使用增强型 for 循环（for-each 循环）

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

1. int[] numbers = {1, 2, 3, 4, 5};
2. for (int number : numbers) {
3.     System.out.println(number);
4. }

复制代码

这种方法直接获取数组中的每个元素，语法简洁。
2. 遍历字符串的方法

2.1 使用 for 循环

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

1. String text = "Hello";
2. for (int i = 0; i < text.length(); i++) {
3.     System.out.println(text.charAt(i));
4. }

复制代码

charAt(i) 方法返回字符串中第 i 个字符。
2.2 使用增强型 for 循环（for-each 循环）

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

1. String text = "Hello";
2. for (char ch : text.toCharArray()) {
3.     System.out.println(ch);
4. }

复制代码

toCharArray() 方法将字符串转换为字符数组，然后举行遍历。
2.3 使用 Stream API

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

1. String text = "Hello";
2. text.chars().forEach(c -> System.out.println((char) c));

复制代码

chars() 方法返回一个包含字符的 IntStream，需要将 int 范例转换为 char 范例。
3. 其他的遍历方法

3.1 使用迭代器（Iterator）

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

1. List<String> list = Arrays.asList("A", "B", "C");
2. Iterator<String> iterator = list.iterator();
3. while (iterator.hasNext()) {
4.     System.out.println(iterator.next());
5. }

复制代码

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

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

1. List<String> list = Arrays.asList("A", "B", "C");
2. list.forEach(System.out::println);
4. Map<Integer, String> map = new HashMap<>();
5. map.put(1, "One");
6. map.put(2, "Two");
7. map.forEach((key, value) -> System.out.println(key + " = " + value));

复制代码

这种方法语法简洁，尤其适合使用 Lambda 表达式举行处理。
6. 数组

数组是雷同数据范例的聚集，可以存储固定大小的元素。

1. int[] numbers = new int[5];
2. numbers[0] = 1;
3. numbers[1] = 2;
4. // 其他元素初始化
6. int[] primes = {2, 3, 5, 7, 11};
7. System.out.println(primes[0]); // 输出第一个元素

复制代码

7. 面向对象编程

面向对象编程 (OOP) 是 Java 的焦点概念，以下是几个紧张的面向对象概念：
7.1 接口

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

1. interface Animal {
2.     void eat();
3.     void sleep();
4. }
6. class Dog implements Animal {
7.     @Override
8.     public void eat() {
9.         System.out.println("Dog eats");
10.     }
12.     @Override
13.     public void sleep() {
14.         System.out.println("Dog sleeps");
15.     }
16. }
18. public class Main {
19.     public static void main(String[] args) {
20.         Dog dog = new Dog();
21.         dog.eat();
22.         dog.sleep();
23.     }
24. }

复制代码

7.2 抽象类

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

1. abstract class Animal {
2.     abstract void makeSound();
4.     public void sleep() {
5.         System.out.println("Sleeping...");
6.     }
7. }
9. class Dog extends Animal {
10.     @Override
11.     public void makeSound() {
12.         System.out.println("Bark");
13.     }
14. }
16. public class Main {
17.     public static void main(String[] args) {
18.         Dog dog = new Dog();
19.         dog.makeSound();
20.         dog.sleep();
21.     }
22. }

复制代码

7.3 继承

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

1. class Animal {
2.     public void eat() {
3.         System.out.println("Animal eats");
4.     }
5. }
7. class Dog extends Animal {
8.     @Override
9.     public void eat() {
10.         System.out.println("Dog eats");
11.     }
12. }
14. public class Main {
15.     public static void main(String[] args) {
16.         Dog dog = new Dog();
17.         dog.eat();
18.     }
19. }

复制代码

7.4 多态

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

1. class Animal {
2.     public void makeSound() {
3.         System.out.println("Some sound");
4.     }
5. }
7. class Dog extends Animal {
8.     @Override
9.     public void makeSound() {
10.         System.out.println("Bark");
11.     }
12. }
14. class Cat extends Animal {
15.     @Override
16.     public void makeSound() {
17.         System.out.println("Meow");
18.     }
19. }
21. public class Main {
22.     public static void main(String[] args) {
23.         Animal myDog = new Dog();
24.         Animal myCat = new Cat();
25.         myDog.makeSound();
26.         myCat.makeSound();
27.     }
28. }

复制代码

8. 输入输出 (I/O)

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

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

1. import java.util.Scanner;
3. public class ScannerExample {
4.     public static void main(String[] args) {
5.         Scanner scanner = new Scanner(System.in);
7.         System.out.print("请输入您的名字: ");
8.         String name = scanner.nextLine(); // 读取整行输入
9.         System.out.println("你好, " + name + "!");
11.         System.out.print("请输入您的年龄: ");
12.         int age = scanner.nextInt(); // 读取整数输入
13.         System.out.println("您 " + age + " 岁了!");
15.         scanner.close(); // 关闭 Scanner
16.     }
17. }

复制代码

常用方法：

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

BufferedReader 类

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

示例代码：

1. import java.io.BufferedReader;
2. import java.io.IOException;
3. import java.io.InputStreamReader;
5. public class BufferedReaderExample {
6.     public static void main(String[] args) throws IOException {
7.         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
9.         System.out.print("请输入您的名字: ");
10.         String name = reader.readLine(); // 读取整行输入
11.         System.out.println("你好, " + name + "!");
13.         System.out.print("请输入您的年龄: ");
14.         int age = Integer.parseInt(reader.readLine()); // 读取整行输入并解析为整数
15.         System.out.println("您 " + age + " 岁了!");
17.         reader.close(); // 关闭 BufferedReader
18.     }
19. }

复制代码

常用方法：

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

对比 Scanner 和 BufferedReader

雷同点：

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

不同点：

• 功能：
  
  
  
  • Scanner 提供了更多解析输入数据的方法，如 nextInt(), nextDouble() 等，可以直接读取根本范例数据。
    
  • BufferedReader 主要用于读取字符串，需要手动解析根本范例数据。
    
  
  
• 性能：
  
  
  
  • BufferedReader 通常性能更高，因为它使用缓冲机制，适合读取大量文本数据。
    
  • Scanner 在方便性上有优势，但性能可能稍逊色。
    
  
  
• 使用场景：
  
  
  
  • Scanner 更适合处理交互式的终端输入，或者需要解析各种根本范例数据的场景。
    
  • BufferedReader 更适合读取大量文本数据，或者需要更高效的输入操作的场景。
    
  
  

8.2 文件操作

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

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

1. import java.io.BufferedReader;
2. import java.io.FileReader;
3. import java.io.IOException;
5. public class FileRead {
6.     public static void main(String[] args) {
7.         try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
8.             String line;
9.             while ((line = br.readLine()) != null) {
10.                 System.out.println(line);
11.             }
12.         } catch (IOException e) {
13.             e.printStackTrace();
14.         }
15.     }
16. }

复制代码

写入文件

使用 BufferedWriter 将数据写入文件。

1. import java.io.BufferedWriter;
2. import java.io.FileWriter;
3. import java.io.IOException;
5. public class FileWrite {
6.     public static void main(String[] args) {
7.         try (BufferedWriter bw = new BufferedWriter(new FileWriter("test.txt"))) {
8.             bw.write("Hello, World!");
9.         } catch (IOException e) {
10.             e.printStackTrace();
11.         }
12.     }
13. }

复制代码

8.3 输出

将数据输出到控制台。
1. System.out.print()

• 示例:
  1. // 输出内容到控制台，末尾没有换行
  2. System.out.print("Hello");
  3. System.out.print("World");

  复制代码
  输出:
  1. Hello
  2. World

  复制代码

2. System.out.println()

• 示例:
  1. // 输出内容到控制台，并在内容后自动添加换行符。
  2. System.out.println("Hello");
  3. System.out.println("World");

  复制代码
• 输出:
  1. Hello
  2. World

  复制代码

3. System.out.printf()

• 用法: System.out.printf(formatString, arguments);
  
• 示例:
  1. //  使用格式化字符串输出内容，类似于 C 语言中的 `printf`。允许你使用格式说明符控制输出的格式。
  2. int age = 25;
  3. double height = 1.75;
  4. System.out.printf("Age: %d years\n", age);
  5. System.out.printf("Height: %.2f meters\n", height);

  复制代码
  输出:
  1. Age: 25 years
  2. 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(): 返回列表中元素的数目。
  

示例代码：

1. import java.util.ArrayList;
2. import java.util.List;
4. public class ArrayListExample {
5.     public static void main(String[] args) {
6.         List<String> list = new ArrayList<>();
7.         list.add("Apple");
8.         list.add("Banana");
9.         list.add("Cherry");
11.         System.out.println("List: " + list);
12.         System.out.println("Element at index 1: " + list.get(1));
14.         list.set(1, "Blueberry");
15.         System.out.println("Updated List: " + list);
17.         list.remove(0);
18.         System.out.println("List after removal: " + list);
19.     }
20. }

复制代码

LinkedList

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

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

常用方法：

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

示例代码：

1. import java.util.LinkedList;
2. import java.util.List;
4. public class LinkedListExample {
5.     public static void main(String[] args) {
6.         List<String> list = new LinkedList<>();
7.         list.add("Apple");
8.         list.add("Banana");
9.         list.add("Cherry");
11.         System.out.println("List: " + list);
12.         System.out.println("Element at index 1: " + list.get(1));
14.         list.set(1, "Blueberry");
15.         System.out.println("Updated List: " + list);
17.         list.remove(0);
18.         System.out.println("List after removal: " + list);
19.     }
20. }

复制代码

Set 接口

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

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

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

常用方法：

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

示例代码：

1. import java.util.HashSet;
2. import java.util.Set;
4. public class HashSetExample {
5.     public static void main(String[] args) {
6.         Set<String> set = new HashSet<>();
7.         set.add("Apple");
8.         set.add("Banana");
9.         set.add("Cherry");
10.         set.add("Apple"); // 重复元素
12.         System.out.println("Set: " + set);
13.         System.out.println("Set contains 'Banana': " + set.contains("Banana"));
15.         set.remove("Banana");
16.         System.out.println("Set after removal: " + set);
17.     }
18. }

复制代码

TreeSet

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

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

常用方法：

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

示例代码：

1. import java.util.Set;
2. import java.util.TreeSet;
4. public class TreeSetExample {
5.     public static void main(String[] args) {
6.         Set<String> set = new TreeSet<>();
7.         set.add("Banana");
8.         set.add("Apple");
9.         set.add("Cherry");
11.         System.out.println("Set: " + set);
12.         System.out.println("Set contains 'Banana': " + set.contains("Banana"));
14.         set.remove("Banana");
15.         System.out.println("Set after removal: " + set);
16.     }
17. }

复制代码

Map 接口

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

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

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

常用方法：

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

示例代码：

1. import java.util.HashMap;
2. import java.util.Map;
4. public class HashMapExample {
5.     public static void main(String[] args) {
6.         Map<String, Integer> map = new HashMap<>();
7.         map.put("Apple", 1);
8.         map.put("Banana", 2);
9.         map.put("Cherry", 3);
11.         System.out.println("Map: " + map);
12.         System.out.println("Value for 'Banana': " + map.get("Banana"));
14.         map.remove("Banana");
15.         System.out.println("Map after removal: " + map);
16.     }
17. }

复制代码

TreeMap

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

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

常用方法：

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

示例代码：

1. import java.util.Map;
2. import java.util.TreeMap;
4. public class TreeMapExample {
5.     public static void main(String[] args) {
6.         Map<String, Integer> map = new TreeMap<>();
7.         map.put("Banana", 2);
8.         map.put("Apple", 1);
9.         map.put("Cherry", 3);
11.         System.out.println("Map: " + map);
12.         System.out.println("Value for 'Banana': " + map.get("Banana"));
14.         map.remove("Banana");
15.         System.out.println("Map after removal: " + map);
16.     }
17. }

复制代码

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。
  

示例代码：

1. import java.util.LinkedList;
2. import java.util.Queue;
4. public class QueueExample {
5.     public static void main(String[] args) {
6.         Queue<String> queue = new LinkedList<>();
7.         queue.add("Apple");
8.         queue.offer("Banana");
9.         queue.add("Cherry");
11.         System.out.println("Queue: " + queue);
12.         System.out.println("Head of the queue: " + queue.peek());
14.         queue.remove();
15.         System.out.println("Queue after removal: " + queue);
17.         queue.poll();
18.         System.out.println("Queue after poll: " + queue);
19.     }
20. }

复制代码

PriorityQueue

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

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

常用方法与 LinkedList 雷同：

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

示例代码：

1. import java.util.PriorityQueue;
2. import java.util.Queue;
4. public class PriorityQueueExample {
5.     public static void main(String[] args) {
6.         Queue<String> queue = new PriorityQueue<>();
7.         queue.add("Banana");
8.         queue.offer("Apple");
9.         queue.add("Cherry");
11.         System.out.println("PriorityQueue: " + queue);
12.         System.out.println("Head of the queue: " + queue.peek());
14.         queue.remove();
15.         System.out.println("PriorityQueue after removal: " + queue);
17.         queue.poll();
18.         System.out.println("PriorityQueue after poll: " + queue);
19.     }
20. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。