JAVA基础知识总结(二)

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

JAVA基础知识总结(二)

---

在 Java 编程中，字符串操作、集合操作 和 数组操作 是非常常用且重要的概念。它们分别用于处理文本、动态集合和固定长度的数据集合。

1. 字符串操作

Java 中的字符串通过 String 类来处理。字符串是不可变的对象，即一旦创建，字符串的内容就无法更改。Java 中也提供了 StringBuilder 和 StringBuffer 类，允许进行可变字符串操作。

创建字符串

String str1 = "Hello";
String str2 = new String("World");

常见的字符串操作

1. 获取字符串长度：
   使用 length() 方法获取字符串的长度。

   int length = str1.length();  // 5
   

2. 拼接字符串：
   可以使用 + 操作符或者 concat() 方法拼接字符串。

   String fullString = str1 + " " + str2;  // "Hello World"
   String fullStringConcat = str1.concat(" ").concat(str2);  // "Hello World"
   

3. 比较字符串：
   使用 equals() 方法来比较字符串内容。

   boolean isEqual = str1.equals(str2);  // false
   

4. 忽略大小写比较：
   使用 equalsIgnoreCase() 方法。

   boolean isEqualIgnoreCase = str1.equalsIgnoreCase("hello");  // true
   

5. 提取子字符串：
   使用 substring() 方法提取字符串的一部分。

   String sub = str1.substring(1, 4);  // "ell"
   

6. 查找字符或字符串：
   使用 indexOf() 方法查找字符或子字符串的位置，返回第一次出现的位置索引，找不到则返回 -1。

   int index = str1.indexOf('e');  // 1
   

7. 替换字符串：
   使用 replace() 方法替换字符或子字符串。

   String replacedStr = str1.replace('l', 'p');  // "Heppo"
   

8. 字符串的分割：
   使用 split() 方法可以根据正则表达式将字符串分割为数组。

   String[] words = str1.split(" ");  // { "Hello", "World" }
   

9. 去掉字符串两边的空格：
   使用 trim() 方法。

   String trimmed = " Hello ".trim();  // "Hello"
   

可变字符串：StringBuilder 和 StringBuffer

• StringBuilder：适用于单线程环境，速度快。
• StringBuffer：适用于多线程环境，线程安全。

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");  // "Hello World"

2. 集合操作

Java 的集合框架用于处理一组对象。常用的集合类位于 java.util 包下，主要分为三大接口：List、Set 和 Map。集合提供了一种动态操作数据的方式，与数组不同，集合的大小可以动态变化。

常见集合类：

1. List 接口：

   • ArrayList：动态数组，允许元素重复。
   • LinkedList：链表，允许快速插入和删除元素。

   List<String> list = new ArrayList<>();
   list.add("Apple");
   list.add("Banana");
   list.add("Apple");  // 允许重复元素
   

2. Set 接口：

   • HashSet：无序集合，不允许元素重复。
   • TreeSet：有序集合，基于红黑树实现。

   Set<String> set = new HashSet<>();
   set.add("Apple");
   set.add("Banana");
   set.add("Apple");  // 不会添加重复的 "Apple"
   

3. Map 接口：

   • HashMap：键值对映射，允许键和值为 null，无序。
   • TreeMap：有序映射，基于红黑树实现。

   Map<String, Integer> map = new HashMap<>();
   map.put("Apple", 1);
   map.put("Banana", 2);
   

常见集合操作：

1. 添加元素：

   • List 和 Set 使用 add() 方法添加元素。
   • Map 使用 put() 方法添加键值对。

   list.add("Orange");  // List 添加元素
   set.add("Orange");  // Set 添加元素
   map.put("Orange", 3);  // Map 添加键值对
   

2. 删除元素：
   使用 remove() 方法删除元素。

   list.remove("Apple");
   set.remove("Apple");
   map.remove("Apple");
   

3. 获取元素：

   • List 使用 get() 方法根据索引获取元素。
   • Map 使用 get() 方法根据键获取值。

   String fruit = list.get(1);  // "Banana"
   Integer count = map.get("Banana");  // 2
   

4. 遍历集合：

   • List 和 Set 使用增强 for 循环或迭代器遍历。
   • Map 可以使用 keySet()、values() 或 entrySet() 遍历。

   for (String fruit : list) {
       System.out.println(fruit);
   }
   
   for (Map.Entry<String, Integer> entry : map.entrySet()) {
       System.out.println(entry.getKey() + ": " + entry.getValue());
   }
   

5. 检查是否包含：

   • List 和 Set 使用 contains() 方法。
   • Map 使用 containsKey() 和 containsValue() 方法。

   boolean hasApple = list.contains("Apple");
   boolean hasKey = map.containsKey("Apple");
   

6. 清空集合：
   使用 clear() 方法清空集合。

   list.clear();
   set.clear();
   map.clear();
   

3. 数组操作

数组是固定长度的数据结构，所有元素类型必须相同。与集合不同，数组一旦创建，大小就不能更改。

声明和初始化数组：

int[] numbers = new int[5];  // 声明一个长度为5的数组
int[] initializedNumbers = {1, 2, 3, 4, 5};  // 声明并初始化数组

常见数组操作：

1. 访问数组元素：
   通过数组索引访问元素，索引从 0 开始。

   int first = numbers[0];
   numbers[1] = 10;
   

2. 获取数组长度：
   使用 length 属性获取数组长度。

   int length = numbers.length;
   

3. 遍历数组：
   可以使用 for 循环或增强 for 循环遍历数组。

   for (int i = 0; i < numbers.length; i++) {
       System.out.println(numbers[i]);
   }
   
   for (int num : numbers) {
       System.out.println(num);
   }
   

4. 多维数组：
   Java 支持多维数组，常见的是二维数组（矩阵）。

   int[][] matrix = new int[2][3];  // 2行3列的二维数组
   matrix[0][1] = 5;
   

5. 数组排序：
   使用 Arrays.sort() 方法对数组进行排序。

   Arrays.sort(numbers);  // 对数组进行升序排序
   

6. 数组转换为集合：
   可以使用 Arrays.asList() 方法将数组转换为 List。

   List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5);
   

数组的局限性：

1. 数组大小固定，无法动态增加或减少元素。
2. 数组只能存储相同类型的元素。

小结：

1. 字符串操作 主要通过 String、StringBuilder 和 StringBuffer 类实现，支持查找、替换、拼接等操作。
2. 集合操作 是通过 List、Set 和 Map 等接口实现，适用于动态处理数据，能够方便地进行元素的添加、删除、遍历等操作。
3. 数组操作 提供了一种固定长度的数据存储方式，适合处理已知大小的数据，支持快速的元素访问。