Array-Liste nur einmal ausgeben

[dolu28]

Hallo ich will das die Array-Liste zufällig ausgegeben wird, aber jedes Tier soll nur ein einziges mal ausgegeben werden.

package x;
import java.util.Random;
public class ausgabe {

public static void main(String[] args){
String[] liste = { "Katze", "Hund", "Maus"};
Random b = new Random();

for(int r=0;r<3; r++){
int a = b.nextInt(2)+1;
System.out.println(liste[a]);
    }}
}

Könnte mir vllt einer helfen? MfG

 

[Joose]

Dann musst du dir speichern welche Indexe du schon ausgegeben hast.
Und solange ein neuen Wert für 'a' berechnen bis du einen gefunden hast der noch nicht ausgegeben wurde.

 

[dolu28]

Aber wie kann ich zwei Indexe speichern?
Meine Idee wäre eine Variable den Wert von a zu geben

int p=a;

und danach zu prüfen ob es mit der nächsten zufälligen Zahl übereinstimmt

if(p==i){
//continue
}

. Aber damit kann ich nur 1 Zahl speichern?
MfG

 

[Joose]

Aber wie kann ich zwei Indexe speichern?

Wenn du mehrere Sachen speichern willst brauchst du entweder eine Liste oder ein Array


du könntest zum Beispiel ein weiteres Array verwenden welches so groß wie deine Array ist.
Alle Werte im Array sind am Anfang -1 oder 0 .... wenn du etwas aus deiner Liste ausgibst änderst du den Wert in diesem 2ten Array auf etwas > 0.

Jetzt musst du solange einen neuen Index suchen bis du für diesen Index im 2ten Array einen Wert <= 0 hast. Dann wurde das Element noch nicht ausgegeben usw.

 

[Harry Kane]

Alle Werte im Array sind am Anfang -1 oder 0 .

Oder true oder false, wenn man ein boolean[] benutzt.

 

[dolu28]

Ich verstehe es immernoch nicht könnt ihr mir ein Beispiel-Code zeigen MfG

 

[Harry Kane]

So zum Beispiel. Bitte die Kommentarre im Code durchlesen und bei Verständisfragen melden.

import java.util.Random;
public class UniqueRandomizer {
    public static void main(String[] args) {
        String[] liste = {"Katze", "Hund", "Maus", "Kuh", "Pferd", "T-Rex"};
        Random r = new Random();
        int anzahlInArray = liste.length;// Länge der Liste
        boolean[] schonAusgegeben = new boolean[anzahlInArray];//Alle Felder initialisiert mit "false"
        int anzahlAusgaben = 0;//Anzahl der schon ausgegebenen Felder aus liste
        //Solange noch nicht alle Einträge ausgegeben wurden
        while (anzahlAusgaben < anzahlInArray) {
            //neuen zufälligen aktuellen Index beschaffen
            int aktuellerIndexZumTesten = r.nextInt(anzahlInArray);
            //Falls Wert aus liste am aktuellen Index noch NICHT ausgegeben wurde
            if (!schonAusgegeben[aktuellerIndexZumTesten]) {
                //Den Wert aus liste am aktuellen Index ausgeben
                System.out.println(liste[aktuellerIndexZumTesten]);
                //Im array "schonAusgegeben" marrkieren, dass am aktuellen Index schon was ausgegeben wurde
                schonAusgegeben[aktuellerIndexZumTesten] = true;
                //und die Anzahl der Ausgaben um eins erhöhen
                anzahlAusgaben++;
            }
        }
    }
}

 

[Flown]

Alternativ: Du erstellst eine Kopie von deinem Array/Liste und mischt es. So ist auch garantiert, dass jeder Eintrag beim Iterieren vorkommt.

import java.util.*;

public class Test {
  public static void main(String... args) {
    String[] animals = {"Hund", "Katze", "Maus"};

    //Using List
    List<String> animalList = new ArrayList<>(Arrays.asList(animals));
    Collections.shuffle(animalList);
    for (String animal : animalList) {
      System.out.println(animal);
    }

    //Using Array
    for (String animal : shuffledCopy(animals)) {
      System.out.println(animal);
    }
  }

  private static String[] shuffledCopy(String[] animals) {
    String[] copy = animals.clone();
    Random r = new Random();
    for (int i = copy.length - 1; i > 0; i--) {
      final int idx = r.nextInt(i + 1);
      if (idx != i && copy[idx] != copy[i]) {
        String temp = copy[idx];
        copy[idx] = copy[i];
        copy[i] = temp;
      }
    }
    return copy;
  }
}

 

[Flown]

Ein wenig generischer:

import java.util.*;

public class Test {
  public static void main(String... args) {
    String[] animals = {"Hund", "Katze", "Maus"};
    for (String animal : shuffledCopy(Arrays.asList(animals))) {
      System.out.println(animal);
    }

    for (String animal : shuffledCopy(animals)) {
      System.out.println(animal);
    }
    System.out.println(Arrays.toString(animals));

  }

  private static <E> List<E> shuffledCopy(List<E> list) {
    List<E> copy = new ArrayList<>(list);
    Collections.shuffle(copy);
    return copy;
  }

  private static <T> T[] shuffledCopy(T[] arr) {
    T[] copy = arr.clone();
    Random r = new Random();
    for (int i = copy.length - 1; i > 0; i--) {
      final int idx = r.nextInt(i + 1);
      if (idx != i && copy[idx] != copy[i]) {
        T temp = copy[idx];
        copy[idx] = copy[i];
        copy[i] = temp;
      }
    }
    return copy;
  }
}