ArrayList mit Zahlen

GianaSisters

Bekanntes Mitglied
Hallo Zusammen,

ich bin ziemlich am Verrückt werden mit dem Problem. Ich versuche es auf den Punkt zu bringen. Da ich im jTable Rahmen mache, die hinzugefügt werden können habe ich eine ArrayList benutzt um dort die Felder einzutragen die einen Rahmen besitzen. Soweit so gut...

Das hinzufügen klappt eigentlich ganz gut.
Aufgrund folgender Methode werden die Felder hochgerechnet
Java:
 public ArrayList<Integer> passendErhoehen(ArrayList<Integer> rahmen, int anzahlExistZeilen, int rahmencount){
        // Logisch, der letzte Wert wird erhöht, jetzt noch die anderen
      
                 // Sortieren (ACHTUNG, Nur gemacht weil bei 17, sich es von 1-17 auf 17-1 umdreht
                 //Collections.sort(rahmen);
        System.out.println(rahmen);
                 rahmen.set(rahmen.size()-1, anzahlExistZeilen);
        
             // Erhöhungsschleife
                for (int j = rahmencount; j < rahmen.size()-1; j++ ){
                  rahmen.set(j, (rahmen.get(j)+1));
               }
                  return rahmen;
}

Ich habe bereits ein paar Hilfen für mich mit eingebaut. Jedenfalls wird diese Methode immer richtig aufgerufen und es erscheint:

[1, 2]
[1, 3]
[1, 4]
[1, 5]
[1, 6]
[1, 7]
[1, 8]
[1, 9]
[1, 10]
[1, 11]
[1, 12]
[1, 13]
[1, 14]
[1, 15]
[1, 16]
[17, 1]
[17, 18]
[18, 19]

Wie kann das sein ? Eigentlich sollte ja 1,17 kommen und nicht 17,1
Wenn mir jemand helfen könnte wäre spitzenmäßig. Als Problembehebung ist zwar mit Collections.sort(rahmen); einigermaßen geholfen, aber ich möchte doch dann ganz gern den Grund dafür wissen. Falls mehr Code benötigt wird um mir zu helfen mach ich das gerne...
Vielen Dank schonmal,
Giana
 
Zuletzt bearbeitet von einem Moderator:
S

SlaterB

Gast
mehr Logging Logging Logging,
ich verstehe deine Code generell nicht so sehr, Zeile 7 setzt das letzte Element auf anzahlExistZeilen? was ist das für ein Wert, erhöht der sich jedes Mal um 1?

die Schleife Zeile 10-12 kann sich doch nur auf j=0 beziehen, aber der erste Eintrag bleibt ja lange 1, wird nicht erhöht?
was ist rahmencount, macht diese Schleife gar nichts?
wird die Liste außerhalb der Methode geändert?

bevor irgendjemand verrückt wird, würde ich die Methode mit 10x System.out.println() vollpflastern, alle Variablen wie anzahlExistZeilen ausgeben, vor und nach jeder Änderung (Zeile 7 + VOR, IN, NACH der Schleife) den Listeninhalt ausgaben,
sowie insbesondere die Liste am Anfang + Ende der Methode,
zur Unterscheidung mehrere Durchläufe noch sowas wie ausgabe("start") am Anfang, dann siehst du wirklich wer wann was ändert
 

kirax

Bekanntes Mitglied
bevor irgendjemand verrückt wird, würde ich die Methode mit 10x System.out.println() vollpflastern, alle Variablen wie anzahlExistZeilen ausgeben, vor und nach jeder Änderung (Zeile 7 + VOR, IN, NACH der Schleife) den Listeninhalt ausgaben,
sowie insbesondere die Liste am Anfang + Ende der Methode,
zur Unterscheidung mehrere Durchläufe noch sowas wie ausgabe("start") am Anfang, dann siehst du wirklich wer wann was ändert

Debugger machen da sogar weniger Arbeit ;)
 

GianaSisters

Bekanntes Mitglied
Hallo SlaterB (und Andere natürlich auch),

ich versuche hier mal alles aufzutragen was mit der Sache zu tun hat. Erstmal ein Screenshot
problemss.jpg


Ziel ist es, wenn man auf ein Feld klickt ein neues entsteht. Also wird ein Feld auf pot.Fehler z.b. angewählt und auf "Funktion hinzufügen" (eigentlich nur Hinzufügen soll es heißen) geklickt, dann wird der Rahmen bei Spalte 1 und 2 (No. und Funktion) um einen erhöht, wie auch der gesamte jTable. Klickt man auf "pot Folge" dann splittet sich der pot.Fehler und wird in der passenden Zeile verändert. Das heißt für die Rahmen, dass nachgeguckt wird in welcher Zeile befinde ich mich und in welchem Kästchen auf der Spalte davor. Da sich ja erst ab dieser Zeile was von den Werten für die Rahmen ändert. Hier ein Beispiel:
problemss1.jpg


Jetzt ein Bild bei dem der benannte Fehler auftritt.
problemss2.jpg


Also, es wurde 2 mal die erste Spalte angewählt und hinzufügen geklickt, dadurch bekam ich 2 Funktionen. Jetzt Splitte ich die untere Funktion auf indem ich im Feld pot Fehler klicke. Das sollte unendlich so weiter gehen. Tuts aber nicht.. Bei 1,16 wird 17,1.
Hier nun was Code:

Beim Buttonklick:

Java:
 AktuelleRahmen komplettrahmen = new AktuelleRahmen();

 if (Globales.globalSpalte < 6)    ((DefaultTableModel)jTable1.getModel()).addRow(new Object[]{null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null});
    if ((Globales.globalSpalte == 0) || (Globales.globalSpalte == 1)) { 
        komplettrahmen.addRow1(jTable1.getRowCount());
        komplettrahmen.addRow2(jTable1.getRowCount());
        komplettrahmen.addRow3(jTable1.getRowCount());
         }
    if ((Globales.globalSpalte == 2) || (Globales.globalSpalte == 3) || (Globales.globalSpalte == 5)) {
        komplettrahmen.addRow3(jTable1.getRowCount());
        }

 //   System.out.println("Eins:" + komplettrahmen.getRow1());
 //   System.out.println("Zwei:" + komplettrahmen.getRow2());
 //   System.out.println("Drei:" + komplettrahmen.getRow3());
               

        // ABSATZ ENTSCHEIDUNG WELCHE SPALTE AUSGEWÄHLT IST
     if ((Globales.globalSpalte == 0) || (Globales.globalSpalte == 1)) {                           
        jTable1.setValueAt(dialog.getFunktionNummer(), rowcount, 0);
        jTable1.setValueAt(dialog.getFunktionName(), rowcount, 1);
     }

       // Für jeden Fall einen eigenen Rahmen nachprüfen
    if (Globales.globalSpalte == 2) komplettrahmen.editRow1(jTable1.getRowCount(), 2);
    if (Globales.globalSpalte == 2) komplettrahmen.editRow2(jTable1.getRowCount(), 2);
    if (Globales.globalSpalte == 2) komplettrahmen.editRow3(jTable1.getRowCount(), 2);

Die AktuelleRahmen-Klasse sieht so aus, wobei zu beachten ist, das editRow3 hier keinerlei Benutzung findet. Auch EditRow2 wird nicht verändert. Das passiert nur wie man auf dem mittleren Screenshot sieht, wenn diese angeklickt wird.


Java:
package fmea;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;


public class AktuelleRahmen {
    ArrayList<Integer> rahmen1 = new ArrayList<Integer>();
    ArrayList<Integer> rahmen2 = new ArrayList<Integer>();
    ArrayList<Integer> rahmen3 = new ArrayList<Integer>();
    Rahmenerkennung ra = new Rahmenerkennung();
    Rahmenerkennung ra2 = new Rahmenerkennung();
    Rahmenerkennung ra3 = new Rahmenerkennung();
    int rahmencounter = 0;
    int rahmencounter2 = 0;
    int rahmencounter3 = 0;
    
// Funktion
    public void addRow1(int reihe){
        rahmen1.add(reihe);
    }
 // Pot Fehler
    public void addRow2(int reihe){
        rahmen2.add(reihe);
    }
// Pot Folge
    public void addRow3(int reihe){
        rahmen3.add(reihe);
    }
    ArrayList<Integer> getRow1(){
        return rahmen1;
    }
    
    ArrayList<Integer> getRow2(){
        return rahmen2;
    }

    ArrayList<Integer> getRow3(){
        return rahmen3;
    }
    // Berechnung der zu erwartenden Rahmenzeilen
    public void editRow1(int anzahlExistierenderZeilen, int klickspalte){

          rahmencounter=0;
           // Prüfen, zwischen welchen beiden Arrays die aktuelle Zeile ist
          rahmencounter = ra3.getRahmen(rahmen1);
          // Die Rahmenwerte anpassen
          
          // Bis hier ist alles in ordnung
          ra3.passendErhoehen(rahmen1, anzahlExistierenderZeilen, rahmencounter);
      //    System.out.println("Rahmen 1: " + this.getRow1());
     //   System.out.println("Rahmen 2: " + this.getRow2());

    }

      public void editRow2(int anzahlExistierenderZeile, int klickspalte){
        rahmencounter2=0;
        // Einfügen des selben neunen Rahmens an die Passende Stelle
          if (klickspalte == 2) {          
            rahmen2 = ra2.einfuegeRahmen(rahmen1, rahmen2);
          }

        // die Nachfolgende Spalte wird erhoeht, also vergrößert sich rahmen 2 mehr
        if (klickspalte == 3) {
            //voher war in der folgenden zeile ra2 anstatt ra
                      Collections.sort(rahmen2);
           rahmencounter2 = ra2.getRahmen(rahmen2);
           System.out.println("KOMMTS HIER REIN ?? " + rahmencounter2);
           ra2.passendErhoehen(rahmen2, anzahlExistierenderZeile, rahmencounter2);
           }       
      }
      public void editRow3(int anzahlExistierenderZeile, int klickspalte){
        // Absicherung, damit kein unfug passiert wenn man es anklickt wenn noch nix existiert.
         rahmencounter3 = 0;
    
         if (anzahlExistierenderZeile >= 3) {

              if (klickspalte == 5) {
              // beim Rahmen3 muss sich was ändern
              rahmencounter3 = ra.getRahmen(rahmen3);
              ra.passendErhoehen(rahmen3, anzahlExistierenderZeile, rahmencounter3);

              }
               if (klickspalte == 3) {
                   rahmen3 = ra.einfuegeRahmen(rahmen2, rahmen3);
                   
               }

              // Hier wird von der vorherigen auf die Nachfolgende geschlossen
              if (klickspalte == 2) {
                  rahmen3 = ra.einfuegeRahmen(rahmen1, rahmen3);
                  
                  int rahmentest;
                      rahmencounter3 = (ra.getRahmen(rahmen3));
                  // Rausfinden auf welchem Punkt rahmen1 liegt, nur ab da wird geschoben
        //          rahmentest = rahmen1.get(ra.getRahmen(rahmen1));
                
                  // Klappt schon richtig bei der untersten funktion
         //         for (int j = (rahmentest); j < rahmen3.size(); j++ ){
         //         rahmen3.set(j, (rahmen3.get(j)+1));
         //         System.out.println("Dazwischen: " + rahmen3);
         //         }
                  // In welchem kasten von 3 ist man
                  
                    
         //           System.out.println("Anzeige Rahmen1:" + rahmentest);
         //           System.out.println("Das Ende: "+ anzahlExistierenderZeile);
         //
         //           for (int k = rahmentest; k < anzahlExistierenderZeile; k++ ){
                      
                    //  rahmen3.set(k, (rahmen3.get(k)+1));
         //           }

                    //rahmen3.add(rahmentest);

                  // Die Linie von Rahmen1 spielt noch eine rolle
                 

              } else {
                  
              }
        }

        
      }
    }


Dann gibts noch die Klasse Rahmenerkennung, die methoden-Enthält, die mir das Leben was einfacher gemacht hatten.

Java:
package fmea;

import java.util.ArrayList;
import java.util.Collections;

/**
 *
 * @author Timo
 */
public class Rahmenerkennung {

    public int getRahmen(ArrayList<Integer> rahmen){
        int aktuellerRahmen = 0;
         for (int y = 0; y < rahmen.size(); y++ )
             {
               // *********** Erkennung in welchem eigenen Rahmen man sich befindet
                 if (rahmen.get(y) < Globales.globalZeile+2) {aktuellerRahmen++;}
                  // Unterstes PotfehlerElement ausgewählt, also = = sache
                 if (rahmen.contains(Globales.globalZeile+1)) {aktuellerRahmen = rahmen.indexOf(Globales.globalZeile+1); break;}
              }
        
        return aktuellerRahmen;
    }


    public ArrayList<Integer> passendErhoehen(ArrayList<Integer> rahmen, int anzahlExistZeilen, int rahmencount){
        // Logisch, der letzte Wert wird erhöht, jetzt noch die anderen
      
                 // Sortieren (ACHTUNG, Nur gemacht weil bei 17, sich es von 1-17 auf 17-1 umdreht
                 //Collections.sort(rahmen);
        System.out.println(rahmen);
                 rahmen.set(rahmen.size()-1, anzahlExistZeilen);
        
             // Erhöhungsschleife
                for (int j = rahmencount; j < rahmen.size()-1; j++ ){
                  rahmen.set(j, (rahmen.get(j)+1));
               }
                  return rahmen;
}

    
    // Vom vorherigen Rahmen schauen wo sachen einzufügen sind
    public ArrayList<Integer> einfuegeRahmen(ArrayList<Integer> vorherigerRahmen, ArrayList<Integer> aktuellerRahmen){
   
        for (int y = 0; y < aktuellerRahmen.size(); y++ ){
                if ((aktuellerRahmen.get(y)) >= (vorherigerRahmen.get(this.getRahmen(vorherigerRahmen)))) {
                    //Elemente die nach der Einfügung sind erhöhen
                    aktuellerRahmen.set((y), (aktuellerRahmen.get(y)+1) );
                }
            }
         // Einfügen und danach sortieren
            aktuellerRahmen.add(vorherigerRahmen.get(this.getRahmen(vorherigerRahmen)));
            aktuellerRahmen.add(vorherigerRahmen.get(this.getRahmen(vorherigerRahmen))-1);
            Collections.sort(aktuellerRahmen);

         return aktuellerRahmen;
    }
}


Abschließend möchte ich noch sagen, dass ich genug Logging gemacht habe und der Fehler genau in der Methode bei Rahmenerkennung : rahmen.set(rahmen.size()-1, anzahlExistZeilen);
zu finden war.

Antworten zu slaterB: anzahlExistZeilen ist immer die Anzahl der Zeilen die der jTable hat.
Unten der Code für Deine weitere Frage.
Java:
// Erhöhungsschleife
                for (int j = rahmencount; j < rahmen.size()-1; j++ ){
                  rahmen.set(j, (rahmen.get(j)+1));
               }
rahmencount ist die Variable die erkennt in welchem Rahmen man sich befindet, also welche Werte um einen erhöht werden müssen, da sich der Rahmen ja nicht nach oben hin vergrößert sondern nach unten hin. Es geht bis rahmen.size()-1, da der unterste Rahmen bereits erhöht wurde, also nur die dazwischen müssen erhöht werden. rahmen.set ändert logischeweise die passenden Werte.
Ich hoffe Jemand hat die Geduld und Zeit mir da zu helfen
 
S

SlaterB

Gast
ich persönlich verstehe überhaupt nicht wie deine Screenshots oder Code irgendwas zu diesem Problem beitragen sollen

> Abschließend möchte ich noch sagen, dass ich genug Logging gemacht habe [..]

komisch, dass du diese einzige wichtige Info hier aber nicht freigibst, ich wiederum kann dann nicht weiterhelfen,

nochmal zur Verdeutlichung:
eine Liste springt nicht einfach von [1, 16] auf [17, 1], da sind wenigstens zwei Änderungen nötig,
wenn du durch Loggen/ Debuggen den Zeitpunkt eines Zwischenzustands ([1] oder [1, 1] oder [17, 16] oder noch andere) herausfinden könntest, wäre schon viel geschafft,
was spricht gegen diese Vorgehensweise?

dass meine System.out.println() das ganze schaffen ist nicht gesagt, es kann noch mehr Probleme geben, z.B. VERSCHIEDENE Listen,
oder wie gesagt Änderungen außerhalb der fraglichen Methode oder separat laufende Threads,
für extremeres Logging würde ich gar eine eigene Liste-Klasse verwenden

aber erstmal eins nach dem anderen, ohne den ersten Schritt kann kein zweiter erfolgen
 

GianaSisters

Bekanntes Mitglied
Ja, du hast recht. Ich hatte gehofft, dass das Problem irgendwie bekannt ist, dass ab einem bestimmten Wert irgendetwas spinnt. Ich werde jetzt mal mein Bestes geben :)
 

GianaSisters

Bekanntes Mitglied
Ganz komisch:

Java:
   private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {                                         

        // Erkennen, welche Spalte markiert wurde
  	//System.out.println("Spalte " + markierteSpalte);
     if ((Globales.globalSpalte == 4) || (Globales.globalSpalte == 6)) {}
 else {

       System.out.println("Ganz Vorher: " + komplettrahmen.getRow1());
        //   jTable1.setValueAt("wuwu", 0, 0);
        int rowcount;
        int x;
        int rahmencounter = 0;
        Integer intAktuell = null;
        FmeaFunktionHinzu FFH = new  FmeaFunktionHinzu();
        FmeaFunktionDialog dialog = new FmeaFunktionDialog(FFH, true);
        if ((Globales.globalSpalte == 0) || (Globales.globalSpalte == 1)) {
            dialog.setVisible(true);
        }
        jTable1.setEnabled(true);
        rowcount = jTable1.getRowCount();

        // ************** Neue Leere Zeile hinzufügen
    if (Globales.globalSpalte < 6)    ((DefaultTableModel)jTable1.getModel()).addRow(new Object[]{null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null});
    if ((Globales.globalSpalte == 0) || (Globales.globalSpalte == 1)) { 
        komplettrahmen.addRow1(jTable1.getRowCount());
        komplettrahmen.addRow2(jTable1.getRowCount());
        komplettrahmen.addRow3(jTable1.getRowCount());
         }
    if ((Globales.globalSpalte == 2) || (Globales.globalSpalte == 3) || (Globales.globalSpalte == 5)) {
        komplettrahmen.addRow3(jTable1.getRowCount());
        }

 //   System.out.println("Eins:" + komplettrahmen.getRow1());
 //   System.out.println("Zwei:" + komplettrahmen.getRow2());
 //   System.out.println("Drei:" + komplettrahmen.getRow3());
       // * Der letzte Stimmt ja immer :)
         

        // ABSATZ ENTSCHEIDUNG WELCHE SPALTE AUSGEWÄHLT IST
     if ((Globales.globalSpalte == 0) || (Globales.globalSpalte == 1)) {                           
        jTable1.setValueAt(dialog.getFunktionNummer(), rowcount, 0);
        jTable1.setValueAt(dialog.getFunktionName(), rowcount, 1);
     }

       // Für jeden Fall einen eigenen Rahmen nachprüfen

    if (Globales.globalSpalte == 2) komplettrahmen.editRow1(jTable1.getRowCount(), 2);
    if (Globales.globalSpalte == 2) komplettrahmen.editRow2(jTable1.getRowCount(), 2);
    if (Globales.globalSpalte == 2) komplettrahmen.editRow3(jTable1.getRowCount(), 2);


    if (Globales.globalSpalte == 3) komplettrahmen.editRow1(jTable1.getRowCount(), 3);
//    if (Globales.globalSpalte == 3) komplettrahmen.editRow1(jTable1.getRowCount(), 3,komplettrahmen.getRow2());
    if (Globales.globalSpalte == 3) komplettrahmen.editRow2(jTable1.getRowCount(), 3);
    if (Globales.globalSpalte == 3) komplettrahmen.editRow3(jTable1.getRowCount(), 3);
// HIER IN REIHE 2 MUSS SICH AUCH WAS TUN
    
    
        // Spalte 3 muss sich nun hier auch verändern
        //ENDE FÜR 5.APRIL !! Rahmen3 krams und so

//NOCH AUSGESTELLT
 //   if (Globales.globalSpalte == 5) komplettrahmen.editRow1(jTable1.getRowCount(), 5);
 //   if (Globales.globalSpalte == 5) komplettrahmen.editRow1(jTable1.getRowCount(), 5,komplettrahmen.getRow2());
 //   if (Globales.globalSpalte == 5) komplettrahmen.editRow3(jTable1.getRowCount(), 5);

        
        // Also erstmal Rahmen "sammeln" und hier übergeben zum Zeichnen
    if (Globales.globalSpalte < 6) jTable1.setDefaultRenderer(Object.class,new MyTableCellRenderer(true,komplettrahmen, jTable1, Globales.globalSpalte, (jTable1.getRowCount()-1),rahmencounter));
    System.out.println("NachZeichnung: " + komplettrahmen.getRow1());

        }
    }


Ergebnis:
Ganz Vorher: [1, 15]
NachZeichnung: [1, 16]
Ganz Vorher: [1, 16]
NachZeichnung: [1, 17]
Ganz Vorher: [17, 1]
NachZeichnung: [17, 18]

Also liegt es am Klick ??

Also an den Sachen die dazwischen liegen scheint es nicht zu liegen, und außer dem selben Klick wie immer hab ich da nichts zwischenzeitlich gemacht.
 
S

SlaterB

Gast
was ist ein Klick? dass die actionPerformed()-Ausführung etwas geändert hat, ist anzunehmen, ja,

innerhalb dieser actionPerformed() wird ja editRow1() ausgeführt, welches zur ursprünglichen Methode passendErhoehen() führt
(doch gut dass du schon bisschen mehr Code gepostet hast)

dort hast du bisher kein weiteres Logging,
da der Code in passendErhoehen() nicht unbedingt verrücktes vermuten läßt lohnt sich insbesondere auch dort Anfang + Ende zu loggen,
wenn dort nichts (schlimmes) passiert, dann wohl irgendwo im Rest der actionPerformed(), logge einfach zwischen jedem einzelnen Befehl
bzw. zunächst nach 50% der Befehle, wenn oben oder unten dann bei 25% bzw. 75%, Intervallhalbierung ;)

vielleicht ist editRow2() Schuld oder editRow3() weil alle dasselbe List-Objekt verwenden,
Panik oder Verwirrung ist bei sowas nicht nötig, in Ruhe Schritt für Schritt den Fehler finden, er kann sich gut verstecken, aber nicht auf Dauer
 

GianaSisters

Bekanntes Mitglied
Vielen dank,
ich hab genau die Änderung mal mitgeloggt: Also System out im "getRow1"
Unten der komplette CellRenderer... Ich denke es liegt an dem HashSet irgendwie (rote Markierung beachten):

Java:
 //-------------Doppelte wegschneiden
    HashSet<Integer> hashSet = new HashSet<Integer>(rliste.getRow1());
    rliste.getRow1().clear();
    rliste.getRow1().addAll(hashSet);
    //-------------Doppelte wegschneiden Ende

Die Ausgabe beim getRow, wenn
Java:
ArrayList<Integer> getRow1(){
        System.out.println("rahmengetten: " + rahmen1);
        return rahmen1;
    }

Interessant, der ist am hin- und herspinnen, hier die interessante Ausgabe an der er das erste mal den zweiten Wert mit nach vorne nimmt ! (Nicht vergessen unten ist der ganze Cellrederer):

rahmengetten: []
rahmengetten: [1, 15]
rahmengetten: [1, 15]
rahmengetten: [1, 15]
rahmengetten: []
rahmengetten: [1, 15]
1.Ganz Vorher: [1, 15]
rahmengetten: [1, 16]
NachZeichnung: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: []
rahmengetten: [16, 1]
rahmengetten: [16, 1]
rahmengetten: [16, 1]
rahmengetten: []
rahmengetten: [1, 16]

rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: [1, 16]
rahmengetten: []
rahmengetten: [16, 1]
rahmengetten: [16, 1]
rahmengetten: [16, 1]
rahmengetten: []
rahmengetten: [1, 16]
1.Ganz Vorher: [1, 16]
rahmengetten: [1, 17]
NachZeichnung: [1, 17]
rahmengetten: [1, 17]
rahmengetten: [1, 17]
rahmengetten: [1, 17]
 
Zuletzt bearbeitet:
S

SlaterB

Gast
Java:
HashSet<Integer> hashSet = new HashSet<Integer>(rliste.getRow1());
rliste.getRow1().clear();
rliste.getRow1().addAll(hashSet);
ist in der Tat ein Code der keine Reihenfolge beachtet, den Inhalt vertauschen kann, da hast du es doch gefunden?
LinkedHashSet statt normales HashSet hilft vielleicht, oder nach dem Einfügen sortieren
 

GianaSisters

Bekanntes Mitglied
Vielen Dank, ohne Dich hätte ich es nicht geschafft. Habe die Sortierung direkt im anschluss vollzogen jetzt klappt das Ganze mit den nachfolgenden Spalten auch! Danke für die ganze Mühe ! Komisch, dass das erst ab dem Wert 16 passiert und nicht schon eher...
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
N Zahlen in Strings einer ArrayList sortieren Allgemeine Java-Themen 14
M ArrayList oder LinkedList Allgemeine Java-Themen 10
C Sortieren und Selektieren einer ArrayList<Point3D> Allgemeine Java-Themen 6
A Einzelne Objekte und Unterobjekte einer ArrayList ausgeben Allgemeine Java-Themen 53
T Remove bei ArrayList funktioniert nicht Allgemeine Java-Themen 2
B Type mismatch: cannot convert from Graph.Edge to ArrayList<Graph.Edge> Allgemeine Java-Themen 21
R ArrayList Allgemeine Java-Themen 4
G jToggleButton in Array/ArrayList Allgemeine Java-Themen 12
J ArrayList, ganze Zeilen löschen oder überspringen Allgemeine Java-Themen 4
L ArrayList sortieren Allgemeine Java-Themen 2
C ArrayList Problem Allgemeine Java-Themen 3
O Datentypen Wie kann ich den Typ einer ArrayList abfragen ? Allgemeine Java-Themen 7
S Best Practices CopyConstrutor mit ArrayList Allgemeine Java-Themen 1
S ArrayList Design Allgemeine Java-Themen 4
S Array dynamisieren oder ArrayList verwenden? Allgemeine Java-Themen 17
L ArrayList mit String Arrays in ein Array umwandeln Allgemeine Java-Themen 1
H Elemente aus ArrayList in Array speichern Allgemeine Java-Themen 8
MiMa Person in einer Arraylist hinzugügen mit Prüfung ? Allgemeine Java-Themen 6
X Adjazenzliste ohne ArrayList Allgemeine Java-Themen 6
X Output von ArrayList Allgemeine Java-Themen 3
H Stream in ArrayList umwandeln Allgemeine Java-Themen 2
H Mehrere Datentypen in einer Arraylist speichern Allgemeine Java-Themen 9
H Arraylist mit anderer ArrayList überschreiben Allgemeine Java-Themen 17
MiMa ArrayList sortieren?? Allgemeine Java-Themen 5
Curtis_MC Pointer mit ArrayList vergleichen Allgemeine Java-Themen 6
F ArrayList`s in Klassen mit Getter/Setter Allgemeine Java-Themen 8
W Array vs. ArrayList vs. HashMap Allgemeine Java-Themen 20
F Arraylist vollständig abspeichern und laden Allgemeine Java-Themen 1
R Arraylist in andere Klasse leiten und bearbeiten Allgemeine Java-Themen 10
D ArrayList Indexlänge ändern Allgemeine Java-Themen 2
E Elemente innerhalb einer ArrayList vergleichen Allgemeine Java-Themen 33
K ursprüngliche ArrayList ändert sich bei Übergabe in Methode Allgemeine Java-Themen 18
N Mehrdimensionale ArrayList mischen Allgemeine Java-Themen 10
S JTable - mehrere ausgewählte Rows in ArrayList Allgemeine Java-Themen 5
MiMa Date aus einer ArrayList<Date> holen ?? Allgemeine Java-Themen 5
MiMa ArrayList Rückgabewerte aus einer Funktion Allgemeine Java-Themen 15
L CSV File lesen, in ArrayList speichern und ausgeben Allgemeine Java-Themen 3
M Was geschieht mit Java-Klasse, die aus ArrayList entfernt wird? Allgemeine Java-Themen 10
M Methoden Generische Methode für ArrayList Allgemeine Java-Themen 7
T Collections ArrayList Sortieren Allgemeine Java-Themen 4
P GUI: ArrayList anzeigen funktioniert nicht Allgemeine Java-Themen 5
H ArrayList: Leere Elemente finden? Allgemeine Java-Themen 2
GreenTeaYT Verständnisprobleme zur Arraylist Allgemeine Java-Themen 1
T Methoden Methode zum durchsuchen einer ArrayList Allgemeine Java-Themen 8
K ArrayList sortieren Allgemeine Java-Themen 16
A Bestimmte Inhalte aus ArrayList 1 in ArrayList 2 kopieren Allgemeine Java-Themen 6
S Mehrdimensionales ArrayList ins HashSet Allgemeine Java-Themen 10
C ArrayList Allgemeine Java-Themen 8
Streeber Probleme mit AWT-EventQueue: ArrayList Elemente hinzufügen Allgemeine Java-Themen 1
F Methoden Arraylist weiterverwenden nach methoden Aufruf Allgemeine Java-Themen 2
Z NullPointerException beim Schreiben einer ArrayList in eine Datei Allgemeine Java-Themen 6
L Von ArrayList abgeleitete Klasse nur mit bestimmten Objekten füllen Allgemeine Java-Themen 1
K Array in ArrayList Allgemeine Java-Themen 16
Paul15 2D Arraylist in Jtable Allgemeine Java-Themen 1
Paul15 Arraylist 2D Allgemeine Java-Themen 8
B ArrayList in ein Objekt legen Allgemeine Java-Themen 1
Neumi5694 Datentypen ArrayList vs TreeMap Allgemeine Java-Themen 6
F ArrayList Allgemeine Java-Themen 11
X ArrayList will nicht so wie ich will. Hilfe Allgemeine Java-Themen 8
N ArrayList in eigenem Object nicht richtig serialisierbar Allgemeine Java-Themen 14
M ArrayList mit verschiedenen Datentypen in String konvertieren Allgemeine Java-Themen 10
Z Elemente einer ArrayList von rechts wegnehmen Allgemeine Java-Themen 5
W Arraylist Text Suchen und Datei löschen Allgemeine Java-Themen 5
R ArrayList und HashMap Allgemeine Java-Themen 7
T ArrayList zeilenumbruch entfernen Allgemeine Java-Themen 13
D Arraylist/For Schleife/Scanner Allgemeine Java-Themen 30
E ArrayList Anzahl der gleichen Elemente Allgemeine Java-Themen 4
Doopy ArrayList plötzlich leer Allgemeine Java-Themen 2
D Arraylist eigener Klasse an iReport übergeben Allgemeine Java-Themen 7
L ArrayList Inhaltstyp. Allgemeine Java-Themen 5
Z Klassen ArrayList selbst machen Allgemeine Java-Themen 5
J Arraylist speichern und laden? Allgemeine Java-Themen 5
C Generics Objekt in ArrayList Allgemeine Java-Themen 2
D ArrayList index auf gültigkeit prüfen Allgemeine Java-Themen 12
M ArrayList<String> Frage Allgemeine Java-Themen 7
O ArrayList kaputt?! Allgemeine Java-Themen 5
M ArrayList<Foo> in ein Foo[] konvertieren? Allgemeine Java-Themen 8
Bananabert Abstract ArrayList Allgemeine Java-Themen 4
A Collections Array-Elemente in ArrayList kopieren ohne Schleife Allgemeine Java-Themen 7
O ArrayList - Serialisierungs-Problem Allgemeine Java-Themen 11
M JTable + ArrayList Allgemeine Java-Themen 3
M Datentypen ArrayList in Integer konvertieren Allgemeine Java-Themen 3
O Collections ListIterator gibt Inhalt von ArrayList nicht aus Allgemeine Java-Themen 3
Madlip Variablen 3 Werte aus ArrayList und weiter ... Allgemeine Java-Themen 4
S arraylist nach n. Eintrag numerisch Sortiren Allgemeine Java-Themen 5
O Problem beim Auslesen einer Arraylist von JComboBoxen Allgemeine Java-Themen 2
R Threads korrekte Synchronisation bei Vector und ArrayList Allgemeine Java-Themen 6
M Kovariante Rückgabewerte mit ArrayList Allgemeine Java-Themen 3
H LinkedList<LinkedList<String>> nach ArrayList<ArrayList<String>> ? Allgemeine Java-Themen 9
E NetBeans Vector durch ArrayList ersetzen Allgemeine Java-Themen 4
Maxim6394 Problem mit ArrayList Allgemeine Java-Themen 5
E Berechnung in Arraylist Allgemeine Java-Themen 10
E ArrayList mit unbekannter Größe Allgemeine Java-Themen 8
V Fork Join bei Arraylist Allgemeine Java-Themen 6
H Fehler in Arraylist Allgemeine Java-Themen 2
S Datensätze in eine ArrayList<Movie> speichern Allgemeine Java-Themen 13
S Alle Kombinationen aus ArrayList - Potenzmenge Allgemeine Java-Themen 7
V ArrayList vergleichen mit .equals? Allgemeine Java-Themen 13
J ArrayList-Problem Allgemeine Java-Themen 16
S Von einer ArrayList in die andere schreiben? Allgemeine Java-Themen 6

Ähnliche Java Themen

Neue Themen


Oben