【Java】【更新中】java常用操作以及数据结构

1. 数组（Array）

• 创建方式：

  int[] arr = new int[10];
  

• 常用方法：
  • length：获取数组长度。
  • set(int index, E element)：设置指定索引的元素值。
  • get(int index)：获取指定索引的元素值。
  • add(int index, E element)：在指定索引添加元素。
  • remove(int index)：移除指定索引的元素。
• 遍历方式：

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

2. 列表（List）

可以分为arraylist和linkedlist。

前者的实现是基于动态数组的数据结构，它允许快速随机访问元素，因为它是通过索引来直接访问元素的。后者是基于双向链表的数据结构，它通过元素之间的指针来进行遍历和访问。这意味着 LinkedList 在插入和删除元素时不需要移动其他元素，只需要改变指针的指向。

ArrayList 在随机访问元素时更快，因为它是通过索引直接访问的。
LinkedList 在插入和删除元素时更快，尤其是在列表的开始和结束处，因为不需要移动其他元素。

也就是说，如果你需要频繁地进行随机访问操作，那么 ArrayList 可能是更好的选择。如果你需要频繁地进行插入和删除操作，尤其是在列表的开始和结束处，那么 LinkedList 可能是更好的选择。

arraylist

• 创建方式：

List<Integer> list = new ArrayList<>();

• 常用方法：
• add(E element)：添加元素到列表末尾。
• add(int index, E element)：在指定索引添加元素。
• remove(int index)：移除指定索引的元素。
• remove(Object o)：移除列表中指定的元素。
• get(int index)：获取指定索引的元素值。
• size()：获取列表中元素的数量。
• 遍历方式：

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

linkedlist

• 创建方式：

List<Integer> list = new LinkedList<>();
//或者，如果你需要使用 LinkedList 作为双端队列（deque）：
Deque<Integer> deque = new LinkedList<>();

• 列表（List）接口的常用方法：
  • add(E e)：添加元素到列表的末尾。
  • add(int index, E element)：在列表的指定位置插入元素
  • get(int index)：获取列表中指定位置的元素。
  • set(int index, E element)：替换列表中指定位置的元素。
  • remove(int index)：移除列表中指定位置的元素。
  • remove(Object o)：移除列表中首次出现的指定元素。
  • size()：获取列表中的元素数量。
  • isEmpty()：检查列表是否为空
  • contains(Object o)：检查列表是否包含指定的元素。
  • clear()：清空列表中的所有元素。
• 双端队列（Deque）接口的常用方法：
  • addFirst(E e)：在列表的开始处插入元素。
  • addLast(E e)：在列表的末尾插入元素（与 add(E e) 相同）。
  • offerFirst(E e)：在列表的开始处插入元素，如果列表有空间限制，则在不违反容量限制的情况下返回 true。
  • offerLast(E e)：在列表的末尾插入元素，如果列表有空间限制，则在不违反容量限制的情况下返回 true。
  • removeFirst()：移除列表的第一个元素。
  • removeLast()：移除列表的最后一个元素。
  • pollFirst()：移除列表的第一个元素，如果列表为空，则返回 null。
  • pollLast()：移除列表的最后一个元素，如果列表为空，则返回 null。
  • getFirst()：获取列表的第一个元素。
  • getLast()：获取列表的最后一个元素。
  • peekFirst()：获取列表的第一个元素，如果列表为空，则返回 null。
  • peekLast()：获取列表的最后一个元素，如果列表为空，则返回 null。

当你将 LinkedList 当作 List 使用时，你主要关注的是它可以动态地增长和收缩，以及可以在任何位置插入和移除元素的能力。将 LinkedList 当作 Deque 使用时，你主要关注的是它可以在两端高效地插入和移除元素，这使得 LinkedList 可以作为栈（Stack）或队列（Queue）使用。

当你创建一个 LinkedList 对象时，无论你使用的是 List 接口还是 Deque 接口，你得到的 LinkedList 实例都是相同的。这意味着你可以通过 LinkedList 对象调用它实现的所有方法，包括 List 接口和 Deque 接口的方法。

实现不同的接口确实为 LinkedList 提供了不同的视角和使用场景，即使它内部的数据结构和方法是相同的。这为用户提供了更大的灵活性和选择性，可以根据具体的需求来使用这个类。

3. 集合（Set）

• 创建方式：

  Set<Integer> set = new HashSet<>();
  

• 常用方法：
  • add(E element)：添加元素到集合中。
  • remove(Object o)：移除集合中指定的元素。
  • contains(Object o)：检查集合中是否包含指定的元素。
  • size()：获取集合中元素的数量。
• 遍历方式：

  for (Integer element : set) {
      System.out.println(element);
  }
  

4. 映射（Map）

• 创建方式：

  Map<String, Integer> map = new HashMap<>();
  

• 常用方法：
  • put(K key, V value)：向映射中添加键值对。
  • get(Object key)：根据键获取对应的值。
  • remove(Object key)：移除映射中指定的键值对。
  • containsKey(Object key)：检查映射中是否包含指定的键。
  • size()：获取映射中键值对的数量。
• 遍历方法：
  （1）使用entrySet()和for-each循环
  entrySet()方法返回的是一个包含Map中所有键值对的集合（Set），其中每个元素都是一个Map.Entry对象。Map.Entry表示一个键值对。通过entrySet()，你可以遍历Map中的所有键值对。

HashMap<String, Integer> map = new HashMap<>();
// 填充HashMap
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Cherry", 3);

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

（2）使用keySet()和for-each循环

for (String key : map.keySet()) {
    System.out.println("Key: " + key + ", Value: " + map.get(key));
}

(3)使用values()和for-each循环（仅遍历值）

for (Integer value : map.values()) {
    System.out.println("Value: " + value);
}

(4)使用Iterator遍历

Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}

5.栈

栈是一种后进先出（LIFO）的数据结构，Java中的Stack类提供了管理栈的标准方法。
创

• 创建方式

Stack<Integer> stack = new Stack<>();

• 常用方法

  • push(E item)：将元素推入栈顶。
  • pop()：移除栈顶元素，并作为此函数的值返回该元素。
  • peek()：查看栈顶元素，但不从栈中移除它。
  • empty()：检查栈是否为空。
  • search(Object o)：返回对象在栈中的位置，以1为基数。

• 示例

import java.util.Stack;

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

        // 添加元素到栈
        stack.push(10);
        stack.push(20);
        stack.push(30);
        
        // 查看栈顶元素
        System.out.println("栈顶元素: " + stack.peek());
        
        // 移除栈顶元素并返回
        System.out.println("移除栈顶元素: " + stack.pop());
        
        // 检查栈是否为空
        System.out.println("栈是否为空: " + stack.empty());
        
        // 在栈中搜索元素（返回基于1的位置）
        System.out.println("元素20的位置: " + stack.search(20));
    }
}

6.堆

堆主要用于实现优先队列和解决一些特定问题。堆是一棵特殊的二叉树，具有以下特性：

完全二叉树：堆是一棵完全二叉树，即所有层都是满的，只有最后一层的节点可能不满，并且节点是从左到右依次排列。
堆的性质：

• 最大堆（Max Heap）：每个节点的值都大于或等于其子节点的值。
• 最小堆（Min Heap）：每个节点的值都小于或等于其子节点的值。

PriorityQueue 的常用方法
添加元素：

• add(E e)：将元素 e 添加到优先队列中。如果队列已满，则抛出 IllegalStateException。
• offer(E e)：将元素 e 添加到优先队列中，如果成功则返回 true，否则返回 false。

移除元素：

• poll()：移除并返回队列的头部元素。如果队列为空，则返回 null。
• remove(Object o)：移除指定的元素 o。

访问元素：

• peek()：返回队列的头部元素，但不移除。如果队列为空，则返回 null。
• element()：返回队列的头部元素，但不移除。如果队列为空，则抛出 NoSuchElementException。

查询队列大小：

• size()：返回队列中的元素个数。

创建最小堆:

import java.util.PriorityQueue;

public class MinHeapExample {
    public static void main(String[] args) {
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
        
        // 添加元素到最小堆
        minHeap.add(5);
        minHeap.add(3);
        minHeap.add(8);
        minHeap.add(1);

        // 输出堆顶元素并移除
        while (!minHeap.isEmpty()) {
            System.out.println(minHeap.poll());
        }
    }
}

创建最大堆

import java.util.Collections;
import java.util.PriorityQueue;

public class MaxHeapExample {
    public static void main(String[] args) {
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
        
        // 添加元素到最大堆
        maxHeap.add(5);
        maxHeap.add(3);
        maxHeap.add(8);
        maxHeap.add(1);

        // 输出堆顶元素并移除
        while (!maxHeap.isEmpty()) {
            System.out.println(maxHeap.poll());
        }
    }
}

优先队列是队列内每个元素都附带一个优先级，元素按优先级顺序进行排序和处理。优先队列可以分为两种：

1. 最大优先队列（Max Priority Queue）：优先级最高的元素具有最高的值。
2. 最小优先队列（Min Priority Queue）：优先级最高的元素具有最低的值。
   因此堆和优先队列很相似，不过优先级的表现形式是数据的大小。

7.StingBuilder

StringBuilder 是 Java 中用于处理可变字符串的一个类，它提供了一个可变的字符串序列。这意味着与字符串（String）相比，使用 StringBuilder 可以在不生成新的对象实例的情况下修改字符串，从而提供更高的性能。

StringBuilder 主要用在需要进行频繁的字符串操作的场景，例如添加、删除、插入或替换字符。它的使用场景通常包括：

• 创建方法

StringBuilder sb = new StringBuilder("Hello");

• 常用操作：

  • append()：将数据添加到当前StringBuilder对象的末尾。这个方法重载了多种参数类型，如append(String), append(int), append(char)等，使得几乎所有基本类型和对象类型都可以被添加

  • insert()：在指定位置插入数据，而不是像append()方法那样总是在末尾添加。

  • delete() 和 deleteCharAt()：从StringBuilder对象中移除字符或字符序列。

  • replace()：替换StringBuilder中指定位置的字符或字符序列。

  • reverse()：将StringBuilder中的字符序列反转。

  • toString()：返回与StringBuilder对象对应的String表示。

• 示例代码

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(" World"); // 添加字符串
        sb.insert(5, ",");  // 在指定位置插入字符
        sb.replace(6, 11, "Java"); // 替换字符串
        sb.delete(11, 16); // 删除字符串中的字符
        System.out.println(sb.toString()); // 输出结果
    }
}