Java 根据字符串的第一个字符从ArrayList中删除重复项

我想从数组列表中删除第一个字符与另一个字符串相同的字符串

示例

List<String> collection = new ArrayList<String>();

collection.add("1 w a");
collection.add("2 r a");
collection.add("1 r b");
collection.add("2 r b");
collection.add("3 w a");

---

我尝试使用

hashset

和

linkedhashset

列表中包含要删除的索引

但是上面的评论是对的，计算上，也就是说。 从算法上看，您应该使用更好的数据结构 这里，而不是ArrayList

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


public class Test005 {

    public static void main(String[] args) {
        List<String> collection = new ArrayList<String>();
        collection.add("1 w a");
        collection.add("2 r a");
        collection.add("1 r b");
        collection.add("2 r b");
        collection.add("3 w a");

        List<Integer> ind = new ArrayList<Integer>();

        for (int i=0; i<collection.size(); i++){
            for (int j=0; j<i; j++){
                if (collection.get(j).charAt(0) == collection.get(i).charAt(0)){
                    ind.add(i);
                    break;
                }
            }
        }

        for (int k=0; k<ind.size(); k++){
            collection.remove(ind.get(k).intValue());
        }

        for (int i=0; i<collection.size(); i++){
            System.out.println(collection.get(i));
        }
    }

}

import java.util.ArrayList；
导入java.util.List；
公共类Test005{
公共静态void main（字符串[]args）{
列表集合=新的ArrayList（）；
收款。添加（“1 w a”）；
集合。添加（“2 r a”）；
集合。添加（“1 r b”）；
集合。添加（“2 r b”）；
收款。添加（“3 w a”）；
List ind=new ArrayList（）；
对于（int i=0；i基本上您要做的是遍历列表，对于每个元素，遍历列表的其余部分并删除具有相同起始字符的任何元素

示例实现：

List<String> deleteList = new ArrayList<String>();
for(int i = 0;i < collection.size();i ++){
    //If this is flagged for deletion continue
    if(deleteList.contains(collections.get(i)))continue; 
    for(int j = i + 1;j < collection.size();j ++){
        //If this is flagged for deletion continue
        if(deleteList.contains(collections.get(j)))continue;
        //If the chars are the same, add it to the list to be deleted
        if(collection.get(i).charAt(0) == collection.get(j).charAt(0)){
            deleteList.add(collection.get(j));
        }
    } 
}

collection.removeAll(deleteList);

List deleteList=new ArrayList（）；
对于（int i=0；i
只需最少存储第一个
字符
，您就可以查找和删除DUP：

List<Character> dups = new ArrayList<Character>();
        Iterator<String> itr = collection.iterator();
        while(itr.hasNext()) {
            String s = itr.next();
            char c = s.charAt(0);
            if(dups.contains(c)) {
                itr.remove();
                continue;
            }
            dups.add(c);
        }
        System.out.println(collection);

List dups=new ArrayList（）；
迭代器itr=collection.Iterator（）；
while（itr.hasNext（））{
字符串s=itr.next（）；
字符c=s.charAt（0）；
如果（重复包含（c））{
itr.remove（）；
继续；
}
重复添加（c）；
}
系统输出打印项次（集合）；

输出：

[1 w a，2 r a，3 w a]
列表集合=新的ArrayList（）；
 List<String> collection = new ArrayList<String>();

    collection.add("1 w a");
    collection.add("2 r a");
    collection.add("1 r b");
    collection.add("2 r b");
    collection.add("3 w a");

    Set set = new HashSet();
    for(int i=0;i<collection.size();++i){
        String temp = collection.get(i);
        if(set.contains(temp.charAt(0))){
            collection.remove(temp);
            i--;
        }  else{
            set.add(temp.charAt(0));
        }
    }
    for(int i=0;i<collection.size();++i){
        System.out.println(collection.get(i));
    }

收款。添加（“1 w a”）；
集合。添加（“2 r a”）；
集合。添加（“1 r b”）；
集合。添加（“2 r b”）；
收款。添加（“3 w a”）；
Set=newhashset（）；
对于（int i=0；i遍历给定列表的每个元素，借助临时集合，我们检查第一个元素是否在集合中。如果不在集合中，则将其添加到最终列表中。如果它已包含该元素，则跳过它

import java.util.*;
public class Test {

public static void main(String[] args) {
    List<String> collection = new ArrayList<String>();

    collection.add("1 w a");
    collection.add("2 r a");
    collection.add("1 r b");
    collection.add("2 r b");
    collection.add("3 w a");
    System.out.println(removeDuplicates(collection));
}

private static List<String> removeDuplicates(List<String> collection) {

    HashSet<String> withoutDuplicates = new HashSet<String>();
    List<String> collection2 = new ArrayList<String>();
    for(String s : collection){
        String[]  temp = s.split(" ");

        if(!withoutDuplicates.contains(temp[0])){
            withoutDuplicates.add(temp[0]);
            collection2.add(s);
        }
    }
    return collection2;
}
}

import java.util.*；
公开课考试{
公共静态void main（字符串[]args）{
列表集合=新的ArrayList（）；
收款。添加（“1 w a”）；
集合。添加（“2 r a”）；
集合。添加（“1 r b”）；
集合。添加（“2 r b”）；
收款。添加（“3 w a”）；
System.out.println（移除副本（收集））；
}
移除的私有静态列表副本（列表集合）{
HashSet without duplicates=新HashSet（）；
List collection2=新的ArrayList（）；
用于（字符串s:集合）{
字符串[]temp=s.split（“”）；
如果（！withoutDuplicates.contains（临时[0]））{
无重复项。添加（临时[0]）；
集合2.添加（s）；
}
}
退货回收2；
}
}
使用
树集
和只查看第一个字符的
比较器
。将所有元素插入该集中

 new TreeSet<String>(
   new Comparator<String>(){
     public int compare(String s1, String s2){
         if (s1 == null || s1.length() == 0)
            return (s2 == null || s2.length() == 0) ? 0 : 1;
         else if (s2 == null || s2.length == 0)
            return -1;
         else 
            return s1.substring(0,1).compareTo(s2.substring(0,1));
     }
 });

新树集(
新比较器（）{
公共整数比较（字符串s1、字符串s2）{
如果（s1==null | | s1.length（）==0）
返回值（s2==null | | s2.length（）==0）？0:1；
else if（s2==null | | s2.length==0）
返回-1；
其他的
返回s1.子串（0,1）.比较到（s2.子串（0,1））；
}
});
您可以使用
映射
，将第一个字符映射到字符串，尽管这可能有点过分。@Quilliom谢谢。但我想使用ArrayList。使用此方法填充另一个ArrayList，然后在一个步骤中将第一个字符添加到一个单独的
集合
，并在每个步骤检查下一个字符串的第一个字符列表。如果不需要，请告诉我清楚地理解这一点。@Prateek但是ArrayList对于这种任务来说是错误的数据结构A
TreeSet
与任何其他
Set
操作类似，因为它只允许一个它认为“相等”的元素。我提供的
比较器
只查看
字符串
的第一个字符。它增加了一些处理空/空大小写的复杂性。通过向
树集
提供此
比较器
，
集
将只保留具有唯一第一个字符的第一个
字符串。现在只需添加y即可ou将元素集合到集合中。
 new TreeSet<String>(
   new Comparator<String>(){
     public int compare(String s1, String s2){
         if (s1 == null || s1.length() == 0)
            return (s2 == null || s2.length() == 0) ? 0 : 1;
         else if (s2 == null || s2.length == 0)
            return -1;
         else 
            return s1.substring(0,1).compareTo(s2.substring(0,1));
     }
 });