如何保留，但是关于Java中的双精度？

假设我有两个ArrayList，其中都有一些对象：

Object a = new Object();
Object b = new Object();
Object c = new Object();
Object d = new Object();

ArrayList list1 = new ArrayList();
list1.add(a);
list1.add(a);
list1.add(a);
list1.add(b);
list1.add(b);
list1.add(c);
ArrayList list2 = new ArrayList();
list2.add(a);
list2.add(a);
list2.add(b);
list2.add(c);
list2.add(c);
list2.add(d);

ArrayList output = retainAllButRegardingDoubles(list1, list2);

现在我想找到与另一个数组中的元素相交的元素，但是关于双精度。“关于doubles”的意思是：如果列表1包含三次对象A，列表2包含两次对象A，那么返回的数组将包含两次对象A，因为对象A在两个数组中至少出现两次

因此，我希望输出列表如下所示：

ArrayList {
    a,
    a,
    b,
    c
}

“a”在两个列表中出现两次，“b”出现一次，“c”出现一次

---

有没有这样做的图书馆，还是我必须自己写？如果是，如何进行？

您可以遍历第一个列表，每次从第二个列表中找到与某个对象匹配的对象时，从第二个列表中删除找到的对象

public List<Object> retainAllButRegardingDoubles(List<Object> list1, List<Object> list2) {
   List<Object> result = new ArrayList<Object>();
   for (Object o : list1) {
      if (list2.contains(o)) {
         result.add(o);
         list2.remove(o);
      }
   }
   return result;
}

public List retainalbutregardingdoubles（列表1、列表2）{
列表结果=新建ArrayList（）；
for（对象o:list1）{
if（列表2.contains（o））{
结果.加入（o）；
清单2.删除（o）；
}
}
返回结果；
}

试试这个：

private static ArrayList retainAllButRegardingDoubles(ArrayList list1, ArrayList list2) {
        //Remove duplicates and get each object only once to improve performance
        Set<?> set1 = new HashSet(list1);
        Set<?> set2 = new HashSet(list2);

        ArrayList<Object> result = new ArrayList();

        for (Object o : set1){
            //You're adding to the result each element that appears twice at least in list1
            if (Collections.frequency(list1, o) > 1){
                result.add(o);
            }
        }
        for (Object o : set2){
            //You're adding to the result each element that appears twice at least in list2
            if (Collections.frequency(list2, o) > 1){
                result.add(o);
            }
        }
        return result;
    }

私有静态ArrayList RetainalButteregardingDoubles（ArrayList列表1，ArrayList列表2）{
//删除重复项并仅获取每个对象一次，以提高性能
Set set1=新哈希集（列表1）；
Set set2=新的HashSet（列表2）；
ArrayList结果=新建ArrayList（）；
用于（对象o:set1）{
//您正在将列表1中至少出现两次的每个元素添加到结果中
if（收集频率（列表1，o）>1）{
结果.加入（o）；
}
}
用于（对象o:set2）{
//您正在将列表2中至少出现两次的每个元素添加到结果中
if（收集频率（列表2，o）>1）{
结果.加入（o）；
}
}
返回结果；
}

我认为没有库可以做到这一点。首先查找元素在一个列表中存在的时间：

int times1;
for (Object o: list1) {
    if (o.equals(a)) {
        times1++;
    }
}

然后对第二个列表执行相同的操作：

int times2;
for (Object o: list1) {
    if (o.equals(a)) {
        times2++;
    }
}

if (min(times1, times2) > 0) {
    int times = min(times1, times2);
    for (int i = 0; i < times; i++) {
        list.add(a);
    }
}

int-times2；
for（对象o:list1）{
如果（o等于（a））{
times2++；
}
}
如果（最小值（时间1，时间2）>0）{
int times=min（times1，times2）；
for（int i=0；i

当然，您必须稍微调整代码。

List list1=new ArrayList（）；
         List<String> list1 = new ArrayList<String>();
         list1.add("object1");
         list1.add("object1");
         list1.add("object3");
         list1.add("object5");
         list1.add("object10");

         List<String> list2 = new ArrayList<String>();
         list2.add("object1");
         list2.add("object1");
         list2.add("object2");
         list2.add("object6");
         list2.add("object10");

         List<String> list3 = new ArrayList<String>();
         list3.add("object1");
         list3.add("object1");
         list3.add("object3");
         list3.add("object7");
         list3.add("object10");

         List<String> list4 = new ArrayList<String>();
         list4.add("object1");
         list4.add("object1");
         list4.add("object2");
         list4.add("object8");  
         list4.add("object10");

         Collection<List<String>> collection = new ArrayList<List<String>>();
         collection.add(list1);
         collection.add(list2);
         collection.add(list3);
         collection.add(list4);

         List<String> result = new ArrayList<String>();
         result =((ArrayList<List<String>>) collection).get(0);

         for (int i=1;i< collection.size(); i++) {           
            result.retainAll(((ArrayList<List<String>>) collection).get(i));            
         }      


         for(String s:result){
             System.out.println(s);
         }

列表1.添加（“对象1”）；
列表1.添加（“对象1”）；
清单1.添加（“对象3”）；
清单1.添加（“异议5”）；
清单1.添加（“对象10”）；
List list2=新的ArrayList（）；
清单2.添加（“对象1”）；
清单2.添加（“对象1”）；
清单2.添加（“对象2”）；
清单2.添加（“对象6”）；
清单2.添加（“对象10”）；
List list3=新的ArrayList（）；
清单3.添加（“对象1”）；
清单3.添加（“对象1”）；
清单3.添加（“对象3”）；
清单3.添加（“对象7”）；
清单3.添加（“对象10”）；
List list4=新的ArrayList（）；
清单4.添加（“对象1”）；
清单4.添加（“对象1”）；
清单4.添加（“对象2”）；
清单4.添加（“异议8”）；
清单4.添加（“对象10”）；
集合集合=新的ArrayList（）；
集合。添加（列表1）；
集合。添加（列表2）；
集合。添加（列表3）；
集合。添加（列表4）；
列表结果=新建ArrayList（）；
结果=（（ArrayList）集合）.get（0）；
对于（inti=1；i

我不认为有任何库支持此特定操作

在执行此操作时，您可以选择一种方式：

List retainAllButRegardingDoubles(list1, list2){

  ArrayList<Object> result = new ArrayList();

  for (Object 0:list1){
     int count1=Collections.frequency(list1, o);
     int count2=Collections.frequency(list2, o);
     int iMin=Math.min(count1,count2);
        for(int i=iMin;i>0;i--){
            result.add(o);
        }
    }
  return result;
 }

List retainalButteregardingDoubles（列表1、列表2）{
ArrayList结果=新建ArrayList（）；
对于（对象0:list1）{
int count1=集合频率（列表1，o）；
int count2=集合频率（列表2，o）；
int iMin=Math.min（count1，count2）；
对于（int i=iMin；i>0；i--）{
结果.加入（o）；
}
}
返回结果；
}

---

这是在两个列表中保留最小值的最简单的方法。

更详细地解释它的含义：关于双精度。元素顺序对您的问题很重要，还是只是顺便说一句，您使用的是

list

而不是

Set

？一个简单但有效的解决方案，只需几行代码。这正是我想要的。