【Java集合框架】高效的数据结构和算法

博主： Fivk
发布时间：2023 年 03 月 07 日
730 次浏览
暂无评论
13362字数
分类：数据结构

## 一、简介

`Java`集合框架包括许多接口和类，它们提供了一组高效的数据结构和算法，用于存储和操作对象。

以下是`Java`集合框架中一些常用的类和接口：

1. `List`接口：表示一个有序的元素集合，允许重复元素。常用的实现类包括`ArrayList`和`LinkedList`。
2. `Set`接口：表示一个没有重复元素的集合。常用的实现类包括`HashSet`和`TreeSet`。
3. `Map`接口：表示一个键值对的集合，每个键最多只能映射到一个值。常用的实现类包括HashMap和`TreeMap`。
4. `Queue`接口：表示一个先进先出`（FIFO）`的元素集合。常用的实现类包括`LinkedList`和`ArrayDeque`。
5. `Stack`类：表示一个后进先出`（LIFO）`的元素集合。

`Java`集合框架还提供了一些算法和工具类，用于排序、查找、比较、迭代等操作。例如，`Collections`类提供了排序、查找、随机化、反转等方法；`Arrays`类提供了数组操作方法；`Iterator`和`ListIterator`接口提供了遍历集合元素的方法。

`Java`集合框架提供了一组强大的工具，使得Java编程变得更加方便和高效。

## 二、List

`List`是`Java`集合框架中的一个接口，它表示一个有序的元素集合，允许重复元素。`List`可以根据索引访问集合中的元素，还支持添加、删除和修改元素等操作。

`List`的实现类有很多种，其中最常用的是`ArrayList`和`LinkedList`。`ArrayList`是基于数组实现的，它提供了快速的随机访问和修改元素的能力；而`LinkedList`则是基于链表实现的，它提供了快速的添加和删除元素的能力。

下面是`List`的一些常用方法：

1. `add(element)`：在`List`的末尾添加一个元素。
2. `add(index, element)`：在指定索引处插入一个元素。
3. `remove(index)`：删除指定索引处的元素。
4. `get(index)`：返回指定索引处的元素。
5. `set(index, element)`：将指定索引处的元素替换为新元素。
6. `size()`：返回List中元素的数量。
7. `indexOf(element)`：返回指定元素第一次出现的索引。
8. `contains(element)`：判断`List`是否包含指定元素。
9. `toArray()`：将`List`转换成数组。

使用`List`的示例代码如下：

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

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

// 添加元素
        list.add("apple");
        list.add("banana");
        list.add("orange");

// 获取元素
        String first = list.get(0);
        System.out.println(first); // 输出 "apple"

// 修改元素
        list.set(1, "pear");

// 删除元素
        list.remove(2);

// 遍历元素
        for (String fruit : list) {
            System.out.println(fruit);
        }
    }
}
```

这个例子创建了一个`ArrayList`对象，添加了三个元素，然后获取、修改和删除了其中的元素。最后，使用`for-each`循环遍历了`List`中的元素，并打印出来。这只是`List`的一些基本操作，还有很多其他方法可以使用。

## 三、Set

`Set`是`Java`集合框架中的一个接口，它表示一个不允许重复元素的集合。`Set`中的元素是无序的，不能根据索引访问元素。`Set`中常用的实现类有`HashSet`和`TreeSet`。

`HashSet`是基于哈希表实现的，它提供了`O(1)`的插入、删除和查找操作。`HashSet`中的元素没有特定的顺序，插入和删除元素的顺序可能会影响到哈希表的性能。

`TreeSet`是基于红黑树实现的，它提供了`O(log n)`的插入、删除和查找操作。`TreeSet`中的元素是按照它们的自然顺序排序的，或者根据`Comparator`接口的规则排序。

下面是`Set`的一些常用方法：

1. `add(element)`：向`Set`中添加一个元素。
2. `remove(element)`：从`Set`中删除指定元素。
3. `contains(element)`：判断`Set`中是否包含指定元素。
4. `size()`：返回`Set`中元素的数量。
5. `iterator()`：返回一个迭代器，用于遍历`Set`中的元素。

使用`Set`的示例代码如下：

```java
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.remove("banana");

// 判断元素是否存在
        boolean hasApple = set.contains("apple");
        System.out.println(hasApple); // 输出 true

// 遍历元素
        for (String fruit : set) {
            System.out.println(fruit);
        }
    }
}
```

这个例子创建了一个`HashSet`对象，添加了三个元素，然后删除了一个元素。接着，使用`contains`方法判断了`Set`中是否包含指定元素，并使用`for-each`循环遍历了`Set`中的元素。`Set`也有很多其他的方法可以使用，例如`union`、`intersect`、`difference`等集合操作方法。

除了上面提到的常用方法之外，`Set`还有很多其他的方法，包括集合操作方法、转换方法、比较方法等。下面介绍一些常用的方法：

1. `addAll(Collection<? extends E> c)`：将另一个集合中的所有元素添加到当前`Set`中。
2. `removeAll(Collection<?> c)`：从当前`Set`中删除另一个集合中的所有元素。
3. `retainAll(Collection<?> c)`：从当前`Set`中保留与另一个集合中相同的元素，删除其他元素。
4. `clear()`：清空`Set`中的所有元素。
5. `isEmpty()`：判断`Set`是否为空。
6. `toArray()`：将`Set`转换成数组。
7. `equals(Object o)`：判断`Set`是否与另一个对象相等。
8. `hashCode()`：返回`Set`的哈希码。
9. `iterator()`：返回一个迭代器，用于遍历`Set`中的元素。

集合操作方法`（addAll、removeAll、retainAll）`用于对`Set`进行交、并、差等操作。例如，可以使用`addAll`方法将另一个`Set`中的所有元素添加到当前`Set`中；使用`removeAll`方法从当前`Set`中删除另一个`Set`中的所有元素；使用`retainAll`方法从当前`Set`中保留与另一个`Set`中相同的元素，删除其他元素。

转换方法`（toArray）`用于将`Set`转换成数组。可以使用`toArray`方法将`Set`转换成数组，然后使用数组的一些方法进行操作。

比较方法`（equals、hashCode）`用于判断`Set`是否与另一个对象相等。`equals`方法比较两个`Set`中的元素是否相等；`hashCode`方法返回`Set`的哈希码，用于判断两个`Set`是否相等。

使用`Set`的示例代码如下：

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

public class SetExample {
    public static void main(String[] args) {
        Set<String> set1 = new HashSet<>();
        set1.add("apple");
        set1.add("banana");
        set1.add("orange");

Set<String> set2 = new HashSet<>();
        set2.add("banana");
        set2.add("pear");
        set2.add("kiwi");

// 求两个Set的交集
        Set<String> intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        System.out.println(intersection); // 输出 [banana]

// 求两个Set的并集
        Set<String> union = new HashSet<>(set1);
        union.addAll(set2);
        System.out.println(union); // 输出 [apple, banana, orange, pear, kiwi]

// 求两个Set的差集
        Set<String> difference = new HashSet<>(set1);
        difference.removeAll(set2);
        System.out.println(difference); // 输出 [apple, orange]
    }
}
```

这个例子创建了两个`HashSet`对象`set1`和`set2`，分别添加了三个元素。接着，使用`retainAll`方法求`set1`和`set2`的交集，使用`addAll`方法求`set1`和`set2`的并集，使用`removeAll`方法求`set1`和`set2`的差集。注意，集合操作方法不会改变原有的`Set`，而是创建一个新的`Set`来保存结果。

## 四、Map

`Map`是一种将键映射到值的数据结构，每个键都是唯一的，每个键可以映射到一个值。`Map`是一个接口，`Java`提供了多个实现类，包括`HashMap`、`TreeMap`、`LinkedHashMap`等。

`Map`的常用方法包括：

1. `put(K key, V value)`：将键值对添加到`Map`中。
2. `get(Object key)`：根据键获取值。
3. `containsKey(Object key)`：判断`Map`中是否包含指定的键。
4. `containsValue(Object value)`：判断`Map`中是否包含指定的值。
5. `remove(Object key)`：根据键删除`Map`中的键值对。
6. `size()`：获取`Map`中键值对的数量。
7. `clear()`：清空`Map`中的所有键值对。
8. `keySet()`：获取`Map`中所有键的集合。
9. `values()`：获取`Map`中所有值的集合。
10. `entrySet()`：获取`Map`中所有键值对的集合。

使用`Map`的示例代码如下：

```java
import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 1);
        map.put("banana", 2);
        map.put("orange", 3);

// 根据键获取值
        int value1 = map.get("apple");
        System.out.println(value1); // 输出 1

// 判断Map中是否包含指定的键
        boolean containsKey = map.containsKey("banana");
        System.out.println(containsKey); // 输出 true

// 判断Map中是否包含指定的值
        boolean containsValue = map.containsValue(3);
        System.out.println(containsValue); // 输出 true

// 根据键删除Map中的键值对
        map.remove("orange");
        System.out.println(map); // 输出 {apple=1, banana=2}

// 获取Map中所有键的集合
        System.out.println(map.keySet()); // 输出 [apple, banana]

// 获取Map中所有值的集合
        System.out.println(map.values()); // 输出 [1, 2]

// 获取Map中所有键值对的集合
        System.out.println(map.entrySet()); // 输出 [apple=1, banana=2]
    }
}
```

这个例子创建了一个`HashMap`对象`map`，向其中添加了三个键值对。接着，使用`get`方法根据键获取值，使用`containsKey`方法判断`Map`中是否包含指定的键，使用`containsValue`方法判断`Map`中是否包含指定的值，使用`remove`方法根据键删除`Map`中的键值对，使用`keySet`方法获取`Map`中所有键的集合，使用`values`方法获取`Map`中所有值的集合，使用`entrySet`方法获取`Map`中所有键值对的集合。注意，`Map`中键必须唯一，如果添加一个已经存在的键，将会替换原有的值。

## 五、Queue

`Queue`是一种先进先出`（FIFO）`的数据结构，用于保存一组元素。`Java`提供了多个实现类，包括`LinkedList`、`PriorityQueue`等。

`Queue`的常用方法包括：

1. `add(E e)`：将元素添加到队列尾部。
2. `offer(E e)`：将元素添加到队列尾部，成功返回`true`，否则返回`false`。
3. `remove()`：删除并返回队列头部的元素，如果队列为空，则抛出`NoSuchElementException`异常。
4. `poll()`：删除并返回队列头部的元素，如果队列为空，则返回`null`。
5. `element()`：获取队列头部的元素，如果队列为空，则抛出`NoSuchElementException`异常。
6. `peek()`：获取队列头部的元素，如果队列为空，则返回`null`。

使用`Queue`的示例代码如下：

```java
import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.add("apple");
        queue.add("banana");
        queue.add("orange");

// 删除并返回队列头部的元素
        String element1 = queue.remove();
        System.out.println(element1); // 输出 apple

// 删除并返回队列头部的元素
        String element2 = queue.poll();
        System.out.println(element2); // 输出 banana

// 获取队列头部的元素
        String element3 = queue.element();
        System.out.println(element3); // 输出 orange

// 获取队列头部的元素
        String element4 = queue.peek();
        System.out.println(element4); // 输出 orange
    }
}
```

这个例子创建了一个`LinkedList`对象`queue`，向其中添加了三个元素。接着，使用`remove`方法和`poll`方法删除并返回队列头部的元素，使用`element`方法和`peek`方法获取队列头部的元素。注意，`Queue`接口继承自`Collection`接口，因此`Queue`中包含了`Collection`中的所有方法，如`size`、`isEmpty`、`contains`等。

## 六、Stack

`Stack`是一种后进先出`（LIFO）`的数据结构，用于保存一组元素。`Java`提供了一个`Stack`类来实现这个数据结构。

`Stack`的常用方法包括：

1. `push(E e)`：将元素压入栈顶。
2. `pop()`：将栈顶元素弹出并返回，如果栈为空，则抛出`EmptyStackException`异常。
3. `peek()`：获取栈顶元素，但不弹出，如果栈为空，则抛出`EmptyStackException`异常。
4. `empty()`：判断栈是否为空。

使用`Stack`的示例代码如下：

```java
import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.push("apple");
        stack.push("banana");
        stack.push("orange");

// 将栈顶元素弹出并返回
        String element1 = stack.pop();
        System.out.println(element1); // 输出 orange

// 获取栈顶元素
        String element2 = stack.peek();
        System.out.println(element2); // 输出 banana

// 判断栈是否为空
        boolean isEmpty = stack.empty();
        System.out.println(isEmpty); // 输出 false
    }
}
```

这个例子创建了一个`Stack`对象`stack`，向其中压入了三个元素。接着，使用`pop`方法弹出并返回栈顶元素，使用`peek`方法获取栈顶元素，使用`empty`方法判断栈是否为空。注意，`Stack`类继承自`Vector`类，因此除了`Stack`自己的方法之外，还包含了`Vector`中的方法，如`size`、`isEmpty`、`contains`等。

## 七、工具类

`Java`集合框架提供了一些算法和工具类，它们可以方便地操作集合数据，包括：

1. `Collections`类：提供了大量静态方法，如`sort`、`reverse`、`shuffle`等，可以对`List`、`Set`等集合进行排序、反转、随机排序等操作。
2. `Arrays`类：提供了一系列用于操作数组的静态方法，如`sort`、`binarySearch`等。
3. `Iterator`接口：提供了一种遍历集合的方法，使用`Iterator`可以对集合中的元素进行迭代操作。
4. `Comparable`接口和`Comparator`接口：用于定义集合中元素的比较方法，`Comparable`接口用于定义元素自身的比较方法，而`Comparator接口则用于定义元素之间的比较方法。

### 1.Collections类的一些常用方法：

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

public class CollectionsExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(2);

// 排序
        Collections.sort(list);
        System.out.println(list); // 输出 [1, 2, 3]

// 反转
        Collections.reverse(list);
        System.out.println(list); // 输出 [3, 2, 1]

// 随机排序
        Collections.shuffle(list);
        System.out.println(list); // 输出 [1, 3, 2]
    }
}
```

### 2.Arrays类的一些常用方法:

```java
import java.util.Arrays;

public class ArraysExample {
    public static void main(String[] args) {
        int[] arr = {3, 1, 2};

// 排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // 输出 [1, 2, 3]

// 二分查找
        int index = Arrays.binarySearch(arr, 2);
        System.out.println(index); // 输出 1

// 填充
        Arrays.fill(arr, 0);
        System.out.println(Arrays.toString(arr)); // 输出 [0, 0, 0]

// 比较
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {1, 2, 3};
        boolean isEqual = Arrays.equals(arr1, arr2);
        System.out.println(isEqual); // 输出 true
    }
}
```

这个例子创建了一个`int`数组`arr`，并向其中添加了三个元素。接着，使用`Arrays`类的`sort`方法对数组进行排序，使用`binarySearch`方法对数组进行二分查找，使用`fill`方法对数组进行填充，使用`equals`方法比较两个数组是否相等。需要注意的是，`Arrays`类中的`sort`和`binarySearch`方法都是针对基本数据类型和实现了`Comparable`接口的类的，而对于其他类型的对象，需要自行实现`Comparable`接口或使用`Comparator`接口进行比较。

### 3.自定义类型排序

对于自定义的类，如果需要对其进行排序等操作，可以实现`Comparable`接口或使用`Comparator`接口进行比较。下面分别介绍这两种方法：

#### 3.1实现`Comparable`接口

实现`Comparable`接口需要重写`compareTo`方法，该方法返回一个`int`值，表示当前对象与另一个对象的大小关系，如小于、等于、大于。一般情况下，`compareTo`方法的实现需要比较对象的某个属性或某些属性的组合，以确定对象的大小关系。示例代码如下：

```java
public class Person implements Comparable<Person> {
    private String name;
    private int age;

public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

@Override
    public int compareTo(Person o) {
        // 按照年龄从小到大排序
        return this.age - o.age;
    }

// 省略getter和setter方法
}
```

这个例子中，`Person`类实现了`Comparable`接口，并重写了`compareTo`方法。该方法根据年龄大小比较两个`Person`对象的大小关系，以便在排序时使用。

#### 3.2 使用Comparator接口

使用`Comparator`接口可以在不修改原有类的情况下，为该类定义多个比较方法。`Comparator`接口有一个`compare`方法，该方法接受两个参数，表示要比较的两个对象，返回一个`int`值，表示两个对象的大小关系。示例代码如下：

```java
public class Person {
    private String name;
    private int age;

public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

// 省略getter和setter方法

public static class AgeComparator implements Comparator<Person> {
        @Override
        public int compare(Person o1, Person o2) {
            // 按照年龄从小到大排序
            return o1.age - o2.age;
        }
    }

public static class NameComparator implements Comparator<Person> {
        @Override
        public int compare(Person o1, Person o2) {
            // 按照姓名字典序排序
            return o1.name.compareTo(o2.name);
        }
    }
}
```

这个例子中，`Person`类定义了两个静态内部类`AgeComparator和NameComparator`，它们都实现了Comparator接口，并重写了`compare`方法。这两个比较器分别按照年龄从小到大和按照姓名字典序排序。可以使用这些比较器对`Person`对象进行排序等操作。

#### 3.3两个接口的区别

实现`Comparable`接口或使用`Comparator`接口都可以实现对象的排序。但是，两者在使用方式上有所不同。

实现`Comparable`接口的对象可以使用`Collections.sort(List<T> list)`方法进行排序。该方法会自动调用对象的`compareTo`方法进行排序，从而实现按照对象属性的大小关系排序。

使用`Comparator`接口的对象可以使用`Collections.sort(List<T> list, Comparator<? super T> c)`方法进行排序。该方法需要传入一个比较器对象`c`，然后根据该比较器的`compare`方法进行排序，从而实现按照比较器定义的规则排序。

因此，如果实现了`Comparable`接口，可以直接使用`Collections.sort`进行排序。如果没有实现`Comparable`接口，或者需要按照不同的规则进行排序，可以实现`Comparator`接口，并传入相应的比较器对象进行排序。

最后修改：2023 年 03 月 07 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

本当迷
哈哈时过境迁再看一遍帆的文章质量还是那么高
挺胸的打工人
感谢博主分享
菜菜
一天就学一些我不知道的东西(´இ皿இ｀)
zhanqy
博主赛高！
null ？？［］
还可以把扩展运算符加上呀，这个很有用［…arr］，用于数组合...

【Java集合框架】高效的数据结构和算法

Fivk • 2023 年 03 月 07 日

## 一、简介

`Java`集合框架包括许多接口和类，它们提供了一组高效的数据结构和算法，用于存储和操作对象。

以下是`Java`集合框架中一些常用的类和接口：

`Java`集合框架提供了一组强大的工具，使得Java编程变得更加方便和高效。

## 二、List

下面是`List`的一些常用方法：

使用`List`的示例代码如下：

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

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

// 添加元素
        list.add("apple");
        list.add("banana");
        list.add("orange");

// 获取元素
        String first = list.get(0);
        System.out.println(first); // 输出 "apple"

// 修改元素
        list.set(1, "pear");

// 删除元素
        list.remove(2);

// 遍历元素
        for (String fruit : list) {
            System.out.println(fruit);
        }
    }
}
```

## 三、Set

下面是`Set`的一些常用方法：

使用`Set`的示例代码如下：

```java
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.remove("banana");

// 判断元素是否存在
        boolean hasApple = set.contains("apple");
        System.out.println(hasApple); // 输出 true

// 遍历元素
        for (String fruit : set) {
            System.out.println(fruit);
        }
    }
}
```

除了上面提到的常用方法之外，`Set`还有很多其他的方法，包括集合操作方法、转换方法、比较方法等。下面介绍一些常用的方法：

转换方法`（toArray）`用于将`Set`转换成数组。可以使用`toArray`方法将`Set`转换成数组，然后使用数组的一些方法进行操作。

使用`Set`的示例代码如下：

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

public class SetExample {
    public static void main(String[] args) {
        Set<String> set1 = new HashSet<>();
        set1.add("apple");
        set1.add("banana");
        set1.add("orange");

Set<String> set2 = new HashSet<>();
        set2.add("banana");
        set2.add("pear");
        set2.add("kiwi");

// 求两个Set的交集
        Set<String> intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        System.out.println(intersection); // 输出 [banana]

// 求两个Set的并集
        Set<String> union = new HashSet<>(set1);
        union.addAll(set2);
        System.out.println(union); // 输出 [apple, banana, orange, pear, kiwi]

// 求两个Set的差集
        Set<String> difference = new HashSet<>(set1);
        difference.removeAll(set2);
        System.out.println(difference); // 输出 [apple, orange]
    }
}
```

## 四、Map

`Map`的常用方法包括：

使用`Map`的示例代码如下：

```java
import java.util.HashMap;
import java.util.Map;

// 根据键获取值
        int value1 = map.get("apple");
        System.out.println(value1); // 输出 1

// 判断Map中是否包含指定的键
        boolean containsKey = map.containsKey("banana");
        System.out.println(containsKey); // 输出 true

// 判断Map中是否包含指定的值
        boolean containsValue = map.containsValue(3);
        System.out.println(containsValue); // 输出 true

// 根据键删除Map中的键值对
        map.remove("orange");
        System.out.println(map); // 输出 {apple=1, banana=2}

// 获取Map中所有键的集合
        System.out.println(map.keySet()); // 输出 [apple, banana]

// 获取Map中所有值的集合
        System.out.println(map.values()); // 输出 [1, 2]

// 获取Map中所有键值对的集合
        System.out.println(map.entrySet()); // 输出 [apple=1, banana=2]
    }
}
```

## 五、Queue

`Queue`是一种先进先出`（FIFO）`的数据结构，用于保存一组元素。`Java`提供了多个实现类，包括`LinkedList`、`PriorityQueue`等。

`Queue`的常用方法包括：

使用`Queue`的示例代码如下：

```java
import java.util.LinkedList;
import java.util.Queue;

// 删除并返回队列头部的元素
        String element1 = queue.remove();
        System.out.println(element1); // 输出 apple

// 删除并返回队列头部的元素
        String element2 = queue.poll();
        System.out.println(element2); // 输出 banana

// 获取队列头部的元素
        String element3 = queue.element();
        System.out.println(element3); // 输出 orange

// 获取队列头部的元素
        String element4 = queue.peek();
        System.out.println(element4); // 输出 orange
    }
}
```

## 六、Stack

`Stack`是一种后进先出`（LIFO）`的数据结构，用于保存一组元素。`Java`提供了一个`Stack`类来实现这个数据结构。

`Stack`的常用方法包括：

使用`Stack`的示例代码如下：

```java
import java.util.Stack;

// 将栈顶元素弹出并返回
        String element1 = stack.pop();
        System.out.println(element1); // 输出 orange

// 获取栈顶元素
        String element2 = stack.peek();
        System.out.println(element2); // 输出 banana

// 判断栈是否为空
        boolean isEmpty = stack.empty();
        System.out.println(isEmpty); // 输出 false
    }
}
```

## 七、工具类

`Java`集合框架提供了一些算法和工具类，它们可以方便地操作集合数据，包括：

### 1.Collections类的一些常用方法：

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

public class CollectionsExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(2);

// 排序
        Collections.sort(list);
        System.out.println(list); // 输出 [1, 2, 3]

// 反转
        Collections.reverse(list);
        System.out.println(list); // 输出 [3, 2, 1]

// 随机排序
        Collections.shuffle(list);
        System.out.println(list); // 输出 [1, 3, 2]
    }
}
```

### 2.Arrays类的一些常用方法:

```java
import java.util.Arrays;

public class ArraysExample {
    public static void main(String[] args) {
        int[] arr = {3, 1, 2};

// 排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // 输出 [1, 2, 3]

// 二分查找
        int index = Arrays.binarySearch(arr, 2);
        System.out.println(index); // 输出 1

// 填充
        Arrays.fill(arr, 0);
        System.out.println(Arrays.toString(arr)); // 输出 [0, 0, 0]

// 比较
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {1, 2, 3};
        boolean isEqual = Arrays.equals(arr1, arr2);
        System.out.println(isEqual); // 输出 true
    }
}
```

### 3.自定义类型排序

对于自定义的类，如果需要对其进行排序等操作，可以实现`Comparable`接口或使用`Comparator`接口进行比较。下面分别介绍这两种方法：

#### 3.1实现`Comparable`接口

```java
public class Person implements Comparable<Person> {
    private String name;
    private int age;

public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

@Override
    public int compareTo(Person o) {
        // 按照年龄从小到大排序
        return this.age - o.age;
    }

// 省略getter和setter方法
}
```

这个例子中，`Person`类实现了`Comparable`接口，并重写了`compareTo`方法。该方法根据年龄大小比较两个`Person`对象的大小关系，以便在排序时使用。

#### 3.2 使用Comparator接口

```java
public class Person {
    private String name;
    private int age;

public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

// 省略getter和setter方法

#### 3.3两个接口的区别

实现`Comparable`接口或使用`Comparator`接口都可以实现对象的排序。但是，两者在使用方式上有所不同。

【Java集合框架】高效的数据结构和算法

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

【踩坑日志】SpringBoot项目启动提示This primary key of "id" is primitive !不建议如此请使用包装类 in Class:

【C】极域电子教室学生端解除控制

【开发技巧】@CrossOrigin注解解决跨域问题

【Fivk】文章归档

回忆刚入天柱二中的我

数据没了

【C】联合_Typedef

【探花交友】数据统计与内容审核

【开发技巧】Feign请求任意地址，不通过注册中心请求

【C】指针、指针变量、解引用

【Java集合框架】高效的数据结构和算法

发表评论 取消回复 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

【Java集合框架】高效的数据结构和算法

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款