Getter Methode

[vogelspinne24]

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

 

[httpdigest]

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:

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:

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

 

[vogelspinne24]

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:

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:

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:


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.

 

[kneitzel]

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.....

 

[vogelspinne24]

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]

Du solltest dein intArray auch irgendwo deklarieren, d.h. dem Compiler sagen daß du irgendwo ein intArray brauchst.

public class MyClass{
    private int intArray[];
   
    //Muß im Konstruktor erzeugt oder per Setter übergeben werden
    public MyClass(){
        intArray = new int[];
    }
}

 

[httpdigest]

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`:

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;
    }
}

 

[vogelspinne24]

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?

 

[httpdigest]

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.

 

[vogelspinne24]

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?

 

[httpdigest]

Ja. Das sagte ja bereits @kneitzel . Du solltest nach Möglichkeit komplett auf das "static" Schlüsselwort verzichten (außer bei der "main" Methode). Betrachte das mal als eine Herausforderung.

 

[vogelspinne24]

Ja. Das sagte ja bereits @kneitzel . Du solltest nach Möglichkeit komplett auf das "static" Schlüsselwort verzichten (außer bei der "main" Methode). Betrachte das mal als eine Herausforderung.

Okay, ich schreib mal alles um

 

[ARadauer]

so mit Instanz Variablen:

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

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]

@vogelspinne24 Und wenn wir schon dabei sind: verwende separate Methoden, die jeweils nur eine Aufgabe haben.

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.

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

 

[vogelspinne24]

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)

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();
    }
}

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);
        }
    }

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]

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

 

[vogelspinne24]

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 ?

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]

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

Openbooks. Rheinwerk-Bücher kostenlos online lesen. Ein Service des Rheinwerk Verlags

openbook.rheinwerk-verlag.de

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

 

[vogelspinne24]

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?

 

[vogelspinne24]

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]

Ich weiß ehrlich gesagt nicht einmal, was das ganze werden soll, wenn es fertig ist.

 

[Blender3D]

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

Diese getter erlaubte es auch schreibend von außen auf das Array zuzugreifen.
Falls es ausschließlich lesend sein soll müsstest Du eine Kopie des Arrays zurückgeben.

 

[vogelspinne24]

Ich weiß ehrlich gesagt nicht einmal, was das ganze werden soll, wenn es fertig ist.

Ich will eigentlich nur ein paar ArrayListen mit Zahlen und Buchstaben erstellen, die dann durch Bubblesort und Quicksort laufen lassen, das wars..

 

[mihe7]

Ja, dann

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.

 

[vogelspinne24]

Ja, dann

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

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]

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.

 

[vogelspinne24]

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 !

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 ?


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

.

 

[White_Fox]

Wie überprüft ihr alten Hasen sowas?

Der Debugger ist dein Freund. Manchmal dein Einziger.

 

[mrBrown]

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)

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>
    }

    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 ?

Die meisten solcher Probleme löst man mit ein bisschen strukturiertem Vorgehen.

In deinem Fall im ersten Schritt z.B. Getter und Ausgabe trennen.

 

[mrBrown]

Der Debugger ist dein Freund. Manchmal dein Einziger.

Debuggers are a wasteful Timesink

As debuggers have grown in power and capability, they have become more and more harmful to the process of software development.

 

[mihe7]

Wie überprüft ihr alten Hasen sowas?

Wir sortieren nicht selbst, wir lassen sortieren

 

[White_Fox]

@mrBrown
Wie kommt man denn auf sowas Schräges?

 

[vogelspinne24]

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?

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

 

[mihe7]

Arraygenerator01.generateListArrayZahlen(anzahlZahlen);
ArrayList<Integer> array01Zahlen = Arraygenerator01.getArrayZahlen();
System.out.println("Vorher: " + array01Zahlen);
Bubblesort01.Bubblesortzahlen(array01Zahlen);
System.out.println("Nachher: " + array01Zahlen);

 

[vogelspinne24]

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]

@mrBrown
Wie kommt man denn auf sowas Schräges?

Steht doch in dem verlinkten Post

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]

@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.

 

[vogelspinne24]

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

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

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 !

 

[mihe7]

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

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:

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:

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.