Getter Methode

Bitte aktiviere JavaScript!
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?
 
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

.
 
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
 
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
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.
 
@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
 
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.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben