在Java中删除Arraylist中的元素对

我知道以前也有人问过类似的问题，但它们通常会从Arraylist中删除所有指定的元素

我需要做的是从ArrayList中删除成对的值（如果一个数字出现3次，它将删除该元素的2个副本，并保留其中1个副本）。更一般地说，如果一个数字出现奇数次，则保留1，如果一个数字出现偶数次，则将其全部删除。因此，如果我的Arraylist是这样的

[5,4,3,3,2,1,2,3,1]

输出将是

[5,4,3]

由于数字“2”出现两次，因此它已被完全删除。与数字“1”相同。但是由于数字“3”出现了三次，它会在ArrayList中留下其中一个，因为我只想成对删除这些数字

我一点也不在乎订购，反正我要重新订购

有人对此有什么建议吗？我想我可以使用for循环反复比较每个值，但它似乎效率低下，所以我想知道是否有更好的方法

---

谢谢大家!

您可以使用贴图作为辅助对象

• 在ArrayList上迭代
• 假设列表的第i个元素包含数字n
• 如果map.containsKey（n），则map.get（n）是上一次出现的n在列表中的位置。
  • 从列表中删除第i个元素和map.get（n）个元素
  • 从地图中删除键n
• 否则
  • map.put（n，i）

实施说明：

---

不要使用增强的for循环来迭代列表（因为它不允许删除元素）。迭代列表的索引。这将允许您按索引删除元素（但请记住，当您删除第i个元素时，以前的i+1元素将成为新的第i个元素）。

您可以使用贴图作为辅助对象

• 在ArrayList上迭代
• 假设列表的第i个元素包含数字n
• 如果map.containsKey（n），则map.get（n）是上一次出现的n在列表中的位置。
  • 从列表中删除第i个元素和map.get（n）个元素
  • 从地图中删除键n
• 否则
  • map.put（n，i）

实施说明：

---

不要使用增强的for循环来迭代列表（因为它不允许删除元素）。迭代列表的索引。这将允许您按索引删除元素（但请记住，当您删除第i个元素时，以前的i+1元素将成为新的第i个元素）。

我认为您最好对列表进行排序

然后，向后看，如果看到相同的整数，请删除整数，同时跟踪当前整数的总数

如果看到偶数总数，则不会删除最后一次出现。 如果您看到一个奇数总数，您将删除最后一个出现的

public void removePairElementsFrom(Arraylist<Integer> myArrayList)
{
    if (myArrayList == null)
    {
        return null;
    }

    int arrayLength = myArrayList.size();

    if (arrayLegnth == 1)
    {
        return myArrayList;
    )

    Collections.sort(myArrayList);

    int lastSeenInt = myArrayList.get(arrayLength - 1);
    int lastSeenIntCount = 1;

    for (int i = arrayLength - 2; i >= 0; --i)
    {
        if (myArrayList[i] == lastSeenInt)
        {
            myArrayList.remove(i+1);
            ++lastSeenIntCount;
        }
        else
        {
            if ((lastSeenIntCount % 2) == 0)
            {
                myArrayList.remove(i+1);
            }

            lastSeenInt = myArrayList.get(i);
            lastSeenIntCount = 1;
        }
    }

    if ((lastSeenIntCount % 2) == 0)
    {
        myArrayList.remove(0);
    }
}

public void removepaireleasfrom（Arraylist myArrayList）
{
如果（myArrayList==null）
{
返回null；
}
int-arrayLength=myArrayList.size（）；
如果（ArrayLenth==1）
{
返回myArrayList；
)
Collections.sort（myArrayList）；
int lastSeenInt=myArrayList.get（arrayLength-1）；
int lastSeenIntCount=1；
对于（int i=阵列长度-2；i>=0；--i）
{
if（myArrayList[i]==lastSeenInt）
{
myArrayList.remove（i+1）；
++最后一次计数；
}
其他的
{
如果（（LastSeenNintCount%2）==0）
{
myArrayList.remove（i+1）；
}
lastSeenInt=myArrayList.get（i）；
LastSeenNintCount=1；
}
}
如果（（LastSeenNintCount%2）==0）
{
myArrayList.remove（0）；
}
}

---

享受：）

我认为你最好的选择是对列表进行排序

然后，向后看，如果看到相同的整数，请删除整数，同时跟踪当前整数的总数

如果看到偶数总数，则不会删除最后一次出现。 如果您看到一个奇数总数，您将删除最后一个出现的

public void removePairElementsFrom(Arraylist<Integer> myArrayList)
{
    if (myArrayList == null)
    {
        return null;
    }

    int arrayLength = myArrayList.size();

    if (arrayLegnth == 1)
    {
        return myArrayList;
    )

    Collections.sort(myArrayList);

    int lastSeenInt = myArrayList.get(arrayLength - 1);
    int lastSeenIntCount = 1;

    for (int i = arrayLength - 2; i >= 0; --i)
    {
        if (myArrayList[i] == lastSeenInt)
        {
            myArrayList.remove(i+1);
            ++lastSeenIntCount;
        }
        else
        {
            if ((lastSeenIntCount % 2) == 0)
            {
                myArrayList.remove(i+1);
            }

            lastSeenInt = myArrayList.get(i);
            lastSeenIntCount = 1;
        }
    }

    if ((lastSeenIntCount % 2) == 0)
    {
        myArrayList.remove(0);
    }
}

public void removepaireleasfrom（Arraylist myArrayList）
{
如果（myArrayList==null）
{
返回null；
}
int-arrayLength=myArrayList.size（）；
如果（ArrayLenth==1）
{
返回myArrayList；
)
Collections.sort（myArrayList）；
int lastSeenInt=myArrayList.get（arrayLength-1）；
int lastSeenIntCount=1；
对于（int i=阵列长度-2；i>=0；--i）
{
if（myArrayList[i]==lastSeenInt）
{
myArrayList.remove（i+1）；
++最后一次计数；
}
其他的
{
如果（（LastSeenNintCount%2）==0）
{
myArrayList.remove（i+1）；
}
lastSeenInt=myArrayList.get（i）；
LastSeenNintCount=1；
}
}
如果（（LastSeenNintCount%2）==0）
{
myArrayList.remove（0）；
}
}

---

享受：）

如果允许您对arraylist进行排序，这将变得非常简单

public void removePairedElements(ArrayList<Integer> a){

    Collections.sort(a); //Sort a

    int i = 0;
    while(i < a.size() - 1){
      //Check if i and i+1 are the same element. If so, remove both
      if(a.get(i).equals(a.get(i+1))){
        //Remove i twice - effectively removes i and i+1
        a.remove(i);
        a.remove(i);

        //Move i *back* one index, which is equivalent to 
        //moving forward one because we just removed two elements.
        //Prevent i from becoming negative though.
        i = Math.max(0, (i - 1));
      }
      else{
        i++;
      }
    }
}

public void removePairedElements（数组列表a）{
Collections.sort（a）；//sort a
int i=0；
而（i

O（n log n）时间和O（1）空间。这可能是最干净的答案。如果不允许您更改arraylist的顺序，您必须执行其他操作，否则应该可以执行此操作。

如果您

[3, 7, 5, 5, 4, 7] 

class RemoveBadPairs {    
    Public Static void main() {
        ArrayList numbersList = new ArrayList();
        numberslist={3,7,9,2,5,5,8,5,6,3,4,7,3,1,7};   
        System.out.println("Original List...");
        for (e in : numbersList) {
            System.out.print("{0},", e);
        }
        if (((numbersList.Count % 2)!= 0)) {
            numbersList.RemoveAt((numbersList.Count - 1));
        }
        for (int i = (numbersList.Count - 1); (i <= 0); i = (i + -2)) {
            if ((numbersList[i] < numbersList[(i - 1)])) {
                numbersList.RemoveRange((i - 1), 2);
            }   
        }
        System.out.println("Final List...");
        for (e in : numbersList) {
            System.out.print(","+ e);
        }
    }
}