Vectorelemente in einen anderen Vector kopieren

[prototype0815]

Hey folks,

ich bin mal wieder auf ein ungewöhnliches Problem gestoßen. Ziel ist es, Elemente eines Vectors zu vervielfältigen.

Meine Gedankengänge waren folgende...

Ich habe einen Vector "vA" der beinhaltet ebenfalls wieder Vectoren. Sagen wir mal er fasst 3 Vectoren.Also fasst vA -> Vector "vA1", "vA2", "vA3"
Ich möchte nun diese 3 Vectoren mit einem variablen Faktor vervielfältigen. Sasgen wir *4.

Zum Ende hat mein äußerer Vector vA folgende Vectoren gefasst...
"vA1", "vA1", "vA1", "vA1", "vA2", "vA2", "vA2", "vA2", "vA3","vA3","vA3","vA3"
jeden Vector statt 1 mal also nun 4 mal... Eigentlich ganz simpel, nur kommt jetzt der Haken...

Hole ich mir den ersten Vector "vA1" und verändere irgendeinen Wert dieses Vectors, werden vom zweiten, dritten und vierten "vA1" die Werte ebenfalls geändert!
Und genau hierbei liegt mein Problem.

Zur Verdeutlichung hier mein Code mit dem ich den Inhalt vervielfältige.

            Vector temp = new Vector(dataVector.size(), 1);

            for (int m = 0; m < dataVector.size(); m++)
              temp.addElement(dataVector.elementAt(m)); // übertragen der Elemente in den Temp Vector, weil die Ausgangsvariable "dataVector" sein muss
            
            dataVector.removeAllElements();
           
            for (int j = 0; j < temp.size(); j++) {
              for (int k = 0; k < ctrVarPcs.getValue(); k++) { // k < größe des Faktors
                dataVector.addElement(temp.elementAt(j));
              }                
            }

Wie kann ich also die Elemente in einem Vector vervielfältigen ohne das es letztendlich nur "ein Objekt an 4 Stellen des Speichers dargestellt" ist.

 

[Flown]

Ist doch ganz einfach:

import java.util.Arrays;
import java.util.Vector;

public class Test {
  public static void main(String... args) {
    Vector<String> vA = new Vector<String>();
    vA.addAll(Arrays.asList("vA1", "vA2", "vA3"));
    
    System.out.println(multiplyElements(vA, 4));
    multiplyElementsInPlace(vA, 3);
    System.out.println(vA);
  }
  
  public static <T> Vector<T> multiplyElements(Vector<T> vector, int times) {
    Vector<T> result = new Vector<T>();
    for (T elem : vector) {
      for (int i = 0; i < times; i++) {
        result.add(elem);
      }
    }
    return result;
  }
  
  public static <T> void multiplyElementsInPlace(Vector<T> vector, int times) {
    for (int i = vector.size() - 1; i >= 0; i--) {
      for (int j = 0; j < times; j++) {
        vector.add(i, vector.get(i));
      }
    }
  }
}

 

[prototype0815]

deine Funktionen machen was sie sollen, sie vervielfältigen die Vectoren in meinem äußeren Vector. Allerdings tritt das selbe Problem auf wie bei meiner Variante.

 

[Flown]

Aus deinem Beispiel oben wie soll, nach der Änderung, sagen wir an der 1. Stelle, dein Vector aussehen?

 

[Flown]

Ahja jetzt versteh ich dich richtig, dann benötigst du sowas wie ein clone(shallow copy) oder ein deep-Copy. Hier mal ne Anregung:

import java.util.Arrays;
import java.util.Vector;

public class Test {
  public static void main(String... args) {
    Vector<MyClass> vARef = new Vector<>();
    vARef.addAll(Arrays.asList(new MyClass(1), new MyClass(2), new MyClass(3)));
    
    System.out.println(multiplyElementsReferences(vARef, 4));
    multiplyElementsInPlaceReferences(vARef, 3);
    System.out.println(vARef);
    vARef.get(0).setNumber(5);
    System.out.println(vARef);
    
    Vector<MyClass> vA = new Vector<>();
    vA.addAll(Arrays.asList(new MyClass(1), new MyClass(2), new MyClass(3)));
    
    System.out.println(multiplyElements(vA, 4));
    multiplyElementsInPlace(vA, 3);
    System.out.println(vA);
    vA.get(0).setNumber(5);
    System.out.println(vA);
  }
  
  public static <T extends Copyable<T>> Vector<T> multiplyElements(Vector<T> vector, int times) {
    Vector<T> result = new Vector<T>();
    for (T elem : vector) {
      for (int i = 0; i < times; i++) {
        result.add(elem.copy());
      }
    }
    return result;
  }
  
  public static <T extends Copyable<T>> void multiplyElementsInPlace(Vector<T> vector, int times) {
    for (int i = vector.size() - 1; i >= 0; i--) {
      for (int j = 0; j < times; j++) {
        vector.add(i, vector.get(i).copy());
      }
    }
  }
  
  public static <T> Vector<T> multiplyElementsReferences(Vector<T> vector, int times) {
    Vector<T> result = new Vector<T>();
    for (T elem : vector) {
      for (int i = 0; i < times; i++) {
        result.add(elem);
      }
    }
    return result;
  }
  
  public static <T> void multiplyElementsInPlaceReferences(Vector<T> vector, int times) {
    for (int i = vector.size() - 1; i >= 0; i--) {
      for (int j = 0; j < times; j++) {
        vector.add(i, vector.get(i));
      }
    }
  }
  
  static class MyClass implements Copyable<MyClass> {
    
    private int number;
    
    public MyClass(int number) {
      this.number = number;
    }
    
    public int getNumber() {
      return number;
    }
    
    public void setNumber(int number) {
      this.number = number;
    }
    
    @Override
    public MyClass copy() {
      return new MyClass(getNumber());
    }
    
    @Override
    public String toString() {
      return String.valueOf(getNumber());
    }
  }
  
  interface Copyable<T> {
    T copy();
  }
}

 

[prototype0815]

vA sieht nach der Änderung genau so aus wie ich es oben dargestellt hab, bzw. wie deine Funktionen es machen.

vA1 z.B. ist ebenfalls ein Vector der in meinem Beispiel 10 Objekte enthällt. (Long, Long, Double, Long, String,....)

das Problem an der ganzen Sache, soweit ich das verstanden hab, ist dass sogenannte flache Kopien der enthaltenen Vectoren gemacht werden. Sprich der Vector "vA1" existiert im Speicher genau 1 mal, wird aber durch diese ganzen kopieraktionen mehrmals in meinem Vector "vA" dargestellt (an Stelle 0-3). Es wird in "vA" wahrscheinlich nur ein Verweis auf "vA1" angelegt.

 

[Flown]

Habs gesehen, du hast aber auch String als Beispiel genommen. Die sind von Haus aus immutable. Darum funktionierst mit Strings und primitiven Datentypen.

Ich hab dir oben eine Möglichkeit geboten, wie du das mit dem Kopieren hinbekommst!

 

[prototype0815]

hm, ok. Ich hab es oben nicht ganz korrekt angegeben. Es sind nicht direkt die primitiven Datentypen in den Vectoren gespeichert. Es sind selbst geschriebene Klassenobjekte. DoubleElement, LongElement, StringElement... diese speichern die Daten natürlich mit primitiven Datentypen aber des weiteren speichern sie noch viel mehr Information die ich an so ein Element anhängen kann.

 

[prototype0815]

hab ne Lösung zusammengefriemelt...

            for (int m = 0; m < dataVector.size(); m++)         // alle Vectoren in einem Temp Vector speichern
              temp.addElement(dataVector.elementAt(m));
            dataVector.removeAllElements();
           
            for (int j = 0; j < temp.size(); j++) {
              Vector v = new Vector(5, 2);
              for (int k = 0; k < ((Vector)temp.elementAt(j)).size(); k++) {   // jeden inneren Vector vom Vector Temp holen
                v.addElement(((Vector)temp.elementAt(j)).elementAt(k));         // und jedes Double-, Long-, StringElement in einem neuen Vector abbilden.
              }
              for (int l = 0; l < ctrVarPcs.getValue(); l++) {  // größe des Faktors
                Vector v2 = new Vector(5, 2);                   // es muss jedes mal ein neuer Vector erstellt werden
                for (int n = 0; n < v.size(); n++) {
                  if(v.elementAt(n) instanceof LongElement) {
                    LongElement le = (LongElement)(((LongElement)v.elementAt(n)).clone());
                    v2.addElement(le);
                  }
                  else if(v.elementAt(n) instanceof DoubleElement) {
                    DoubleElement le = (DoubleElement)(((DoubleElement)v.elementAt(n)).clone());
                    v2.addElement(le);
                  }
                  else if(v.elementAt(n) instanceof StringElement) {
                    StringElement le = (StringElement)(((StringElement)v.elementAt(n)).clone());
                    v2.addElement(le);
                  }
                }
                dataVector.addElement(v2);
              }                
            }

nach diesem umständlichen hin und her kopiere, ist mein Problem verschwunden. Ich vermute weil ich jedes mal einen neuen Vector (v2) erstellt habe, und dort die einzelnen Elemente hinein geclont hab.

 

[Flown]

Also Lösung ja. Eine saubere nein.

Warum verwendest du kein Generics?

 

[prototype0815]

Zum ersten bin ich noch nicht so fit in Sachen Generics, zweitens kenne ich noch keine wirklichen Vorteile, ich sehe eher die Nachteile darin. Zudem entwickeln wir in der Firma auf Basis Java 1.4, da unser Applet auf einer Linux Kiste läuft deren Kernel wir zum Teil selbst geschrieben haben, und diese Linux Version kein höheres Java unterstützt.

Deshalb lässt mich der Compiler auch schön in Ruhe wenn ich es nicht verwende

Was würde es mir denn, so grob gesagt, für Vorteile bringen wenn ich Generics verwende?
Ich hab mit dem Vector doch so ein tolles Konstrukt in das ich alles hinein schmeissen kann, warum muss ich mir diese Box dann auf einen Elementaren Datentyp verschmälern?

 

[Flown]

Dann hat sich das erledigt, wenn ihr auf 1.4 programmiert.

Vorteile sind weniger typecasts instanceof und weitere Errungenschaften für "Typsicherheit".

 

[prototype0815]

Vorteile sind weniger typecasts instanceof und weitere Errungenschaften für "Typsicherheit".

Ah danke, ja das macht Sinn.