Nochmal zweidimensionaler Vector

[Guest]

Hallo Forum,

ich habe es leider immer noch nicht geschafft, das zweidim. Vector zu erstellen.

x = new Vector(1,1);
y = new Vector(1,1);
x.addElement(y);

Macht das Sinn?
Wie packe ich double-Werte da rein?
Wie kann ich darauf zugreifen?

Gruß,
Andi[/code]

 

[Beni]

Mit Java 1.4 sieht das etwa so aus:

int size = 2345;
Vector x = new Vector( size );
for( int i = 0; i < size; i++ )
  x.add( new Vector( size ));

((Vector)x.get( 3 )).add( Double.valueOf( 12.34 ));
double z = ((Double)((Vector)x.get(3)).get(0)).getDoubleValue();

Und mit Java 1.5:

int size = 2345
Vector<Vector<Double>> x = new Vector<Vector<Double>>();

for( int i = 0; i < size; i++ )
  x.add( new Vector<Double>() );

x.get(3).add( 12.34 );
double z = x.get(3).get(0);

 

[Guest]

Prima, vielen Dank!

Für eine quadratische Matrix müsste ich dann wohl folgendes angeben:

for( int i = 0; i < size; i++ ) 
  x.add( new Vector<Double>(size) );

Was mir allerdings noch etwas umständlich erscheint:
Ich möchte per Methode das Array um eine Zeile/Spalte erweitern.
Muss ich dann erst alle Spalten auslesen und um eins erweitern?

 

[Beni]

Hm? Vergiss nicht, ein Vector hat die Länge 0, solange keine Werte eingetragen wurden...
Also, um eine quadratische Matrix zu haben, müsste man noch für jeden inneren Vector eine Schleife machen, und ihn auffüllen.

Ach ja, ein Vector ist kein Array! Ein Vector ist eine Liste die dynamisch ihre Grösse ändern kann. Ein Array hat immer dieselbe Grösse (das ist doch ein wichtiger Unterschied).

Wäre es für dich vielleicht einfacher, einen echten Array zu verwenden?

double[][] array = new double[4][6];
array[1][2] = 45.432;
double z = array[1][2];

[Edit]
Ja, du müsstest alle Vectoren auslesen, und erweitern, um die Matrix grösser zu machen.

 

[Guest]

Wow, Beni, da bin ich ja gleich an den richtigen geraten!

Ich habe das mit double[][] auch schon probiert.
Das große Problem: diesem muss ich als Klassenvariable eine feste Größe geben. Ich kann dann in der Methode nicht mehr mit Gewalt die Größe ändern.

Hier mein erster Code:

public class BOMatrix extends Matrix{ 
    
    private double werte[][]; 
    private double werte_neu[][]; 
    public Vector BOb; 
    
    /** Creates a new instance of BewertungsObjektMatrix */ 
    public BOMatrix() { 
        super(); 
        BOb = new Vector( 0, 1 ); 
        werte = new double[1][1]; 
    } 
    
    //** Neue Spalte für Matrix hinfügen*/ 
    public void BOHinzufuegen(String name, String beschreibung){ 
        BOb.addElement( new Bewertungsobjekt( name, beschreibung) ); 
        // Die Größe des Array muss angepasst werden: 
        double werte_neu[][] = new double[BOb.size()][BOb.size()]; 
        System.arraycopy(werte, 0, werte_neu, 0, werte.length); 
               double werte[][] = new double[BOb.size()][BOb.size()]; 
        System.arraycopy(werte_neu, 0, werte, 0, werte_neu.length); 
        }

Ich hoffe, du verstehst das Problem:
Habe ich der Klassenvar. einmal eine Größe gegeben [1][1], kann ich sie auch in der Methode nicht mehr ändern. Es werden einfach nur die Werte bis [1][1] (also nur ein Wert) in die Klassenvar. zurückgeschrieben.

Da dachte ich an Vector...

 

[mic_checker]

1) Insofern du nicht synchronisieren musst -> nimm ArrayList
2) Mach ne ArrayList, in die du die ArrayList reinpackst. Wenn du in die "äußere" ArrayList eine ArrayList hinzufügst wäre das als ob du eine Spalte hinzufügst....wenn du in die inneren was hinzufügst , entspricht das den Zeilen.

 

[Guest]

Soweit, so gut:

public void BOHinzufuegen(String name, String beschreibung){
        BOb.addElement( new Bewertungsobjekt( name, beschreibung) );
        x.setSize(BOb.size());
             for( int i = 0; i < BOb.size(); i++ ) {
                x.add(i, new Vector<Double>(BOb.size(),1) );
             }
    }

Problem: der neue Vector in x hat immer die Größe 0, obwohl BOb.size() tatsächlich wächst.

 

[mic_checker]

x soll dein "äußerer" Vektor sein ?

U. was ist B0b ?

Eigentlich sollte das ganze kein Prob sein - gib deinen Variablen auch mal bessere Namen - damit man am Namen schon erkennt was damit gemacht wird.

List spalten = new ArrayList();

List reihe1 = new ArrayList();
reihe1.add(...);
reihe1.add(...);

List reihe2 = new ArrayList();
reihe2.add(...);
reihe2.add(...);

spalten.add(reihe1);
spalten.add(reihe2);

//etc. pp.

 

[Gast]

BOb ist ein andere Vector, dessen Größe die Größe des Vectors x ändert.
Ich muss das daher in eine Schleife packen.
Außerdem würde ich ganz gerne bei Vector bleiben.

Das ganze beinhaltet double werte. Wie würdest du bei deiner Lösung auf double bei den Koordinaten x,y zugreifen?

 

[mic_checker]

Warum bei Vector bleiben ? Abgesehen von den synchronisierten Methoden hast du keinen Vorteil - aber egal...

Sagen wir du willst auf die 2 Spalte und 3 Reihe zugreifen:

// matrix wurde vorher richtig mit werten belegt 

// zuerst holst du dir die zweite spalte
List myReihe = spalten.get(1);

// jetzt kannst du in der zweiten Spalte auf die 3 Reihe zugreifen
System.out.println(myReihe.get(2));

 

[Gast]

Vielen Dank!

Muss aber noch besser gehen...