一：数组

（1）概述

在Java中，数组是一种用于存储固定大小、相同类型元素的数据结构。它具有以下特点：

• 固定大小：一旦创建，数组的大小就不能改变。
• 同类型元素：数组中的所有元素必须是相同的数据类型。
• 连续内存分配：数组中的元素在内存中是连续存储的，这有助于快速访问和操作数组元素。
• 零索引：数组的索引从0开始，第一个元素的索引是0，第二个是1，以此类推。

在使用数组时，我们可以声明、初始化和访问数组元素，可以获取数组的长度，并且可以进行多维数组的创建。另外，数组也可以作为方法的参数传递

// 声明并分配了长度为5的整型数组
int[] arr = new int[5];

// 声明并初始化整型数组
int[] arr2 = {1, 2, 3, 4, 5};

// 访问数组元素
int firstElement = arr2[0]; // 访问第一个元素

// 获取数组的长度
int length = arr2.length;

// 声明并分配了一个3x3的二维数组
int[][] matrix = new int[3][3];

（2）Java.util.Arrays

在Java中，java.util.Arrays类提供了许多有用的方法来操作数组。这些方法包括数组的排序、搜索、复制等操作。以下是java.util.Arrays类的一些常用方法：

• . 排序（Sorting）：
  • sort(int[] array): 对指定的整型数组进行升序排序。
  • sort(T[] array): 对指定的对象数组进行升序排序（需要数组中的元素实现Comparable接口）。
  • sort(int[] array, int fromIndex, int toIndex): 对指定的整型数组的指定范围进行升序排序。
  • sort(T[] array, Comparator<? super T> c): 使用指定的比较器对对象数组进行排序。
• 搜索（Searching）：
  • binarySearch(int[] array, int key): 使用二分查找算法在指定的整型数组中搜索指定的值。
  • binarySearch(T[] array, T key): 使用二分查找算法在指定的对象数组中搜索指定的值。
  • binarySearch(int[] array, int fromIndex, int toIndex, int key): 在指定范围内使用二分查找算法搜索指定的值。
  • binarySearch(T[] array, int fromIndex, int toIndex, T key, Comparator<? super T> c): 在指定范围内使用指定的比较器进行二分查找。
• 复制（Copying）：
  • copyOf(boolean[] original, int newLength): 复制指定的boolean数组，截取或填充0（false）以使副本具有指定的长度。
  • copyOf(int[] original, int newLength): 复制指定的int数组，截取或填充0以使副本具有指定的长度。
  • copyOf(T[] original, int newLength): 复制指定的对象数组，截取或填充null以使副本具有指定的长度。
• 数组填充（Filling）：
  • fill(int[] array, int val): 使用指定的值填充整型数组的所有元素。
  • fill(int[] array, int fromIndex, int toIndex, int val): 使用指定的值填充整型数组的指定范围内的元素。
• 数组转换为列表（Converting to List）：
  • asList(T... a): 将指定数组转换为列表。
• 数组比较（Comparing）：
  • equals(Object[] a, Object[] a2): 比较两个对象数组是否相等

关于降序排序

import java.util.Arrays;
import java.util.Comparator;

public class ArrayDescendingSortingExample {
    public static void main(String[] args) {
        Integer[] numbers = {5, 2, 8, 1, 9, 3};

        System.out.println("Before sorting: " + Arrays.toString(numbers));

        // 使用自定义的比较器进行降序排序
        Arrays.sort(numbers, new Comparator<Integer>() {
            @Override
            public int compare(Integer num1, Integer num2) {
                return num2.compareTo(num1); // 降序排序
            }
        });

        System.out.println("After sorting: " + Arrays.toString(numbers));
    }
}

更为简单的lambda表达式写法

// 升序
Arrays.sort(arr, (o1,o2)->o1-o2);
// 降序
Arrays.sort(arr, (o1,o2)->o2-o1);

二：List

在Java中，List是一个接口，它继承自Collection接口，代表了一个有序的集合，允许存储重复元素。List接口的实现类包括ArrayList、LinkedList、Vector等，其中ArrayList是最常用的

• 有序性： List中的元素按照它们被插入的顺序进行存储，并且可以通过索引访问元素
• 允许重复元素： List中可以存储重复的元素
• 可变大小： List的大小可以根据需要动态改变，可以添加、删除、插入元素
• 索引访问： 可以通过索引来访问List中的元素，索引从0开始
• Iterator遍历： 可以使用迭代器（Iterator）来遍历List中的元素
• 替代数组： List通常被用作数组的替代，因为它提供了更灵活的功能，如动态大小调整和更多的操作方法
• 支持泛型： List支持泛型，可以指定存储的元素类型，提高了类型安全性和代码可读性

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

public class ListExample {
    public static void main(String[] args) {
        // 创建一个ArrayList对象
        List<String> myList = new ArrayList<>();

        // 添加元素到列表
        myList.add("Apple");
        myList.add("Banana");
        myList.add("Orange");

        // 访问列表中的元素
        System.out.println("Elements in the list:");
        for (String element : myList) {
            System.out.println(element);
        }

        // 在指定位置插入元素
        myList.add(1, "Grape");

        // 移除指定位置的元素
        myList.remove(2);

        // 获取列表的大小
        int size = myList.size();
        System.out.println("Size of the list: " + size);

        // 检查列表是否包含某个元素
        boolean containsBanana = myList.contains("Banana");
        System.out.println("List contains Banana: " + containsBanana);
    }
}

另外对集合排序和数组差不多，使用Collection.sort()

package environment;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.ArrayList;

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

        System.out.println("Before sorting: " + numbers);

        // 使用 Collections.sort() 对集合进行排升序
        Collections.sort(numbers);

        // 使用 Collections.sort() 对集合进行排降序（方法1）
        Collections.sort(numbers, new Comparator<Integer>() {
        	@Override
        	public int compare(Integer o1, Integer o2) {
        		return o2-o1;
        	}
        });
        
     // 使用 Collections.sort() 对集合进行排降序（方法2）
        Collections.sort(numbers, (o1,o2)->(o2-o1));

        System.out.println("After sorting: " + numbers);
    }
}

三：Set

在Java中，Set是一个接口，它继承自Collection接口，代表了一种不允许包含重复元素的集合。Set接口的实现类通常包括HashSet、TreeSet、LinkedHashSet等

• 不允许重复元素： Set中不允许包含重复的元素，即集合中的每个元素都是唯一的
• 无序性： Set中的元素没有特定的顺序，即集合中的元素不按照它们被插入的顺序进行存储
• 可包含null元素： Set中可以包含一个null元素，但不能包含多个
• 基于哈希表或树结构实现： 不同的Set实现类可能使用不同的底层数据结构来存储元素。例如，HashSet使用哈希表实现，TreeSet使用红黑树实现
• 高效的查找操作： Set提供了高效的查找操作，可以快速判断一个元素是否存在于集合中
• 不可变性： 一旦创建了Set对象，其内容不能被更改。但是可以向集合中添加或删除元素
• 用于去重和快速查找： Set常用于去重操作，即从一个包含重复元素的集合中去除重复元素。另外，由于Set提供了快速的查找操作，它也经常用于快速查找某个元素是否存在于集合中

import java.util.HashSet;
import java.util.Set;

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

        // 添加元素到集合
        set.add("Apple");
        set.add("Banana");
        set.add("Orange");
        set.add("Apple"); // 尝试添加重复元素

        // 输出集合的内容
        System.out.println("Set: " + set);

        // 检查集合中是否包含某个元素
        boolean containsOrange = set.contains("Orange");
        System.out.println("Set contains Orange: " + containsOrange);

        // 删除集合中的元素
        set.remove("Banana");
        System.out.println("Set after removing Banana: " + set);
    }
}

四：Map

Java 中的 Map 是一种键值对的集合，常用于存储和操作数据，其中每个键都是唯一的，但值可以重复。Map 接口提供了丰富的方法，使得可以方便地添加、获取、移除和遍历键值对数据。常用的实现类包括 HashMap、TreeMap 和 LinkedHashMap

• put(key, value)：将指定的值与指定的键关联，并将其放入 Map 中。
• get(key)：返回指定键所映射的值，如果 Map 中不包含该键，则返回 null。
• containsKey(key)：如果 Map 包含指定键的映射关系，则返回 true。
• containsValue(value)：如果 Map 中至少包含一个指定值的映射关系，则返回 true。
• remove(key)：从 Map 中移除指定键的映射关系。
• keySet()：返回 Map 中所有键的 Set 视图。
• values()：返回 Map 中所有值的 Collection 视图。
• entrySet()：返回 Map 中所有键值对的 Set 视图
• getOrDefault(key, default)：找到就用找到的，没有的话就用default

import java.util.*;

public class MapExample {
    public static void main(String[] args) {
        // 创建一个 HashMap 实例
        Map<String, Integer> map = new HashMap<>();

        // 添加键值对
        map.put("apple", 10);
        map.put("banana", 5);
        map.put("orange", 8);

        // 获取键对应的值
        Integer appleCount = map.get("apple");
        System.out.println("Number of apples: " + appleCount);

        // 检查是否包含指定键
        if (map.containsKey("banana")) {
            System.out.println("Map contains key 'banana'");
        }

        // 检查是否包含指定值
        if (map.containsValue(8)) {
            System.out.println("Map contains value 8");
        }

        // 移除指定键的映射关系
        map.remove("orange");

        // 遍历键的集合
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println("Key: " + key);
        }

        // 遍历值的集合
        Collection<Integer> values = map.values();
        for (Integer value : values) {
            System.out.println("Value: " + value);
        }

        // 遍历键值对的集合
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        for (Map.Entry<String, Integer> entry : entrySet) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

五：Stack

在 Java 中，Stack 类表示了一个后进先出（LIFO）的对象堆栈。它继承自 Vector 类，因此拥有 Vector 的所有特性，但是在使用时更适合作为栈来使用。Stack 类提供了一组方法，可以让你轻松地将对象推入栈顶、从栈顶弹出对象、查看栈顶的对象等操作

• push(E item)：将指定的元素推入栈顶。
• pop()：移除并返回栈顶的元素。
• peek()：返回但不移除栈顶的元素。
• empty()：判断栈是否为空。
• search(Object o)：在栈中查找指定元素，并返回其相对于栈顶的位置

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        // 创建一个 Stack 实例
        Stack<String> stack = new Stack<>();

        // 将元素推入栈顶
        stack.push("Java");
        stack.push("Python");
        stack.push("JavaScript");

        // 查看栈顶的元素
        String topElement = stack.peek();
        System.out.println("Top element: " + topElement);

        // 移除并返回栈顶的元素
        String poppedElement = stack.pop();
        System.out.println("Popped element: " + poppedElement);

        // 判断栈是否为空
        boolean isEmpty = stack.empty();
        System.out.println("Is stack empty? " + isEmpty);

        // 查找元素在栈中的位置
        int position = stack.search("Java");
        System.out.println("Position of 'Java' in the stack: " + position);
    }
}

六：Queue

在 Java 中，Queue（队列）是一种常用的数据结构，它按照先进先出（FIFO）的原则进行元素的插入和删除操作。Java 中的 Queue 接口表示了这种数据结构，它提供了一组方法，可以轻松地对队列进行操作

• add(E e)：将指定的元素插入到队列尾部，如果队列已满，则抛出 IllegalStateException 异常。
• offer(E e)：将指定的元素插入到队列尾部，如果队列已满，则返回 false。
• remove()：移除并返回队列头部的元素，如果队列为空，则抛出 NoSuchElementException 异常。
• poll()：移除并返回队列头部的元素，如果队列为空，则返回 null。
• element()：返回队列头部的元素，但不移除它，如果队列为空，则抛出 NoSuchElementException 异常。
• peek()：返回队列头部的元素，但不移除它，如果队列为空，则返回 null。

Queue 接口有多种实现，其中常用的包括：

• LinkedList：LinkedList 类实现了 Queue 接口，因此可以用作队列。它是一个双端链表，因此在队列的两端都可以进行元素的插入和删除操作。
• ArrayDeque：ArrayDeque 类也实现了 Queue 接口，并且通常比 LinkedList 在大多数情况下都更高效。它是一个基于数组的双端队列

import java.util.*;

public class QueueExample {
    public static void main(String[] args) {
        // 创建一个 LinkedList 实例作为队列
        Queue<String> queue = new LinkedList<>();

        // 将元素插入队列尾部
        queue.offer("Java");
        queue.offer("Python");
        queue.offer("JavaScript");

        // 获取并移除队列头部的元素
        String headElement = queue.poll();
        System.out.println("Removed element: " + headElement);

        // 获取队列头部的元素（不移除）
        String peekElement = queue.peek();
        System.out.println("Peeked element: " + peekElement);

        // 遍历队列中的所有元素
        System.out.println("Queue elements:");
        for (String element : queue) {
            System.out.println(element);
        }
    }
}