# Java 算法

> 原文： [https://www.programiz.com/java-programming/algorithms](https://www.programiz.com/java-programming/algorithms)

#### 在本教程中，我们将借助示例学习 Java 集合框架提供的不同算法。

Java 集合框架提供了各种算法，可用于处理存储在数据结构中的元素。

Java 中的算法是静态方法，可用于对集合执行各种操作。

由于算法可用于各种集合，因此也称为**通用算法**。

让我们看一下集合框架中可用的不同方法的实现。

* * *

## 1.使用`sort()`排序

集合框架提供的`sort()`方法用于对元素进行排序。 例如，

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

class Main {
    public static void main(String[] args) {

        // Creating an array list
        ArrayList<Integer> numbers = new ArrayList<>();

        // Add elements
        numbers.add(4);
        numbers.add(2);
        numbers.add(3);
        System.out.println("Unsorted ArrayList: " + numbers);

        // Using the sort() method
        Collections.sort(numbers);
        System.out.println("Sorted ArrayList: " + numbers);

    }
} 
```

**输出**

```java
Unsorted ArrayList: [4, 2, 3]
Sorted ArrayList: [2, 3, 4] 
```

在此，排序以自然顺序（升序）进行。 但是，我们可以使用比较器接口来自定义`sort()`方法的排序顺序。

要了解更多信息，请访问 [Java Sorting](/java-programming/collections-sort "Java Collections sort()") 。

* * *

## 2.使用`shuffle()`打乱

Java 集合框架的`shuffle()`方法用于破坏数据结构中存在的任何种类的顺序。 它与排序相反。 例如，

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

class Main {
    public static void main(String[] args) {

        // Creating an array list
        ArrayList<Integer> numbers = new ArrayList<>();

        // Add elements
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        System.out.println("Sorted ArrayList: " + numbers);

        // Using the shuffle() method
        Collections.shuffle(numbers);
        System.out.println("ArrayList using shuffle: " + numbers);

    }
} 
```

**输出**：

```java
Sorted ArrayList: [1, 2, 3]
ArrayList using shuffle: [2, 1, 3] 
```

当我们运行程序时，`shuffle()`方法将返回随机输出。

打乱算法主要用于需要随机输出的游戏中。

* * *

## 3.常规数据处理

在 Java 中，集合框架提供了可用于处理数据的不同方法。

*   `reverse()`-反转元素的顺序
*   `fill()`-用指定的值替换集合中的每个元素
*   `copy()`-创建从指定源到目标的元素副本
*   `swap()`-交换集合中两个元素的位置
*   `addAll()`-将一个集合的所有元素添加到其他集合

例如，

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

class Main {
    public static void main(String[] args) {
        // Creating an ArrayList
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        System.out.println("ArrayList1: " + numbers);

        // Using reverse()
        Collections.reverse(numbers);
        System.out.println("Reversed ArrayList1: " + numbers);

        // Using swap()
        Collections.swap(numbers, 0, 1);
        System.out.println("ArrayList1 using swap(): " + numbers);

        ArrayList<Integer> newNumbers = new ArrayList<>();

        // Using addAll
        newNumbers.addAll(numbers);
        System.out.println("ArrayList2 using addAll(): " + newNumbers);

        // Using fill()
        Collections.fill(numbers, 0);
        System.out.println("ArrayList1 using fill(): " + numbers);

        // Using copy()
        Collections.copy(newNumbers, numbers);
        System.out.println("ArrayList2 using copy(): " + newNumbers);
    }
} 
```

**输出**：

```java
ArrayList1: [1, 2]
Reversed ArrayList1: [2, 1]
ArrayList1 Using swap(): [1, 2]
ArrayList2 using addALl(): [1, 2]
ArrayList1 using fill(): [0, 0]
ArrayList2 using copy(): [0, 0] 
```

**注意**：执行`copy()`方法时，两个列表的大小均应相同。

* * *

## 4.使用`binarySearch()`搜索

Java 集合框架的`binarySearch()`方法搜索指定的元素。 它返回元素在指定集合中的位置。 例如，

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

class Main {
    public static void main(String[] args) {
        // Creating an ArrayList
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        // Using binarySearch()
        int pos = Collections.binarySearch(numbers, 3);
        System.out.println("The position of 3 is " + pos);
    }
} 
```

**输出**：

```java
The position of 3 is 2. 
```

**注意**：应在执行`binarySearch()`方法之前对集合进行排序。

要了解更多信息，请访问 [Java Binary Search](/java-programming/binarysearch "Java binarySearch()") 。

* * *

## 5.组成

*   `frequency()`-返回元素在集合中存在的次数计数
*   `disjoint()`-检查两个集合是否包含某些公共元素

例如：

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

class Main {
    public static void main(String[] args) {
        // Creating an ArrayList
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(2);
        System.out.println("ArrayList1: " + numbers);

        int count = Collections.frequency(numbers, 2);
        System.out.println("Count of 2: " + count);

        ArrayList<Integer> newNumbers = new ArrayList<>();
        newNumbers.add(5);
        newNumbers.add(6);
        System.out.println("ArrayList2: " + newNumbers);

        boolean value = Collections.disjoint(numbers, newNumbers);
        System.out.println("Two lists are disjoint: " + value);
    }
} 
```

**输出**：

```java
ArrayList1: [1, 2, 3, 2]
Count of 2: 2
ArrayList2: [5, 6]
Two lists are disjoint: true 
```

* * *

## 6.寻找极致价值

Java 集合框架的`min()`和`max()`方法分别用于查找最小和最大元素。 例如，

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

class Main {
    public static void main(String[] args) {
        // Creating an ArrayList
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        // Using min()
        int min = Collections.min(numbers);
        System.out.println("Minimum Element: " + min);

        // Using max()
        int max = Collections.max(numbers);
        System.out.println("Maximum Element: " + max);
    }
} 
```

**输出**：

```java
Minimum Element: 1
Maximum Element: 3 
```