Löschen Sie doppelte strings in der string-array

Ich bin ein Programm zu machen, basierend auf string-Verarbeitung in Java, in dem muss ich entfernen, doppelte strings aus einem string-array. In diesem Programm, die Größe der alle strings gleich sind.

Den 'array' was ist ein string-array enthält eine Anzahl von Zeichenfolgen, in denen zwei Zeichenketten ähneln einander. Also mit dem code unten die doppelte Schnur muss entfernt werden, aber es wird nicht entfernt.

Wie entfernen Sie doppelte strings?

Ich bin mit dem folgenden code.

    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]);
        }
    }

InformationsquelleAutor der Frage | 2012-04-28

30

Diese arbeiten
```
array = new HashSet<String>(Arrays.asList(array)).toArray(new String[0]);
```
oder benutzen Sie einfach eine HashSet anstelle eines Arrays.

InformationsquelleAutor der Antwort Garrett Hall
2

Es sei denn, dies ist [homework] ich würde einen Satz
```
String[] array =
Set<String> uniqueWords = new HashSet<String>(Arrays.asList(array));
```
InformationsquelleAutor der Antwort Peter Lawrey

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

oder starten Sie mit

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
                }
    } 
}

InformationsquelleAutor der Antwort Joop Eggen

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);
    }
}

InformationsquelleAutor der Antwort Thangenapally Rajesh

0
- Warum nutzen Sie nicht String.equals() für den Vergleich statt, Durchlaufen die Zeichen in den strings manuell?
- Ihre Logik ist tatsächlich fehlerhaft: für array[s] == "12345" und array[m] == "123" es würde behaupten, dass Sie gleich sind
- außerdem in Ihrem inneren Schleife for(int m=0;m<array.length;m++) m auch gleich s an einem gewissen Punkt, so dass Sie eine Zeichenfolge vergleichen, die sich
Diese Hinweise davon ausgehen, dass Sie implementieren müssen, um die Entfernung Logik mit Ihrem eigenen code, nicht erlaubt die Verwendung der Klassenbibliothek. Wenn dies nicht der Fall, wie die anderen angemerkt, mit einem HashSet ist der einfachste Ansatz.

InformationsquelleAutor der Antwort Péter Török
0

Warum hast du nicht entfernen die innere Schleife zugunsten der String.equals(String)?

In der ersten iteration, die Sie vergleichen array[0] array[0], die gleich sind, und es würde entfernt werden. Dann vergleichen Sie die original-array[1] mit allen anderen Elementen des Arrays array, und wenn Sie gleich sind, Sie entfernen, array[1] (nicht die anderen).

Gibt es einige Probleme, wenn es einige doppelte Strings, den Sie entfernen das erste, das reduziert die Größe des Arrays, ohne eine Verringerung der r so, einige der Strings im array übersprungen werden.

Ich würde verwenden Sie eine Daten-Struktur, die erzwingt Eindeutigkeit, wie ein Satz.

Was wird passieren, wenn du 3 gleiche Strings im array bin ich mir nicht sicher, was passieren wird.

Ich glaube, Sie würden auf einige ArrayIndexOutOfBoundsExceptions.

InformationsquelleAutor der Antwort Amir Pashazadeh
0

Denke ich, dass die if-Bedingung am Ende sein sollte
if(n==(array[m].length()-1))

Gesagt, dass Sie scheinen, zu versuchen, das umzusetzen, was String.equals () - Methode führt in Ihrem innersten Schleife.

InformationsquelleAutor der Antwort Martin Prakash

     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));
        }

InformationsquelleAutor der Antwort Janmejai

0

Vorgeschlagene Lösung Sie nicht halten Sie die Reihenfolge der Elemente. Wenn Sie Java 8 oder höher und pflegen wollen, ist die Reihenfolge, die Sie verwenden können, strömen Sie wie folgt vor:
```
array = Arrays.stream(array).distinct().toArray(String[]::new);
```
Vollständigen Beispiel: https://www.javacodeexamples.com/java-string-array-remove-duplicates-example/849

InformationsquelleAutor der Antwort Hubert Schumacher

-2

Doppelte Ganzzahl entfernen : das ist die perfekte Antwort
///Haris ///

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;
    }

}

InformationsquelleAutor der Antwort haris

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.