Question

我想在Java中进行联合，交叉，差异和反向操作。

首先，我有ArrayList<Integer>

的2个实例

a = [0,2,4,5,6,8,10]
b = [5,6,7,8,9,10]

联盟b应该返回c = [0,2,3,4,5,6,7,8,9,10]

交叉b应该返回c = [5,8,10]

defference b应返回c = [0,2,3,4]

反向a = [10,8,6,5,4,2,0]

像这样。

如何在Java中实现该方法？

更新：我必须从这个模板开始：

package IntSet;
import java.util.ArrayList;
import java.util.Collection;


public class IntSet {

private ArrayList<Integer> intset;

public IntSet(){
    intset = new ArrayList<Integer>();
}

public void insert(int x){
    intset.add(x);
}

public void remove(int x){
    //implement here
    intset.indexOf(x);
}

public boolean member(int x){
    //implement here
    return true;
}

public IntSet intersect(IntSet a){
    //implement here
    return a;
}

public IntSet union(IntSet a){
    //implement here
    return a;
}

public IntSet difference(IntSet a){
    //implement here
    IntSet b = new IntSet();
    return b; 
}

Answer 1

首先，您描述的操作（反向除外）是设置操作，而不是列表操作，因此请使用HashSet或（如果需要订购）TreeSet。

    Set<Integer> a = new TreeSet<Integer>(Arrays.asList(new Integer[]{0,2,4,5,6,8,10}));
    Set<Integer> b = new TreeSet<Integer>(Arrays.asList(new Integer[]{5,6,7,8,9,10}));

    //union
    Set<Integer> c = new TreeSet<Integer>(a);
    c.addAll(b);
    System.out.println(c);

    //intersection
    Set<Integer> d = new TreeSet<Integer>(a);
    d.retainAll(b);
    System.out.println(d);

    //difference
    Set<Integer> e = new TreeSet<Integer>(a);
    e.removeAll(b);
    System.out.println(e);

    //reverse
    List<Integer> list = new ArrayList<Integer>(a);
    java.util.Collections.reverse(list);
    System.out.println(list);

Answer 2

//Union 
List<Integer> c = new ArrayList<Integer>(a.size() + b.size());
addNoDups(c,a);
addNoDups(c,b);

private void addNoDups(List<Integer> toAddTo,List<Integer> iterateOver) {
    for(Integer num:iterateOver){
        if(toAddTo.indexOf(num) == -1) {
            toAddTo.add(num);
        }
    }
}

//intersection
List<Integer> c = new ArrayList<Integer> (a.size() > b.size() ?a.size():b.size());
c.addAll(a);
c.retainAll(b);

//difference a-b
List<Integer> c = new ArrayList<Integer> (a.size());
c.addAll(a);
c.removeAll(b);

Answer 3

如果你正在使用集合（正如你应该的那样，除了反向之外的所有那些都是设置操作），Guava在它的Sets类中提供了这些操作。

Set<Integer> union = Sets.union(set1, set2);
Set<Integer> intersection = Sets.intersection(set1, set2);
Set<Integer> difference = Sets.difference(set1, set2);

所有这些都返回不可修改的视图，由原始集支持。

请参阅Guava Explained -> Collection Utilities -> Sets

如果列表是你拥有的，你可以使用所有标准集合中的复制构造函数将它们转换为Set：

List<X> list = new ArrayList<>();
// fill up list here
Set<X> set = new HashSet<>(list);

Answer 4

许多答案告诉您使用能够为您完成工作的库。虽然这是对现实世界的正确解决方案，但请记住，你正在做家庭作业，而你的老师可能希望你了解如何编写函数，而不仅仅是如何找到库来为你做这项工作。

那就是说，你已经开始使用你所展示的代码了。让我们一步一步地解决问题。

首先，您知道Java文档的位置吗？ http://download.oracle.com/javase/1.4.2/docs/api/这很关键，因为这就是你如何找出哪些功能做什么的。这是Java 1.4的链接。我没注意到你正在使用什么版本，但Java是向后兼容的，所以这应该足够了。

在文档中，找到ArrayList条目。

现在我们已经获得了API文档，我们需要打破你的问题。你已经发布了代码，所以我将按功能解决它。

insert（）：你必须有一个有序列表，或者订单无关紧要？或者您是否保证会按顺序提供给您的价值？你学习了排序算法吗？

remove（）：此功能不起作用。看一下ArrayList API，看看如何从列表中删除一个项目。使用那种方法。

member（）：您的成员方法不起作用。您需要检查列表的每个条目，并确定当前成员是否与函数参数匹配。你学习了循环吗？

intersect（）：好的，用英语告诉我应该做什么交叉。如果你可以帮助它，请不要使用教师的描述 - 使用你自己的话（注意别人，这是OP学习编程的练习，所以请不要为他回答）

差异（）：再次，用英语告诉我它应该做什么。

reverse（）：再次，给我一个关于这应该做什么的英文描述。

一旦你有英文描述，描述一个可以完成工作的算法。不要用Java编写它。只需用英文写一个算法，用笔和纸描述你将如何完成工作。

此时，请尝试将算法转换为Java代码。

Answer 5

此代码段将使用apache commons CollectionUtils.union方法找到两个集合的联合

Collection<String> totalFriends = CollectionUtils.union(yourFriends, myFriends);

Answer 6

我会把它留在这里。 java-8和streams

有一种新方法

List<Integer> listA = Arrays.asList(0, 2, 4, 5, 6, 8, 10);
List<Integer> listB = Arrays.asList(5, 6, 7, 8, 9, 10);

List<Integer> intersection = listA.stream()
        .filter(listB::contains)
        .collect(Collectors.toList());

List<Integer> union = Stream.concat(listA.stream(), listB.stream())
        .distinct().sorted()
        .collect(Collectors.toList());

List<Integer> aDiffB = listA.stream()
        .filter(i -> !listB.contains(i))
        .collect(Collectors.toList());

System.out.println(intersection); // [5, 6, 8, 10]
System.out.println(union); // [0, 2, 4, 5, 6, 7, 8, 9, 10]
System.out.println(aDiffB); // [0, 2, 4]

Answer 7

方法addAll，retainAll和removeAll是在Java中最常用于实现union，intersect和difference的方法。借助Java 8+中的Streams，您确实可以使用intersect为difference和filter使用@Test public void unionIntersectDifferenceReverse() { IntList list1 = IntLists.immutable.with(0, 2, 4, 5, 6, 8, 10); IntList list2 = IntLists.immutable.with(5, 6, 7, 8, 9, 10); MutableIntSet set1 = list1.toSet(); MutableIntSet set2 = list2.toSet(); IntSet union = set1.union(set2); IntSet intersection = set1.intersect(set2); IntSet difference = set1.difference(set2); IntList reversed = list1.toReversed(); Assert.assertEquals(IntSets.mutable.with(0, 2, 4, 5, 6, 7, 8, 9, 10), union); Assert.assertEquals(IntSets.mutable.with(5, 6, 8, 10), intersection); Assert.assertEquals(IntSets.mutable.with(0, 2, 4), difference); Assert.assertEquals(IntLists.mutable.with(10, 8, 6, 5, 4, 2, 0), reversed); }的更多选项。

如果您愿意使用第三方库，则在发布库的11.0版时，以下代码将使用Eclipse Collections处理原始集合。

@Test
public void unionIntersectDifferenceReverseWithBoxedIntegers()
{
    ImmutableList<Integer> list1 = Lists.immutable.with(0, 2, 4, 5, 6, 8, 10);
    ImmutableList<Integer> list2 = Lists.immutable.with(5, 6, 7, 8, 9, 10);

    MutableSet<Integer> set1 = list1.toSet();
    MutableSet<Integer> set2 = list2.toSet();

    MutableSet<Integer> union = set1.union(set2);
    MutableSet<Integer> intersection = set1.intersect(set2);
    MutableSet<Integer> difference = set1.difference(set2);

    ImmutableList reversed = list1.toReversed();

    Assert.assertEquals(Sets.mutable.with(0, 2, 4, 5, 6, 7, 8, 9, 10), union);
    Assert.assertEquals(Sets.mutable.with(5, 6, 8, 10), intersection);
    Assert.assertEquals(Sets.mutable.with(0, 2, 4), difference);
    Assert.assertEquals(Lists.mutable.with(10, 8, 6, 5, 4, 2, 0), reversed);
}

此功能为recently contributed to primitive Sets in Eclipse Collections。链接的博客描述了如何在原始集上实现这些方法。

以下代码将对象集合与带框的整数一起使用。该代码将与今天可用的Eclipse Collections版本一起使用。

{{1}}

注意：我是Eclipse Collections的提交者。

如何在java中进行联合，交叉，差异和反转数据

7 个答案: