Getter Methode

Hallo Zusammen,
ich möchte eine Get Methode erstellen,
hier die 2 relevanten Klassen
ArrayGenerator
https://pastebin.com/zmFDvT7s
Program01.java
https://pastebin.com/2QbiRM7B

im ArrayGenerator wuerde ich gerne eine methode erstellen mit der ich das "intArray" in program01.java aufrufen kann, jedoch gelingt mir dies einfach nicht..
was mache ich falsch?

edit1: glaube das problem zu gefunden haben, werde die methode ja nicht nehmen koennen ohne dass ich variablen verlange.. edit2 kommt sobald behoben
 
Zuletzt bearbeitet:

httpdigest

Top Contributor
Du verwendest ein etwas komisches Vokabular. "Array [...] aufrufen" und "Variablen verlangen".
Was genau willst du tun? Möchtest du auf das intArray in der Klasse `ArrayGenerator` lesend innerhalb der Klasse `program01` zugreifen? Falls ja, kannst du - wie du schon sagtest - eine Getter-Methode in ArrayGenerator implementieren. Die aktuelle Methode:
Java:
public void getIntArray(int[] intArray) {
  this.intArray = intArray;
}
ist von der Semantik her eher ein "Setter", denn sie _setzt_ das intArray von `this` auf das per Parameter übergebene Array.
Ein _Getter_ würde so aussehen:
Java:
public int[] getIntArray() {
  return this.intArray;
}
 
Du verwendest ein etwas komisches Vokabular. "Array [...] aufrufen" und "Variablen verlangen".
Was genau willst du tun? Möchtest du auf das intArray in der Klasse `ArrayGenerator` lesend innerhalb der Klasse `program01` zugreifen? Falls ja, kannst du - wie du schon sagtest - eine Getter-Methode in ArrayGenerator implementieren. Die aktuelle Methode:
Java:
public void getIntArray(int[] intArray) {
  this.intArray = intArray;
}
ist von der Semantik her eher ein "Setter", denn sie _setzt_ das intArray von `this` auf das per Parameter übergebene Array.
Ein _Getter_ würde so aussehen:
Java:
public int[] getIntArray() {
  return this.intArray;
}
Hallo,
moechte im Endeffekt folgendes tun: das array intArray moechte ich in Program01 weiterverwenden, da dachte ich mir das sollte mit einer get methode klappen? soweit noch i.o?
habe nun probiert deinen code einzufuegen jedoch gibt´s leider folgende Meldung:
12247

bzgl verlangen meinte ich, ich habe eine methode test in der klasse ArrayGenerator erstellt, will ich diese von program01 aufrufen wird sie mir von intellij nicht angezeigt, setze ich allerdings in die condition irgendwas rein, sei es "int test" wird mir diese methode als moegliche auswahl in program01 angezeigt.
 
K

kneitzel

Gast
Also was mir so auffällt:
- ArrayGenerator.arrayGenerieren ist statisch und hat daher keinen Zugriff auf eine Instanzvariable. (Du erzeugst ja auch keine Instanz von der Klasse ....(
- Die statische Method hat eine lokale Variable. Wenn die Funktion durch ist, ist der Inhalt der Variablen weg.

Tipp: Mach wirklich nur die main Methode statisch. Alles andere ist nicht statisch. Bei Anfängern ist das eigentlich zu 99,9% aller Fälle einfach nur ein schlechtes/falsches Design.....
 
Also was mir so auffällt:
- ArrayGenerator.arrayGenerieren ist statisch und hat daher keinen Zugriff auf eine Instanzvariable. (Du erzeugst ja auch keine Instanz von der Klasse ....(
- Die statische Method hat eine lokale Variable. Wenn die Funktion durch ist, ist der Inhalt der Variablen weg.

Tipp: Mach wirklich nur die main Methode statisch. Alles andere ist nicht statisch. Bei Anfängern ist das eigentlich zu 99,9% aller Fälle einfach nur ein schlechtes/falsches Design.....
Moment, ich probiers mal.. Dass mein Design noch grottenschlecht ist, ist mir (leider) auch bewusst ;)
 

White_Fox

Top Contributor
Du solltest dein intArray auch irgendwo deklarieren, d.h. dem Compiler sagen daß du irgendwo ein intArray brauchst.
Java:
public class MyClass{
    private int intArray[];
   
    //Muß im Konstruktor erzeugt oder per Setter übergeben werden
    public MyClass(){
        intArray = new int[];
    }
}
 

httpdigest

Top Contributor
habe nun probiert deinen code einzufuegen jedoch gibt´s leider folgende Meldung: [leider als Bild eingefügt...]
Der Code sieht ja nochmal anders aus als im pastebin. Dort hatte deine ArrayGenerator Klasse noch eine Instanzvariable `int[] intArray`:
Java:
import java.util.Arrays;
public class ArrayGenerator {
    private int[] intArray; // <- DAS IST DIE INSTANZVARIABLE, DIE ICH MEINE!
    public static void arrayGenerieren(int zahlenYesNo, int buchstabenYesNo, int intArrayHatStellen) {
        if (zahlenYesNo == 1) {
            /* Array mit Zahlen generieren*/
            int[] intArray = new int[intArrayHatStellen];
            for (int i = 0; i < intArrayHatStellen ; i++){
                intArray[i] = (int) (Math.random() * 10000);
            }
            System.out.println(Arrays.toString(intArray));
        }
        if (buchstabenYesNo == 1) {
            /* array mit buchstaben generieren */
            String[] stringArray = new String[intArrayHatStellen];
        }
    }
    // DAS HIER IST DER GETTER, DEN ICH MEINE!
    public int[] getIntArray() {
        return this.intArray;
    }
}
 
So,
danke an alle, vermute dass ich es herausgefunden habe,
ArrayGenerator ArrayGenerator01 = new ArrayGenerator();
ArrayGenerator01.getIntArray();

damit scheints zu klappen...
Designfrage: Wäre es besser nicht direkt aufzurufen sondern eine neue Instanz zu erzeugen und von der aus weiter arbeiten?
 
Kommt drauf an, was du genau mit "direkt aufrufen" und "eine neue Instanz" (wovon?) und "weiter arbeiten" meinst. Drücke dich bitte präziser aus.


Okay, ich probiers:

Ich meine: anstatt dass ich z.B ArrayGenerator.xyz tippe , wäre es besser wenn ich gleich am Anfang der Klasse
ArrayGenerator ArrayGenerator01 = new ArrayGenerator();
reintippe und dann mit ArrayGenerator01 weiterarbeite?
 

ARadauer

Top Contributor
so mit Instanz Variablen:
Java:
import java.util.Arrays;

public class ArrayGenerator
{
    private int[] intArray;
    private String[] stringArray;

    public void arrayGenerieren(boolean generiereZahlen, boolean generiereBuchstaben, int intArrayHatStellen)
    {
        if (generiereZahlen)
        {
            /* Array mit Zahlen generieren*/
            intArray = new int[intArrayHatStellen];
            for (int i = 0; i < intArrayHatStellen; i++)
            {
                intArray[i] = (int) (Math.random() * 10000);
            }
        }
        if (generiereBuchstaben)
        {
            /* array mit buchstaben generieren */
            String[] stringArray = new String[intArrayHatStellen];
        }
    }

    public int[] getIntArray()
    {
        return this.intArray;
    }

    //zum testen
    public static void main(String[] args)
    {
        ArrayGenerator generator = new ArrayGenerator();
        generator.arrayGenerieren(true, false, 10);
        System.out.println(Arrays.toString(generator.getIntArray()));
    }
}

oder statisch
Java:
import java.util.Arrays;

public class ArrayGenerator
{
    private static int[] intArray;
    private static String[] stringArray;

    public static void arrayGenerieren(boolean generiereZahlen, boolean generiereBuchstaben, int intArrayHatStellen)
    {
        if (generiereZahlen)
        {
            /* Array mit Zahlen generieren*/
            intArray = new int[intArrayHatStellen];
            for (int i = 0; i < intArrayHatStellen; i++)
            {
                intArray[i] = (int) (Math.random() * 10000);
            }
        }
        if (generiereBuchstaben)
        {
            /* array mit buchstaben generieren */
            String[] stringArray = new String[intArrayHatStellen];
        }
    }

    public static int[] getIntArray()
    {
        return intArray;
    }

    //zum testen
    public static void main(String[] args)
    {

        ArrayGenerator.arrayGenerieren(true, false, 10);
        System.out.println(Arrays.toString(ArrayGenerator.getIntArray()));
    }
}
der unterschied ist, das es statisch die Werte nur einmal gibt und beim obigen Beispiel kannst du so viele ArrayGeneratoren machen wie du willst, oder ram hast ;-)

zahlenYesNo -> geil.. you made my day ;-)
 

mihe7

Top Contributor
@vogelspinne24 Und wenn wir schon dabei sind: verwende separate Methoden, die jeweils nur eine Aufgabe haben.
Java:
void generiereZahlen(int laenge) { ... }
void generiereBuchstaben(int laenge) { ... }

Noch was, bevor Du Dich wunderst: die Deklaration von stringArray innerhalb der Methode sorgt dafür, dass es innerhalb der Methode eine lokale Variable gibt, die den gleichen Namen trägt, wie die Klassen-/Instanzvariable.

Java:
public class ArrayGenerator
{
    private int[] intArray;
    private String[] stringArray; // <-- hier die Instanzvariable
// ...
    public void arrayGenerieren(boolean generiereZahlen, boolean generiereBuchstaben, int intArrayHatStellen)
    {
// ...
        if (generiereBuchstaben)
        {
            /* array mit buchstaben generieren */
            String[] stringArray = new String[intArrayHatStellen]; // <-- hier die lokale Variable
        }
    }

Dadurch wird innerhalb der Methode arrayGenerieren mit stringArray die lokale Variable und nicht die Klassen- oder Instanzvariable angesprochen. Sprich: wenn Du beim Aufruf der Methode für den Parameter generiereBuchstaben true einsetzt, wird die Klassen-/Instanzvariable stringArray nicht angetastet und bleibt null
 
Hallo zusammen, habe nochmals probiert das ganze ein bisschen konformer zu machen =)
Kann mir bitte wer sagen, ob
a) das Design so nun besser ist
b) warum ich in der klasse bubblesort folgende Fehlermeldung bekomme --> Operator '>' cannot be applied to 'java.lang.Object','java.lang.Object' (den Code von Bubblesort hab ich mir von http://www.javatechblog.com/java/java-program-to-sort-arraylist-without-using-collections/ kopiert)




Java:
import java.util.ArrayList;
class Main


{

    public static void main(String[] args) {
        Arraygenerator Arraygenerator01 = new Arraygenerator();
        // hier bool abfrage ob zahlen
        //hier bool abfrage ob Buchstaben
        // hier Abfrage wieviele Zahlen im Array sein sollen

        Arraygenerator01.setAnzahlZahlen(292); // anpassen mit scanner
        Arraygenerator01.generateList();
        //Bubblesort Bubblesort01 = new Bubblesort();
        ArrayList $Array01 = Arraygenerator01.getArray();
        // System.out.println("Dein Array befindet sich an folgender Stelle im RAM: " + Arraygenerator01.getArray());
        //Bubblesort01.Bubblesort($Array01);
        // Array an Bubblesort weitergeben
       // Bubblesort01.Bubblesort();
    }
}



Java:
import java.util.ArrayList;
import java.util.List;

class BubbleSort {

        public static void main(String[] args) {
            Arraygenerator Arraygenerator01 = new Arraygenerator();
            ArrayList $Array01 = Arraygenerator01.getArray();
            int $Array01Size = $Array01.size();
            System.out.println("Elements before sorting: ");
            System.out.println($Array01);
            for (int i = 0; i < $Array01.size(); i++) {
                for (int j = 0; j < $Array01.size() - i - 1; j++) {
                    if ($Array01.get(j) > $Array01.get(j + 1)) {
                        int temp = $Array01.get(j);
                        $Array01.set(j, $Array01.get(j + 1));
                        $Array01.set(j + 1, temp);
                    }
                }
            }
            System.out.println("Elements After sorting (in Ascending order): ");
            System.out.println($Array01);
        }
    }


Java:
import java.util.Collections;
import java.util.ArrayList;
/*public*/ class Arraygenerator {

    int $private_anzahlZahlen;
    ArrayList $Array01;
    //private ArrayList $Array01;

      void setAnzahlZahlen(int $anzahlZahlen) {
        $private_anzahlZahlen = $anzahlZahlen;
    }

    public  ArrayList getArray() {
        return $Array01;
    }

    void generateList(){

       
        ArrayList $Array01 = new ArrayList();
        for(int i = 0; i < $private_anzahlZahlen; i++)
        {
            $Array01.add(i+1);
            //$Array01.add('a');
        }
        Collections.shuffle($Array01);
        System.out.println($Array01);
    }

}
 

mrBrown

Super-Moderator
Mitarbeiter
a) das Design so nun besser ist
Du solltest dir mal Generics und die Konventionen zur Variablenbenennung angucken ;)

b) warum ich in der klasse bubblesort folgende Fehlermeldung bekomme --> Operator '>' cannot be applied to 'java.lang.Object','java.lang.Object' (den Code von Bubblesort hab ich mir von http://www.javatechblog.com/java/java-program-to-sort-arraylist-without-using-collections/ kopiert)
Deine Liste enthält nur Objekte (dass da Integer drin liegen, weiß deine Bubblesort-Klasse nicht), und Objekte kann man eben nicht mit > vergleichen. Generics angucken ;)
 
Du solltest dir mal Generics und die Konventionen zur Variablenbenennung angucken ;)
mach ich sogleich, hast du vielleicht einen Link zu einer guten Erklärung (bzgl Generics)? bevor ich mich in den OracleDocs versenke :D?

Deine Liste enthält nur Objekte (dass da Integer drin liegen, weiß deine Bubblesort-Klasse nicht), und Objekte kann man eben nicht mit > vergleichen. Generics angucken ;)
Das heißt, ich muss die Listen in "reine" Arrays konvertieren, dann sortieren und dann in die ArrayList reingeben ;) ?
Oder wird mir das auch erst mit dem verstehen der Generics klar?
 

mrBrown

Super-Moderator
Mitarbeiter
mach ich sogleich, hast du vielleicht einen Link zu einer guten Erklärung (bzgl Generics)? bevor ich mich in den OracleDocs versenke :D?

Das heißt, ich muss die Listen in "reine" Arrays konvertieren, dann sortieren und dann in die ArrayList reingeben ;) ?
Oder wird mir das auch erst mit dem verstehen der Generics klar?
Letzteres :)
 
So, Punkt 1 mit den Bennenungen sollte nun OK sein.
Punkt 2 ist mir immer noch nicht klar,
so wie ich es verstanden habe, kann ich in der ArrayList zb einen TypA-int und einen TypB-char machen?
und dann beim auffuellen der ArrayList den Eintrag mit dem passenden Typ hinzufuegen?
(siehe Listing 7.5 bei dem Link den du mir geschickt hast)


Edit: nach ein bisschen mehr einlesen, im Konstruktor den Typ reingeben den ich in der ArrayList verwenden will und dann z.B im Arraygenerator in der Schleife richtig anpassen?
 
Zuletzt bearbeitet:
Konnte leider nicht mehr editieren, somit schreibe ich es hier rein, so wie es aussieht war das ein recht arger Designfehler von mir, ich fahre wohl besser wenn ich einfach 2 arrayLists erstelle einmal mit zahlen, einmal mit buchstaben
die danach durch den Algorithmus laufen lasse, und danach in einer dritten ArrayList zusammenführe und ausgebe
 

mihe7

Top Contributor
Ja, dann
Java:
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class RandomLists {
    private final Random rand;

    public RandomLists() {
        rand = new Random();
    }

    public RandomLists(long seed) {
        rand = new Random(seed);
    }

    public List<Integer> generateInts(int count, int min, int maxExcl) {
        List<Integer> result = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            result.add(rand.nextInt(maxExcl-min)+min);
        }
        return result;
    }

    public List<String> generateStrings(int count, int sizePerString, char[] alphabet) {
        List<String> result = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            StringBuilder b = new StringBuilder();
            for (int k = 0; k < sizePerString; k++) {
                int letterIndex = rand.nextInt(alphabet.length);
                b.append(alphabet[letterIndex]);
            }
            result.add(b.toString());
        }
        return result;
    }

    public List<String> generateStrings(int count, int sizePerString) {
        return generateStrings(count, sizePerString, 
                ("abcdefghijklmnopqrstuvwxyz" +
                "ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray());
    }

    public static void main(String[] args) {
        RandomLists l = new RandomLists(42L);
        
        System.out.println("Zahlen:");
        System.out.println(l.generateInts(10, 20, 40));
        System.out.println("Strings:");
        System.out.println(l.generateStrings(10, 4));
        
        
        
    }   
}

Die Listen kannst Du dann nehmen und durch BubbleSort etc. laufen lassen.
 
Ja, dann
Java:
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class RandomLists {
    private final Random rand;

    public RandomLists() {
        rand = new Random();
    }

    public RandomLists(long seed) {
        rand = new Random(seed);
    }

    public List<Integer> generateInts(int count, int min, int maxExcl) {
        List<Integer> result = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            result.add(rand.nextInt(maxExcl-min)+min);
        }
        return result;
    }

    public List<String> generateStrings(int count, int sizePerString, char[] alphabet) {
        List<String> result = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            StringBuilder b = new StringBuilder();
            for (int k = 0; k < sizePerString; k++) {
                int letterIndex = rand.nextInt(alphabet.length);
                b.append(alphabet[letterIndex]);
            }
            result.add(b.toString());
        }
        return result;
    }

    public List<String> generateStrings(int count, int sizePerString) {
        return generateStrings(count, sizePerString,
                ("abcdefghijklmnopqrstuvwxyz" +
                "ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray());
    }

    public static void main(String[] args) {
        RandomLists l = new RandomLists(42L);
      
        System.out.println("Zahlen:");
        System.out.println(l.generateInts(10, 20, 40));
        System.out.println("Strings:");
        System.out.println(l.generateStrings(10, 4));
      
      
      
    } 
}

Die Listen kannst Du dann nehmen und durch BubbleSort etc. laufen lassen.
Hi!
Danke erstmal so ähnlich habe ich meinen Arraygenerator mittlerweile schon implementiert :D

Java:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

class Arraygenerator {

    // Konstruktor START
    int arrayTypeNumber;
    char arrayTypeLetter;
    int privateAnzahlZahlen;
    int privateAnzahlBuchstaben;
    ArrayList <Integer> array01Zahlen;
    ArrayList <Character> array01Buchstaben;
    int arrayElementId;
    // Konstruktor END

    // Letter Generator START
    Character letterGenerator() {
        String chars = "ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        Random rnd = new Random();
        Character c = chars.charAt(rnd.nextInt(chars.length()));
        return c;
    }
    // Letter Generator END

    // setter Anzahl Zahlen im Array START
    void setAnzahlZahlen(int anzahlZahlen) {
        privateAnzahlZahlen = anzahlZahlen;
    }
    // setter Anzahl Zahlen im Array END

    // setter Anzahl Buchstaben im Array START
    void setAnzahlBuchstaben(int anzahlBuchstaben) {
        privateAnzahlBuchstaben = anzahlBuchstaben;
    }
    // setter Anzahl Buchstabenim Array END

    // setter Element ID im Array START
    public void setArrayElementId(int arrayElementId) {
        this.arrayElementId = arrayElementId;
    }
    // setter Element ID im Array END

    // getter arrayZahlen START
    public ArrayList getArrayZahlen() {
        return array01Zahlen;
    }
    // getter array01Zahlen END

    // getter arrayBuchstaben START
    public ArrayList getArrayBuchstaben() {
        return array01Buchstaben;
    }
    // getter array01Zahlen END

    //Generatorfunktion Zahlen START
    void generateListArrayZahlen(int privateAnzahlZahlen) {
        for (Integer i = 0; i < privateAnzahlZahlen; i++) {
            array01Zahlen.add(i + 1);
            Collections.shuffle(array01Zahlen);
        }
      //  System.out.println(array01Zahlen);
    }
    // Generatorfunktion Zahlen END

    //Generatorfunktion Buchstaben START
    void generateListArrayBuchstaben(int privateAnzahlBuchstaben) {
        for (Integer i = 0; i < privateAnzahlBuchstaben; i++) {

            array01Buchstaben.add(letterGenerator());
            Collections.shuffle(array01Buchstaben);
        }
        //System.out.println(array01Buchstaben);
    }
    // Generatorfunktion Buchstaben END
}

Aber wo ich das größte Problem habe ist bei der Implementierung von Bubblesort.
So wie ich das nach ein wenig Recherce mitbekommen habe kann man bei Arraylisten nicht einfach mit <> und dergleichen arbeiten, sondern benötigt die java.util.Compare Methode? und die implementiert ja schon einen anderen Alogrithmus?
 

mihe7

Top Contributor
So wie ich das nach ein wenig Recherce mitbekommen habe kann man bei Arraylisten nicht einfach mit <> und dergleichen arbeiten, sondern benötigt die java.util.Compare Methode?
Du willst die Elemente einer ArrayList vergleichen und nicht die Listen selbst.

Für Elemente, auf denen eine feste Ordnung definiert werden soll, kann die zugehörige Klasse das Comparable-Interface implementieren. Dieses Interface wird von einigen Standard-Klassen implementiert, z. B. String: so gilt z. B. "a".compareTo("b") < 0

Nun gibt es Fälle, in denen man eine andere Ordnung haben will, beispielsweise kann man bei Personen eine Ordnung über den Nachnamen, den Vornamen oder das Geburtsdatum etc. festlegen. Hierfür kann man einen Comparator verwenden, dessen compare-Methode zwei Objekte entgegennimmt und diese miteinander vergleicht.
 
Du willst die Elemente einer ArrayList vergleichen und nicht die Listen selbst.

Für Elemente, auf denen eine feste Ordnung definiert werden soll, kann die zugehörige Klasse das Comparable-Interface implementieren. Dieses Interface wird von einigen Standard-Klassen implementiert, z. B. String: so gilt z. B. "a".compareTo("b") < 0

Nun gibt es Fälle, in denen man eine andere Ordnung haben will, beispielsweise kann man bei Personen eine Ordnung über den Nachnamen, den Vornamen oder das Geburtsdatum etc. festlegen. Hierfür kann man einen Comparator verwenden, dessen compare-Methode zwei Objekte entgegennimmt und diese miteinander vergleicht.
So bin kurz vorm Ziel,
der Bubblesort den ich implementiert habe haut hin :D!

aber eine Sache ist da noch die mich verblüfft, warum muss ich in der main zwei mal Bubblesort aufrufen dass der richtig sortierte Output kommt?
Wie überprüft ihr alten Hasen sowas? Oder passiert euch sowas einfach nicht mehr :D ?
12274

hier nochmal alle java files:
https://pastebin.com/hdV6hqZv

.
 

mrBrown

Super-Moderator
Mitarbeiter
aber eine Sache ist da noch die mich verblüfft, warum muss ich in der main zwei mal Bubblesort aufrufen dass der richtig sortierte Output kommt?
Hier sind einmal die relevanten Code-Stücke (Kommentare hab ich mal entfernt)
Java:
public static void main(String[] args) {
        Arraygenerator Arraygenerator01 = new Arraygenerator();
        Scanner Scanner01 = new Scanner(in);
        Bubblesort Bubblesort01 = new Bubblesort();

        out.println("Wieviele Zahlen sollen im Array sein (max 32767)");
        int anzahlZahlen = Scanner01.nextInt();
        Arraygenerator01.setAnzahlZahlen(anzahlZahlen);

        Arraygenerator01.generateListArrayZahlen(anzahlZahlen);
        Arraygenerator01.getArrayZahlen(); //<1>

        Bubblesort01.Bubblesortzahlen(Arraygenerator01.getArrayZahlen()); //<2>
        Bubblesort01.Bubblesortzahlen(Arraygenerator01.getArrayZahlen()); //<3>
    }

Java:
    public ArrayList getArrayZahlen() {
        System.out.println(array01Zahlen);  //<4>
        return array01Zahlen;

    }

Die Liste wird innerhalb des Getter-Aufrufs ausgegeben (4), also erst Ausgabe, danach wird die Liste zurückgegeben.

Die erste Ausgabe passiert in 1, du rufst den getter auf, der gibt die Liste aus, und die Rückgabe ignorierst du.
Die zweite Ausgabe passiert in 2, getter wird aufgerufen und Liste darin ausgegeben. Danach wird immer noch in Zeile 2 mit dem Rückgabewert das sortieren aufgerufen, danach ist die Liste dann sortiert.
In 3 rufst du dann noch mal den Getter auf, Die Liste, die in 2 sortiert wurde, wird dabei zum dritten Mal ausgegeben (diesmal eben sortiert), und danach nochmals sortiert.

Wie überprüft ihr alten Hasen sowas? Oder passiert euch sowas einfach nicht mehr :D ?
Die meisten solcher Probleme löst man mit ein bisschen strukturiertem Vorgehen.

In deinem Fall im ersten Schritt z.B. Getter und Ausgabe trennen.
 
Brauche bitte nochmals einen Denkanstoß,
Wenn ich es richtig verstanden habe, muesste ich dann folgendes implementieren
Leider bekomme ich so gar keine Ausgabe mehr...
Mein Gedankengang dahinter = mach nochmal eine Variable array01Zahlen die den Returnwert vom getter kriegt und gib dem Bubblesort diese Variable mit?
Java:
Arraygenerator01.generateListArrayZahlen(anzahlZahlen);
ArrayList<Integer> array01Zahlen = Arraygenerator01.getArrayZahlen();
Bubblesort01.Bubblesortzahlen(array01Zahlen);

P.S Der Getter war sogar von der Ausgabe getrennt, wollte damit nur testen ob das Ding ueberhaupt was macht o_O
 

mihe7

Top Contributor
Java:
Arraygenerator01.generateListArrayZahlen(anzahlZahlen);
ArrayList<Integer> array01Zahlen = Arraygenerator01.getArrayZahlen();
System.out.println("Vorher: " + array01Zahlen);
Bubblesort01.Bubblesortzahlen(array01Zahlen);
System.out.println("Nachher: " + array01Zahlen);
 
Java:
Arraygenerator01.generateListArrayZahlen(anzahlZahlen);
ArrayList<Integer> array01Zahlen = Arraygenerator01.getArrayZahlen();
System.out.println("Vorher: " + array01Zahlen);
Bubblesort01.Bubblesortzahlen(array01Zahlen);
System.out.println("Nachher: " + array01Zahlen);
Ahhh, danke, ich habe vergessen das ganze nochmals zu printen...
 

mrBrown

Super-Moderator
Mitarbeiter
@mrBrown
Wie kommt man denn auf sowas Schräges?
Steht doch in dem verlinkten Post :p

Und zumindest in meinem Umfeld ist Debugger-Nutzung wirklich wenig verbreitet. Die meisten Fehler vermeidet man durch guten Stil, die restlichen sind durch Tests abgedeckt (selbst wenn man nur den „Happy-Path“ testet, reicht das meist) oder durch sowieso vorhandene Log-Ausgaben offensichtlich.
Hängt aber vermutlich auch ein bisschen davon ab, was genau man macht.
 

White_Fox

Top Contributor
@mrBrown
Naja, da steht z.B.:
Since I started using Test Driven Development in 1999, I have not found a serious use for a debugger. The kinds of bugs I have to troubleshoot are easily isolated by my unit tests, and can be quickly found through inspection and a few judiciously placed print statements.
Ich habe keine Ahnung was das für ein Codegott ist, aber bei mir kommt der Debugger recht häufig zum Einsatz. Und das eigentlich immer, weil ein Unittest einen Fehler liefert. Meistens ist das nur eine Kleinigkeit (Ver-NICHT-ung in einem if-Statement vergessen oder sowas) und ich würde auch nicht sagen daß ich damit mein Hirn abschalte und irgendwas Wesentliches an den Debugger übergebe.

Zugegeben, Debugger sind heute schon recht ausgewachsene Werkzeuge geworden, aber das ist m.E. kein Grund, nicht mit ihnen zu arbeiten. Und mit derselben Begründung (sehr komplex, Zeitverschwendung sich damit zu befassen, und man überläßt der IDE ja auch viel Arbeit und damit ja irgendwie auch ein Stück Programmierung) kann man auch den Einsatz von IDEs ablehnen - was ich auch für groben Käse halte.

Ohne implizieren zu wollen das Robert Martin sein Handwerk nicht verstünde: Ich kenne diese "Arbeitsphilosophie" auch aus dem Hardwarebau. Meines Erachtens wird diese aber aber eher von lernfaulen Hardwerkern gelebt.
 
Hallo zusammen, soweit so gut, habe jetzt alles aufgeräumt, jetzt bleibt nur noch eine Sache uebrig, Quicksort..

Ich wuerde folgenden gerne wie in diesem Code schnipsel welches ich auf stackoverflow gefunden habe implementieren.

Einer der hiesigen User war so nett und hat mir ohne Nachfrage einen funktionierenden Quicksort geschickt.

Allerdings wuerde ich in "Version 1" noch gerne den Quicksort in einer Methode haben und erst beim zweiten Anlauf mit GUI alles "richtigerweise" Objektorientiert machen..


Wo ich jetzt noch einen Denkanstoß bräuchte, wie macht man das nun mit Buchstaben?

Original von StackOverflow
Java:
class Quicksort {



    @FunctionalInterface

    public interface Func {

        void call(int[] arr, int i, int j);

    }



     void Quicksortzahlen (String[] args) {



        System.out.println("Unsorted array: " + Arrays.toString(numbers));



        // store swap function as a lambda to avoid code duplication

        Func swap = (int[] arr, int i, int j) -> {

            int temp = arr[i];

            arr[i] = arr[j];

            arr[j] = temp;

        };



        Stack<Integer> stack = new Stack<>();

        stack.push(0);

        stack.push(numbers.length);



        while (!stack.isEmpty()) {

            int end = stack.pop();

            int start = stack.pop();

            if (end - start < 2) {

                continue;

            }



            // partitioning part

            int position = start + ((end - start) / 2);

            int low = start;

            int high = end - 2;

            int piv = numbers[position];

            swap.call(numbers, position, end - 1);

            while (low < high) {

                if (numbers[low] < piv) {

                    low++;

                } else if (numbers[high] >= piv) {

                    high--;

                } else {

                    swap.call(numbers, low, high);

                }

            }

            position = high;

            if (numbers[high] < piv) {

                position++;

            }

            swap.call(numbers, end - 1, position);

            // end partitioning part



            stack.push(position + 1);

            stack.push(end);

            stack.push(start);

            stack.push(position);

        }



        System.out.println("Sorted array: " + Arrays.toString(numbers));

    }




}



Mein Versuch
Java:
import java.util.ArrayList;
import java.util.Stack;

class Quicksort {
    ArrayList<Integer> array01Zahlen = new ArrayList<>();

    @FunctionalInterface
    public interface Func {
        void call(ArrayList<Integer> arr, int i, int j);
    }

     void Quicksortzahlen (ArrayList<Integer> array01Zahlen) {

         // store swap function as a lambda to avoid code duplication
        Func swap = (ArrayList<Integer> arr, int i, int j) -> {
            int temp = arr.get(i);
            arr.set(i, arr.get(j));
            arr.set(j, temp);
        };

        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        stack.push(array01Zahlen.size());

        while (!stack.isEmpty()) {
            int end = stack.pop();
            int start = stack.pop();
            if (end - start < 2) {
                continue;
            }

            // partitioning part
            int position = start + ((end - start) / 2);
            int low = start;
            int high = end - 2;
            int piv = array01Zahlen.get(position);
            swap.call(array01Zahlen, position, end - 1);
            while (low < high) {
                if (array01Zahlen.get(low) < piv) {
                    low++;
                } else if (array01Zahlen.get(high) >= piv) {
                    high--;
                } else {
                    swap.call(array01Zahlen, low, high);
                }
            }
            position = high;
            if (array01Zahlen.get(high) < piv) {
                position++;
            }
            swap.call(array01Zahlen, end - 1, position);
            // end partitioning part

            stack.push(position + 1);
            stack.push(end);
            stack.push(start);
            stack.push(position);
        }

            }
}


geht sogar :D !
12278
 

mihe7

Top Contributor
Ich wuerde folgenden gerne wie in diesem Code schnipsel welches ich auf stackoverflow gefunden habe implementieren.
Da hat wohl einer zu viel vom Lambda-Gras geraucht. Mal abgesehen davon, dass hier eine simple Methode einfacher gewesen wäre, kannst Du auch gleich Collections.swap verwenden.

Wo ich jetzt noch einen Denkanstoß bräuchte, wie macht man das nun mit Buchstaben?
Genauso, nur der Vergleich läuft anders, nämlich über compareTo. Du kannst Deine aktuelle Methode auch auf compareTo umschreiben.

Tatsächlich wäre das von Haus aus "richtiger", denn Deine Methode funktioniert aktuell nur aufgrund eines Features, das es erst seit Java 5 gibt: auto unboxing.

Deine Methode erhält eine Liste, deren Elemente vom Typ Integer sind. Ein Integer-Objekt kapselt ein primitives int. Vor Java 5 wären Anweisungen wie
Java:
int piv = array01Zahlen.get(position);
if (array01Zahlen.get(low) < piv) {
nicht möglich gewesen, denn array01Zahlen.get() liefert ein Objekt vom Referenztyp Integer, während piv ein Wert vom primitiven Typ int darstellt (hier werden also Äpfel mit Birnen verglichen). Seinerzeit hat man sich vom Integer-Objekt erst einmal explizit den primitiven Wert geben lassen müssen:

Java:
int piv = array01Zahlen.get(position).intValue();
if (array01Zahlen.get(low).intValue() < piv) {

(EDIT: das wird seit Java 5 automatisch für Dich erledigt) Tatsächlich brauchst Du das aber gar nicht, denn Integer implementiert Comparable und bietet somit den Vergleich mit anderen Integer-Objekten direkt an:
Java:
Integer piv = array01Zahlen.get(position);
if (array01Zahlen.get(low).compareTo(piv) < 0) {

Dieser Code funktioniert mit allen Typen, die das Comparable-Interface implementieren, also z. B. auch String.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
O Instanzattribut per Getter Methode zuweisbar, warum? Java Basics - Anfänger-Themen 8
E Methoden Objekte in Methode aufrufen ohne getter und setter? Java Basics - Anfänger-Themen 1
S Array und Getter-Methode Java Basics - Anfänger-Themen 2
N Klassen fragen zur getter und setter methode Java Basics - Anfänger-Themen 11
N Sprite Methode (Getter, Setter, Konstruktor) Java Basics - Anfänger-Themen 9
J Die Getter Methode Java Basics - Anfänger-Themen 6
F 2 dimensionales Array getter Methode Java Basics - Anfänger-Themen 3
S JTextField in anderer Classe mit getter Methode auslesen. Java Basics - Anfänger-Themen 2
T Getter/Setter - wie sieht ein Setter aus? Und wie nicht? Java Basics - Anfänger-Themen 34
Say Class scope und Instance scope und Getter nur selbstgeschrieben Methoden Java Basics - Anfänger-Themen 11
W Getter/Setter Java Basics - Anfänger-Themen 4
W Unterschiede bei Zugriff auf Objekt und Klassenvariablen über einen Getter? Java Basics - Anfänger-Themen 2
KogoroMori21 Objektvariable anderer Klasse übernehmen, Getter/Setter Java Basics - Anfänger-Themen 11
T Verständnisfrage Objekt Getter Setter Java Basics - Anfänger-Themen 102
KogoroMori21 Getter und Setter Java Basics - Anfänger-Themen 5
P Klassenübergreifende Ausgabe mittels "getter" nicht möglich Java Basics - Anfänger-Themen 21
J Array über Getter erlangen Java Basics - Anfänger-Themen 34
S Klassen instanziieren und verwenden von Getter und Setter Java Basics - Anfänger-Themen 4
P Klasse hat keinen Zugriff auf getter/setter-Methoden eines Objektes Java Basics - Anfänger-Themen 9
V getter/setter Garage Java Basics - Anfänger-Themen 12
M Getter einer PriorityQueue Java Basics - Anfänger-Themen 1
KopaCoda Getter mehrfach aufrufen -> ist das guter code? Java Basics - Anfänger-Themen 3
S getter, setter in abstrakter Klasse oder lieber Unterklassen Java Basics - Anfänger-Themen 4
topi Kapselung getter und setter Java Basics - Anfänger-Themen 5
D Setter/Getter für Instanzvariablen praktisch? Java Basics - Anfänger-Themen 19
S Getter/Setter - Variablenklasse ? Java Basics - Anfänger-Themen 5
S getter and setter Java Basics - Anfänger-Themen 12
L Getter und Setter Java Basics - Anfänger-Themen 2
T Extrahiertes Objekt durch Getter bekommen Java Basics - Anfänger-Themen 2
M Generics getter und setter Methoden Java Basics - Anfänger-Themen 4
D Kapselung final Variablen mit Getter? Java Basics - Anfänger-Themen 2
A getter Java Basics - Anfänger-Themen 3
T Getter für Array Java Basics - Anfänger-Themen 4
J-Gallus Ein Getter bekommt eine anderen Type als er Return soll Java Basics - Anfänger-Themen 9
K Public Attribute oder getter - funktioniert leider beides hier nicht Java Basics - Anfänger-Themen 5
L Klassen - Getter & Setter Methoden Java Basics - Anfänger-Themen 2
D Erste Schritte Java - Setter und Getter Java Basics - Anfänger-Themen 1
Z Getter/Setter NullPointer Exception Java Basics - Anfänger-Themen 6
P getter Java Basics - Anfänger-Themen 1
K Klassen Setter/Getter Java Basics - Anfänger-Themen 3
F OOP Schleifen und Probleme mit Setter und Getter Java Basics - Anfänger-Themen 1
L Setter und Getter/Vererbung Java Basics - Anfänger-Themen 6
M Getter Problematik mit ItemListener Java Basics - Anfänger-Themen 17
K Kapselung getter & setter Java Basics - Anfänger-Themen 11
Avarion Getter von Super-Klasse funktioniert nicht Java Basics - Anfänger-Themen 10
J Frage zu Setter u. Getter Java Basics - Anfänger-Themen 7
T Variablen Getter-Setter vs Public Variable? Java Basics - Anfänger-Themen 5
Y Konstruktor - Setter/Getter Java Basics - Anfänger-Themen 3
D Ab wann getter und setter Java Basics - Anfänger-Themen 2
J Variable per Getter holen - wie ? Java Basics - Anfänger-Themen 2
K getter & setter Java Basics - Anfänger-Themen 6
C getter/setter Problem anscheinend Java Basics - Anfänger-Themen 13
D Getter Mehtode Unsicher Java Basics - Anfänger-Themen 6
G Erste Schritte Getter und Setter Java Basics - Anfänger-Themen 12
B Getter,Setter - Konstruktor überflüssig? Java Basics - Anfänger-Themen 26
S getter/setter aufrufen Java Basics - Anfänger-Themen 9
B Java getter/setter funktioniert nicht! Java Basics - Anfänger-Themen 7
X OOP Getter/Setter überschreiben den Wert ihrer Variablen nicht Java Basics - Anfänger-Themen 4
T Erste Schritte Verständnisfrage: Getter und Setter Methoden Java Basics - Anfänger-Themen 3
M Problem mit getter, liefert nur alte Werte Java Basics - Anfänger-Themen 6
V public Variablen vs Getter + Setter Java Basics - Anfänger-Themen 4
F Getter und Setter Java Basics - Anfänger-Themen 4
lulas[]args getter/setter umstellung Java Basics - Anfänger-Themen 6
El_Lobo Methoden Zu viele Getter- und Settermethoden - geht das einfacher? Java Basics - Anfänger-Themen 3
G Generics kein Zugriff auf getter eines Objekts Java Basics - Anfänger-Themen 4
B Klassen Getter-Setter vor neuem Klassenaufruf - wie? Java Basics - Anfänger-Themen 20
M OOP Aufruf vieler Getter Methoden abkürzen? Java Basics - Anfänger-Themen 7
N OOP Getter, Setter und andere Probleme Java Basics - Anfänger-Themen 8
A OOP Getter und Setter Java Basics - Anfänger-Themen 18
MU5T4NG Getter und Setten bei GUI-Erstellung Java Basics - Anfänger-Themen 13
B Variablen keine Arrayübergabe für getter im Interface Java Basics - Anfänger-Themen 8
L Unterschied Konstruktor / Getter Setter Java Basics - Anfänger-Themen 13
L Setter und Getter für Arrays? Java Basics - Anfänger-Themen 4
N boolean bei Setter und getter methoden Java Basics - Anfänger-Themen 21
J int Wert mit getter holen und in String parsen Java Basics - Anfänger-Themen 5
O Universeller GETTER Java Basics - Anfänger-Themen 5
J Getter und Setter auch intern benutzen - guter Stil? Java Basics - Anfänger-Themen 31
Houly Setter/Getter MEthoden testen Java Basics - Anfänger-Themen 4
P OOP Getter&Setter Methoden funktionieren nicht Java Basics - Anfänger-Themen 7
E [Erledigt] Schöner Code zur Reduktion von unzähligen Getter-Methoden Java Basics - Anfänger-Themen 2
H Setter-und-Getter-Konvention Java Basics - Anfänger-Themen 8
V Reflection API - getter und setter Java Basics - Anfänger-Themen 7
-horn- EINE setter/getter klasse aus mehreren klassen befüllen Java Basics - Anfänger-Themen 13
C Getter/Setter Java Basics - Anfänger-Themen 61
H Frage zu getter und setter Java Basics - Anfänger-Themen 5
S Unbenutzte/überflüssige Getter/Setter herausfinden? Java Basics - Anfänger-Themen 2
K Getter Java Basics - Anfänger-Themen 6
M getter/setter bei JTextField ? Java Basics - Anfänger-Themen 21
G warum Setter/Getter Java Basics - Anfänger-Themen 25
S In einer Liste auf getter und setter zugreifen Java Basics - Anfänger-Themen 6
M if oder verschiedene getter Java Basics - Anfänger-Themen 31
T Rekursive Methode Java Basics - Anfänger-Themen 13
Ü Methode soll Quadrat aus der Summer zurückgeben Java Basics - Anfänger-Themen 10
P Objekt einer Methode eines anderen Objektes übergeben Java Basics - Anfänger-Themen 5
Leyla Spezifischte Methode Java Basics - Anfänger-Themen 16
M Methode zielnah zeigt das gewünschte Ausgabe nicht an Java Basics - Anfänger-Themen 3
L Variablenwerte aus einer Methode übergeben Java Basics - Anfänger-Themen 2
T Methode soll etwas ausrechnen und zurückgeben (klappt nd) hat wer eine Idee? Java Basics - Anfänger-Themen 11
P Main Methode scheint Constructor aufzurufen, ohne dass es so gecoded ist Java Basics - Anfänger-Themen 2
T Aufruf der Methode einer Oberklasse, wenn sie in der Unterklasse überschrieben ist. Polymorphie. Java Basics - Anfänger-Themen 2

Ähnliche Java Themen

Neue Themen


Oben