【建议收藏合集整理】国一大佬带你，蓝桥杯Java组拿奖基础知识整理集合，看完，3天冲蓝桥杯省一。

---

前文引导

此文章为系统训练，建议反复观看，将所有例题的知识点掌握，文章结尾将分享新手如何通过3天达到冲击蓝桥杯省一的实力。

蓝桥杯Java知识点记忆（必须熟练记忆）

（1）输入输出

题解

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		while (scanner.hasNext()) {
			int a = scanner.nextInt();
			int b = scanner.nextInt();
			int c = a + b;
			System.out.println(c);
		}
	}
}

知识点记忆

这段代码涵盖了Java中的输入输出（IO）知识点，具体来说是使用了Scanner类和System.out.println方法。

1. 导入Scanner类：

   import java.util.Scanner;

   这行代码是用来导入Java标准库中的Scanner类，Scanner类提供了一种简单的方式来从标准输入中获取用户输入。

2. 定义main方法：

   public static void main(String[] args) {}

   这是Java程序的入口点，程序从这里开始执行。

3. 创建Scanner对象：

   Scanner scanner = new Scanner(System.in);

   这行代码创建了一个Scanner对象，它与标准输入流（System.in）相关联，以便从键盘读取用户的输入。

4. 读取整数输入：

   int a = scanner.nextInt();

   这行代码使用Scanner对象的nextInt()方法读取用户输入的整数，并将其存储在变量a中。

5. 输出结果：

   System.out.println();

   这行代码使用System.out.println()方法将结果打印到标准输出流（通常是控制台）。在这个例子中，括号内没有参数，因此仅打印一个空行。

（2）加减乘除

题解

import java.util.Scanner;
public class Main{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);	
		while(scanner.hasNext()){
			int a = scanner.nextInt();
			int b = scanner.nextInt();
			int c = scanner.nextInt();	
			System.out.println((a+b)*c);
		}
	}
}

 知识点记忆

System.out.println() 是Java标准库中用于输出信息的方法。它的作用是将指定的内容打印到标准输出流（通常是控制台），并在最后添加一个换行符，以使输出的内容换行显示。下面来详细讲解它的使用方法：

基本用法

System.out.println(); // 打印空行，只输出一个换行符

以上代码将在控制台输出一个空行。

打印字符串

System.out.println("Hello, world!"); // 打印字符串，输出 Hello, world!

可以将需要输出的字符串作为参数传递给 System.out.println() 方法，它会将字符串内容打印到控制台。

打印变量或表达式的值

int number = 42; System.out.println("The answer is: " + number); // 打印带有变量值的字符串

可以将变量或表达式的值与其他文本一起打印出来。在上面的示例中，输出的结果将是 "The answer is: 42"。

打印多个值

int a = 10; int b = 20; System.out.println("a = " + a + ", b = " + b); // 打印多个变量的值

多个值可以通过字符串拼接的方式一起输出。在这个例子中，输出的结果将是 "a = 10, b = 20"。

格式化输出

double pi = 3.14159; System.out.printf("The value of pi is %.2f", pi); // 使用格式化输出

除了 System.out.println()，Java还提供了 System.out.printf() 方法来实现格式化输出。可以使用格式说明符指定输出的格式，例如 %.2f 表示保留两位小数输出。在上面的示例中，输出的结果将是 "The value of pi is 3.14"。

打印特殊字符

System.out.println("This is a tab:\t\tand this is a new line.\n"); // 打印特殊字符

在字符串中可以使用特殊的转义序列，如 \t 表示水平制表符（Tab），\n 表示换行符。上面的示例展示了如何在输出中使用这些特殊字符。

注意事项

• System.out.println() 是线程安全的，可以在多线程环境下使用。
• System.out.println() 总是会在输出内容的末尾添加一个换行符，以使输出内容换行显示。
• 输出的内容可以是任意类型，Java会自动将其转换为字符串并输出。

通过灵活运用 System.out.println() 方法，可以方便地进行调试和输出信息，帮助理解程序的执行过程和结果。

（3） 取余

题解

import java.util.Scanner;
public class Main{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		while(scanner.hasNext()){		
			int a = scanner.nextInt();			
			 if(a % 4 == 0 && a % 100 != 0 || a % 400 == 0){			 
				 System.out.println("Y");
			 }		 
			 else{
				 System.out.println("N");
			 }	
		}	
	}
}

知识点记忆

在 Java 中，取余操作使用 % 运算符，也称为模运算符。取余操作用于计算除法的余数。下面是取余操作的基本用法和一些示例：

int a = 10; int b = 3; int remainder = a % b; System.out.println("10 除以 3 的余数是：" + remainder); // 输出结果为：1

在这个示例中，a 除以 b 的余数是 1。

取余操作也适用于负数。例如：

int c = -10; int d = 3; int remainder2 = c % d; System.out.println("-10 除以 3 的余数是：" + remainder2); // 输出结果为：-1

在这个示例中，-10 除以 3 的余数是 -1。

需要注意的是，取余操作的结果的符号与被除数的符号相同。这意味着，如果被除数是正数，那么余数也是正数；如果被除数是负数，那么余数也是负数。取余操作的结果的绝对值永远不会超过除数的绝对值。

另外，Java 中的取余操作也适用于浮点数，但不建议在浮点数上使用取余操作，因为浮点数的精度问题可能导致不可预测的结果。通常情况下，应该避免在浮点数上执行取余操作。

（4） 字符串

1、使用 nextLine() 方法获取一行输入：

Scanner scan = new Scanner(System.in);
String s = scan.nextLine();
System.out.println("输入的字符串是：" + s);

2、使用 charAt(int index) 方法获取指定索引位置的字符：

String str = "Hello";
char c = str.charAt(2);
System.out.println("索引位置2的字符是：" + c); // 输出 "l"

3、使用 indexOf(int ch) 方法查找字符在字符串中的索引位置：

String text = "Hello World";
int index = text.indexOf('o');
System.out.println("字符 'o' 第一次出现的索引位置是：" + index); // 输出 "4"

4、使用 compareTo(String anotherString) 方法比较字符串的字典顺序：

String str1 = "abc";
String str2 = "def";
int result = str1.compareTo(str2);
System.out.println("比较结果：" + result); // 输出 "-3"，因为 "abc" 在字典顺序上小于 "def"

5、使用 concat(String str) 方法连接两个字符串：

String s1 = "Hello";
String s2 = "World";
String result = s1.concat(s2);
System.out.println("连接后的字符串：" + result); // 输出 "HelloWorld"

6、使用 length() 方法获取字符串的长度：

String str = "Hello";
int length = str.length();
System.out.println("字符串的长度是：" + length); // 输出 "5"

7、使用 equals(Object anObject) 方法比较字符串是否相等：

String s1 = "hello";
String s2 = "world";
boolean isEqual1 = s1.equals(s2);
boolean isEqual2 = s1.equals("hello");
System.out.println("s1 equals s2: " + isEqual1); // 输出 "false"
System.out.println("s1 equals \"hello\": " + isEqual2); // 输出 "true"

8、substring(int beginIndex, int endIndex) 方法：截取字符串的子串，从指定的起始索引（包括）到指定的结束索引（不包括）。

String str = "Hello World";
String substr = str.substring(6); // 截取从索引6开始到字符串结束的子串
System.out.println("截取的子串：" + substr); // 输出 "World"

9、toLowerCase() 和 toUpperCase() 方法：将字符串转换为小写或大写。

String str = "Hello";
String lowerCase = str.toLowerCase(); // 转换为小写
String upperCase = str.toUpperCase(); // 转换为大写
System.out.println("转换为小写：" + lowerCase); // 输出 "hello"
System.out.println("转换为大写：" + upperCase); // 输出 "HELLO"

10、trim() 方法：去除字符串前后的空格。

String str = "   Hello   ";
String trimmed = str.trim();
System.out.println("去除空格后的字符串：" + trimmed); // 输出 "Hello"

11、replace(char oldChar, char newChar) 方法：替换字符串中的字符。

String str = "Hello World";
String replaced = str.replace('o', 'x'); // 将字符 'o' 替换为 'x'
System.out.println("替换后的字符串：" + replaced); // 输出 "Hellx Wxrld"

12、startsWith(String prefix) 和 endsWith(String suffix) 方法：检查字符串是否以指定的前缀或后缀开头或结尾。

String str = "Hello World";
boolean startsWithHello = str.startsWith("Hello");
boolean endsWithWorld = str.endsWith("World");
System.out.println("是否以Hello开头：" + startsWithHello); // 输出 "true"
System.out.println("是否以World结尾：" + endsWithWorld); // 输出 "true"

（5）StringBuilder

当涉及到大量字符串操作或需要频繁修改字符串内容时，使用 StringBuilder 类可以提高效率。下面是一些使用Java字符串 StringBuilder 方法的具体例子：

追加字符串：

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World"); // 追加字符串
System.out.println(sb.toString()); // 输出 "Hello World"

插入字符串：

StringBuilder sb = new StringBuilder("Hello");
sb.insert(5, "World"); // 在索引5处插入字符串
System.out.println(sb.toString()); // 输出 "HelloWorld"

替换字符串：

StringBuilder sb = new StringBuilder("Hello World");
sb.replace(6, 11, "Java"); // 替换索引6到索引11之间的字符串为"Java"
System.out.println(sb.toString()); // 输出 "Hello Java"

删除字符：

StringBuilder sb = new StringBuilder("Hello World");
sb.delete(6, 11); // 删除索引6到索引11之间的字符
System.out.println(sb.toString()); // 输出 "Hello"

反转字符串：

StringBuilder sb = new StringBuilder("Hello");
sb.reverse(); // 反转字符串
System.out.println(sb.toString()); // 输出 "olleH"

获取长度和容量：

StringBuilder sb = new StringBuilder("Hello");
int length = sb.length(); // 获取字符串长度
int capacity = sb.capacity(); // 获取字符串容量
System.out.println("长度：" + length); // 输出 "5"
System.out.println("容量：" + capacity); // 输出 "16"，初始容量为16

清空字符串：

StringBuilder sb = new StringBuilder("Hello");
sb.delete(0, sb.length()); // 清空字符串内容
System.out.println(sb.toString()); // 输出 ""

（6）排序库的使用

Java 提供了多种排序算法和排序库，其中比较常用的是 Arrays.sort() 方法和 Collections.sort() 方法，分别用于对数组和集合进行排序。

使用 Arrays.sort() 对数组排序：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 6};
        Arrays.sort(arr); // 对数组进行升序排序
        System.out.println("升序排序后的数组：" + Arrays.toString(arr));
    }
}

使用 Collections.sort() 对集合排序：

import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(2);
        list.add(9);
        list.add(1);
        list.add(6);

        Collections.sort(list); // 对集合进行升序排序
        System.out.println("升序排序后的集合：" + list);
    }
}

如果需要对自定义对象进行排序，需要实现 Comparable 接口或者使用 Comparator 比较器。下面是一个使用 Comparable 接口进行对象排序的例子：

import java.util.ArrayList;
import java.util.Collections;

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }

    public String toString() {
        return name + " (" + age + ")";
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 30));
        people.add(new Person("Charlie", 20));

        Collections.sort(people); // 对Person对象按年龄升序排序
        System.out.println("按年龄升序排序后的Person对象：" + people);
    }
}

这些是基本的排序方法，根据具体情况选择合适的方式进行排序。

（7）队列的使用

1. add(element) 方法：将元素添加到队列的末尾。如果添加成功，则返回 true；如果队列已满，抛出异常。
2. poll() 方法：移除并返回队列的头部元素。如果队列为空，则返回 null。
3. peek() 方法：返回队列的头部元素，但不移除。如果队列为空，则返回 null。
4. empty() 方法：检查队列是否为空。如果队列为空，则返回 true；否则返回 false。

举例说明

使用 add(element) 方法添加元素到队列：

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        // 添加元素到队列
        queue.add(5);
        queue.add(10);
        queue.add(15);

        // 输出队列中的元素
        System.out.println("队列中的元素：" + queue); // 输出 "[5, 10, 15]"
    }
}

使用 poll() 方法移除并返回队列头部元素：

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        // 添加元素到队列
        queue.add(5);
        queue.add(10);
        queue.add(15);

        // 移除并返回队列头部元素
        int element = queue.poll();
        System.out.println("移除的队列头部元素：" + element); // 输出 "5"

        // 输出剩余队列中的元素
        System.out.println("剩余队列中的元素：" + queue); // 输出 "[10, 15]"
    }
}

使用 peek() 方法返回队列头部元素但不移除：

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        // 添加元素到队列
        queue.add(5);
        queue.add(10);
        queue.add(15);

        // 返回队列头部元素但不移除
        int frontElement = queue.peek();
        System.out.println("队列头部元素：" + frontElement); // 输出 "5"

        // 输出队列中的元素
        System.out.println("队列中的元素：" + queue); // 输出 "[5, 10, 15]"
    }
}

使用 empty() 方法检查队列是否为空：

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        // 添加元素到队列
        queue.add(5);
        queue.add(10);
        queue.add(15);

        // 检查队列是否为空
        boolean isEmpty = queue.isEmpty();
        System.out.println("队列是否为空：" + isEmpty); // 输出 "false"

        // 清空队列
        queue.clear();
        isEmpty = queue.isEmpty();
        System.out.println("清空后队列是否为空：" + isEmpty); // 输出 "true"
    }
}

这些例子演示了基础队列方法的使用，包括添加元素、移除元素、获取队列头部元素以及检查队列是否为空。

（8）栈的使用

1. push(element) 方法：将元素压入栈顶。
2. pop() 方法：从栈顶弹出元素并返回。
3. peek() 方法：查看栈顶元素但不移除。
4. isEmpty() 方法：判断栈是否为空。

你可以通过这些方法来操作栈，实现数据的压入、弹出、查看栈顶元素以及判断栈是否为空。

举例说明

使用 push(element) 方法将元素压入栈顶：

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        // 将元素压入栈顶
        stack.push(5);
        stack.push(10);
        stack.push(15);

        // 输出栈中的元素
        System.out.println("栈中的元素：" + stack); // 输出 "[5, 10, 15]"
    }
}

使用 pop() 方法从栈顶弹出元素：

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        // 将元素压入栈顶
        stack.push(5);
        stack.push(10);
        stack.push(15);

        // 弹出栈顶元素并返回
        int element = stack.pop();
        System.out.println("弹出的栈顶元素：" + element); // 输出 "15"

        // 输出剩余栈中的元素
        System.out.println("剩余栈中的元素：" + stack); // 输出 "[5, 10]"
    }
}

使用 peek() 方法查看栈顶元素但不移除：

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        // 将元素压入栈顶
        stack.push(5);
        stack.push(10);
        stack.push(15);

        // 查看栈顶元素但不移除
        int topElement = stack.peek();
        System.out.println("栈顶元素：" + topElement); // 输出 "15"

        // 输出栈中的元素
        System.out.println("栈中的元素：" + stack); // 输出 "[5, 10, 15]"
    }
}

使用 isEmpty() 方法判断栈是否为空：

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        // 判断栈是否为空
        boolean isEmpty = stack.isEmpty();
        System.out.println("栈是否为空：" + isEmpty); // 输出 "true"

        // 将元素压入栈顶
        stack.push(5);
        stack.push(10);

        // 再次判断栈是否为空
        isEmpty = stack.isEmpty();
        System.out.println("栈是否为空：" + isEmpty); // 输出 "false"
    }
}

这些例子演示了基础栈方法的使用，包括将元素压入栈顶、弹出栈顶元素、查看栈顶元素、判断栈是否为空等操作。

（9）List 和Map

List 和 Map 是 Java 中常用的集合类，用于存储和操作数据。List 是有序集合，可以存储重复元素；Map 是键值对的集合，每个键对应一个值，键不能重复。以下是关于 List 和 Map 的知识点和例子：

List 知识点：

1. ArrayList：基于数组实现的 List，支持动态扩容。
2. LinkedList：基于链表实现的 List，适合频繁插入、删除操作。
3. Vector：线程安全的 List，性能略低于 ArrayList。

List 常用方法：

• add(element)：向列表尾部添加元素。
• get(index)：获取指定位置的元素。
• remove(index)：移除指定位置的元素。
• size()：获取列表大小。
• isEmpty()：判断列表是否为空。

List 示例：

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();

        // 添加元素
        arrayList.add("Apple");
        arrayList.add("Banana");
        arrayList.add("Cherry");

        // 获取元素
        String fruit = arrayList.get(1);
        System.out.println("第二个元素：" + fruit); // 输出 "Banana"

        // 移除元素
        arrayList.remove(0);
        System.out.println("移除第一个元素后：" + arrayList); // 输出 "[Banana, Cherry]"

        // 判断是否为空
        boolean isEmpty = arrayList.isEmpty();
        System.out.println("列表是否为空：" + isEmpty); // 输出 "false"

        // 获取列表大小
        int size = arrayList.size();
        System.out.println("列表大小：" + size); // 输出 "2"
    }
}

Map 知识点：

1. HashMap：基于哈希表实现的 Map，查找速度快，无序。
2. TreeMap：基于红黑树实现的 Map，键有序。
3. LinkedHashMap：继承自 HashMap，保持元素插入顺序。

Map 常用方法：

• put(key, value)：添加键值对。
• get(key)：根据键获取值。
• remove(key)：移除指定键的键值对。
• containsKey(key)：判断是否包含指定键。
• size()：获取键值对数量。

Map 示例：

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> hashMap = new HashMap<>();

        // 添加键值对
        hashMap.put("Apple", 5);
        hashMap.put("Banana", 10);
        hashMap.put("Cherry", 15);

        // 获取值
        int quantity = hashMap.get("Banana");
        System.out.println("Banana 的数量：" + quantity); // 输出 "10"

        // 移除键值对
        hashMap.remove("Cherry");
        System.out.println("移除 Cherry 后：" + hashMap); // 输出 "{Apple=5, Banana=10}"

        // 判断是否包含键
        boolean containsKey = hashMap.containsKey("Apple");
        System.out.println("是否包含 Apple 键：" + containsKey); // 输出 "true"

        // 获取键值对数量
        int size = hashMap.size();
        System.out.println("键值对数量：" + size); // 输出 "2"
    }
}

这些知识点和示例涵盖了 List 和 Map 的基本概念和常用操作，希望能帮助到你理解它们的用法。

（10）一维数组二维数组

一维数组（Array）知识点：

1. 定义：一维数组是具有相同数据类型的元素按顺序排列的集合。
2. 长度：一维数组的长度在创建时就确定，无法改变。
3. 访问元素：通过索引访问数组元素，索引从 0 开始。
4. 初始化：可以使用静态初始化或动态初始化来创建数组。
5. 遍历：常用的遍历方法包括使用 for 循环或增强型 for 循环。

一维数组示例：

public class ArrayExample {
    public static void main(String[] args) {
        // 静态初始化一维数组
        int[] array1 = {1, 2, 3, 4, 5};

        // 动态初始化一维数组
        int[] array2 = new int[5];
        array2[0] = 10;
        array2[1] = 20;
        array2[2] = 30;
        array2[3] = 40;
        array2[4] = 50;

        // 访问元素
        System.out.println("第一个数组的第三个元素：" + array1[2]); // 输出 "3"
        System.out.println("第二个数组的第四个元素：" + array2[3]); // 输出 "40"

        // 遍历数组
        System.out.println("第一个数组元素：");
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + " ");
        }
        System.out.println();

        System.out.println("第二个数组元素：");
        for (int num : array2) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

二维数组（Array of Arrays）知识点：

1. 定义：二维数组是一种特殊的数组，每个元素又是一个一维数组。
2. 行和列：二维数组有行和列的概念，每行表示一个一维数组。
3. 初始化：可以使用静态初始化或动态初始化来创建二维数组。
4. 访问元素：通过两个索引访问二维数组中的元素。

二维数组示例：

public class TwoDimensionalArrayExample {
    public static void main(String[] args) {
        // 静态初始化二维数组
        int[][] array1 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        // 动态初始化二维数组
        int[][] array2 = new int[3][3];
        array2[0][0] = 1;
        array2[0][1] = 2;
        array2[0][2] = 3;
        array2[1][0] = 4;
        array2[1][1] = 5;
        array2[1][2] = 6;
        array2[2][0] = 7;
        array2[2][1] = 8;
        array2[2][2] = 9;

        // 访问元素
        System.out.println("第一个数组的第二行第三列元素：" + array1[1][2]); // 输出 "6"
        System.out.println("第二个数组的第一行第一列元素：" + array2[0][0]); // 输出 "1"

        // 遍历二维数组
        System.out.println("第一个数组元素：");
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                System.out.print(array1[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println("第二个数组元素：");
        for (int[] row : array2) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }
}

这些知识点和示例可以帮助你理解和使用 Java 中的一维数组和二维数组。

（11）哈希表set的使用

知识点：

1. 哈希表（HashSet）特点：

   • 不允许存储重复元素。
   • 不保证集合中元素的顺序，即不保证集合中元素的存储顺序和插入顺序一致。
   • 允许存储null元素。

2. 底层实现：

   • HashSet底层是由HashMap实现的，HashSet中的元素被存储为HashMap的key，value统一为一个占位对象（通常为PRESENT）。

3. 添加元素：

   • 使用add()方法向HashSet中添加元素。

4. 判断元素是否存在：

   • 使用contains()方法判断HashSet中是否包含某个元素。

5. 删除元素：

   • 使用remove()方法从HashSet中删除指定元素。

6. 遍历元素：

   • 可以使用增强for循环或迭代器来遍历HashSet中的元素。

示例代码：

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        // 创建一个HashSet
        HashSet<String> set = new HashSet<>();

        // 添加元素
        set.add("apple");
        set.add("banana");
        set.add("orange");

        // 判断元素是否存在
        boolean containsBanana = set.contains("banana");
        System.out.println("Contains 'banana': " + containsBanana);

        // 删除元素
        set.remove("orange");

        // 遍历集合
        System.out.println("Elements in set:");
        for (String element : set) {
            System.out.println(element);
        }
    }
}

在这个示例中，我们创建了一个HashSet对象，向其中添加了几个元素，然后检查了是否包含指定元素，删除了一个元素，并且最后遍历了HashSet中的所有元素。 

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        // 创建一个空的HashSet
        HashSet<String> set = new HashSet<>();

        // 添加元素
        set.add("apple");
        set.add("banana");
        set.add("orange");

        // 判断HashSet是否为空
        if (set.isEmpty()) {
            System.out.println("HashSet is empty");
        } else {
            System.out.println("HashSet is not empty");

            // 遍历集合
            System.out.println("Elements in set:");
            for (String element : set) {
                System.out.println(element);
            }
        }
    }
}

（12）scanner不同类型的输入方法和不同类型的输出方法

1. 读取整数

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入一个整数：");
        int num = scanner.nextInt();
        System.out.println("你输入的整数是：" + num);
        
        scanner.close();
    }
}

2. 读取浮点数

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入一个浮点数：");
        double num = scanner.nextDouble();
        System.out.println("你输入的浮点数是：" + num);
        
        scanner.close();
    }
}

3. 读取字符串

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入一个字符串：");
        String str = scanner.nextLine();
        System.out.println("你输入的字符串是：" + str);
        
        scanner.close();
    }
}

4. 读取布尔值

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入一个布尔值（true/false）：");
        boolean bool = scanner.nextBoolean();
        System.out.println("你输入的布尔值是：" + bool);
        
        scanner.close();
    }
}

5. 读取字符

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入一个字符：");
        char ch = scanner.next().charAt(0);
        System.out.println("你输入的字符是：" + ch);
        
        scanner.close();
    }
}

以上是一些常见的使用 Scanner 类不同类型输入方法的示例。根据你的需求，可以选择适当的方法来读取不同类型的输入数据。记得在使用完 Scanner 后调用 close() 方法来关闭输入流。

---

1. 输出整数

public class Main {
    public static void main(String[] args) {
        int num = 10;
        System.out.println("整数输出：" + num);
    }
}

2. 输出浮点数

public class Main {
    public static void main(String[] args) {
        double num = 3.14;
        System.out.println("浮点数输出：" + num);
    }
}

3. 输出字符串

public class Main {
    public static void main(String[] args) {
        String str = "Hello, world!";
        System.out.println("字符串输出：" + str);
    }
}

4. 格式化输出

public class Main {
    public static void main(String[] args) {
        String name = "Alice";
        int age = 30;
        double height = 1.75;
        System.out.printf("姓名：%s，年龄：%d，身高：%.2f\n", name, age, height);
    }
}

以上是一些常见的Java输出方法示例，你可以根据需要选择适合的方法来打印输出你的数据。