瓜瓜头条

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

2024-08-19 12:49 由 小程xy 发表于 #后端开发

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

1. Java 概述

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

2. 基本语法

2.1 Java 程序结构

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

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);
    }
}