Java 从列表中检索所有值对<；整数>；

例如，我有一个

列表

对象，其中包含以下内容：

3, 6, 5, 3, 3, 6

结果是3和6。如何创建一个函数来测试重复项，然后返回重复项的1个值（不是对，而是对中的一个）？可能出现的一个问题是，如果有四个值：

3,4,5,3,8,3,3

，那么我想返回3和3。我怎样才能做到这一点

// ArrayList<Integer> list = {3, 6, 5, 3, 3, 6}
Collections.sort(list);

ArrayList<Integer> pairs = new ArrayList<Integer>();
int last = Integer.MIN_VALUE;  // some value that will never appear in the list
for (Integer cur : list) {
    if (last == cur) {
        pairs.add(cur);
        last = Integer.MIN_VALUE;  // some value that will never appear in the list
    } else {
        last = cur;
    }
}
System.out.println(Arrays.toString(pairs.toArray()));

**编辑**

稍微好一点的算法，修改给定的列表

// ArrayList<Integer> list = {3, 6, 5, 3, 3, 6}
Collections.sort(list);
int index = 1, last;
while (index < list.size()) {
    last = list.remove(index - 1);
    if (list.get(index - 1) == last) {
        index++;
    }
    if (index == list.size()) {
        list.remove(index - 1);
    }
}

//ArrayList={3,6,5,3,3,6}
集合。排序（列表）；
int index=1，最后一个；
while（索引

伪代码中的一种可能方式：

sortedList = sort (list)
duplicates = empty list
while (length (list) > 1)
{
    if (list [0] == list [1] )
    {
         duplicates.append (list [0] )
         list.removeAt (0)
    }
    list.removeAt (0);
}

---

我将遍历列表，计算每个实例的数量（将它们存储在地图中），然后根据地图创建一个新列表：

List<Integer> values = // the list of values you have
Map<Integer,Integer> counts = new HashMap<Integer,Integer>();

for(Integer value : values) {
    if(counts.containsKey(value)) {
        counts.put(value, counts.get(value)+1);
    } else {
        counts.put(value, 1);
    }
}

List<Integer> resultValues = new ArrayList<Integer>();
for(Integer value : counts.keySet()) {
    Integer valueCount = counts.get(value);
    for(int i=0; i<(valueCount/2); i++) { //add one instance for each 2
        resultValues.add(value);
    }
}
return resultValues;

List values=//您拥有的值列表
映射计数=新的HashMap（）；
for（整数值：值）{
if（计数。容器（值））{
counts.put（值，counts.get（值）+1）；
}否则{
计数。put（值，1）；
}
}
List resultValues=new ArrayList（）；
for（整数值：counts.keySet（））{
Integer valueCount=counts.get（值）；
对于（int i=0；i我认为@RHSeeger的“映射”方式已经足够好了。在这里，我只是建议另一种方式，只是为了“好玩”，这样你就可以看一看。它给出了一种稳定的结果：第一个完成的对首先出现：

List<Integer> values = ....;
List<Integer> result = new ArrayList<Integer>();
Set<Integer> unpairedValues = new HashSet<Integer>();

for (int i : values) {
  if (unpairedValues.contains(i)) {
    result.add(i);
    unpairedValues.remove(i);
  } else {
    unpairedValues.add(i);
  }
}
// result contains what u want

列表值=。。。。；
列表结果=新建ArrayList（）；
Set unpairedValues=新HashSet（）；
for（int i：值）{
if（未配对值。包含（i））{
结果.添加（i）；
未配对值。删除（i）；
}否则{
未配对值。添加（i）；
}
}
//结果包含您想要的内容
输出顺序是否必须是稳定的，这意味着这些对的输出顺序与它们在输入中出现的顺序相同？特别是，给定您的示例输入，发出
[6，3]
是否会违反您的预期约定？不，不会。它只需以任何顺序显示3和6即可。
List<Integer> values = ....;
List<Integer> result = new ArrayList<Integer>();
Set<Integer> unpairedValues = new HashSet<Integer>();

for (int i : values) {
  if (unpairedValues.contains(i)) {
    result.add(i);
    unpairedValues.remove(i);
  } else {
    unpairedValues.add(i);
  }
}
// result contains what u want