常用Java API

1 字符串处理惩罚

1.1 String 类

String 类是 Java 中不可变的字符序列。它提供了以下常用方法：

• length()：返回字符串的长度。
  
• charAt(index)：返回指定索引处的字符。
  
• substring(startIndex, endIndex)：返回从 startIndex 到 endIndex-1 处的子字符串。
  
• indexOf(char)：返回字符在字符串中初次出现的索引，假如没有找到则返回 -1。
  

示例代码：

1. String str = "Hello World";
3. // 获取字符串长度
4. int length = str.length();
6. // 获取指定索引处的字符
7. char ch = str.charAt(0);
9. // 获取子字符串
10. String substring = str.substring(0, 5);
12. // 查找字符在字符串中首次出现的索引
13. int index = str.indexOf('o');

复制代码

1.2 StringBuilder 类

StringBuilder 类是一个可变的字符序列，用于高效地构造和修改字符串。它提供了以下常用方法：

• append(string)：将字符串追加到 StringBuilder 的末尾。
  
• insert(index, string)：在指定索引处插入字符串。
  
• reverse()：反转 StringBuilder 中的字符次序。
  

示例代码：

1. StringBuilder sb = new StringBuilder();
3. // 追加字符串
4. sb.append("Hello ");
5. sb.append("World");
7. // 插入字符串
8. sb.insert(5, "Java ");
10. // 反转字符串
11. sb.reverse();

复制代码

2 集合框架

2.1 List 接口

List 接口表示一个有序的元素集合。它提供了以下常见的实现：

• ArrayList：基于数组实现，支持元素的随机访问和动态增长。
  
• LinkedList：基于链表实现，支持高效的插入和删除操纵。
  

示例代码（ArrayList）：

1. List<String> list = new ArrayList<>();
3. // 添加元素
4. list.add("Hello");
5. list.add("World");
7. // 获取元素
8. String element = list.get(0);
10. // 移除元素
11. list.remove(1);

复制代码

示例代码（LinkedList）：

1. List<String> list = new LinkedList<>();
3. // 添加元素
4. list.add("Hello");
5. list.add("World");
7. // 获取元素
8. String element = list.getFirst();
10. // 移除元素
11. list.removeFirst();

复制代码

2.2 Set 接口

Set 接口表示一个不包罗重复元素的集合。它提供了以下常见的实现：

• HashSet：基于哈希表实现，不答应重复元素。
  
• TreeSet：基于红黑树实现，元素按天然次序排序。
  

示例代码（HashSet）：

1. Set<String> set = new HashSet<>();
3. // 添加元素
4. set.add("Hello");
5. set.add("World");
7. // 检查元素是否存在
8. boolean contains = set.contains("Hello");
10. // 移除元素
11. set.remove("World");

复制代码

示例代码（TreeSet）：

1. Set<String> set = new TreeSet<>();
3. // 添加元素
4. set.add("Hello");
5. set.add("World");
7. // 获取第一个元素
8. String first = set.first();
10. // 移除第一个元素
11. set.remove(first);

复制代码

2.3 Map 接口

Map 接口表示一个键值对集合。它提供了以下常见的实现：

• HashMap：基于哈希表实现，键值对之间的映射不保证次序。
  
• TreeMap：基于红黑树实现，键值对按键的天然次序排序。
  

示例代码（HashMap）：

1. Map<String, Integer> map = new HashMap<>();
3. // 添加键值对
4. map.put("Hello", 1);
5. map.put("World", 2);
7. // 获取值
8. int value = map.get("Hello");
10. // 移除键值对
11. map.remove("World");

复制代码

示例代码（TreeMap）：

1. Map<String, Integer> map = new TreeMap<>();
3. // 添加键值对
4. map.put("Hello", 1);
5. map.put("World", 2);
7. // 获取第一个键
8. String firstKey = map.firstKey();
10. // 移除第一个键值对
11. map.remove(firstKey);

复制代码

2.4 遍历方式

1). 使用迭代器（Iterator）

1. // 创建一个 ArrayList
2. List<String> list = new ArrayList<>();
3. list.add("Hello");
4. list.add("World");
5. list.add("Java");
7. // 使用迭代器遍历 ArrayList
8. Iterator<String> iterator = list.iterator();
9. while (iterator.hasNext()) {
10.     String element = iterator.next();
11.     System.out.println(element);
12. }

复制代码

2). 使用增强 for 循环

1. // 创建一个 HashSet
2. Set<String> set = new HashSet<>();
3. set.add("Hello");
4. set.add("World");
5. set.add("Java");
7. // 使用增强 for 循环遍历 HashSet
8. for (String element : set) {
9.     System.out.println(element);
10. }

复制代码

3). 使用流（Stream）

1. // 创建一个 HashMap
2. Map<String, Integer> map = new HashMap<>();
3. map.put("Hello", 1);
4. map.put("World", 2);
5. map.put("Java", 3);
7. // 使用流遍历 HashMap
8. map.keySet().stream()
9.         .forEach(key -> System.out.println(key + ": " + map.get(key)));

复制代码

4). 使用 lambda 表达式

1. // 创建一个 ArrayList
2. List<String> list = new ArrayList<>();
3. list.add("Hello");
4. list.add("World");
5. list.add("Java");
7. // 使用 lambda 表达式遍历 ArrayList
8. list.forEach(element -> System.out.println(element));

复制代码

5). 使用并行流（Parallel Stream）

1. // 创建一个 ArrayList
2. List<String> list = new ArrayList<>();
3. list.add("Hello");
4. list.add("World");
5. list.add("Java");
7. // 使用并行流遍历 ArrayList
8. list.parallelStream()
9.         .forEach(element -> System.out.println(element));

复制代码

2.5 区别

• 数据布局： ArrayList 使用数组，LinkedList 使用链表，HashSet 使用哈希表。
  
• 元素次序： ArrayList 和 LinkedList 保持插入次序，而 HashSet 无序。
  
• 是否答应重复： ArrayList 和 LinkedList 答应重复元素，而 HashSet 不答应。
  
• 时间复杂度： ArrayList 和 HashSet 的查找、插入和删除操纵的平均时间复杂度为 O(1)，而 LinkedList 的查找操纵为 O(n)，插入和删除操纵为 O(1)。
  
• 线程安全性： ArrayList、LinkedList 和 HashSet 都黑白线程安全的。
  

3 Java文件操纵

3.1 读取文件

要读取文件，可以使用 FileReader 和 BufferedReader 类：

1. FileReader fr = new FileReader("file.txt");
2. BufferedReader br = new BufferedReader(fr);
3. String line;
4. while ((line = br.readLine()) != null) {
5.     // 处理每一行
6. }
7. br.close();
8. fr.close();

复制代码

3.2 写入文件

要写入文件，可以使用 FileWriter 和 BufferedWriter 类：

1. FileWriter fw = new FileWriter("file.txt");
2. BufferedWriter bw = new BufferedWriter(fw);
3. bw.write("内容");
4. bw.close();
5. fw.close();

复制代码

结语：以上就是关于Java的常用API的学习，也是学习Java基础必须要把握的，非常之紧张，感谢各位看官的观看，谢谢，下期见！ 

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