Entfernen doppelte strings aus einem array?

Wie kann ich entfernen Sie doppelte strings aus einem string-array ohne Verwendung eines HashSet?

Ich versuche es mal mit Schleifen, aber die Wörter nicht löschen.

StringBuffer outString = new StringBuffer("Our, aim, and, isn't, easy, you, you're, actual, and, are, aren't, and, improve, achieving, and, Obviously, and, illumination, are");

wordList = outString.toString().split(", ");
for (i = 0; i < wordList.length; i++) {
  for (j = 0; j < wordList.length; j++) {
    if((wordList[i]!=wordList[j])&&(j>i)){
      t=true;
    }
  }
  if(t==true){
    k++;
  }
}
String[] wordList1 = new String[k];
wordList = outString.toString().split(", ");
for (i = 0; i < wordList.length; i++) {
  (j = 0; j < wordList.length; j++) {
    if((wordList[i]!=wordList[j])&&(j>i)){
      t=true;
    }
  }
  if(t==true){
    wordList1[i]=wordList[i];
  }
}

Und warum ist die Verwendung von einem Satz aus der Bild? Auch kann ich nicht verstehen, wie Sie versuchen zu entfernen, in Ihrem Beispiel.
Bitte geben Sie ein Beispiel-Wert für outString.
Es ist Teil meiner Arbeit(
Sie am Ende immer die Einstellung, dass t wahr ist, was bedeutet, dass alle Wörter kopiert. Blick auf die Logik der Schleife. t ist nie festgelegt auf false wieder! Auch, da Sie eine j>i Zustand, warum nicht starten Sie die zweite Schleife mit i+1 statt bei 0. Es gibt viele andere Probleme mit dem code...
Jones StringBuffer outString = new StringBuffer("Our, aim, and, isn't, easy, you, you're, actual, and, are, aren't, and, improve, achieving, and, Obviously, and, illumination, are");

InformationsquelleAutor Anton Artemov | 2013-04-23

Versuchen, diesen code zu entfernen dup Worten:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < wordList.length; i++) {
    boolean found = false;
    for (int j = i+1; j < wordList.length; j++) {
        if (wordList[j].equals(wordList[i])) {
            found = true;
            break;
        }
    }
    //System.out.printf("Checking: [%s]%n", wordList[i]);
    if (!found) {
        if (sb.length() > 0)
            sb.append(' ');
        sb.append(wordList[i]);
    }
}
System.out.printf("Unique: [%s]%n", sb);

InformationsquelleAutor anubhava

4

1)
Ich glaube, Sie müssen verwenden Sie die equals-operator. Versuchen
```
if (!wordList[i].equals(wordList[j])){
```
statt !=.

2) Auch Kevin hat Recht. Sie benötigen, um t wieder auf false.

3) Seite Hinweis: wie bereits von anderen schon: um noch effizienter Zu werden, sollten Sie beginnen, die innere Schleife mit
```
for (j = i+1; j < wordList.length; j++) {
```
4) ein Weiterer kleiner Hinweis: Dein Ergebnis-array ist immer noch zu lang. Wenn Sie nicht wollen, zu einem List<String> und es ist ok zu verlieren, das ursprüngliche array, das Sie gehen könnte mit einer Lösung wie vorgeschlagen von Zim-Zam O'Pootertoot und legen Sie die original-Duplikate, null -, ein Zähler
zu zählen, wie viele null-Werte zugewiesen, initialisieren Sie das neue array mit der richtigen Größe und Schleife ein letztes mal über das erste array und kopieren Sie nur die nicht-null-Werte in dein neues array.
- Immer noch nicht richtig(
- Können Sie mir mehr code?
- Ich verstehe nicht, nur diesen Teil.
- das Teil ist schwer? versuchen zu beschreiben, was du versucht hast und was deine Ergebnisse sind. Sonst weiß niemand, was die Probleme sind, die Sie mit zu kämpfen. Versuchen Sie, mehr spezielle.
InformationsquelleAutor luksch

Wenn Sie berechtigt sind, zu verwenden Lists definieren Sie eine generische Methode, die das ziemlich leicht:

public <T> T[] removeDuplicates(final T[] array) {
    List<T> noDuplicates = new ArrayList<T>();
    for (T arrayElem : array) {
        if (!noDuplicates.contains(arrayElem)) {
            noDuplicates.add(arrayElem);
        }
    }
    return (T[]) noDuplicates.toArray();
}

I cant use-Liste(((

InformationsquelleAutor Keppil

2

Werden Sie wahrscheinlich wollen, um die Menge t wieder auf false nach dem ziehen der Wert, den Sie wollen:
```
if(t)
{
     wordList1[i]=wordList[i];
     t = false;
}
```
Auch dies:
```
if((wordList[i]!=wordList[j])&&(j>i))
```
Wird immer true zurück, da die strings sind unveränderlich (es sei denn, Sie im Vergleich einer Zeichenfolge, um eine genaue Referenz von sich selbst, die Sie verbieten mit j>i). Sie müssen, um es zu ändern, dies zu sagen:
```
if (!(wordList[i].equals(wordList[j]))&&(j>i))
```
Mit .equals wird im Vergleich, dass Sie dieselbe Zeichenfolge enthalten, nicht, dass Sie Punkt um den genauen Verweis auf eine Zeichenfolge.

Nicht sicher, ob das die einzigen Probleme, oder nicht, ist ein wenig unklar aus, was gegeben.

InformationsquelleAutor Kevin DiTraglia
0

In Ihrem inneren Schleife initialisieren j = i + 1
```
if(wordlist[i] != null && wordlist[i].equals(worldlist[j])) { wordlist[j] = null; }
```
...und dann compact array, wenn Sie fertig sind, entfernen Sie alle null-Werte

InformationsquelleAutor Zim-Zam O'Pootertoot
0

Wie wäre es mit einer Liste:
```
wordList = outString.toString().split(", ");
List<String> finalList = new ArrayList<String>();
for(String val : wordList) {
  if(!finalList.contains(val)) {
    finalList.add(val);
  }
}
```
Einer Reihe effizienter wäre, aber. Wenn Sie nicht verwenden können, eine Liste oder ein Set, und Sie sind gezwungen, entfernen Sie die Duplikate, dann müssen Sie eine Schleife durch das array jedes mal, das für die schrecklich.
- Oh. Auch kann ich nicht verwenden List<>
- Dann, warum nicht ersetzen die Liste mit einer einfachen Reihe? Sie müssen manuell Schleife das array, das Sie hinzufügen, um zu sehen, ob der Wert bereits vorhanden ist. Sie könnten eine Funktion schreiben, die für, die.
InformationsquelleAutor CodeChimp
0

Iteration durch das array und speichern Sie in einem Hilfs - int[] oder List<Integer> die Indizes von Duplikaten, die Sie finden, mit Ihren zwei for's.

Erstellen Sie ein neues Array mit der Größe dem original gleich eins minus der Größe des wiederholten Zeichenfolgen.

Durchlaufen Ihre original-array, wenn der index nicht auf Ihre Hilfs-Liste, legen Sie es auf Ihr neues Array.

InformationsquelleAutor pcalcao

Die beste und effektivste Methode ist, um angenommen arr ist das array, das strings enthält, und kann doppelte Werte:

Arrays.sort(arr);
int l = 0;
for (int a = 0; a < arr.length; a++) {
    if (a == arr.length - 1)
        l++;//its a unique value
    else if (!(a[a + 1].equals(arr[a])))
        l++;//its also a unique
}
String newArray[] = new String[l];
l = 0;
for (int a = 0; a < arr.length; a++) {
    if (a == arr.length - 1)
        newArray[l] = arr[a];
    else if (!(a[a + 1].equals(arr[a]))) {
        newArray[l] = arr[a];
        l++;
    }
}

Ich denke, es wäre effektiver, wenn es nicht syntax-Fehler.

InformationsquelleAutor Mamoon Ahmed

Versuchen, diese...

public class RemoveDupsStringArray {

public static void main(String[] args) {
    String[] withDuplicates = new String[] {"one","one","two","three","one","three","three"};
    String[] withoutDuplicates = new String[] {"one","two","three"};

    removeDuplicates(withDuplicates);
    removeDuplicates(withoutDuplicates);
}

private static void removeDuplicates(String[] array) {
    int[] occurence = new int[array.length];
    for (int i = 0; i < array.length; i++) {
        for(int j=i+1;j<array.length;j++){
            if(array[i]==array[j]){
                occurence[j]=j;
            }
        }
    }
    int resultLength=0;
    for(int i=0;i<occurence.length;i++){
        if(occurence[i]==0){
            resultLength++;
        }
    }
    String[] result=new String[resultLength];
    int index=0;int j=0;
    for(int i=0;i<occurence.length;i++){
        index = occurence[i];
        if(index==0){
            result[j]= array[i];
            j++;
        }
    }

    for(String eachString : result){
        System.out.println(eachString);
    }
}
}

Dies kann zwar theoretisch die Frage zu beantworten, wäre es vorzuziehen gehören die wesentlichen Teile der Antwort hier, und geben Sie den link zur Referenz.

InformationsquelleAutor SunilPalla

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.