Java 中 LinkedTransferQueue retainAll() 方法及示例

2025 年 1 月 6 日 | 阅读 6 分钟

Java Util Concurrent 包中的 LinkedTransferQueue 类的 retainAll() 函数用于仅保留队列中属于指定集合的元素。如果您有两个集合，只想保留两者共有的元素，这个方法会非常有用。特别是在任务基于同时进行的队列和集合完成的情况下，通过这种方式修改队列是线程安全的。

方法签名

解释

方法名： retainAll：这是执行基于集合保留队列中元素操作的方法的名称。

返回类型： boolean：返回类型为布尔值，指示队列是否因操作而修改。如果队列被更改，则函数返回 true。如果队列未更改，则函数返回 false。

参数： C：参数 C 代表一个包含要在队列中保留的元素的集合。

示例 1：从集合中保留元素

在此示例中，我们首先创建一个名为 queue 的 LinkedTransferQueue 并向其中添加元素 [1, 2, 3, 4]。然后，我们创建另一个名为 retainCollection 的 LinkedTransferQueue 并向其中添加元素 [2, 4]。我们调用 queue.retainAll(retainCollection) 来仅保留 queue 和 retainCollection 中都存在的元素。操作后，queue 将仅包含元素 [2, 4]，因为它们是 queue 和 retainCollection 之间的共同元素。retainAll() 方法返回 true，表示队列已被修改。

文件名： RetainElementsExample.java

import java.util.concurrent.LinkedTransferQueue;
public class RetainElementsExample {
    public static void main(String[] args) {
        // Create a LinkedTransferQueue
        LinkedTransferQueue<Integer> queue = new LinkedTransferQueue<>();
        // Add elements to the queue
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        // Display the original queue
        System.out.println("Original Queue: " + queue);
        // Create a collection to retain
        LinkedTransferQueue<Integer> retainCollection = new LinkedTransferQueue<>();
        retainCollection.add(2);
        retainCollection.add(4);
        // Display the collection to retain
        System.out.println("Collection to Retain: " + retainCollection);
        // Retain only the elements from the retainCollection
        boolean modified = queue.retainAll(retainCollection);
        // Display whether queue was modified or not
        System.out.println("Modified: " + modified);
        // Display the queue after retainAll operation
        System.out.println("Queue after retainAll: " + queue);
    }
}

输出

Original Queue: [1, 2, 3, 4]
Collection to Retain: [2, 4]
Modified: true
Queue after retainAll: [2, 4]

示例 2：从列表中保留字符串

在此示例中，我们将演示如何使用 LinkedTransferQueue 的 retainAll() 方法来仅保留队列和字符串列表之间共有的元素。此示例侧重于保留字符串，但相同的原理也适用于从任何类型的集合中保留元素。

文件名： RetainStringExample1.java

import java.util.concurrent.LinkedTransferQueue;
import java.util.ArrayList;
import java.util.List;
public class RetainStringExample1 {
    public static void main(String[] args) {
        // Create a LinkedTransferQueue
        LinkedTransferQueue<String> fruitQueue = new LinkedTransferQueue<>();
        // Add elements (fruits) to the queue
        fruitQueue.add("apple");
        fruitQueue.add("banana");
        fruitQueue.add("orange");
        fruitQueue.add("pear");
        // Display the original queue
        System.out.println("Original Fruit Queue: " + fruitQueue);
        // Create a List to retain (selected fruits)
        List<String> selectedFruits = new ArrayList<>();
        selectedFruits.add("banana");
        selectedFruits.add("orange");
        // Display the list of selected fruits
        System.out.println("Selected Fruits: " + selectedFruits);
        // Retain only the elements from the selected fruits list
        boolean modified = fruitQueue.retainAll(selectedFruits);
        // Display whether the queue was modified or not
        System.out.println("Modified: " + modified);
        // Display the queue after retainAll operation
        System.out.println("Queue after retainAll: " + fruitQueue);
    }
}

输出

Original Fruit Queue: [apple, banana, orange, pear]
Selected Fruits: [banana, orange]
Modified: true
Queue after retainAll: [banana, orange]

示例 3：从另一个队列中保留元素

在此示例中，我们创建了两个包含整数的 LinkedTransferQueue，queue1 和 queue2。queue1 包含元素 [1, 2, 3]，而 queue2 包含 [2, 3, 4]。我们调用 queue1.retainAll(queue2) 来仅保留 queue1 中也存在于 queue2 中的元素。操作后，queue1 将仅包含元素 [2, 3]，它们是 queue1 和 queue2 之间的共同元素。retainAll() 方法返回 true，表示 queue1 已被修改。

文件名： RetainFromAnotherQueueExample.java

import java.util.concurrent.LinkedTransferQueue;
public class RetainFromAnotherQueueExample {
    public static void main(String[] args) {
        // Create the first LinkedTransferQueue
        LinkedTransferQueue<Integer> queue1 = new LinkedTransferQueue<>();
        queue1.add(1);
        queue1.add(2);
        queue1.add(3);
        // Create the second LinkedTransferQueue
        LinkedTransferQueue<Integer> queue2 = new LinkedTransferQueue<>();
        queue2.add(2);
        queue2.add(3);
        queue2.add(4);
        // Display the original queue1
        System.out.println("Queue1: " + queue1);
        // Display the queue2
        System.out.println("Queue2: " + queue2);
        // Retain only the elements from queue1 that are present in queue2
        boolean modified = queue1.retainAll(queue2);
        // Display whether queue1 was modified or not
        System.out.println("Modified: " + modified);
        // Display queue1 after retainAll operation
        System.out.println("Queue1 after retainAll: " + queue1);
    }
}

输出

Queue1: [1, 2, 3]
Queue2: [2, 3, 4]
Modified: true
Queue1 after retainAll: [2, 3]

示例 4：从两个队列中保留偶数

在此示例中，我们创建了两个包含整数的 LinkedTransferQueue，queue1 和 queue2。queue1 包含元素 [1, 2, 3]，而 queue2 包含 [2, 3, 4]。我们调用 queue1.retainAll(queue2) 来仅保留 queue1 中也存在于 queue2 中的偶数。操作后，queue1 将仅包含偶数 2，它是 queue1 和 queue2 之间的共同元素。retainAll() 方法会就地修改 queue1 并返回 true，表示 queue1 已被修改。

文件名： RetainEvenNumbersExample.java

import java.util.concurrent.LinkedTransferQueue;
public class RetainEvenNumbersExample {
    public static void main(String[] args) {
        // Create the first LinkedTransferQueue
        LinkedTransferQueue<Integer> queue1 = new LinkedTransferQueue<>();
        queue1.add(1);
        queue1.add(2);
        queue1.add(3);
        // Create the second LinkedTransferQueue
        LinkedTransferQueue<Integer> queue2 = new LinkedTransferQueue<>();
        queue2.add(2);
        queue2.add(3);
        queue2.add(4);
        // Display the original contents of queue1
        System.out.println("Original Queue1: " + queue1);
        // Display the original contents of queue2
        System.out.println("Original Queue2: " + queue2);
        // Retain only the even numbers from both queues in queue1
        LinkedTransferQueue<Integer> tempQueue = new LinkedTransferQueue<>();
        for (Integer num : queue1) {
            if (queue2.contains(num) && num % 2 == 0) {
                tempQueue.add(num);
            }
        }
        queue1.clear();
        queue1.addAll(tempQueue);
        // Display queue1 after the retainAll operation
        System.out.println("Queue1 after retaining even numbers from Queue2: " + queue1);
    }
}

输出

Original Queue1: [1, 2, 3]
Original Queue2: [2, 3, 4]
Queue1 after retaining even numbers from Queue2: [2]

示例 5：从两个队列中保留公共字符串

在此示例中，我们创建了两个包含字符串的 LinkedTransferQueue，queue1 和 queue2。queue1 最初包含元素 ["apple", "banana", "orange"]，而 queue2 包含元素 ["banana", "orange", "pear"]。我们调用 queue1.retainAll(queue2) 来仅保留 queue1 中也存在于 queue2 中的字符串。操作后，queue1 将仅包含字符串 "banana" 和 "orange"，它们是 queue1 和 queue2 之间的共同元素。retainAll() 方法会就地修改 queue1 并返回 true，表示 queue1 已被修改。

文件名： RetainCommonStringsExample.java

import java.util.concurrent.LinkedTransferQueue;
public class RetainCommonStringsExample {
    public static void main(String[] args) {
        // Create the first LinkedTransferQueue
        LinkedTransferQueue<String> queue1 = new LinkedTransferQueue<>();
        queue1.add("apple");
        queue1.add("banana");
        queue1.add("orange");
        // Create the second LinkedTransferQueue
        LinkedTransferQueue<String> queue2 = new LinkedTransferQueue<>();
        queue2.add("banana");
        queue2.add("orange");
        queue2.add("pear");
        // Display the original contents of queue1
        System.out.println("Original Queue1: " + queue1);
        // Display the original contents of queue2
        System.out.println("Original Queue2: " + queue2);
        // Retain only the common strings from both queues in queue1
        LinkedTransferQueue<String> tempQueue = new LinkedTransferQueue<>();
        for (String str : queue1) {
            if (queue2.contains(str)) {
                tempQueue.add(str);
            }
        }
        queue1.clear();
        queue1.addAll(tempQueue);
        // Display queue1 after the retainAll operation
        System.out.println("Queue1 after retaining common strings: " + queue1);
    }
}

输出

Original Queue1: [apple, banana, orange]
Original Queue2: [banana, orange, pear]
Queue1 after retaining common strings: [banana, orange]

示例 6：从两个队列中保留素数

在此示例中，我们创建了两个包含整数的 LinkedTransferQueue，queue1 和 queue2。我们遍历 queue1 中的每个元素，并检查它是否存在于 queue2 中以及它是否是素数。如果两个条件都满足，我们将该数字添加到临时队列中。遍历所有元素后，我们清空 queue1 并将临时队列中的所有元素添加到其中。结果是，queue1 将仅包含存在于两个队列中的素数 2 和 3。

文件名： RetainPrimeNumbersExample.java

import java.util.concurrent.LinkedTransferQueue;
public class RetainPrimeNumbersExample {
    public static void main(String[] args) {
        // Create the first LinkedTransferQueue
        LinkedTransferQueue<Integer> queue1 = new LinkedTransferQueue<>();
        queue1.add(1);
        queue1.add(2);
        queue1.add(3);
        queue1.add(4);
        // Create the second LinkedTransferQueue
        LinkedTransferQueue<Integer> queue2 = new LinkedTransferQueue<>();
        queue2.add(2);
        queue2.add(3);
        queue2.add(5);
        queue2.add(7);
        // Display the original contents of queue1
        System.out.println("Original Queue1: " + queue1);
        // Display the original contents of queue2
        System.out.println("Original Queue2: " + queue2);
        // Retain only the prime numbers from both queues in queue1
        LinkedTransferQueue<Integer> tempQueue = new LinkedTransferQueue<>();
        for (Integer num : queue1) {
            if (queue2.contains(num) && isPrime(num)) {
                tempQueue.add(num);
            }
        }
        queue1.clear();
        queue1.addAll(tempQueue);
        // Display queue1 after the retainAll operation
        System.out.println("Queue1 after retaining prime numbers from Queue2: " + queue1);
    }
    // Helper method to check if a number is prime
    private static boolean isPrime(int num) {
        if (num <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
}

输出

Original Queue1: [1, 2, 3, 4]
Original Queue2: [2, 3, 5, 7]
Queue1 after retaining prime numbers from Queue2: [2, 3]

下一主题Linkedtransferqueue-trytransfer-method-in-java-with-examples

Java 中 LinkedTransferQueue retainAll() 方法及示例

方法签名

示例 1：从集合中保留元素

示例 2：从列表中保留字符串

示例 3：从另一个队列中保留元素

示例 4：从两个队列中保留偶数

示例 5：从两个队列中保留公共字符串

示例 6：从两个队列中保留素数

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中 LinkedTransferQueue retainAll() 方法及示例

方法签名

示例 1：从集合中保留元素

示例 2：从列表中保留字符串

示例 3：从另一个队列中保留元素

示例 4：从两个队列中保留偶数

示例 5：从两个队列中保留公共字符串

示例 6：从两个队列中保留素数

相关帖子

ArrayList Implementation in Java

Java Editors

Hashing Algorithm in Java

Java 中将 JSON 转换为 Map

Java Program to Break Integer into Digits

Java 程序将数组中的所有元素加一

Can We Override Static Method in Java

Java 中从 Calendar 获取日期

How to Create Package in Java

Pandigital Number in Java

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器