• Wir präsentieren Dir heute ein Stellenangebot für einen Java Entwickler - m/w/d in Augsburg, München, Stuttgart oder Bamberg. Hier geht es zur Jobanzeige

Arrays auflisten ohne Wiederholung

Sinan

Sinan

Mitglied
Hallo zusammen,
Ich hoffe ich konnte mit meinen Titel,mein Problem etwas erklären. Da ich mir seit tagen den kopf zerbreche und auch schon mehrere Stunden gegoogelt habe.
Ich finde einfach keinen Ansatz wie ich mein Problem in Wörter fassen soll,deshalb wollte ich fragen ob ihr mir helfen könnt.
Ich muss für ein Schulprojekt einen "Oberstufen-Fachwahl" Programm in Java coden. Das habe ich bis jetzt, und es fiel mir auch relativ leicht.
Java:
import java.util.Scanner;
public class Example{

    public static void main(String args[]){
        String [] faecher01 = {"Mathematik", "Englisch", "Spanisch", "Biologie", "Chemie", "Physik"};
        String [] faecher02 = {"Mathematik", "Englisch", "Spanisch", "Biologie", "Chemie", "Physik", "Deutsch", "Kunst", "Geschichte", "PoWi", "Informatik",};
        int aa,bb;
        Scanner in = new Scanner(System.in);
        System.out.println("Willkommen zum Fachwahlprogramm der Schule. Bitte wählen sie ihre gewünschten Leistungskurse.Achten sie darauf das sie ein Fach nicht doppelt wählen") ;
    System.out.println("Folgende Pflicht-LK-Fächer stehen zur Wahl: 0=Mathe, 1=Englisch, 2=Spanisch, 3=Biologie, 4=Chemie, 5=Physik ");
    System.out.println("Geben Sie eine Nr. fuer die Ausgabe des 1. LK-Fachs an: "); aa = in.nextInt();
    System.out.println("Das 1. LK-Fach ist " + faecher01[aa]);
     System.out.println("Folgende weitere LK-Fächer stehen zur Wahl: 0=Mathematik, 1=Englisch, 2=Spanisch, 3=Biologie, 4=Chemie, 5=Physik, 6=Deutsch, 7=Kunst, 8=Geschichte, 9=PoWi, 10=Informatik");
    System.out.println("Geben Sie eine Nr. fuer die Ausgabe des 2. LK-Fachs an: "); bb = in.nextInt();
    System.out.println("Das 2. LK-Fach ist " + faecher02[bb]);
Mein Problem ist wie folgt:
In der Aufgabenstellung wurde auch gefordert,dass nachdem man die Leistungskurse gewählt hat,die restlichen Fächer als "Grundkurse" nochmal aufgezählt werden sollen
Java:
System.out.println("Sie haben " +  faecher01[aa]  +  faecher02[bb] + "gewählt," );
Das auflisten der Gewählten Leistungskurse viel mir relativ leicht,jedoch weiß ich nicht wie ich die restlichen fächer auflisten soll. Denn die Leistungskurse dürfen ja nicht auch in den Grundkursen gelistet sein.
Beispiel ausgabe:
"Sie haben Spanisch und Englisch Gewählt, ihre Grundkurse sind Mathematik,Biologie,Chemie,Physik,Deutsch,Kunst,Geschichte,PowI,Informatik"
Ich hoffe ihr wisst was ich meine und könnt mir dabei helfen. Ich habe das Gefühl das ich die Lösung schon lange kenne,aber ich komme einfach nicht drauf.
 
Zuletzt bearbeitet:
mihe7

mihe7

Top Contributor
Ist doch gut, wenn es Dir bislang leicht gefallen ist, jedoch melde ich Zweifel an, dass es Sinn der Übung ist, das Array nochmal als String zu wiederholen. Und mit Wiederholung sind wir auch schon beim Thema.
 
Zuletzt bearbeitet:
kneitzel

kneitzel

Top Contributor
Also neben dem, was @mihe7 schon angemerkt hat:

- Wähle vernünftige Bezeichner! aa, bb, faecher01, faecher02, ... da sind Probleme vorprogrammiert. Was für Fächer sind denn die 01er? Was ist in aa und bb? Aussagekräftige Namen sind wichtig, so St wirst du Fehler nie finden ...

- Pack nicht zu viel in eine Zeile! Du nimmst dir absichtlich Lesbarkeit!

- unterteilen das Problem in Teilprobleme. Also wenn ihr noch nicht objektorientiert arbeitet, dann als Minimum eine Aufteilung in Methoden!

Und das, was du bisher hast, ist so nicht gut:
- das abfangen ungültigen Eingaben mag evtl. nicht gefordert sein (ich nehme LK 10001)
- Die Leistungskurse Physik und Physik dürften aber als Auswahl nicht gültig sein, oder?
 
Sinan

Sinan

Mitglied
Also neben dem, was @mihe7 schon angemerkt hat:

- Wähle vernünftige Bezeichner! aa, bb, faecher01, faecher02, ... da sind Probleme vorprogrammiert. Was für Fächer sind denn die 01er? Was ist in aa und bb? Aussagekräftige Namen sind wichtig, so St wirst du Fehler nie finden ...

- Pack nicht zu viel in eine Zeile! Du nimmst dir absichtlich Lesbarkeit!

- unterteilen das Problem in Teilprobleme. Also wenn ihr noch nicht objektorientiert arbeitet, dann als Minimum eine Aufteilung in Methoden!

Und das, was du bisher hast, ist so nicht gut:
- das abfangen ungültigen Eingaben mag evtl. nicht gefordert sein (ich nehme LK 10001)
- Die Leistungskurse Physik und Physik dürften aber als Auswahl nicht gültig sein, oder?
Danke erstmal für all die Tipps. Ich muss aufjedenfall meine Ordunung und Struktur verbessen. Wir haben erst kürzlich mit Java angefangen und damit tue ich mir noch schwer.

Also Danke erstmal für all die Tipps. Ich muss aufjedenfall meine Ordunung und Struktur verbessen. Wir haben erst kürzlich mit Java angefangen und damit tue ich mir noch schwer.

" das abfangen ungültigen Eingaben mag evtl. nicht gefordert sein (ich nehme LK 10001)"
Also für ungültige Eingaben etc. wurde nichts gesagt. Es soll ein sehr simpler code sein und nur die Sachen die ich aufgelistet habe werden bewertet von der Schule.

- "Die Leistungskurse Physik und Physik dürften aber als Auswahl nicht gültig sein, oder?"
Richtig,das habe ich vergessen zu erwähnen. Dieses Problem wollte ich einfach mit einer If-Anweisung beheben,also :

Java:
 if (aa==bb)
    {
        System.out.println("Die Kombination ist ungültig. Wählen Sie erneut!");
    }
 
Sinan

Sinan

Mitglied
Wenn aa und bb Strings/Texte sind, dann ist der Vergleich mit == falsch. Du musst mit aa.equals(bb) vergleichen.
aa und bb sind keine Strings/Texte sondern int. Also aa speichert die zahl (0 bis 5) die man bei der ersten eingabe wählt.
Das wäre diese zeile hier
Java:
System.out.println("Geben Sie eine Nr. fuer die Ausgabe des 1. LK-Fachs an: "); aa = in.nextInt();
Das ist bei bb genau, nur da wird die eingabe der 2. Frage gespeichert (0 bis 10) :D
Java:
 System.out.println("Geben Sie eine Nr. fuer die Ausgabe des 2. LK-Fachs an: "); bb = in.nextInt();
 
Sinan

Sinan

Mitglied
Das einzige woran ich komplett verzweifle ist wie gesagt ,dass nachdem man die Leistungskurse gewählt hat,die restlichen Fächer als "Grundkurse" nochmal aufgezählt werden sollen. Das habe ich noch nie im Unterricht gemacht,und auch google konnte mir nicht helfen. Vom dem Rest habe ich zumindest schonmal ein Konzept und weiß wie ich diese verbessern etc kann.
 
kneitzel

kneitzel

Top Contributor
Der erste Schritt ist immer, sich das genau vorzustellen. Kannst du jemanden in Worten genau beschreiben, was er machen soll?

Wenn du es genau beschrieben hast, dann kannst du es dem Computer beschreiben.
 
Sinan

Sinan

Mitglied
1

123neu

Bekanntes Mitglied
Du musst das insgesamt objektorientierter machen... sowas in die Richtung:

Java:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Oberstufenplaner {

    private static void putFach(Map<Integer, List<Fach>> faecher, Fach fach) {
        int feldnr = fach.getFeldnr();
        if (!faecher.containsKey(feldnr)) {
            faecher.put(feldnr, new ArrayList<>());
        }
        if (!faecher.get(feldnr).contains(fach)) {
            faecher.get(feldnr).add(fach);
        }
    }

    private static boolean containsFach(Map<Integer, List<Fach>> faecher, Fach fach) {
        return faecher.containsKey(fach.getFeldnr()) && faecher.get(fach.getFeldnr()).contains(fach);
    }

    private static void selectOneFach(Map<Integer, List<Fach>> faecher, int feldnr) {
        ArrayList<Fach> toSelect = new ArrayList<>();
        for (Fach fach : Fach.values()) {
            if (fach.getFeldnr() == feldnr && !containsFach(faecher, fach)) {
                toSelect.add(fach);
            }
        }
        System.out.println("Wählen Sie aus den folgenden Fächern eins aus (" + toSelect.get(0).getFeld() + "):");
        int i = 1;
        for (Fach fach : toSelect) {
            System.out.println(i + ": " + fach);
            i++;
        }
        int rawInput = Integer.parseInt(new Scanner(System.in).nextLine());
        putFach(faecher, toSelect.get(rawInput - 1));
    }

    private static void selectOneAbiFach(Map<Integer, List<Fach>> faecher, Map<Integer, List<Fach>> abiFaecher, List<Integer> feldnr, int nr) {
        ArrayList<Fach> toSelect = new ArrayList<>();
        for (Fach fach : Fach.values()) {
            if (feldnr.contains(fach.getFeldnr()) && !containsFach(abiFaecher, fach)) {
                toSelect.add(fach);
            }
        }
        System.out.println("Wählen Sie Ihr " + nr + ". Abiturfach aus (Fach Nr. 4 ist mündlich):");
        int i = 1;
        for (Fach fach : toSelect) {
            System.out.println(i + ": " + fach);
            i++;
        }
        int rawInput = Integer.parseInt(new Scanner(System.in).nextLine());
        putFach(faecher, toSelect.get(rawInput - 1));
        putFach(abiFaecher, toSelect.get(rawInput - 1));
    }

    public static void main(String[] args) {
        int from = 1, to = 5;
        Map<Integer, List<Fach>> faecher = new HashMap<>();
        Map<Integer, List<Fach>> abiFaecher = new HashMap<>();
        putFach(faecher, Fach.Deutsch);
        putFach(faecher, Fach.Mathematik);
        putFach(faecher, Fach.Sport);
        selectOneFach(faecher, 1);
        selectOneFach(faecher, 2);
        selectOneFach(faecher, 3);
        selectOneAbiFach(faecher, abiFaecher, Arrays.asList(1), 1);
        selectOneAbiFach(faecher, abiFaecher, Arrays.asList(3), 2);
        selectOneAbiFach(faecher, abiFaecher, Arrays.asList(1, 2, 3, 4, 5), 3);
        selectOneAbiFach(faecher, abiFaecher, Arrays.asList(1, 2, 3, 4, 5), 4);
        System.out.println("Deine gewählten Fächer sind:");
        for (int i = from; i <= to; i++) {
            List<Fach> list = faecher.get(i);
            if (list != null) {
                for (Fach fach : list) {
                    System.out.println(fach);
                }
            }
        }
        System.out.println("Deine Abiturfächer sind:");
        for (int i = from; i <= to; i++) {
            List<Fach> list = abiFaecher.get(i);
            if (list != null) {
                for (Fach fach : list) {
                    System.out.println(fach);
                }
            }
        }
        System.out.println("Vielen Dank für die Benutzung des Tools.");
    }
}

enum Fach {

    Deutsch(1, "sprachlich-literarisch-künstlerisch", "Deutsch"),
    Musik(1, "sprachlich-literarisch-künstlerisch", "Musik"),
    Kunst(1, "sprachlich-literarisch-künstlerisch", "Kunst"),
    Englisch(1, "sprachlich-literarisch-künstlerisch", "Englisch"),
    Französisch(1, "sprachlich-literarisch-künstlerisch", "Französisch"),
    Russisch(1, "sprachlich-literarisch-künstlerisch", "Russisch"),
    Spanisch(1, "sprachlich-literarisch-künstlerisch", "Spanisch"),
    Niederländisch(1, "sprachlich-literarisch-künstlerisch", "Niederländisch"),
    Italienisch(1, "sprachlich-literarisch-künstlerisch", "Italienisch"),
    Lateinisch(1, "sprachlich-literarisch-künstlerisch", "Lateinisch"),
    Griechisch(1, "sprachlich-literarisch-künstlerisch", "Griechisch"),
    Hebräisch(1, "sprachlich-literarisch-künstlerisch", "Hebräisch"),
    Japanisch(1, "sprachlich-literarisch-künstlerisch", "Japanisch"),
    Chinesisch(1, "sprachlich-literarisch-künstlerisch", "Chinesisch"),
    Türkisch(1, "sprachlich-literarisch-künstlerisch", "Türkisch"),
    Neugriechisch(1, "sprachlich-literarisch-künstlerisch", "Neugriechisch"),
    Portugiesisch(1, "sprachlich-literarisch-künstlerisch", "Portugiesisch"),
    Geschichte(2, "gesellschaftswissenschaftlich", "Geschichte"),
    Geographie(2, "gesellschaftswissenschaftlich", "Geographie"),
    Sozialwissenschaften(2, "gesellschaftswissenschaftlich", "Sozialwissenschaften"),
    Philosophie(2, "gesellschaftswissenschaftlich", "Philosophie"),
    Recht(2, "gesellschaftswissenschaftlich", "Recht"),
    Erziehungswissenschaft(2, "gesellschaftswissenschaftlich", "Erziehungswissenschaft"),
    Psychologie(2, "gesellschaftswissenschaftlich", "Psychologie löl"),
    Mathematik(3, "mathematisch-naturwissenschaftlich-technisch", "Mathematik"),
    Physik(3, "mathematisch-naturwissenschaftlich-technisch", "Physik "),
    Chemie(3, "mathematisch-naturwissenschaftlich-technisch", "Chemie "),
    Biologie(3, "mathematisch-naturwissenschaftlich-technisch", "Biologie "),
    Informatik(3, "mathematisch-naturwissenschaftlich-technisch", "Informatik "),
    Technik(3, "mathematisch-naturwissenschaftlich-technisch", "Technik "),
    Ernährungslehre(3, "mathematisch-naturwissenschaftlich-technisch", "Ernährungslehre"),
    Religionslehre(4, "Religionslehre", "Religionslehre"),
    Sport(5, "Sport", "Sport");

    private int feldnr;
    private String feld, fach;

    private Fach(int feldnr, String feld, String fach) {
        this.feld = feld;
        this.fach = fach;
        this.feldnr = feldnr;
    }

    /**
     * @return the feldnr
     */
    public int getFeldnr() {
        return feldnr;
    }

    /**
     * @return the feld
     */
    public String getFeld() {
        return feld;
    }

    /**
     * @return the fach
     */
    public String getFach() {
        return fach;
    }
}
 
Sinan

Sinan

Mitglied
Du musst das insgesamt objektorientierter machen... sowas in die Richtung:

Java:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Oberstufenplaner {

    private static void putFach(Map<Integer, List<Fach>> faecher, Fach fach) {
        int feldnr = fach.getFeldnr();
        if (!faecher.containsKey(feldnr)) {
            faecher.put(feldnr, new ArrayList<>());
        }
        if (!faecher.get(feldnr).contains(fach)) {
            faecher.get(feldnr).add(fach);
        }
    }

    private static boolean containsFach(Map<Integer, List<Fach>> faecher, Fach fach) {
        return faecher.containsKey(fach.getFeldnr()) && faecher.get(fach.getFeldnr()).contains(fach);
    }

    private static void selectOneFach(Map<Integer, List<Fach>> faecher, int feldnr) {
        ArrayList<Fach> toSelect = new ArrayList<>();
        for (Fach fach : Fach.values()) {
            if (fach.getFeldnr() == feldnr && !containsFach(faecher, fach)) {
                toSelect.add(fach);
            }
        }
        System.out.println("Wählen Sie aus den folgenden Fächern eins aus (" + toSelect.get(0).getFeld() + "):");
        int i = 1;
        for (Fach fach : toSelect) {
            System.out.println(i + ": " + fach);
            i++;
        }
        int rawInput = Integer.parseInt(new Scanner(System.in).nextLine());
        putFach(faecher, toSelect.get(rawInput - 1));
    }

    private static void selectOneAbiFach(Map<Integer, List<Fach>> faecher, Map<Integer, List<Fach>> abiFaecher, List<Integer> feldnr, int nr) {
        ArrayList<Fach> toSelect = new ArrayList<>();
        for (Fach fach : Fach.values()) {
            if (feldnr.contains(fach.getFeldnr()) && !containsFach(abiFaecher, fach)) {
                toSelect.add(fach);
            }
        }
        System.out.println("Wählen Sie Ihr " + nr + ". Abiturfach aus (Fach Nr. 4 ist mündlich):");
        int i = 1;
        for (Fach fach : toSelect) {
            System.out.println(i + ": " + fach);
            i++;
        }
        int rawInput = Integer.parseInt(new Scanner(System.in).nextLine());
        putFach(faecher, toSelect.get(rawInput - 1));
        putFach(abiFaecher, toSelect.get(rawInput - 1));
    }

    public static void main(String[] args) {
        int from = 1, to = 5;
        Map<Integer, List<Fach>> faecher = new HashMap<>();
        Map<Integer, List<Fach>> abiFaecher = new HashMap<>();
        putFach(faecher, Fach.Deutsch);
        putFach(faecher, Fach.Mathematik);
        putFach(faecher, Fach.Sport);
        selectOneFach(faecher, 1);
        selectOneFach(faecher, 2);
        selectOneFach(faecher, 3);
        selectOneAbiFach(faecher, abiFaecher, Arrays.asList(1), 1);
        selectOneAbiFach(faecher, abiFaecher, Arrays.asList(3), 2);
        selectOneAbiFach(faecher, abiFaecher, Arrays.asList(1, 2, 3, 4, 5), 3);
        selectOneAbiFach(faecher, abiFaecher, Arrays.asList(1, 2, 3, 4, 5), 4);
        System.out.println("Deine gewählten Fächer sind:");
        for (int i = from; i <= to; i++) {
            List<Fach> list = faecher.get(i);
            if (list != null) {
                for (Fach fach : list) {
                    System.out.println(fach);
                }
            }
        }
        System.out.println("Deine Abiturfächer sind:");
        for (int i = from; i <= to; i++) {
            List<Fach> list = abiFaecher.get(i);
            if (list != null) {
                for (Fach fach : list) {
                    System.out.println(fach);
                }
            }
        }
        System.out.println("Vielen Dank für die Benutzung des Tools.");
    }
}

enum Fach {

    Deutsch(1, "sprachlich-literarisch-künstlerisch", "Deutsch"),
    Musik(1, "sprachlich-literarisch-künstlerisch", "Musik"),
    Kunst(1, "sprachlich-literarisch-künstlerisch", "Kunst"),
    Englisch(1, "sprachlich-literarisch-künstlerisch", "Englisch"),
    Französisch(1, "sprachlich-literarisch-künstlerisch", "Französisch"),
    Russisch(1, "sprachlich-literarisch-künstlerisch", "Russisch"),
    Spanisch(1, "sprachlich-literarisch-künstlerisch", "Spanisch"),
    Niederländisch(1, "sprachlich-literarisch-künstlerisch", "Niederländisch"),
    Italienisch(1, "sprachlich-literarisch-künstlerisch", "Italienisch"),
    Lateinisch(1, "sprachlich-literarisch-künstlerisch", "Lateinisch"),
    Griechisch(1, "sprachlich-literarisch-künstlerisch", "Griechisch"),
    Hebräisch(1, "sprachlich-literarisch-künstlerisch", "Hebräisch"),
    Japanisch(1, "sprachlich-literarisch-künstlerisch", "Japanisch"),
    Chinesisch(1, "sprachlich-literarisch-künstlerisch", "Chinesisch"),
    Türkisch(1, "sprachlich-literarisch-künstlerisch", "Türkisch"),
    Neugriechisch(1, "sprachlich-literarisch-künstlerisch", "Neugriechisch"),
    Portugiesisch(1, "sprachlich-literarisch-künstlerisch", "Portugiesisch"),
    Geschichte(2, "gesellschaftswissenschaftlich", "Geschichte"),
    Geographie(2, "gesellschaftswissenschaftlich", "Geographie"),
    Sozialwissenschaften(2, "gesellschaftswissenschaftlich", "Sozialwissenschaften"),
    Philosophie(2, "gesellschaftswissenschaftlich", "Philosophie"),
    Recht(2, "gesellschaftswissenschaftlich", "Recht"),
    Erziehungswissenschaft(2, "gesellschaftswissenschaftlich", "Erziehungswissenschaft"),
    Psychologie(2, "gesellschaftswissenschaftlich", "Psychologie löl"),
    Mathematik(3, "mathematisch-naturwissenschaftlich-technisch", "Mathematik"),
    Physik(3, "mathematisch-naturwissenschaftlich-technisch", "Physik "),
    Chemie(3, "mathematisch-naturwissenschaftlich-technisch", "Chemie "),
    Biologie(3, "mathematisch-naturwissenschaftlich-technisch", "Biologie "),
    Informatik(3, "mathematisch-naturwissenschaftlich-technisch", "Informatik "),
    Technik(3, "mathematisch-naturwissenschaftlich-technisch", "Technik "),
    Ernährungslehre(3, "mathematisch-naturwissenschaftlich-technisch", "Ernährungslehre"),
    Religionslehre(4, "Religionslehre", "Religionslehre"),
    Sport(5, "Sport", "Sport");

    private int feldnr;
    private String feld, fach;

    private Fach(int feldnr, String feld, String fach) {
        this.feld = feld;
        this.fach = fach;
        this.feldnr = feldnr;
    }

    /**
     * @return the feldnr
     */
    public int getFeldnr() {
        return feldnr;
    }

    /**
     * @return the feld
     */
    public String getFeld() {
        return feld;
    }

    /**
     * @return the fach
     */
    public String getFach() {
        return fach;
    }
}
Das Ausmaß und die komplexität des oberstufenplaner ist weit über das hinaus was ich bis jetzt gelernt habe glaube ich :D wie gesagt ich bin noch sehr am Anfang.
 
Sinan

Sinan

Mitglied
Was ich mir überlegt habe: das ich das problem mit einer for schleife löse. Ich habe die Struktur schon in meinen Kopf,jedoch weiß ich nicht,wie ich das in Java übersetzen soll.
Sowas wie

for (j in Faecher02 ){
// faecherliste = "Deine Leistungskurse sind" + Subject01 + Subject02[o]" + "Deine Grundkurse sind:"
if (Faecher[j] (!= Faecher01 or Faecher01[o])){
add Faecher[j] to Faecherliste
}
}
also ich checke sozusagen jedes elemet von Faecher02 und vergleiche es mit faecher01 undfaecher01[o]. Falls es nicht das gleiche ist,wird es in die Fächerliste geschrieben etc.
Diese wiederhole ich dann für alle 10 fächer




(dies ist natürlich kein code, sondern nur ein ansatz um meine Gedanken darzustellen)
 
1

123neu

Bekanntes Mitglied
dann sollte man die Methoden aber nicht mit "static" (ausser die main-Methode) versehen
JA, das stimmt. Und die Liste der Fächer und die Liste der Abiturfächer wären dann Objekt- bzw. Instanzvariablen der Klasse...

Zudem könnte dem enum noch eine getString Methode spendiert werden, die eine textuelle Repräsentation des enum zurückgibt.

Außerdem sollte er es auch nicht 1:1 übernehmen, weil jedes Bundesland etwas anders ist...
 
kneitzel

kneitzel

Top Contributor
Also wenn man noch so am Anfang von Java steht und noch keine objektorientierung gemacht hat, dann ist der Vorschlag, es so anzugehen, aus meiner Sicht wenig zielführend!

@Sinan Damit hast Du doch schon einen Ansatz. Denn kannst Du weiter verfolgen.

Und dann überleg Dir doch erst einmal dein Model:
- Du hast zwei Arrays mit Fächern.
- Du hast ein erstes LK Fach und ein zweites LK Fach
- Du hast ein Array mit Grundkursen

Das kannst Du so abbilden. Oder Du kannst hin gehen und sagen: Die Fächer sind ein Array und das erste und zweite Element sind die Leistungskurse. (Gefällt mir nicht so gut, weil ich getrennte Dinge auch gerne entsprechend abbilde. Aber das ist etwas, das Du Dir überlegen kannst - da wir nicht objektorientiert heran gehen ist dies auch nicht ganz so wild in meinen Augen)

Kannst Du sagen, wie viele Grundkurse du hast? (Die Frage ist, ob alle Elemente des ersten LKs auch in der zweiten Liste enthalten ist. Dann wäre es trivial. Ansonsten müsstest Du Dir überlegen, wie Du da etwas berechnen kannst...

Und dann kannst Du über Methoden Deins fast 1:1 umsetzen:
Für alle Elemente - das hört sich stark nach for each an - und das geht auch mit Arrays (Seit Java 1.5):

Und dann sind das einfache überprüfungen: Ist das Fach LKFach1, LKFach2 oder in der Liste der Grundkurse?
istFachEinLKFachOderSchonInGrundkuse(....) - die Liste der Parameter sind dann alle Dinge, Du du brauchst:
- das zu prüfende Fach
- die Fächer (also LKfach1, LKfach2, GKFächer)
und es gibt ein boolean zurück.
Und dann das hinzufügen: fuegeFachHinzu(....)

==> so erhältst Du einfach lesbaren Code und du hast die große Problematik unterteilt in viele kleine Probleme. Denn jetzt musst Du nur noch die entsprechenden Methoden schreiben, die nur noch ein Bruchteil der Komplexität haben...
 
Sinan

Sinan

Mitglied
Also wenn man noch so am Anfang von Java steht und noch keine objektorientierung gemacht hat, dann ist der Vorschlag, es so anzugehen, aus meiner Sicht wenig zielführend!

@Sinan Damit hast Du doch schon einen Ansatz. Denn kannst Du weiter verfolgen.

Und dann überleg Dir doch erst einmal dein Model:
- Du hast zwei Arrays mit Fächern.
- Du hast ein erstes LK Fach und ein zweites LK Fach
- Du hast ein Array mit Grundkursen

Das kannst Du so abbilden. Oder Du kannst hin gehen und sagen: Die Fächer sind ein Array und das erste und zweite Element sind die Leistungskurse. (Gefällt mir nicht so gut, weil ich getrennte Dinge auch gerne entsprechend abbilde. Aber das ist etwas, das Du Dir überlegen kannst - da wir nicht objektorientiert heran gehen ist dies auch nicht ganz so wild in meinen Augen)

Kannst Du sagen, wie viele Grundkurse du hast? (Die Frage ist, ob alle Elemente des ersten LKs auch in der zweiten Liste enthalten ist. Dann wäre es trivial. Ansonsten müsstest Du Dir überlegen, wie Du da etwas berechnen kannst...

Und dann kannst Du über Methoden Deins fast 1:1 umsetzen:
Für alle Elemente - das hört sich stark nach for each an - und das geht auch mit Arrays (Seit Java 1.5):

Und dann sind das einfache überprüfungen: Ist das Fach LKFach1, LKFach2 oder in der Liste der Grundkurse?
istFachEinLKFachOderSchonInGrundkuse(....) - die Liste der Parameter sind dann alle Dinge, Du du brauchst:
- das zu prüfende Fach
- die Fächer (also LKfach1, LKfach2, GKFächer)
und es gibt ein boolean zurück.
Und dann das hinzufügen: fuegeFachHinzu(....)

==> so erhältst Du einfach lesbaren Code und du hast die große Problematik unterteilt in viele kleine Probleme. Denn jetzt musst Du nur noch die entsprechenden Methoden schreiben, die nur noch ein Bruchteil der Komplexität haben...
Das hört sich gut an, an die Foreach schleife habe ich gar nicht mehr gedacht. Ich versuche jetzt meine Idee in code umzuwandeln
 
kneitzel

kneitzel

Top Contributor
Ich versuche jetzt meine Idee in code umzuwandeln
Aber vielleicht probierst Du es auch wirklich mit verstärkter Umgangssprache. Das ist ein Weg, um gut strukturierten Code mit guten Bezeichnern zu haben. Und dann hast Du auch keine so langen Methoden mehr. Also so wie in meinem kleinen Beispiel halt dann die Idee, dass da etwas geprüft werden soll nicht an der Stelle direkt als Code schreiben sondern eben eine Methode daraus machen.

Die Idee dahinter ist zwar ein Thema, das auch erst später kommt, aber das meiner Meinung nach immer und immer wieder von Anfang an erwähnt werden sollte:
So erhältst Du dann halt viele kleine Methoden. Methoden, die eine gewisse Größe überschreiben sind direkt unübersichtlich. Der Name soll aussagen, was die Methode macht. Aber wie soll ein kurzer Name beschreiben, was 20 oder mehr Zeilen Code machen? Das geht einfach nicht. Und damit hast Du dann eine Methode, die nicht klar sagt, was sie macht und die das auch nicht auf den ersten Blick beschreibt.
 
T

Trjavnamen

Bekanntes Mitglied
Bestimmt wird alles in einem male. Wenn es mit Schleife funktionieren soll muß für jedes Fach eine Integer gesetzt werden. Wie Integer Mathematik =0 usw. Schleife If{}..else{.. if{} else{if{} else{} then{}}} then{}} then{}) Wird das entsprechende Fach gewählt wird der wert auf 1 gesetzt. In das Array wird für die Leistungskurse dann Fachnummer,1(z.B.int= 1,1) geschrieben sind die leistungsfächer (anzahl) erreicht ist die innere Schleife beendet Leistungsfächer aus system meldet du hast deine Leistungsfächer gewählt. Nächste außen Schleife Fach nochmals gesetzt steht gewähltes fächer auf zwei wenn es schon besetzt ist. Entscheidung 2 bedeutet falsch doppelt belegt. Schleife löscht den versuch und meldet schon besetzt ist es auf eins fach wird als auswahl akzeptiert in das Ergebnis aray wird geschrieben (Fachnummer, 2) ist die erforderlichr Anzahl erreicht endet die schleife
 
mihe7

mihe7

Top Contributor
Die Idee dahinter ist zwar ein Thema, das auch erst später kommt, aber das meiner Meinung nach immer und immer wieder von Anfang an erwähnt werden sollte:
So erhältst Du dann halt viele kleine Methoden.
Der Witz ist, dass das Grundprinzip bereits von Anfang an und auch in anderen Fächern umgesetzt wird bzw. umgesetzt werden sollte: man arbeitet vom Groben ins Detail. Letztlich läuf es immer darauf hinaus, ein Problem in Teilprobleme zu zerlegen. Wenn man keine eigenen Methoden schreiben kann oder darf, lässt sich der Code trotzdem entsprechend gliedern. Allerdings sollte man schnellstmöglich zu Methoden übergehen :)

Bin eben über ein Schülerskript gestolpert, das mir auf den ersten Blick sehr gut gefällt: https://schuelerlabor.informatik.rw...gramme/Java-Programmierung - Leitprogramm.pdf - da wird nicht lange rumgeschissen; nach dem obligatorischen Hello World geht es sofort um die Struktur von Programmen. Das wenn so mancher Student hier sich mal anschauen würde, dürften sich viele Fragen in Wohlgefallen auflösen.
 
1

123neu

Bekanntes Mitglied
Hier ist es nochmal mit mehr oo und hoffentlich weniger Komplexität. Die Funktionalität sollte wie bei dem anderen Code sein. Drei Grundkurse sind vorgegeben, drei weitere Grundkurse sollten gewählt werden sowie dann vier Leistungskurse. Jeder gewählte Leistungskurs ist gleichzeitig auch Grundkurs. Kurse können nicht doppelt gewählt werden. Also hätte man dann bis zum Abi 6 bis 10 Fächer und mit mind. 4 LKs... Das muss natürlich noch an das Bundesland und an das Angebot der Schule angepasst werden. Maps (als Datenstruktur) könnte durchaus ein Thema sein, was später in Informatik im Abi drankommt. Deswegen kann es nicht schaden, sich schon früh damit zu befassen.

Java:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Objects;
import java.util.Scanner;

public class Oberstufenplaner {
    private LinkedHashMap<Fach, FachEintrag> alleFaecher = new LinkedHashMap<>();
    private int grundkursnr = 1;
    private int leistungskursnr = 1;

    public Oberstufenplaner() {
        for (Fach f : Fach.values()) {
            addFach(f);
        }
    }

    private void addFach(Fach f) {
        FachEintrag fe = new FachEintrag();
        fe.fach = f;
        alleFaecher.put(f, fe);
    }

    private void addGrundkurs(Fach f) {
        alleFaecher.get(f).setIstGrundkurs(grundkursnr++);
    }

    private void addLeistungskurs(Fach f) {
        if (!alleFaecher.get(f).istGrundkurs) {
            addGrundkurs(f);
        }
        alleFaecher.get(f).setIstLeistungskurs(leistungskursnr++);
    }

    private ArrayList<Fach> getFaecherMitNummer(int nr, boolean notGrunkurs, boolean notLeistungskurs) {
        ArrayList<Fach> list = new ArrayList<>();
        for (FachEintrag fe : alleFaecher.values()) {
            if (fe.fach.getFeldnr() == nr && (!notGrunkurs || !fe.istGrundkurs) && (!notLeistungskurs || !fe.istLeistungskurs)) {
                list.add(fe.fach);
            }
        }
        return list;
    }

    private void waehleGrundkurs(int nr) {
        ArrayList<Fach> list = getFaecherMitNummer(nr, true, false);
        System.out.println("Wählen Sie einen Grundkurs aus:");
        for (int i = 0; i < list.size(); i++) {
            System.out.println((i + 1) + " : " + list.get(i).toString());
        }
        @SuppressWarnings("resource")
        int rawinput = new Scanner(System.in).nextInt();
        addGrundkurs(list.get(rawinput - 1));
    }

    private void waehleLeistungskurs(List<Integer> nrs) {
        ArrayList<Fach> list = new ArrayList<>();
        for (int n : nrs) {
            list.addAll(getFaecherMitNummer(n, false, true));
        }
        System.out.println("Wählen Sie einen Leistungskurs aus:");
        for (int i = 0; i < list.size(); i++) {
            System.out.println((i + 1) + ": " + list.get(i).toString());
        }
        @SuppressWarnings("resource")
        int rawinput = new Scanner(System.in).nextInt();
        addLeistungskurs(list.get(rawinput - 1));
    }

    public void waehleKurse() {
        addGrundkurs(Fach.Deutsch);
        addGrundkurs(Fach.Mathematik);
        addGrundkurs(Fach.Sport);
        waehleGrundkurs(1);
        waehleGrundkurs(2);
        waehleGrundkurs(3);
        waehleLeistungskurs(Arrays.asList(1));
        waehleLeistungskurs(Arrays.asList(3));
        waehleLeistungskurs(Arrays.asList(1, 2, 3, 4, 5));
        waehleLeistungskurs(Arrays.asList(1, 2, 3, 4, 5));

        System.out.println("Deine gewählten Grundkurse sind:");
        for (FachEintrag fe : alleFaecher.values()) {
            if (fe.istGrundkurs) {
                System.out.println(fe.toString());
            }
        }
        System.out.println("Deine gewählten Leistungskurse sind:");
        for (FachEintrag fe : alleFaecher.values()) {
            if (fe.istLeistungskurs) {
                System.out.println(fe.toString());
            }
        }
    }

    public static void main(String[] args) {
        Oberstufenplaner oberstufenplaner = new Oberstufenplaner();
        oberstufenplaner.waehleKurse();
    }
}

enum Fach {
    Deutsch(1, "sprachlich-literarisch-künstlerisch", "Deutsch"), Musik(1, "sprachlich-literarisch-künstlerisch", "Musik"), Kunst(1, "sprachlich-literarisch-künstlerisch", "Kunst"), Englisch(1, "sprachlich-literarisch-künstlerisch", "Englisch"),
    Französisch(1, "sprachlich-literarisch-künstlerisch", "Französisch"), Russisch(1, "sprachlich-literarisch-künstlerisch", "Russisch"), Spanisch(1, "sprachlich-literarisch-künstlerisch", "Spanisch"),
    Niederländisch(1, "sprachlich-literarisch-künstlerisch", "Niederländisch"), Italienisch(1, "sprachlich-literarisch-künstlerisch", "Italienisch"), Lateinisch(1, "sprachlich-literarisch-künstlerisch", "Lateinisch"),
    Griechisch(1, "sprachlich-literarisch-künstlerisch", "Griechisch"), Hebräisch(1, "sprachlich-literarisch-künstlerisch", "Hebräisch"), Japanisch(1, "sprachlich-literarisch-künstlerisch", "Japanisch"),
    Chinesisch(1, "sprachlich-literarisch-künstlerisch", "Chinesisch"), Türkisch(1, "sprachlich-literarisch-künstlerisch", "Türkisch"), Neugriechisch(1, "sprachlich-literarisch-künstlerisch", "Neugriechisch"),
    Portugiesisch(1, "sprachlich-literarisch-künstlerisch", "Portugiesisch"), Geschichte(2, "gesellschaftswissenschaftlich", "Geschichte"), Geographie(2, "gesellschaftswissenschaftlich", "Geographie"),
    Sozialwissenschaften(2, "gesellschaftswissenschaftlich", "Sozialwissenschaften"), Philosophie(2, "gesellschaftswissenschaftlich", "Philosophie"), Recht(2, "gesellschaftswissenschaftlich", "Recht"),
    Erziehungswissenschaft(2, "gesellschaftswissenschaftlich", "Erziehungswissenschaft"), Psychologie(2, "gesellschaftswissenschaftlich", "Psychologie"), Mathematik(3, "mathematisch-naturwissenschaftlich-technisch", "Mathematik"),
    Physik(3, "mathematisch-naturwissenschaftlich-technisch", "Physik "), Chemie(3, "mathematisch-naturwissenschaftlich-technisch", "Chemie "), Biologie(3, "mathematisch-naturwissenschaftlich-technisch", "Biologie "),
    Informatik(3, "mathematisch-naturwissenschaftlich-technisch", "Informatik "), Technik(3, "mathematisch-naturwissenschaftlich-technisch", "Technik "), Ernährungslehre(3, "mathematisch-naturwissenschaftlich-technisch", "Ernährungslehre"),
    Religionslehre(4, "Religionslehre", "Religionslehre"), Sport(5, "Sport", "Sport");

    private int feldnr;
    private String feld, fach;

    private Fach(int feldnr, String feld, String fach) {
        this.feld = feld;
        this.fach = fach;
        this.feldnr = feldnr;
    }

    /**
     * @return the feldnr
     */
    public int getFeldnr() {
        return feldnr;
    }

    /**
     * @return the feld
     */
    public String getFeld() {
        return feld;
    }

    /**
     * @return the fach
     */
    public String getFach() {
        return fach;
    }

    public String getString() {
        return this.getFeldnr() + " " + this.getFeld() + " " + this.getFach();
    }
}

class FachEintrag {
    Fach fach;
    boolean istGrundkurs = false;
    boolean istLeistungskurs = false;
    int grundkursnr = 0;
    int leistungskursnr = 0;

    @Override
    public int hashCode() {
        return Objects.hash(fach);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        FachEintrag other = (FachEintrag) obj;
        return fach == other.fach;
    }

    public void setIstGrundkurs(int nr) {
        this.istGrundkurs = true;
        this.grundkursnr = nr;
    }

    public void setIstLeistungskurs(int nr) {
        this.istLeistungskurs = true;
        this.leistungskursnr = nr;
    }

    @Override
    public String toString() {
        return String.format("FachEintrag [fach=%s, istGrundkurs=%s, istLeistungskurs=%s, grundkursnr=%s, leistungskursnr=%s]", fach.getString(), istGrundkurs, istLeistungskurs, grundkursnr, leistungskursnr);
    }
}

Ich bin natürlich auch für Verbesserungsvorschläge dankbar. Es ist ja noch nicht der Weisheit letzter Schluss.
 
kneitzel

kneitzel

Top Contributor
und andere (altbekannte) Fragen aufwerfen. Z.B. verwendet das Skript static-Methoden 'en masse' ( ist aber ein Nebeneffekt, wenn noch keine OOP eingesetzt werden kann), Vergleiche werden mit "==" vorgenommen,...
LOL, das kommt von der RWTH Achen und dann sowas? Das mit dem static würde ich ja noch verstehen ganz am Anfang, denn OO ist da noch kein Thema, aber String Vergleich mit == ... ?? Das ist ein grundlegender Fehler und keine Vereinfachung, weil man da etwas noch nicht hatte ...

Aber ich will nicht sagen, dass das Script zu nichts nütze ist ... Es kann z.B. sehr gut in anderen Fachbereichen eingesetzt werden:
"Wir haben hier einen Ausdruck. 68 Blatt (da beidseitig bedruckt) eines 80g/m² Papieres .... Wie viel Wärme wird abgegeben beim Verbrennen? (Heizwert Papier 4,2 kWh/kg)"
 
M

Meniskusschaden

Top Contributor
Z.B. verwendet das Skript static-Methoden 'en masse' ( ist aber ein Nebeneffekt, wenn noch keine OOP eingesetzt werden kann), Vergleiche werden mit "==" vorgenommen,...
equals anstelle von == lässt sich aber ebenso schwer begründen, ohne Objekte einzuführen und von primitiven Datentypen abzugrenzen.

Abfragen wie if(primzahl == true) finde ich für Musterlösungen aber auch etwas unschön, zumal das durchaus Thema war.
 
kneitzel

kneitzel

Top Contributor
Ja, es ist schon klar, dass sowas schwer zu erklären ist, wenn Objekte so noch nicht behandelt wurden und werden sollen. Aber da sin eine Tabelle zu packen, die man ja nicht auswendig lernen muss - man kann sie ja zum nachschlagen verwenden - das halte ich für komplett falsch.

Zumal dann die Beispiele alle suggerieren, dass es so funktionieren soll

In der aktuellen Situation, in der viele Lehrer mal eben so schnell zu Informatik Lehrern gemacht wurden und daher selbst nicht so tief in der Materie drin sind, würde mich interessieren, wie die dann mit so einem "Script" das Ergebnis des Codes hier erklären:
Java:
        System.out.println("\"Te\" + \"st\" == \"Test\" := " + ("Te" + "st" == "Test"));
        String a = "Te";
        System.out.println("a == \"Te\" := " + (a == "Te"));
        String b = "st";
        System.out.println("b == \"st\" := " + (b == "st"));
        String ab = "Test";
        System.out.println("ab == \"Test\" := " + (ab == "Test"));
        System.out.println("a + b == ab := " + (a + b == ab));

Ausgabe:
"Te" + "st" == "Test" := true
a == "Te" := true
b == "st" := true
ab == "Test" := true
a + b == ab := false

Te + st ist Test ... Die Variablen sind Te, st und Test ... aber die Variablen zu Vergleichen ist nicht mehr gleich?

wenn a1 + b1 == c1 und a1 == a2, b1 == b2 und c1 == c2, dann muss doch a2 + b2 == c2 sein ...

Und da kommt dann nicht nur ein einfaches "Vergleicht man mit equals" - denn dann wäre das erste ja auch false ... da bringt man den Lehrer schnell in ganz andere Erklärungsnot :)

Aber da hat Westernhagen ja schon früher gesungen:
Und darum bin ich froh, dass ich kein Lehrer bin,
denn Lehrer sein ist ne Quälerei ...
ich bin froh, dass ich Softwareentwickler bin,
denn Enwickeln bedeutet frei zu sein ...

Oder sollte ich da den Text falsch im Kopf haben? :)
 
1

123neu

Bekanntes Mitglied
Öh, sorry ich hätte mich mal nicht so flüchtig mit der Problemdomäne beschäftigen sollen, denn ich hab die Begriffe

Fach, Facheintrag, Kurs, Grundkurs, Leistungskurs, Abiturfach und mündliches Abiturfach

total durcheinandergeworfen... Wie jeder weiß, sind unter den 4 Abiturfächern 2 LKs, 1 GK und ein mündliches Fach (das wiederum auch ein zusätzlicher GK ist). Bei mir sind das alles Leistungskurse, die Taxonomie ist also falsch. :(

Und dann noch etwas... Strings nicht mit equals() zu vergleichen, ist in 99 Prozent der Fälle nicht richtig. Aber es ist schon richtig, dass das zu erklären schnell eine zu hohe Komplexität einnimmt, die die Schüler vielleicht überfordert.
 
temi

temi

Top Contributor
Strings nicht mit equals() zu vergleichen, ist in 99 Prozent der Fälle nicht richtig. Aber es ist schon richtig, dass das zu erklären schnell eine zu hohe Komplexität einnimmt, die die Schüler vielleicht überfordert.
Naja, man könnte am Anfang einfach sagen, dass man es so machen soll, auch wenn man den Grund dafür noch nicht versteht. Zu geeigneter Zeit lässt sich das dann aufklären. Da sehe ich eigentlich kein Problem.

Ein Scanner-Objekt wird hier ja auch erzeugt und verwendet, ohne Kenntnisse von OO.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
C Wie 2 Arrays zusammenfügen und sortieren? Java Basics - Anfänger-Themen 11
S Arrays aneinanderketten Java Basics - Anfänger-Themen 20
D Hilfe beim Erzeugen eines Arrays NullPointerException wird ausgelöst Java Basics - Anfänger-Themen 11
R Werte und Reihenfolge in 2d Arrays vergleichen Java Basics - Anfänger-Themen 5
D Verschlüsslungsaufgabe / Arrays Java Basics - Anfänger-Themen 6
L Methode für Zweidimensionale Arrays Java Basics - Anfänger-Themen 4
L Methode zum invertieren eines Arrays Java Basics - Anfänger-Themen 7
S zweidimensionale char arrays Java Basics - Anfänger-Themen 14
J Methoden Mehrdimensionale Arrays übereinander legen Java Basics - Anfänger-Themen 5
D Verwirrung bei Streams aus primitiven Arrays Java Basics - Anfänger-Themen 2
P Arrays mit verschiedenen Längen miteinander dividieren. Java Basics - Anfänger-Themen 1
P Wie kann ich die Zahlen dieses Arrays dividieren? Java Basics - Anfänger-Themen 2
N 2D Arrays jedes xy vergleichen Java Basics - Anfänger-Themen 7
J Traveling Salesman Problem [Arrays] Java Basics - Anfänger-Themen 9
M Arrays mit mehreren Werten über JOptionPane initialisieren Java Basics - Anfänger-Themen 12
Kawastori Größe eines Arrays bestimmen Java Basics - Anfänger-Themen 13
Zeppi Arrays[i] Java Basics - Anfänger-Themen 7
Lena_2611 Vergleich von Array1 Index mit Array2 Wert und erzeugen eines neues Arrays Java Basics - Anfänger-Themen 8
J B-Sprache mit Arrays ausführen Java Basics - Anfänger-Themen 18
A Teilarrays eines 2D-Arrays sortieren Java Basics - Anfänger-Themen 4
C Arrays - deklarieren, initialisieren? Ist das ein Objekt? Java Basics - Anfänger-Themen 3
K Sudoku mit 2D Arrays Java Basics - Anfänger-Themen 19
T Vertikales Histogramm mit Arrays Java Basics - Anfänger-Themen 3
JD_1998 Arrays einlesen, zwischenspeichern und wieder ausgeben Java Basics - Anfänger-Themen 8
Z Kein überprüfen des gesamten Arrays möglich.(Viergewinnt Spiel) Java Basics - Anfänger-Themen 6
F Arrays: Mathematische Funktion Java Basics - Anfänger-Themen 19
mihe7 Von Datentypen und (mehrdimensionalen) Arrays Java Basics - Anfänger-Themen 4
A Teilen eines Arrays Java Basics - Anfänger-Themen 5
DorFey Sortieren eines mehrdimensionalen Arrays Java Basics - Anfänger-Themen 8
N Probleme beim printen von Arrays durch for Schleife Java Basics - Anfänger-Themen 3
L If und else bei 2 Dimensionalen Arrays Java Basics - Anfänger-Themen 8
1 Arrays Java Basics - Anfänger-Themen 7
M Rückgabe eines Arrays Java Basics - Anfänger-Themen 10
L Addition von Arrays über die Parameterliste Java Basics - Anfänger-Themen 11
Z Erste Schritte Indexe innerhalb eines Arrays zusammensählen Java Basics - Anfänger-Themen 14
N Länge eines Arrays in einem Objekt testen Java Basics - Anfänger-Themen 51
S Übergabe von Arrays an Methoden Java Basics - Anfänger-Themen 20
D Collections Arrays in ArrayList abspeichern Java Basics - Anfänger-Themen 6
A Freie Stelle eines Arrays Java Basics - Anfänger-Themen 17
H Ein gegebenes Int Array zu Zwei Arrays zurück geben Java Basics - Anfänger-Themen 6
J 2D Arrays summieren Java Basics - Anfänger-Themen 21
J zwei String Arrays miteinander vergleichen Java Basics - Anfänger-Themen 18
A Java.util.Arrays Java Basics - Anfänger-Themen 15
T Methodenverknüpfung mit Arrays Java Basics - Anfänger-Themen 4
R Zugriff auf den Index eines Arrays, welches ein Objekt ist. Java Basics - Anfänger-Themen 4
F Eine Zahl mit Arrays vergleichen Java Basics - Anfänger-Themen 7
A 2d Arrays aus txt.file einlesen Java Basics - Anfänger-Themen 16
B Arrays Java Basics - Anfänger-Themen 4
P Arrays "automatisch" erstellen lassen Java Basics - Anfänger-Themen 12
B Nur eine bestimmte Anzahl an Arrays ausgeben Java Basics - Anfänger-Themen 9
H Gemeinsame Schnittmenge zweier Arrays ausgeben Java Basics - Anfänger-Themen 12
H Größte Duplikat (Größte Doppelte Wert) eines Arrays ausgeben Java Basics - Anfänger-Themen 9
A Summe des Arrays pd mit alternativer Schleife Java Basics - Anfänger-Themen 2
S Elemente eines Arrays bei Ausgabe auslassen Java Basics - Anfänger-Themen 2
M Verständnisproblem der Rekursion bei Arrays Java Basics - Anfänger-Themen 8
F Mehrdimensionale Arrays Java Basics - Anfänger-Themen 12
M Arrays in Funktion Kopieren und Bearbeiten Java Basics - Anfänger-Themen 4
W Erste Schritte Arrays befüllen und ausgeben Java Basics - Anfänger-Themen 11
J Inhalte von zwei Arrays vertauschen?! Java Basics - Anfänger-Themen 6
Curtis_MC Erzeugung mehrdimensionaler Arrays Java Basics - Anfänger-Themen 2
O zwei Arrays nach Werten durchsuchen und zusammenfügen Java Basics - Anfänger-Themen 3
F Arbeiten mit Arrays Java Basics - Anfänger-Themen 2
D Wert des Arrays unter Bedingungen ändern Java Basics - Anfänger-Themen 1
M Werte des Arrays addieren Java Basics - Anfänger-Themen 5
L Zufällige Übereinstimmungen in 2 Arrays Java Basics - Anfänger-Themen 3
A Arrays kombinieren (länge eines Arrays kann 0 sein) Java Basics - Anfänger-Themen 6
A Alle true Werte eines boolean Arrays herausfiltern Java Basics - Anfänger-Themen 19
iman Variablen Dynamik Arrays Java Basics - Anfänger-Themen 9
R Arrays Java Basics - Anfänger-Themen 4
A Methoden Arrays Java Basics - Anfänger-Themen 20
D Unterschied == und equals in Arrays Java Basics - Anfänger-Themen 2
V Schleife für das Einlesen von Werten für int Variablen, die Bestandteil von Arrays sein sollen Java Basics - Anfänger-Themen 16
V Probleme mit Arrays Java Basics - Anfänger-Themen 8
S Arrays erstellen Java Basics - Anfänger-Themen 6
D Ergebnisse in Arrays ausgeben? Java Basics - Anfänger-Themen 11
M Die Inhalte eines Arrays mit der Methode Arrays.toString ausgeben Java Basics - Anfänger-Themen 4
R Weitergabe von Arrays aus Methoden in andere Klasse Java Basics - Anfänger-Themen 5
scratchy1 vollständige und unvollständige Arrays ausgeben Java Basics - Anfänger-Themen 11
L Tiefe Kopie einer Zeile eines zweidimensionalen Arrays Java Basics - Anfänger-Themen 1
L Dynamische Anzahl an Arrays mit verschiedenen Namen erzeugen Java Basics - Anfänger-Themen 6
L Addition von 1 bis n, in Arrays umstellen Java Basics - Anfänger-Themen 15
M Deklarieren und Initialisieren von Arrays Java Basics - Anfänger-Themen 3
O Arrays sortieren in einer Methode Java Basics - Anfänger-Themen 2
E Mehrere Arrays addieren mit Übertrag Java Basics - Anfänger-Themen 13
B Frage zu Arrays Java Basics - Anfänger-Themen 3
O Unterschied Arrays, Listen, Mengen Java Basics - Anfänger-Themen 24
F Arrays im Konstruktor Java Basics - Anfänger-Themen 5
E Methoden 2 Arrays sortieren (MergeSort) Java Basics - Anfänger-Themen 3
R 2D Arrays mit vorgegebenem Muster Java Basics - Anfänger-Themen 2
R Auf eine Stelle [i] des Arrays zugreifen Java Basics - Anfänger-Themen 7
M Methoden Arrays.deepequals() funktioniert nicht Java Basics - Anfänger-Themen 2
O Länge eines Arrays Java Basics - Anfänger-Themen 6
X Arrays untereinander schreiben Java Basics - Anfänger-Themen 4
F Arrays Duplizieren Java Basics - Anfänger-Themen 14
J Erste Schritte Arrays ineinander Verschachteln Java Basics - Anfänger-Themen 6
UnknownInnocent Variablen Teile eines Arrays zufällig sortieren Java Basics - Anfänger-Themen 7
E Arrays nach best Muster füllen Java Basics - Anfänger-Themen 4
L Bestimmte Werte eines Arrays ausgeben. Java Basics - Anfänger-Themen 3
P JButton -Arrays Java Basics - Anfänger-Themen 4
Kornblume Nulltyp eines Arrays von Objekten? Java Basics - Anfänger-Themen 10

Ähnliche Java Themen

Anzeige

Neue Themen


Oben