通過僅在Java中查看字符串的特定部分來刪除字符串數組的重復項

Question

我擁有的是稱為Id的String對象數組，然后遍歷Id對象以獲取與該Id相關聯的電子郵件地址（然后將它們連接起來）。 現在，我想從只有重復電子郵件地址的數組中刪除String （通過查看String中的Id來忽略它）。

例如， String數組包含以下Id對象：

{1, 2, 3}

現在，我將與該Id關聯的電子郵件地址串聯起來， String數組變為：

{1 - test@gmail.com, 2 - any@gmail.com, 3 - test@gmail.com}

因此，我需要刪除重復的電子郵件（以及與之Id ）以達到以下目的：

{1 - test@gmail.com, 2 - any@gmail.com}

然后，我將使用split刪除電子郵件地址，以得到以下最終結果：

{1, 2}

所以我遇到的問題是，它當然會查找包括email和Id的整個字符串，但是我只需要查找電子郵件地址，然后從數組中刪除整個`String。

我已經完成了以下代碼：

//Remove all duplicate email addresses from list
ArrayList<String> duplicateEmails = new ArrayList<String>();

//looping through cform.getConsumers which is a String[] array of Id's, finding email address of that Id and concatenate it and add to the array list
for (String conId : cform.getToConsumers()){
    Long consId = Long.parseLong(conId);
    Consumer cons = af.getSingleConsumerId(consId);
    duplicateEmails.add(conId + " - " + cons.getEmail());
}

//convert arraylist to String array
String[] stringArray = duplicateEmails.toArray(new String[0]);
//remove the duplicates
Set<String> findDuplicates = new HashSet<String>(Arrays.asList(stringArray));
String[] removedEmails = findDuplicates.toArray(new String[0]);

Answer 1

不用將Strings寫入數組，而是創建一個自己的對象數組。 例：

class MyPair{
    String id;
    String email;
    public String toString(){
        return id + " - " + email;
    }
}

然后，您可以比較電子郵件而無需再次解析整個String。

覆蓋hashCode（）和equals（Object）的完整示例：

package main;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

public class Test {

    public static void main(String[] args) {
        new Test().deduplicate();
    }

    public class MyPair {
         public final String id;
            public final String email;

            public MyPair(String id, String email) {
                super();
                this.id = id;
                this.email = email;
            }

            public String toString(){
                return id + " - " + email;
            }

            @Override
            public boolean equals(Object obj){
                if (!(obj instanceof MyPair))
                    return false;
                if (obj == this)
                    return true;
                return this.email.equals(((MyPair)obj).email);
            }
            @Override
            public int hashCode(){
                return this.email.hashCode();
            }
    }

    public void deduplicate() {
        List<MyPair> pairs = new ArrayList<MyPair>();

        // test data
        MyPair p1 = new MyPair("1", "asd@asd.com");
        MyPair p2 = new MyPair("2", "qwe@qwe.com");
        MyPair p3 = new MyPair("3", "asd@asd.com");
        pairs.add(p1);
        pairs.add(p2);
        pairs.add(p3);

        // just to demonstrate the overridden methods
        System.out.println(p1.equals(p2));
        System.out.println(p1.equals(p3));
        System.out.println(p2.equals(p3));
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        System.out.println(p3.hashCode());

        // dedup will be done by HashSet
        // This only works because we have overridden
        // hashCode and equals!
        HashSet<MyPair> deduped = new HashSet<MyPair>();
        for (MyPair pair : pairs) {
            deduped.add(pair);
        }

        System.out.println(deduped);

    }
}

輸出： [2 - qwe@qwe.com, 1 - asd@asd.com] （請注意更改的順序！這是由於散列而發生的）

Answer 2

您可以按照以下步驟操作：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;

public class Testing {

    public static void main(String[] args) {
        HashMap<String, String> hm = new LinkedHashMap<String, String>();

        String[] values = {"1","2","3"};
        ArrayList<String> ar = new ArrayList<String>();
        ar.add("test@gmail.com");
        ar.add("any@gmail.com");
        ar.add("test@gmail.com");


        for (int i = 0; i<ar.size();i++) {

            if (!hm.containsKey(ar.get(i)))
                hm.put(ar.get(i), values[i]);
        } 
        System.out.println(hm);

    }

}

輸出：

[1, 2]

Answer 3

為什么不使用3個數組，以便將重復電子郵件的索引保留在第三個數組中。 然后遍歷第一個（ID的）數組，並從中刪除那些索引。

因此，您具有ID數組，電子郵件數組，刪除數組的索引。

然后從內存釋放這些數組：）

這樣，您無需連接字符串然后搜索字符串

只是一個主意。