Question

我正在基于Java中的字符串处理创建一个程序，我需要从字符串数组中删除重复的字符串。在这个程序中，所有字符串的大小都是相同的。

作为字符串数组的'array'包含许多字符串，其中两个字符串彼此相似。因此，使用下面的代码必须删除重复的字符串，但不会删除它。

如何删除重复的字符串？

我正在使用以下代码。

    for(int s=0;s<array.length-1;s++)
    {
        for(int m=0;m<array.length;m++)
        {
                for(int n=0;n<array[m].length();n++)
                {   
                    if(array[s].charAt(n)==array[m].charAt(n))
                    {
                      continue;
                    }
                    else 
                break;
        } 
        if(n==array[m].length())
        {
            ArrayUtils.removeElement(array, array[s]);
        }
    }

Answer 1

这将有效

array = new HashSet<String>(Arrays.asList(array)).toArray(new String[0]);

或只使用HashSet代替数组。

Answer 2

Set<String> set = new HashSet<String>();
Collections.addAll(set, array);

或以

开头

for(int s=0;s<array.length-1;s++)
{
    for(int m=s + 1;m<array.length;m++)
    {

                if(array[s] != null && array[s].equals(array[m]))
                {
                  // array = ArrayUtils.removeElement(array, array[s]); --m;??
                  array[m] = null; // Mark for deletion later on
                }
    } 
}

Answer 3

除非[homework]，否则我会使用Set

String[] array =
Set<String> uniqueWords = new HashSet<String>(Arrays.asList(array));

Answer 4

建议的解决方案不保持元素的顺序。如果您使用Java 8或更高版本并希望维护订单，则可以按如下方式使用流：

array = Arrays.stream(array).distinct().toArray(String[]::new);

完整示例：https://www.javacodeexamples.com/java-string-array-remove-duplicates-example/849

Answer 5

import java.util.*;
public class Stringarray {

    public static void main(String args[]){

        String[] name = {"aim","rajesh","raju","aim"};

    Set<String> myset  = new HashSet<String>();
    Collections.addAll(myset,name);

       System.out.println(myset);
    }
}

Answer 6

为什么不使用String.equals()进行比较而不是手动迭代字符串中的字符？
您的逻辑实际上存在缺陷：对于array[s] == "12345"和array[m] == "123"，它会声称它们是平等的
此外，在您的内部循环中，for(int m=0;m<array.length;m++) m在某些时候也会等同于s，因此您需要将字符串与自身进行比较

这些注释假设您需要使用自己的代码实现删除逻辑，而不允许使用类库。如果不是这样，正如其他人所指出的那样，使用HashSet是最简单的方法。

Answer 7

为什么不删除最内层的循环，而不是String.equals(String)？

在第一次迭代中，您将array [0]与数组[0]进行比较，它们是相等的，并且它将被删除。然后你将原始数组[1]与数组中的所有其他元素进行比较，如果它们相等，则删除数组[1]（而不是另一个）。

有一些问题，如果有一些重复的字符串，你要删除第一个，这将减少数组的大小而不减少r所以，数组中的一些字符串被跳过。 / p>

我会使用强制唯一性的数据结构，例如Set。

如果阵列中有3个相等的字符串会发生什么，我不确定会发生什么。

我相信你会遇到一些ArrayIndexOutOfBoundsException。

Answer 8

我认为最终的if条件应该是如果（N ==（阵列[米]。长度（） - 1））

话虽如此，您似乎正在尝试实现String.equals（）方法在内部循环中所执行的操作。

Answer 9

     String[] arr = {"w10","w20","w10","w30","w20","w40","w50","w50"};
     List<String> arrList = new ArrayList<String>();
     int cnt= 0;
       //List<String> arrList = Arrays.asList(arr);
       List<String> lenList = new ArrayList<String>();
          for(int i=0;i<arr.length;i++){
        for(int j=i+1;j<arr.length;j++){
           if(arr[i].equals(arr[j])){
             cnt+=1;
           }                
        }
        if(cnt<1){
          arrList.add(arr[i]);
        }
          cnt=0;
        }

for(int k=0;k<arrList.size();k++){
            System.out.println("Array without Duplicates: "+arrList.get(k));
        }

Answer 10

List<String> al = new ArrayList<String>();
String[] months={"Jan","Feb","Mar","Apr","Jan","Mar","May","May"};
for(int i=0;i<months.length;i++){
    for(int j=1;j<months.length;j++){
        if(months[i].equalsIgnoreCase(months[j])){
            if(!al.contains(months[i])){
                al.add(months[i]);
            }
        }
    }
}

Answer 11

Sring[] myStringArray = {"hello", "hello", "moto"};
String[] filteredArray = new LinkedHashSet<String>(Arrays.asList(myStringArray))
                         .toArray(new String[0]);

System.out.println("filteredArray Size: " + filteredArray.length);
System.out.println("filteredArray[0] = " + filteredArray[0]);
System.out.println("filteredArray[1] = " + filteredArray[1]);

Answer 12

设置数据结构将自动执行该工作。如果您关心元素的顺序，那么最可能选择的是HashSet

TreeSet

Answer 13

在不使用集合的情况下从 String[] 中删除重复的 String

    public static void removeDuplicate(String[] str, int size){
            for(int i=0; i<size-1; i++){
                if(str[i]!=null){
                    for(int j=i+1; j<size-1; j++){
                        if(str[i].equals(str[j])){
                            str[j]=null;
                        }
                    }
                }
            }
            for(int i=0; i<size;i++){
                if(str[i]==null)
                   continue;
                System.out.println(str[i]);
            }
        }

Answer 14

重复整数删除：这是完美的答案 ///哈里斯///

public static void duplicateRemove(int[] arr) {
    int temp = 0;

    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr.length; j++) {
            if (arr[i] < arr[j]) {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }

    int count;
    for (int j = 0; j < arr.length;) {
        count = 1;
        for (int i = j + 1; i < arr.length; i++) {
            if (arr[i] == arr[j]) {
                count++;
            } else
                break;

        }
        System.out.println(arr[j] + " is :  " + count);
        j += count;
    }

}

删除字符串数组中的重复字符串

14 个答案: