【刷题】数据结构——Java常见数据结构

变长数组：List

int[] nums;
// 普通数组转为对象数组
Integer[] integerArray = Arrays.stream(nums) // 创建流
          .boxed() // 装箱 int -> Integer
          .toArray(Integer[]::new); // 转换为 Integer[]
// 转为List，注意这样得到的是不可变的list，即list无法add sort
List<Integer> list = Arrays.stream(nums).boxed().toList();
// 这样得到的才是可变的
List<Integer> list = new ArrayList<>(Arrays.stream(nums).boxed().toList());
// 少量数据可以这样转
List<Integer> list = Arrays.asList(nums[0], nums[1], nums[2]);

---

字符串：string

String str = "123/456/789";
String[] strs = str.split("/");	// 根据符号切分成数组
for (String s : strs) {
    System.out.println(s);
}

str = str.replace("123", "233");  // 123替换成233，注意要返回
System.out.println(str);

str = str.substring(1, 3);  // 获取子字符串，下标从[1, 3)
System.out.println(str);

---

队列：

queue 普通队列

Queue<Integer> queue = new LinkedList<>();

queue.size(); // 返回元素个数 时间O(1)
queue.isEmpty(); // a为空返回true 时间O(1)

queue.add(1); // 向队头插入，错误抛异常
int h1 = queue.remove(); // 返回第一个元素，并在队列中删除，错误抛异常
int h2 = queue.element(); // 返回第一个元素，不删除

queue.offer(1); // 向队头插入，不抛异常
int h3 = queue.poll(); // 返回第一个元素，并在队列中删除，不抛异常
int h4 = queue.peek(); // 返回第一个元素，不删除

for(Integer q : queue){
    System.out.println(q);
}

---

PriorityQueue 优先队列

用堆实现

// 初始大小11，默认小根堆，堆顶是最小的
static PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(100);
public void work() {
    // 压入元素，add和offer在java 17中一样
    priorityQueue.add(3);
    priorityQueue.add(2);
    priorityQueue.offer(1);
    // [1, 3, 2]
    System.out.println(priorityQueue);

    // 堆顶
    System.out.println(priorityQueue.peek());

    // 删除指定元素
    priorityQueue.remove(2);
    System.out.println(priorityQueue);

    // 弹出堆顶
    priorityQueue.poll();
    System.out.println(priorityQueue);

    // 遍历堆
    Iterator<Integer> iterate = priorityQueue.iterator();
    while(iterate.hasNext()) {
        System.out.print(iterate.next());
        System.out.print(", ");
    }
    System.out.println();

    // 堆大小
    System.out.println(priorityQueue.size());
    // 判断是否为空
    System.out.println(priorityQueue.isEmpty());
    // 查找是否在堆中
    System.out.println(priorityQueue.contains(3));

    // 小根堆改成大根堆
    // 比较器返回值：<0代表o1排前面；>0代表o2排前面；=0代表相等
    // 返回值o2-o1，<0代表o2<o1时o1排前面；>0代表o2>o1时o1排前面；从而实现大根堆
    priorityQueue = new PriorityQueue<>((o1, o2) -> o2 - o1);
    priorityQueue.add(3);
    priorityQueue.add(2);
    priorityQueue.offer(1);
    System.out.println(priorityQueue);
}

---

栈

Deque<Integer> deque = new LinkedList<>();
deque.push(1);	// 压栈
Integer top = deque.peek(); // 获取栈顶
top = deque.pop();	//弹栈

---

Map

    static Map<Integer, Integer> map = new HashMap<>();
    
    map.put(1, 2);
    map.put(3, 4);
    map.put(5, 6);
    // {1=2, 3=4, 5=6}
    System.out.println(map);

    // 访问元素
    map.get(3);
    map.getOrDefault(-1, 1);	// 如果get的key -1不存在，则返回默认值1

    // 删除元素
    map.remove(5);
    System.out.println(map);

    // 判断是否包含key
    System.out.println(map.containsKey(3));
    // 判断是否包含value
    System.out.println(map.containsValue(2));

    // 输出 key
    for (Integer i : map.keySet()) {
        System.out.println("key: " + i);
    }
    // 输出 value
    for(Integer value: map.values()) {
        // 输出每一个value
        System.out.print(value + ", ");
    }
    // 输出 key 和value
    for(Map.Entry<Integer, Integer> entry: map.entrySet()) {
        // 输出每一个entry
        System.out.println("key: " + entry.getKey() + ", value: " + entry.getValue());
    }
    map.forEach((k, v) -> {
    	System.out.println(k + " " + v);
    });