Eindeutige Elemente aus Array extrahieren

[AlexDerJavaTyp]

Also ich bin an dieser Aufgabe schon seit 2 Stunden dran und ich hab keine Ahnung was daran nicht stimmt, höchst wahrscheinlich ist es ein bloeder Fehler! ;(

Also es geht darum, dass mehrere Zahlen eingelesen werden, und ich dann alle doppelt-vorkommenden Zahlen lösche.
Also aus 1,2,1,2,1,2 wird 1,2 !

Wir sollen wirklich nur die Basics verwenden und nichts allzu kompliziertes!

hier der Java Code(IN der BL) und die Ausgabe:

public static int []loescheDoppelteZahl(int[]array)
    {
       int array2[] = new int[array.length]; 
int vorkommen = 0;
        for(int i = 0,j=0;i<array.length;i++)
        {
            vorkommen = 0;
            for(int b = 0;b<array.length;b++)
            {
                if(i==b)
                {
                    continue;
                }
                if(array[b]==array[i])
                {
                    vorkommen++;
                }
               
            }
            if(vorkommen==0)
            {
                array2[j]=array[i];j++;
            }
        }
        return array2;
    }

Ausgabe ist bei einer Eingabe von 1,2,1,2 : 0,0,0,0
Ausgabe bei einem anderen Versuch von 1,2,1,2: 1,2,2,2

Vielen Dank schon mal im Voraus!🙂

 

[Flown]

Also das kann man auf mehrere Arten lösen. Such dir eine Möglichkeit aus. Dein Code ist ein wenig wirr und kaum zu verstehen, darum liefere ich dir einen neuen:

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class DistinctTest {
  
  public static void main(String[] args) {
    System.out.println(Arrays.toString(distinctCollection(new Integer[] { 1, 2, 1, 2, 3, 1, 2, 1, 2, 2, 0 })));
    System.out.println(Arrays.toString(distinctArray(new int[] { 1, 2, 1, 2, 3, 1, 2, 1, 2, 2, 0 })));
    System.out.println(Arrays.toString(distinctLambda(new Integer[] { 1, 2, 1, 2, 3, 1, 2, 1, 2, 2, 0 })));
  }
  
  public static <T> T[] distinctCollection(T[] elements) {
    Set<T> distinct = new HashSet<>();
    for (T element : elements) {
      distinct.add(element);
    }
    @SuppressWarnings("unchecked")
    T[] result = (T[]) distinct.toArray();
    return result;
  }
  
  public static int[] distinctArray(int[] elements) {
    int cur = 0;
    int[] map = new int[elements.length];
    outer: for (int i = 0; i < elements.length; i++) {
      for (int j = 0; j < cur; j++) {
        if (map[j] == elements[i]) {
          continue outer;
        }
      }
      map[cur++] = elements[i];
    }
    return Arrays.copyOf(map, cur);
  }
  
  public static <T> T[] distinctLambda(T[] elements) {
    @SuppressWarnings("unchecked")
    T[] result = (T[]) Arrays.stream(elements).distinct().toArray();
    return result;
  }
}

 

[Thallius]

public static <T> T[] distinctLambda(T[] elements) {
@SuppressWarnings("unchecked")
T[] result = (T[]) Arrays.stream(elements).distinct().toArray();
return result;
}
}[/code]

Lamda ist echt geil. Also nicht alles was neu ist ist auch gut finde ich.
Für mich ist so ein Code die perfekte Arbeitsplatz-Erhaltuns-Maßnahme, weil ausser dem Author niemand anders den Code mehr warten kann.

Gruß

Claus

 

[Flown]

Also ich finde das jetzt nicht so schlimm mit der Lesbarkeit. Erst wenn man wirklich mit mappings und groupings arbeitet wirds magisch.

Ich finde nur die Brücken von Array <> Collection <> Stream schlecht gelöst und wünschte mir es wäre möglich mit den primitiven Datentypen wie bei C# zu arbeiten, dann würde das ganze auch runder werden.

 

[Thallius]

Ich finde es lustig, dass nach und nach irgendwelche Dinge "erfunden" werden um nachträglich Funktionalitäten zu schaffen die man früher immer als "Braucht kein Mensch" erachtet hat.

Das fängt ja schon mit den Generics an. Java war ja stolz darauf eine streng statisch typisierte Sprache zu sein. Blöd wenn man dann irgendwann feststellt, dass man damit manche Sachen einfach nicht realisiern kann und dann bastelt man halt schnell noch die Generics dazu.

Jetzt hat man festgestellt, dass es doch sehr nett sein kann mit Methoden-Pointern zu arbeiten und schwups gibt es auf einmal Lamda. Im Endeffekt wird dadurch doch einfach nur alles immer undurchsichtiger und komplexer und für Anfänger wesentlich schwerer zu begreifen. Java verliert damit seinen einzigen Vorteil gegenüber C++, nämlich das es einfacher zu erlernen ist. Wenn aber in Zukunft alle mit solchen Konstrukten wie oben um sich werfen, dann kann ich auch gleich C++ lernen, dass ist dann auf jeden Fall auch noch um einiges performanter.

Gruß

Claus

 

[Harry Kane]

Besonders lustig finde ich es, wenn solche Lösungen angeboten werden, wenn in der Frage extra nach Basics gefragt war.
@TO
Bei deinem Ansatz gehst du 2x über dein Array, 1x mit dem Index i, 1x mit dem Index b. Sobald die Bedingung

 if(array[b]==array[i])

erfüllt ist, wird die Zahl nicht in das Ergebnisarray aufgenommen. Dadurch eliminierst du aber alle Zahlen, die 2x oder mehr im Ausgangsarray vorkommen! Was du aber möchtest, ist des, jede Zahl, die im Ausgangsarray vorkommt, im Ergebnisarray aufzunehmen, aber nur 1x.
Dazu musst du einfach in der inneren for-Schleife den Index b nicht von 0 bis array.length laufen lassen, sondern nur von 0 bis i.

 

[JavaMeister]

Finde die Antworten auch grenzwertig. Entweder man verweist bei Basics auf Google oder man gibt die Lösung an. Mit den Postings kann der TO aber ca. 0 anfangen.

Außerdem ist der Titel des Postings unpassend. Mods können das korrigieren, damit der nächste, der diese Frage hat, diesen Thread als Lösung identifizieren kann.

 

[Flown]

Mit welchen Posting soll/kann der TO nichts anfangen?

 

[taro]

Mit welchen Posting soll/kann der TO nichts anfangen?

Mit Deinem. Deine Lösung mag zwar richtig sein, jedoch passt diese nicht zu der Bitte

Wir sollen wirklich nur die Basics verwenden und nichts allzu kompliziertes!

 

[Flown]

Ein Basic Bsp ist doch in meinem Codesnippet vorhanden! Außerdem wollte ich zeigen welches Spektrum es in Java gibt ein und dieselbe Aufgabe zu lösen. Denn wenn jemand diesen Post irgendwann einmal findet, kann er sich den passenden Lösungsweg aussuchen.