Array einlesen und ausgeben

[AbsolutBeginner]

Hallo liebe Leute!

[CODE lang="java" title="Zunächst wollte ein Array von der Konsole aus einlesen und ausgeben:"]import java.util.Arrays;
import java.util.Scanner;

public class TestOne {

public static void main(String[] args) {

int x = 0;
Ergebnis P = new Ergebnis(); // Klasse Ergebnis mit 2 Untermethoden
Scanner input = new Scanner (System.in);

System.out.println("Länge des ersten Array: ");
x = input.nextInt();

System.out.println("Den Array füllen: ");
int[] y = new int [x]; // y wird auf Länge von dem eingegebenen x gesetz
readInArray(x); // y soll zurückgegeben werden
System.out.println(Arrays.toString(y));
P.setArrayOne(y);

/*System.out.println("Länge des zweiten Array: ");
x = input.nextInt();

System.out.println("Den Array füllen: ");
int[] y = new int [x];
readInArray(x);
System.out.println(Arrays.toString(y));
P.setArrayOne(y);

P.vergleich();
System.out.println(Arrays.toString(P.Summe()));*/

}

public static int[] readInArray(int x) {
int[] y = new int [x];
int j;
for (int i=0; i<x; i++) {
Scanner input = new Scanner (System.in);
j = input.nextInt();
y = j;
}
return y;
}
}
[/CODE]

Und das habe ich dann als Ausgabe:

Länge des ersten Array:
3
Den Array füllen:
1
2
3
[0, 0, 0]

Warum werden die Speicherplätze in dem Array nach der Eingabe immer mit dem Wert 0 belegt? Was mache ich falsch?

 

[Gelöschtes Mitglied 65838]

readInArray(x); // y soll zurückgegeben werden
        System.out.println(Arrays.toString(y));

readInArray x liefert dir ein Array zurück und das schießt ins leere und dann Schreibst du int y das im moment diesen Status hat

int[] y = new int [x];

und das is leer


füg mal System.out.println(y) oben ein

und unten in deiner Methode bevor du return machst

da bekommst du die "Referenz" also zeiger Auf ein Objekt und dann kannst du sehen
wenns gleich ist dann gehts um das gleiche Objekt wenn nicht dann sind das 2 verschiedene

 

[AbsolutBeginner]

Länge des ersten Array:
3
Den Array füllen:
[I@73f792cf
1
2
3
[I@2ed94a8b
[0, 0, 0]

Ähmm. Dann sind das zwei verschiedene ... oder? Ich verstehe das aber trotzdem nicht. Sorry

 

[Gelöschtes Mitglied 65838]

ja das ist richtig dass es 2 verschiedene

y soll zurückgegeben werden

bei diesem kommentar hast du einen DenkFehler

nur weil oben ein Y array ist
und unten auch ein Y array ist heist es nicht dass es die gleichen sind

readInArray(x);

diese Zeile gibt dir irgendein array zurück aber es steht links kein " variable = " also wird das array weg geworfen

was du jetzt MÖCHTEST ist es

" yoben ist gleich dem Rückgabewert von readInArray"

 

[AbsolutBeginner]

😀

y = readInArray(x);

Länge des ersten Array:
4
Den Array füllen:
1
2
3
4
[1, 2, 3, 4]

... Magic - it's a kind of magic ... Aber warum akzeptiert der Compiler das nicht als eine und die gleiche Variable?

Und vielen lieben Dank.

 

[Gelöschtes Mitglied 65838]

naja das ist sozusagen das Lebens Umfeld der Variable

da gibts Lokale .. Globale Variablen und noch eins was ich vergessen hab
Das kurze Leben einer lokaler Java Variable (mein-javablog.de)

probier das mal aus ob ein Fehler kommt und dann google mal was Lokale Variablen sind und in wie lang diese "Existieren"
bzw warum kommt hier kein Fehler vom Compiler

public void test(int x){
for(int i = 0; i < x ; i++){
  
}
for(int i = 0; i < x ; i++){
  
}
}

aber warum kommt hier schon ein Fehler?

public void test2(int x){
int x = 0;
int x = 2;
}

 

[AbsolutBeginner]

Lokale V exisitiert nur innerhalb der Methode, wo sie initialisiert wurde. Meinst du das? (Ist es ok, wenn ich dich duze?). Abar wozu dann return? Auch wenn diese V lokal ist, ich gebe die doch zurück? Ich dachte, dass beim Aufrufen einer Methode in main der Output ebendieser Methode schon irgendwo zwischengespeichert ist und für weitere "Manipulationen" automatisch verfügbar ist. Für mich sieht das y = readInArray(x); irgendwie doppelt gemoppelt aus. Aber ich sehe ein, das bei mir das grundsetzliche Verstehen von Abläufen falsch ist, sowohl Syntax von Java als auch Semantik.

Vielen dank nochmals, muss erst mal probieren, das zu verdauen.

 

[Gelöschtes Mitglied 65838]

Lokale V exisitiert nur innerhalb der Methode, wo sie initialisiert wurde. Meinst du das? (Ist es ok, wenn ich dich duze?). Abar wozu dann return? Auch wenn diese V lokal ist, ich gebe die doch zurück? Ich dachte, dass beim Aufrufen einer Methode in main der Output ebendieser Methode schon irgendwo zwischengespeichert ist und für weitere "Manipulationen" automatisch verfügbar ist. Für mich sieht das y = readInArray(x); irgendwie doppelt gemoppelt aus. Aber ich sehe ein, das bei mir das grundsetzliche Verstehen von Abläufen falsch ist, sowohl Syntax von Java als auch Semantik.

Vielen dank nochmals, muss erst mal probieren, das zu verdauen.

Füg unten nochmal das System.out.println(y) ein

und oben schreibst du
System.out.println (readArray(x)) ein
und schau mal was da raus kommt

 

[AbsolutBeginner]

also mit oben und unten hab nicht ganz verstanden, wo genau ...

System.out.println("Länge des ersten Array: ");
        x = input.nextInt();
        
        System.out.println(readInArray(x));

        System.out.println("Den Array füllen: ");
        int[] y = new int [x]; // y wird auf Länge von dem eingegebenen x gesetz
        y = readInArray(x); // y soll zurückgegeben werden
        System.out.println(Arrays.toString(y));
        P.setArrayOne(y);
        
        System.out.println(y);

dann kommt folgendes:

Länge des ersten Array:
3
1
2
3
[I@73f792cf
Den Array füllen:
1
2
3
[1, 2, 3]
[I@2ed94a8b

 

[Gelöschtes Mitglied 65838]

public class TestOne {

    public static void main(String[] args) {



        System.out.println("Den Array füllen: ");
        int x = 5;
        System.out.println(readInArray(x));


    }

    public static int[] readInArray(int x) {
        int[] y = new int [x];
        for (int i=0; i<x; i++) {

            y[i] = i;
        }
        System.out.println(y);
        return y;
    }
}

so hatte ich es gemeint



ich hab den rest nur raus gelöscht dass es übersichtlich ist.. du kannst dein Zeug natürlich noch drin behalten

 

[Gelöschtes Mitglied 65838]

Den Array füllen:
2
[I@2cb4c3ab
[I@2cb4c3ab


sowas wird raus kommen nur was bedeutet das?

dazu findest du sicher was im internet mit Lokale Variablen...Referenzen....Globale Variablen

 

[AbsolutBeginner]

😩 ... Das es das gleiche Objekt ist, also die gleiche Variable (?) Okey, ich muss darüber bisschen meditieren 😂 ...

Ich verstehe zwar den Grundgedanken hinter diesen Unterscheidungen. Nur kann ich das nicht syntaktisch korrekt ausdrücken.

Danke ✋

 

[Gelöschtes Mitglied 65838]

Eine Variable enthält eine Referenz

public int[] gibt eine Referenz auf ein Array Zurück

sobald keine Variable mehr auf eine Referenz zeigt wird die Referenz weg geworfen

 

[mihe7]

Um das ganze vielleicht nochmal etwas ausführlicher zu beschreiben: Objekte geistern irgendwo im Hauptspeicher rum. Damit wir sie im Programm bequem ansprechen können, speichern wir einen Verweis auf das Objekt (d. h. auf die Stelle im Hauptspeicher, an der das Objekt "lebt") in einer Variablen.

Die Lebensdauer einer Variablen ist nicht das gleiche wie die Lebensdauer eines Objekts. Beispiel:

public void methode() {
    String x = new String("ABC"); // neues Objekt vom Typ String, Adresse wird lokaler Variablen x zugewiesen.
    { // Block
        String y = x;  // die in x gespeicherte Adresse wird y zugewiesen
    }
    // y ist tot, das Objekt lebt weiter
    System.out.println(x);
}

Jetzt die Frage: wie lange lebt das Objekt?

Stellen wir uns mal vor, so ein Objekt würde ewig leben. Nicht nur, dass wir dann sehr schnell keinen Speicher mehr zur Verfügung hätten, es würde auch einfach viel Müll entstehen, denn nach dem Verlassen der Methode methode() können wir das Objekt nicht mehr verwenden, weil es nicht mehr erreichbar ist, da x außerhalb nicht existiert.

Diese Überlegung nutzt nun der Müllsammler (Garbage Collector) von Java: nur die Objekte, die noch erreichbar sind, werden noch benötigt, alles andere kann weg.

Im Code von @Joreyk, Zeile 21, wird nun der Wert von y, d. h. die Adresse auf das int-Array, zurückgegeben. Wenn der aufrufende Code diese Adresse speichert, ist das Array weiterhin erreichbar. Speichert man die Adresse nicht, kann man es nicht mehr erreichen. Damit lebt das Array (für uns unerreichbar) noch eine Zeit lang weiter, bis es der Garbage Collector abräumt.

Alles ganz einfach.