Array Verständnisproblem

[Angelika_25]

Hallo ich habe folgenden Code:

public class Laufzeit1 {
   public static void feldVerlaengern (double[] f) {
     f=new double[2*f.length];
   }
   public static void main (String [] args) {
     double[] f=new double[2];
     f[0]=11.1;
     f[1]=22.2;
     feldVerlaengern(f);
     f[2]=33.3;
     f[3]=44.4;
     System.out.println(f[2]);
   }
}

Der logische Fehler liegt in der 10. Zeile, aber ich verstehe ehrlich gesagt nicht warum.
Wenn er in die Methode feldVerlaengern geht, dann übergibt er dem f seine Referenz zu den zwei Zahlen. Dann wird aber widerum ein neues f angelegt (also ein Objekt erstellt), aber eben mit dem gleichen Buchstaben. Ich versuche ja um alles besser zu verstehen mir das aufzumalen mit den Arrays, aber da komme ich jetzt durcheinander. Warum ist Zeile 10 ein Fehler: Feld-Index zu groß?
Kann mir das jemand vielleicht mal für "Doofe" erklären, sodass ich das auch verstehe?

Viele liebe Grüße

 

[0x7F800000]

"neues feld mit dem gleichen buchstaben" lol^^

Du erstellst in der main ein array der Länge 2, und lässt die referenz auf dieses array zeigen.
Dann übergibst du die referenz an deine verlängerungsmethode.
Dort kommt diese referenz an, und wird einfach durch eine andere referenz auf ein anderes neuerstelltes Array überschrieben. Dann hättest du auch direkt eine lokale, aus der main nicht sichtbare Variable in der verlängerungsmethode nehmen können, die ein neues array referenziert, die aber nach dem verlassen der methode gleich wieder gelöscht wird. Deine methode verrichtet absolut keine sinnvolle arbeit.

Was du anscheinend wolltest, wäre am ehesten ein Zeigerszeiger aus C++, so etwas gibt es in java nicht. Erstelle in der methode ein größeres array, kopiere da den alten inhalt rein, und gib die gesammte konstruktion auf dem normalen wege zurück.

 

[Angelika_25]

So eine Methode würde ich nie schreiben, das ist eine Aufgabe aus einem Buch.
Also wenn ich mir das jetzt so vorstelle. Ich habe eine Variable f, die mit einem Finger auf zwei Zahlen zeigt (11.1 und 22.2). Dann übergebe ich mein f mit dem Finger auf die beiden Zahlen der Methode feldVerlaengern. Dann erstelle ich neue Felder mit 2*f.length, also der Größe 4. Also zeigt jetzt mein f auf die Felder der Größe 4 und nicht mehr auf meine 11.1 und 22.2.
Ich habe zwar mein f mit dem Zeiger auf die beiden Zahlen der Methode übergeben, aber ich habe ja durch das new ein anderes Objekt erzeugt, dass blöderweise zwar genauso heißt, aber ein anderes ist (weil es ja nur lokal gilt) und deswegen bleibt in der main-Methode mein f so wie es ist, also mit der Größe 2 un d deswegen ist f[2]=33.3 auch ein Fehler, weil mein Index ja nur bis [1] geht.
Hab ich das richtig erklärt?

 

[Noctarius]

Die Lösung des Problems besteht in den zwei Varianten wie ein Übergabeparameter an eine Funktion übergeben werden könnte:
1. byVal (by Value)
2. byRef (by Reference)

Kurze Erklärung:
jGuru: Does Java use pass by value or pass by reference semantics when passing parameters to methods?

 

[ARadauer]

sagen wir es so "Referenzen werden als call by value übergeben"
das heißt vereinfacht... der finger wird kopiert, dupliziert.. wenn du nun das veränderst wo der finger in der methode hinzeigt, änderst du auch das in der main....
lässt du den duplizierten finger wo anders hinzeigen, interessiert das den finger drausen in der main nicht...

do könntest zb direkt das array verändern, diese änderung wird auch nach draussen wirksam, aber leider kann man ein array nicht verlängern, darum erstellst du ein neues, auf das der finger in der methode zeigt, von dem bekommt der in der main aber nichts mit... also umkopieren der werte und das neue zurück geben und in der main den zeiger auf das zurück gegebene zeigen lassen....

  public static double[]  feldVerlaengern (double[] f) {
            double[] newf =new double[2*f.length]; //wir müssen ein neues erstellen, da wir ein array nichit velrängern können
            for(int i = 0; i < f.length; i++){ //wir müssen umkopieren
               newf[i] = f[i]; 
            }
           return newf;
         }
         public static void main (String [] args) {
           double[] f=new double[2];
           f[0]=11.1;
           f[1]=22.2;
           f = feldVerlaengern(f);
           f[2]=33.3;
           f[3]=44.4;
           System.out.println(f[2]);
         }

ich weiß, dass ist nicht so einfach mit den referenzen...

 

[Angelika_25]

Jetzt wird es mir langsam klarer. Den Code, den du geschrieben hast, dient dazu eine komplette Kopie eines Arrays zu erstellen, oder? Wenn du nämlich newf veränderst, also Werte veränderst, dann interessiert das f nicht, denn es wurde ja ein neues Objekt erzeugt. Würde man in einer Methode Werte von formalen Variablen verändern, dann würde man auch Werte in f ändern, denn es wird ja lediglich mit einer Referenzkopie in einer Methode gearbeitet, sie zeigen ja beide auf die gleichen Zahlen, oder?

 

[Noctarius]

public class Test {
	public static void main(String[] args) {
		double[] f = new double[2]; // <- Feld ReferenzId 1
		
		f[0] = 0; // <- Feld ReferenzId 1 
		f[1] = 1; // <- Feld ReferenzId 1
		
		feldVerlaengern(f /* <- Feld ReferenzId 1 */);
		
		f[2] = 2; // <- Feld ReferenzId 1
		f[3] = 3; // <- Feld ReferenzId 1
		
		f = feldVerlaengern(f /* <- Feld ReferenzId 1 */);
		
		f[2] = 2; // <- Feld ReferenzId 2
		f[3] = 3; // <- Feld ReferenzId 2
	}
	
	public static double[] feldVerlaengern(double[] f) {
		f[0] = 1; // <- Feld ReferenzId 1
	
		f = new double[2*f.length]; // <- Feld ReferenzId 2
		
		return f; // <- Feld ReferenzId 2
	}
}

Im Speicher wird ein Zeigere (hab's mal als Feld ReferenzId bezeichnet) gespeichert der auf die eigentliche Datenstruktur zeigt. Wenn du also einem Zeiger ein neues Objekt (new double[...]) zuweißt, wird die Feld ReferenzId überschrieben und nicht das alte Objekt.

Erst wenn du in der Main-Funktion das zurückgegebene Objekt speicherst (zweiter Aufruf) wird auch die originale Referenz ersetzt und das alte Objekt (sofern nicht mehr an anderer Stelle referenziert) irgendwann vom GC gelöscht.

 

[Leroy42]

Mach's doch so:

public class Laufzeit1 {
   public static double[] feldVerlaengern (double[] f) {
     return new double[2*f.length];
   }
   public static void main (String [] args) {
     double[] f=new double[2];
     f[0]=11.1;
     f[1]=22.2;
     f = feldVerlaengern(f);
     f[2]=33.3;
     f[3]=44.4;
     System.out.println(f[2]);
   }
}

Beachte aber, daß die Inhalte von f[0] und f[1] dann geändert werden

 

[0x7F800000]

Mach's doch so:...
Beachte aber, daß die Inhalte von f[0] und f[1] dann geändert werden

wozu postest du dann das? ARadauer hat doch schon fast dasselbe gepostet, samt dem ein wenig zu aufwendigen umkopieren

       public static int[] expand(int[] a){
		int[] result=new int[a.length*2];
		System.arraycopy(a,0,result,0,a.length);
		return result;
	}