Redundanz mit Array vermeiden.

[LouCyphre]

Hallo,

ich schreibe gerade ein kleines Programm, wobei viele Instanzen angelegt werden müssen.
ich würde gern mittels Array Redundanz vermeiden, bin mir aber nicht sicher ob das überhaupt geht bzw. noch sinnvoll ist.

[CODE lang="java" title="um 3 Buttons zu erzeugen"]

int size = 3
JButton[] numberButtons = new JButton[size]


for(int i =0;i<size;i++) {

numberButtons = new JButton(String.valueOf(i));

}
[/CODE]

quasi so, dass ich damit eine beliebe Anzahl Buttons erzeugen kann.

Jetzt frage ich mich, gibt es ähnliche Konstrukte für Instanzen mit nicht "ganz" übereinstimmenden Merkmalen.
Zum Beispiel sollen drei Buttons erzeugt werden, allerdings mit unterschiedlichen Beschriftungen o.ä.

Hat da jemand ein Wort?

Danke
Lou

 

[White_Fox]

Probiere es mal mit einem HashSet...ist komfortabler, und vermeidet Redundanz automatisch.

Edit:
Wenn du die Reihenfolge brauchst, kannst du immer noch ArrayList verwenden. Das enthält immerhin eine Methode um einfach abzufragen, ob es ein Element schon enthält.
Aber so ein schnödes Array...es gibt fast immer eine Collection, die besser geeignet ist.

 

[Neumi5694]

Kann White_Fox da nur zusteimmen: Arrays sind nur in sehr seltenen Fällen ein guter Lösungsansatz.
Vor allem willst du ja auch beliebig viele Buttons anlegen, das Array hat aber ein von dir festgelegtes Fassungsvermögen. Womit du also arbeiten solltest, sind Collections.

Für die Reihenfolge gibt's zwei Alternativen zu einer Liste
1. LinkedHashSet: Ein Set mit vorgegebener Reihenfolge. Es behält die Reihenfolge so bei, wie du einfügst. (aus AECCBDBCBDAFC wird AECBDF)
2. TreeSet: Ein sortiertes Set. Laut Dokumentation wird nach der sog. natürlichen Ordnung" sortiert. (aus AECCBDBCBDAFC wird ABCDEF)

Alle Sets prüfen, ob die Elemente laut der equals(...) Methode gleich sind.
Der Nachteil eines Sets ist, dass man keine Indizes hat. Wenn man die Collection durchlaufen will, bietet sich eine for-each-Schleife oder ein Iterator an.
Du kannst natürlich auch deine Buttons zuerst in ein Set einfügen und dieses dann in eine Liste transferieren (new ArrayList<>(mySet))

 

[Barista]

Jetzt frage ich mich, gibt es ähnliche Konstrukte für Instanzen mit nicht "ganz" übereinstimmenden Merkmalen.
Zum Beispiel sollen drei Buttons erzeugt werden, allerdings mit unterschiedlichen Beschriftungen o.ä.

Hat da jemand ein Wort?

Fliegengewicht-Pattern

 

[Barista]

ich würde gern mittels Array Redundanz vermeiden

Bei Deiner Aussage "Redundanz vermeiden" machst Du nicht klar ob eines von Folgenden meinst:

-Redundanz im Speicher

-Redundanz im Code

Redundanz im Speicher kannst Du vermeiden, wenn Teile der Objekte delegiert sind.

Redundanz im Code kannst Du durch Vererbung oder Delegation vermeiden.

Die Buttons sind Klassen, die von Swing vorgegeben sind, Redundanz im Speicher kannst Du da kaum vermeiden.

 

[mrBrown]

Alle Sets prüfen, ob die Elemente laut der equals(...) Methode gleich sind.

TreeSet nicht, das nutzt compare/compateTo

 

[LouCyphre]

Danke erstmal für den Input!

@Barista
Es ging mir um die Redundanz im Code.

@Neumi5694 @White_Fox
Ich finde die Sache mit dem linkedHashset interessant, muss aber erstmal kurz reindenken.

Aber ist es nicht besser, wenn ich eine konstante Größe für das Array haben möchte, ein "schnödes Array"zu nehmen, statt der ArrayList?
Falls nicht, kann ich eine Initialgröße zuweisen?

Also am Beispiel:

Es soll eine fest definierte Anzahl an Buttons geben.
Damit möchte ich vor allem erst einmal den Buttons die Beschriftung " 0 - 9 " zuweisen.
Geht das dann auch eleganter mit ArrayList?

 

[Barista]

Eigentlich musst Du die Buttons gar nicht referenzieren, wenn Du nach dem Erzeugen sofort die entsprechenden ActionListener hinzufügst und die Buttons (den jeweils aktuellen) im Layout unterbringst.

 

[mrBrown]

Eigentlich musst Du die Buttons gar nicht referenzieren, wenn Du nach dem Erzeugen sofort die entsprechenden ActionListener hinzufügst und die Buttons (den jeweils aktuellen) im Layout unterbringst.

Außer man will mehr mit ihnen machen als nur stumpf anzeigen – disable'n, hervorheben, einzelne Buttons löschen, etc ...

 

[LouCyphre]

@mrBrown
Dann wäre das stinknormale Array besser?

 

[White_Fox]

Ein normales Array ist in keinem Fall, der hier bisher diskutiert wurde, besser.

Eine ArrayList kannst du mit einer initialien Größe erstellen ja...aber wozu? Einfach die add()-Methode so oft aufrufen wie du es brauchst, die ArrayList erweitert sich dann selber.

Glaub mir...du arbeitest einmal mit Collections, und wirst Arrays danach vermeiden wo immer es geht.

 

[LouCyphre]

Also mal als Roh Beispiel:

JButton a, b, c;

// später
a = new JButton("a");
b = new JButton("b");
c = new JButton("c");

// dann
ArrayList<JButton> abcButtons = new ArrayList<>();

abcButtons.add(a);
abcButtons.add(b);
abcButtons.add(c);

// irgendwas machen

for(int i, i < abcButtons.size(), i++){
   
    //geht glaub ich garnicht, aber ihr wisst was ich meine ^^
    abcButtons[i].setFont(font);  
}

macht das Sinn? (bis aus die markierte Stelle)

@White_Fox

Ich verstehe absoulut was du meinst.

Allerdings frage ich mich im konkreten Beispiel wie ich das umsetzen soll...

JButton[] numberButtons = new JButton[10];

for(int i =0;i<10;i++) {

            numberButtons[i] = new JButton(String.valueOf(i));
            numberButtons[i].addActionListener(this);
            numberButtons[i].setFont(font);
          
        }

Wie kann ich denn hier die .add() Methode nutzen?

 

[kneitzel]

@White_Fox

Ich verstehe absoulut was du meinst.

Er meinte auch nur, dass Du es so machen sollst, wie Du es jetzt gemacht hast - mit der ArrayList. Also ja: Das macht so prinzipiell Sinn.

 

[LouCyphre]

@kneitzel

Kann man die Deklaration aus Zeile 1 noch irgendwie sinnvoll direkt in die ArrayList packen?

 

[kneitzel]

Du kannst die Variablen a, b und C weglassen. Einfach ein abcButtons.add(new JButton(....));

 

[LouCyphre]

okay, danke! das ist cool!

allerdings wie spreche ich die buttons dann an?
hab es bisher dann mit z.B. a.setBounds(...) gemacht.

 

[White_Fox]

Ja, so in etwa. Geht in die richtige Richtung.

Du kannst statt der for-Schleife aber auch eine for-each-Schleife verwenden, dann mußt du dich mit der Indizierung nicht rumschlagen:

var buttonsList = new ArrayList<Button>();

buttonsList.add(new Button("a"));
buttonsList.add(new Button("b"));
buttonsList.add(new Button("c"));

for(Button currentButton : buttonsList){
    currentButton.setEnable(false); //Zum Beisiel
}

Die for-each-Schleifen waren mir am Anfang auch nicht geheuer, aber irgendwann hab ich die sehr gern genutzt.

 

[White_Fox]

@White_Fox

Ich verstehe absoulut was du meinst.

Allerdings frage ich mich im konkreten Beispiel wie ich das umsetzen soll...

JButton[] numberButtons = new JButton[10];

for(int i =0;i<10;i++) {

numberButtons[i] = new JButton(String.valueOf(i));
numberButtons[i].addActionListener(this);
numberButtons[i].setFont(font);

}

Wie kann ich denn hier die .add() Methode nutzen?

Naja...wie wäre es damit?

var buttonsList = new ArrayList<Button>();

for(int i = 0; i < 10; i++){
    Button nextButton = new Button(String.valueOf(i));
    nextButton.setEnable(false);
    //nextButton. ...mach, was dir mit jedem Button beliebt
  
    buttonsList.add(nextButton);
}

Kleiner Nachtrag fürs Verständnis:
Die add()-Methode macht am Ende des Tages ja auch nichts anderes wie deine Zuweisung für ein Array. Überall, wo du z.B. buttonArray[i] = theNewButton; schreibst, nimmst du einfach die add()-Methode. Diese fügt das neue Element einfach hinten an, um den Index mußt du dich nicht scheren. Und solltest du doch mal ein Element unbedingt auf Index 42 haben wollen...dann müßte es auch eine Methode geben, wo du den gewünschten Index mitgeben kannst.

 

[Neumi5694]

TreeSet nicht, das nutzt compare/compateTo

Auch für den Test, ob ein Element doppelt eingefügt wird, bzw. schon vorhanden ist?

 

[Neumi5694]

Es soll eine fest definierte Anzahl an Buttons geben.
Damit möchte ich vor allem erst einmal den Buttons die Beschriftung " 0 - 9 " zuweisen.
Geht das dann auch eleganter mit ArrayList?

Je nach Collection gibt's nur eine Sache, die Collection nicht können, das sind null-Elemente, das geht mit Sets z.B. nicht.
Wenn du ein Array mit Länge 10 initialisierst, dann wird lenght dir die Größe 10 liefern, die Felder sind allesamt null.
Der Zugriff a[2] wird null lierfern.


Die size() einer ArrayList hängt allerdings nicht von der Kapazität ab, sondern den tatsächlch darin gespeicherten Elementen.
Inizialisierst du eine ArrayList mit einer Kapazität von 10 (wird bei Bedarf automatisch erweitert), dann wird size() 0 liefern, es ist darin ja nichts gespeichert.
Der Zugriff get(2) wird eine OutOfBoundsException liefern, da 2 >= size ist.
(Anm: andere Listen haben womöglich gar keine Kapazitäts-Eigenschaft, die ist für die Verwendung eine Liste nämlich nicht relevant)

Ob du deine 10 Buttons nun in ein Array oder eine Liste speicherst, ist vollkommen wurscht, falls du flexibel bleiben willst.

Mir einem Array kannst du grundsätzlich alles machen, was du auch mit einer Collection machst. Aber damit zu arbeiten erspart dir sehr viel Arbeit und macht den Code viel angenehmer zu lesen (was es zu einer eleganteren Lösung macht).
White_Fox hat dir hier schon ein paar gute Beispiele gezeigt.

 

[Barista]

Es soll eine fest definierte Anzahl an Buttons geben.
Damit möchte ich vor allem erst einmal den Buttons die Beschriftung " 0 - 9 " zuweisen.
Geht das dann auch eleganter mit ArrayList?

Das Zuweisen der Beschriftung kannst Du mit der ArrayList nicht elegenater lösen.

 

[mrBrown]

Auch für den Test, ob ein Element doppelt eingefügt wird, bzw. schon vorhanden ist?

Ja, Treeset nutzt generell kein equals und kein Hashcode.

Kann man z.B. "missbrauchen", wenn man ein anderes "equals" braucht, als eine Klasse selbst implementiert.

 

[kneitzel]

Generell frage ich mich, was denn der Sinn von den Buttons in der ArrayList sein soll. Was willst Du noch wann mit den Buttons machen?

So eine Liste ist gut, wenn Du etwas mit allen Dingen machen willst. Ein Beispiel ist schon genannt worden: Alle Buttons aktivieren oder deaktivieren. (Kommt das so oft vor? Ich kenne es nur von spezifischen Anforderungen - wenn bestimmte Bedingungen erfüllt sind, dann wird ein Control aktiviert oder deaktiviert.

Wenn sowas nicht speziell benötigt wird, dann ist die Frage: Wird überhaupt etwas beabsichtigt? Wenn das nicht der Fall ist, dann würde ich einfach hin gehen und einfach eine lokale Variable verwenden. Dann hat man erst einmal keine Referenz mehr (braucht man ja nicht).

Bezüglich spezielles Control suchen: Wenn ich dies in einer List habe, muss ich die List durchgehen um das gesuchte Element zu finden. Das ist generell möglich, wenn ich den Parent Controller habe. Ich kann mir ja alle Komponenten eines Container Elements geben lassen.
Es kann daher (so es möglich ist) diese Elemente alle in einem Parent halten. Dann habe ich ein Panel mit allen Buttons, die ann geschlossen deaktiviert werden. Oder auch aktiviert.
(Das kann man dann auch sehr schön modellieren wenn man möchte.)

Wenn man eine Menge an Elementen hat und auch zielgerichtet auf einzelne Elemente zugreifen können will, dann ist eine Map evtl. auch das Mittel der Wahl.

Das einfach nur einmal kurz als ein paar Gedanken, die mir gerade durch den Kopf gegangen sind.

 

[LouCyphre]

Das Zuweisen der Beschriftung kannst Du mit der ArrayList nicht elegenater lösen.

Kann man es anders eleganter lösen?

Generell frage ich mich, was denn der Sinn von den Buttons in der ArrayList sein soll. Was willst Du noch wann mit den Buttons machen?

So eine Liste ist gut, wenn Du etwas mit allen Dingen machen willst. Ein Beispiel ist schon genannt worden: Alle Buttons aktivieren oder deaktivieren. (Kommt das so oft vor? Ich kenne es nur von spezifischen Anforderungen - wenn bestimmte Bedingungen erfüllt sind, dann wird ein Control aktiviert oder deaktiviert.

Wenn sowas nicht speziell benötigt wird, dann ist die Frage: Wird überhaupt etwas beabsichtigt? Wenn das nicht der Fall ist, dann würde ich einfach hin gehen und einfach eine lokale Variable verwenden. Dann hat man erst einmal keine Referenz mehr (braucht man ja nicht).

Bezüglich spezielles Control suchen: Wenn ich dies in einer List habe, muss ich die List durchgehen um das gesuchte Element zu finden. Das ist generell möglich, wenn ich den Parent Controller habe. Ich kann mir ja alle Komponenten eines Container Elements geben lassen.
Es kann daher (so es möglich ist) diese Elemente alle in einem Parent halten. Dann habe ich ein Panel mit allen Buttons, die ann geschlossen deaktiviert werden. Oder auch aktiviert.
(Das kann man dann auch sehr schön modellieren wenn man möchte.)

Wenn man eine Menge an Elementen hat und auch zielgerichtet auf einzelne Elemente zugreifen können will, dann ist eine Map evtl. auch das Mittel der Wahl.

Das einfach nur einmal kurz als ein paar Gedanken, die mir gerade durch den Kopf gegangen sind.

na ich würde gern, wie in #12 angerissen, mittels for/ for-each den Elementen der Liste gesammelt Sachen zuweisen, damit ich nicht jeden Button einzeln konfigurieren muss.

@White_Fox

was ist eigentlich der Unterschied die Liste so :

var buttonsList = new ArrayList<Button>();

oder so

ArrayList<JButton> abcButtons = new ArrayList<>();

zu deklarieren?

 

[kneitzel]

was ist eigentlich der Unterschied die Liste so :

var buttonsList = new ArrayList<Button>();

Das mit dem var ist einfach ein "Hey Compiler, schau selbst, was da für ein Typ zugewiesen wird". Das hat zur Konsequenz, dass bei der Zuweisung der Typ natürlich genau angegeben werden muss.

oder so

ArrayList<JButton> abcButtons = new ArrayList<>();

zu deklarieren?

Hier gibst Du den Typ bei der Deklaration der Variable genau an. Das hat dann zur Konsequenz, dass der Compiler das Generic selbst ermitteln kann. Daher kommt da nur noch das "<>" statt einem "<JButton>". (Wobei du das auch incl. dem JButton schreiben könntest:

ArrayList<JButton> abcButtons = new ArrayList<JButton>();

Ersteres mache ich gerne, wenn der Typ klar ist. Letzteres in kleiner Abwandlung ist aber bei so einer Variable üblich:

List<JButton> abcButtons = new ArrayList<>();

==> hier ist also kein var möglich, denn in der Regel will man hier nur ein Interface angeben (also in dem konkreten Fall List<T>) aber bei new muss eine konkrete Klasse angegeben werden (ArrayList<T>).

 

[Jw456]

was ist eigentlich der Unterschied die Liste so :

var buttonsList = new ArrayList<Button>();

oder so

ArrayList<JButton> abcButtons = new ArrayList<>();

zu deklarieren?

der erste Code ist mit sicherheit nicht Java könnte Kotlin sein.

Edit: ja Java kennt das "var" kenne ich nur von anderen Sprachen habe ich noch nie in Java benutzt.

"

 

[LouCyphre]

Das mit dem var ist einfach ein "Hey Compiler, schau selbst, was da für ein Typ zugewiesen wird". Das hat zur Konsequenz, dass bei der Zuweisung der Typ natürlich genau angegeben werden muss.


Hier gibst Du den Typ bei der Deklaration der Variable genau an. Das hat dann zur Konsequenz, dass der Compiler das Generic selbst ermitteln kann. Daher kommt da nur noch das "<>" statt einem "<JButton>". (Wobei du das auch incl. dem JButton schreiben könntest:

ArrayList<JButton> abcButtons = new ArrayList<JButton>();

Ersteres mache ich gerne, wenn der Typ klar ist. Letzteres in kleiner Abwandlung ist aber bei so einer Variable üblich:

List<JButton> abcButtons = new ArrayList<>();

==> hier ist also kein var möglich, denn in der Regel will man hier nur ein Interface angeben (also in dem konkreten Fall List<T>) aber bei new muss eine konkrete Klasse angegeben werden (ArrayList<T>).

okay danke.

Ich habe gerade mal versucht deinen Tipp aus #18 (@White_Fox ) umzu setzen.

ich kann jetzt aber zum Beispiel die Methoden nicht zuweisen.
die IDE sagt mit , als Beispiel:

abcButtons.setFont(myFont); // cannot resolve in ArrayList

Kann man das beheben und wieso tritt es auf?

 

[kneitzel]

setFont ist eine Methode der KLasse JButton, abcButtons ist aber eine ArrayList. Daher kannst Du das nicht aufrufen.

Wenn Du eine Methode auf allen Buttons in der ArrayList aufrufen willst, dann musst Du das auch entsprechende schreiben:

for (JButton button : abcButtons) {
    button.setFont(myFont);
}

 

[Neumi5694]

der erste Code ist mit sicherheit nicht Java könnte Kotlin sein.

Edit: ja Java kennt das "var" kenne ich nur von anderen Sprachen habe ich noch nie in Java benutzt.

Das geht auch erst seit Java 16 (oder 15).

 

[kneitzel]

Das geht auch erst seit Java 16 (oder 15).

Nö, die Typinferenz ist mit Java 10 eingeführt worden. (JEP 286) - also schon deutlich länger vorhanden. Aber durchaus eine Erklärung dafür, dass es in vielen Büchern / Tutorials (noch) nicht zu finden ist.

 

[Jw456]

Nö, die Typinferenz ist mit Java 10 eingeführt worden. (JEP 286) - also schon deutlich länger vorhanden. Aber durchaus eine Erklärung dafür, dass es in vielen Büchern / Tutorials (noch) nicht zu finden ist.

so habe ich jetzt auch gelesen.

in Kotlin oder C# ist mir das bekannt . Ok eben auch in Java

 

[LouCyphre]

setFont ist eine Methode der KLasse JButton, abcButtons ist aber eine ArrayList. Daher kannst Du das nicht aufrufen.

Wenn Du eine Methode auf allen Buttons in der ArrayList aufrufen willst, dann musst Du das auch entsprechende schreiben:

for (JButton button : abcButtons) {
    button.setFont(myFont);
}

okay danke das versteh ich.

aber ich habe scheinbar grundlegend was nicht verstanden.

var buttonsList = new ArrayList<Button>(); for(int i = 0; i < 10; i++){ Button nextButton = new Button(String.valueOf(i)); nextButton.setEnable(false); //nextButton. ...mach, was dir mit jedem Button beliebt buttonsList.add(nextButton); }

Hier habe ich ja eine leere Arraylist die ja mit new Button(String.valueOf(i)); mittels (i) und for Schleife 10 Buttons rein schreibt, ja?
Muss ich dann die Laufvariable vom Typ JButton haben ( was ja garnicht geht)oder steh ich gehörig auf dem Schlauch?
Bzw.
Die for each schleife würde ja in dem Fall garnichts machen, weil ja nichts drin ist oder?

 

[kneitzel]

Dort hast Du eine Laufvariable i vom typ int. Die Schleife soll ja zählen.

In der Schleife selbst hast Du eine lokale Variable, die Du dann nutzt um einen Button zu erzeugen und diesen dann in der Liste hinzu zu fügen.

 

[White_Fox]

was ist eigentlich der Unterschied die Liste so :

var buttonsList = new ArrayList<Button>();

oder so

ArrayList<JButton> abcButtons = new ArrayList<>();

zu deklarieren?

Es ist kürzer zu schreiben, und weniger Redundaz im Ausdruck. Gibt es erst seit Java 9 oder einer höheren Version. Ich habe mein Projekt erst kürzlich von Java 8 auf Java 16 umgestellt, und weiß diesen Ausdruck sehr zu schätzen.

Der lange, umständliche Ausdruck:

ArrayList<Button> list = new ArrayList<>();

ist die zusammengezogene Schreibweise von:

ArrayList<Button> list; //Deklariere eine Objektvariable, die vom Typ ArrayList sein muß, und in die ArrayList können nur Buttonobjekte rein.

//....

list = new ArrayList(); //Rufe den Konstruktor von ArrayList auf, der eine Referenz zu einem neuen ArrayList-Objekt liefert.

Einerseits stellst du in einer einzigen Zeile sicher, daß list vom Typ ArrayList ist und rufst gleichzeitig etwas auf, daß dir ganz sicher eine Referenz auf ein ArrayList-Objekt liefert - doppelt gemoppelt, und wenn der Klassenname mal etwas länger ist, wird der Ausdruck richtig lang.
Und diesen langen Ausdruck kann man einfach abkürzen indem man mit 'var' klarstellt, daß list von dem Typ ist, der da gerade geliefert wird.

 

[Jw456]

okay danke das versteh ich.

aber ich habe scheinbar grundlegend was nicht verstanden.

Hier habe ich ja eine leere Arraylist die ja mit new Button(String.valueOf(i)); mittels (i) und for Schleife 10 Buttons rein schreibt, ja?
Muss ich dann die Laufvariable vom Typ JButton haben ( was ja garnicht geht)oder steh ich gehörig auf dem Schlauch?
Bzw.
Die for each schleife würde ja in dem Fall garnichts machen, weil ja nichts drin ist oder?

die for each weis selber wie viele Elemente in der Liste sind.

du hast ja 10 Button mit new erstellt in der Liste.

 

[Neumi5694]

Nö, die Typinferenz ist mit Java 10 eingeführt worden. (JEP 286) - also schon deutlich länger vorhanden. Aber durchaus eine Erklärung dafür, dass es in vielen Büchern / Tutorials (noch) nicht zu finden ist.

Stimmt, hab da was durcheinandergebracht. Hatte irgendwie in erinnerung, dass es bis 16 ein preview feature war, aber das war was Anderes.

 

[LouCyphre]

Dort hast Du eine Laufvariable i vom typ int. Die Schleife soll ja zählen.

In der Schleife selbst hast Du eine lokale Variable, die Du dann nutzt um einen Button zu erzeugen und diesen dann in der Liste hinzu zu fügen.

Sry ich raffs gerade nicht.

for(int i =0;i<10;i++) {

            JButton nextButton = new JButton(String.valueOf(i));      // nextButton ist doch meine lokale Variable?     
            buttonList.setFont(myFont);
            
            buttonList.add(nextButton);
    
    }

Das klappt leider nicht.

 

[Neumi5694]

Hier habe ich ja eine leere Arraylist die ja mit new Button(String.valueOf(i)); mittels (i) und for Schleife 10 Buttons rein schreibt, ja?
Muss ich dann die Laufvariable vom Typ JButton haben ( was ja garnicht geht)oder steh ich gehörig auf dem Schlauch?
Bzw.
Die for each schleife würde ja in dem Fall garnichts machen, weil ja nichts drin ist oder?

Das ist richtig. Bevor irgendwelche Elemente in der Liste sind, macht for-each erst mal gar nichts.
Wenn du 10 Buttons (oder sonstwas) haben willst, dann ist der einzig brauchbare Weg, eine for-schleife, die zählt. Insofern brauchst du beim ERSTELLEN der Buttons die Laufvariable i, diese dient außerdem der Beschriftung der Buttons.
IN der Schleife erstellst du dann einen Button und fügst ihn mit add der Liste hinzu.

Wenn du ab diesem Zeitpunkt etwas für alle Buttons machen willst, brauchst du keinen Index mehr, for-each geht die gesamte Liste durch.

 

[Neumi5694]

Sry ich raffs gerade nicht.

for(int i =0;i<10;i++) {

            JButton nextButton = new JButton(String.valueOf(i));      // nextButton ist doch meine lokale Variable?  
            buttonList.setFont(myFont);
         
            buttonList.add(nextButton);
 
    }

Das klappt leider nicht.

Kneitzel hat das schon mal beantwortet.
Du versuchst hier, den Font einer Liste zu ändern. Seit wann hat eine Liste einen Font?
Anm: Das wäre mit einem Array auch nicht anders. Du kannst nicht den Font eines Arrays ändern.

Du solltest dich von der "geht nicht" Denkweise lösen.
Wenn du Unsinn eintippst, dann sagt dir der Compiler im Normalfall recht genau, was du falsch gemacht hast. Anstatt zu sagen "geht nicht", solltest du die Fehlermeldung lesen. Weder ein Array noch eine Liste haben eine Methode setFont(...), das kann also nicht klappen.des Buttons ändern

 

[LouCyphre]

Kneitzel hat das schon mal beantwortet.
Du versuchst hier, den Font einer Liste zu ändern. Seit wann hat eine Liste einen Font?

Okay. Das verstehe ich auch, es läuft ja quasi nicht mehr durch.
Also sollte ich ab diesem moment zu einer for each Schleife wechseln um die fonts jedem einzelnen Button zu zuweisen?

 

[Jw456]

Okay. Das verstehe ich auch, es läuft ja quasi nicht mehr durch.
Also sollte ich ab diesem moment zu einer for each Schleife wechseln um die fonts jedem einzelnen Button zu zuweisen?

nein dein font solltest du auf den eben erstellten Button setzen. nextButton

dann haben alle Button den Font schon bei der Erstellung.

das mit der for each ist wenn du später wenn deine Liste fertig ist und du den font für alle Elemente in der liste ändern willst.

 

[White_Fox]

Ich habe den Eindruck du versuchst, etwas auswendig zu lernen, wo du besser versuchen solltest etwas zu verstehen.

Es nutzt dir nichts wenn jetzt auswendiglernst, warum du in diesem speziellen Sonderfall eine for-Schleife und keine for-each-Schleife verwenden sollst. Selbst wenn du das nebst aller Umstände und Bedingungen jetzt perfekt auswendig und für alle Zeiten weißt: Was machst du, wenn es zu irgendeiner Randbedingung eine Abweichung gibt?

Anstatt auswendig zu lernen was die ganzen Zeilen und Wörter machen solltest du mal versuchen, deinen Code und unsere Beispiele zu lesen. Einfach nur lesen und verstehen, zu versuchen den Text in Bedeutung zu übersetzen.
In Java ist eigentlich kein Zeichen überflüssig, jedes hat dir etwas zu sagen. Versuche zu verstehen, was es dir sagen will.

Geh mal ruhig den ganzen Thread zurück und lies die Codebeispiele (auch deine), lies sie als Text der dir etwas sagen soll.

 

[LouCyphre]

Danke für den Einwurf. Den Eindruck habe ich gerade auch.
Ich habe gerade einige Probleme festgestellt, die von euch schon im Vorfeld gerochen wurden.

trotzdem erstmal vielen Dank an @White_Fox @Jw456 @Neumi5694 @kneitzel und Co. !!