Yes:

test2.removeAll(test1)

尽管这会使test2发生变异，所以如果需要保留它，请创建一个副本。

此外，您可能指的是<Integer>而不是<int>。

如果你正在使用Java 8，你可以尝试这样做:

public Set<Number> difference(final Set<Number> set1, final Set<Number> set2){
    final Set<Number> larger = set1.size() > set2.size() ? set1 : set2;
    final Set<Number> smaller = larger.equals(set1) ? set2 : set1;
    return larger.stream().filter(n -> !smaller.contains(n)).collect(Collectors.toSet());
}

顺序很重要，因为你需要4和5是int(不是Integer)， 使用test2.removeAll (test1)。

参考Bojan Vukasovic的回答，这里有一个更完整的答案。

它实际上返回一个delta，提供添加和删除的元素列表。

将集合传递给delta方法的顺序很重要。

要获得delta:

Set<Integer> test1 = new HashSet<Integer>();
test1.add(1);
test1.add(2);
test1.add(3);
test1.add(9);

Set<Integer> test2 = new HashSet<Integer>();
test2.add(1);
test2.add(2);
test2.add(3);
test2.add(4);
test2.add(5);

var delta = Sets.delta(test1, test2);

delta.additions.equals(Set.of(4,5));
delta.subtractions.equals(Set.of(9));

package dev.onepub.util;

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

public class Sets
{
    /**
     * Calculates the delta of the two sets.
     * 
     * The method assumes that you have an existing set
     * that has been revised.
     * 
     * The delta is expressed as:
     *  additions - the list of items FOUND in the revised set, that are not in the existing set.
     *  subtractions - the list of items NOT in the revised set, that are in the existing set.
     *  
     * The existing and revised sets are left unchanged.
     * 
     * @param <T>
     * @param existing - the original set used as the baseline 
     * @param revised - the revised set which will be compared against the existing set.
     * @return a SetDelta that describes the set of changes.
     */
    static public <T> SetDelta<T> delta(Set<T> existing, Set<T> revised)
    {
        var additions = new HashSet<>(revised);
        additions.removeAll(existing);

        var subtractions = new HashSet<>(existing);
        subtractions.removeAll(revised);

        return new SetDelta<T>(additions, subtractions);
    }
    
    /**
     * Describes the changes between two sets. 
     * @author bsutton
     *
     * @param <T> the type of entity held by the set.
     */
    static public class SetDelta<T>
    {
        public SetDelta(HashSet<T> additions, HashSet<T> subtractions)
        {
            this.additions = additions;
            this.subtractions = subtractions;
        }

        // The set of additional items
        final public Set<T> additions;
        
        // The set of removed items.
        final public Set<T> subtractions;

    }
}

单元测试

package dev.onepub.util;

import static org.junit.jupiter.api.Assertions.*;

import java.util.Set;

import org.junit.jupiter.api.Test;

class SetsTest
{

    @Test
    void test()
    {
        Set<Integer> existingState = Set.of(1, 2, 3, 4, 5);
        Set<Integer> newState = Set.of(0, 5, 2, 11, 3, 99);

        var delta = Sets.delta(existingState, newState);

        assertEquals(delta.additions, Set.of(0, 99, 11));
        assertEquals(delta.subtractions, Set.of(1, 4));
    }

    
    @Test
    void testSame()
    {
        Set<Integer> existingState = Set.of(1,2);
        Set<Integer> newState = Set.of(1,2);

        var delta = Sets.delta(existingState, newState);

        assertEquals(delta.additions, Set.of());
        assertEquals(delta.subtractions, Set.of());
    }
    
    @Test
    void testBothEmpty()
    {
        Set<Integer> existingState = Set.of();
        Set<Integer> newState = Set.of();

        var delta = Sets.delta(existingState, newState);

        assertEquals(delta.additions, Set.of());
        assertEquals(delta.subtractions, Set.of());
    }
    
    @Test
    void testAddOne()
    {
        Set<Integer> existingState = Set.of();
        Set<Integer> newState = Set.of(1);

        var delta = Sets.delta(existingState, newState);

        assertEquals(delta.additions, Set.of(1));
        assertEquals(delta.subtractions, Set.of());
    }
    
    @Test
    void testRemoveOne()
    {
        Set<Integer> existingState = Set.of(1);
        Set<Integer> newState = Set.of();

        var delta = Sets.delta(existingState, newState);

        assertEquals(delta.additions, Set.of());
        assertEquals(delta.subtractions, Set.of(1));
    }
    
    @Test
    void testAddOneRemoveOne()
    {
        Set<Integer> existingState = Set.of(1);
        Set<Integer> newState = Set.of(0);

        var delta = Sets.delta(existingState, newState);

        assertEquals(delta.additions, Set.of(0));
        assertEquals(delta.subtractions, Set.of(1));
    }

}

您可以使用. addall()创建两个集合的联合，使用. retainall()创建交集，并使用. removeif()从联合中删除交集(或复制的元素)。

HashSet union = new HashSet(group1);
union.addAll(group2);
        
System.out.println("Union: " + union);
        
HashSet intersection = new HashSet(group1);
intersection.retainAll(group2);
        
System.out.println("Intersection: " + intersection);
        
HashSet difference = new HashSet(union);
difference.removeIf(n -> (difference.contains(intersection)));
        
System.out.println("Difference: " + difference);

如果你使用Guava(前谷歌集合)库有一个解决方案:

SetView<Number> difference = com.google.common.collect.Sets.difference(test2, test1);

返回的SetView是一个Set，它是一个动态表示，你可以使它不可变或复制到另一个Set。Test1和test2保持不变。