# Zahlen in Array speichern und ausgeben



## TobiN (19. Mai 2011)

Hey,

ich will in einer Methode ein paar Zahlen in einem Array speichern und mit einer anderen Methode wieder ausgeben. Leider funktioniert das nicht so. Aber wo ist der Fehler? ???:L


```
public class Feld {

    static int i = 20;
    static int[] feld = new int[i];

    public static void speichere() {
        for (int j = 0; j < 20; j++) {
            feld[i] = j;

        }
    }

    public static void ausgeben() {
        System.out.println(feld[i]);
    }

    public static void main(String[] args) {
        Feld.speichere();
        Feld.ausgeben();
    }
}
```


----------



## Final_Striker (19. Mai 2011)

```
static int i = 20;
...
...
feld[i] = j;
...
...
System.out.println(feld[i]);
```

Das Array läuft von 0 bis 19.


----------



## El Kabong (20. Mai 2011)

ups falsches Thema.


```
public class Feld {


	static int i = 20;
	
static int[] array = new int[i];

	

	static void speichere() {
		for (i=0; i<array.length; i++) {
			array[i] = i;
		}
	}
	
static void ausgeben() {
	for (i=0; i<array.length; i++) {
		System.out.println(array[i]);
	}
}

public static void main(String[] args) {
	
	Feld.speichere();
	Feld.ausgeben();
	
}
}
```


----------



## VfL_Freak (20. Mai 2011)

Moin,



TobiN hat gesagt.:


> ```
> public class Feld
> {
> static int i = 20;
> ...



nur mal eine konkrete Erklärung für Dich, was hier falsch ist:
Du setzt 'i' fix auf 20.
In der Schleife schreibst Du dann die Werte 0 - 19 immer nur auf das i-te (also 20.) Feld im Array !
Nur so wie von El Kabong beschrieben werden alle 20 Felder des Arrays nacheinander mit den 20 Werten gefüllt !

Gruß
Klaus


----------



## nrg (20. Mai 2011)

VfL_Freak hat gesagt.:


> In der Schleife schreibst Du dann die Werte 0 - 19 immer nur auf das i-te (also 20.)



nur mit dem problem, dass es den index 20 nicht gibt


----------



## VfL_Freak (20. Mai 2011)

Moin,


nrg hat gesagt.:


> nur mit dem problem, dass es den index 20 nicht gibt



hmm, hatte ich das geschrieben ???:L ich Looser ... 

Ich will es mal so ausdrücken :
das Array enthält 20 Felder (die Felder 1 bis 20), die aber prgrammtechnisch gesehen mit den Indizes 0 bis 19 angesprochen werden müssen !



> In der Schleife schreibst Du dann die Werte 0 - 19 immer nur auf das i-te (also 20.) Feld im Array !


sagen wir es also so:
*In der Schleife schreibst Du dann die Werte 0 - 19 immer nur auf das letzte Feld im Array !* :toll:

Besser ???:L
Gruß
Klaus


----------



## nrg (20. Mai 2011)

VfL_Freak hat gesagt.:


> *In der Schleife schreibst Du dann die Werte 0 - 19 immer nur auf das letzte Feld im Array !* :toll:



du meinst auf das "nach-letzte" und nachdem es das nicht gibt, scheitert das ganze bereits beim Wert 0


----------



## VfL_Freak (20. Mai 2011)

nrg hat gesagt.:


> du meinst auf das "nach-letzte" und nachdem es das nicht gibt, scheitert das ganze bereits beim Wert 0



jaaaa .....  ... jetzt wo Du es sagst 

Wohl nicht mein Tag heute - ich glaube, ich leg' mich wieder hin :lol:

Gruß
Klaus


----------



## TobiN (20. Mai 2011)

Wenn ich das jetzt richtig verstanden habe hab ich bei meiner Ausgabe immer den Index 20 ausgeben, oder? Hätte ich anstatt dem i eine 19 in meine Ausgabe geschrieben würde ich den letzten Wert aus meinem Array bekommen. Und mit der for-Schleife bekomme ich dann alle Werte. Wenn ich das jetzt richtig verstanden habe.


----------



## nrg (20. Mai 2011)

TobiN hat gesagt.:


> Wenn ich das jetzt richtig verstanden habe hab ich bei meiner Ausgabe immer den Index 20 ausgeben, oder?


in deiner ausgabe hast du immer die referenz auf das im speicher liegende array ausgeben. zum ausgeben von arrays entweder eine schleife nehmen oder 
	
	
	
	





```
Arrays.toString(deinArray)
```
 was dir das Array in der Form 
	
	
	
	





```
[index1, index2, ...]
```
 ausgibt.



TobiN hat gesagt.:


> Hätte ich anstatt dem i eine 19 in meine Ausgabe geschrieben würde ich den letzten Wert aus meinem Array bekommen.


genau. 19 bzw. besser immer dynamisch programmieren > 
	
	
	
	





```
deinArray.length-1
```
 gibt dir das letzte element aus



TobiN hat gesagt.:


> Und mit der for-Schleife bekomme ich dann alle Werte. Wenn ich das jetzt richtig verstanden habe.


nochmal. der aufbau einer for, zum iterieren eines array, ist eigentlich immer gleich

```
for (int i = 0; i < deinArray.length; i++) {
   // hier mit deinArray[i] auf das aktuelle Element zugreifen
}
```
der Schleifenkopf beinhaltet 3 Teile:


```
for (initialisierung; iterationsbedingung; inkrementierung) {
   // BODY
}
```

- die initialisierung wird *ganz am anfang*, *vor* dem ersten durchlauf ausgeführt. variablen, die hier intialisiert werden, sind im kompletten schleifenbody verfügbar
- die iterationsbedingung wird *vor jedem durchlauf* überprüft, ergibt diese 
	
	
	
	





```
true
```
 läuft die schleife weiter
- die inkrementierung wird *nach jedem durchlauf*  und somit *vor* der iterationsbedingung ausgeführt

oder mit for-each:

```
for (DerArrayDatentyp whatEver : deinArray) {
   // hier mit whatEver auf das aktuelle Element zugreifen
}
```
also bei einem int array:

```
for (int i : deinArray) {
   // hier mit i auf das aktuelle Element zugreifen
}
```


----------



## TobiN (20. Mai 2011)

Okay, jetzt hab ich aber noch eine Frage. Ich hab meine Klasse etwas geändert, damit ich von meiner main-Klasse Zahlen in einem Array speichern kann. Es sollten 20 Zahlen abgespeichert werden. Aber bei der Ausgabe bekomme ich immer 20 mal die 18.


```
public class Feld {
       
     int i = 20;
     int[] array = new int[i];


    void speichere(int werte) {
      for (int i=0; i<array.length; i++) {
        this.array[i] = werte;
 
 }
}

    void ausgeben(int[] werte) {
      for (int i=0; i<array.length; i++) {
      System.out.println(array[i]);
  
  }
 }
}
```



```
public class FeldProgramm {

   public static void main(String[] args) {

    int i = 20;
    int[] array = new int[i];


    Feld feld = new Feld();

    for (i=0; i<20; i+=2) {
    feld.speichere(i);

  }

   feld.ausgeben(array);

 }
}
```


----------



## VfL_Freak (20. Mai 2011)

Moin,



TobiN hat gesagt.:


> Aber bei der Ausgabe bekomme ich immer 20 mal die 18.



ganz einfach ... 


```
public class Feld 
{
    int i = 20;
    int[] array = new int[i];

    void speichere( int wert ) 
    {
        for( int i=0; i<array.length; i++ ) 
        {
            this.array[i] = wert;
        }
    }

    void ausgeben( int[] werte ) 
    {
        for( int i=0; i<array.length; i++ ) 
        {
            System.out.println(array[i]);
        }
    }
}

public class FeldProgramm 
{
    public static void main( String[] args ) 
    {
        int i = 20;
        int[] array = new int[i];

        Feld feld = new Feld();

	// (a) warum "+=2"?? 
	// (b) so rufst Du die Schleife 10x auf - nacheinander mit i = 0,2,4,6,8,10,12,14,16,18
        for( i=0; i<array.length; i+=2 )
        {
	    // und hier wird der übergebene Wert i in einer Schleife
	    // 20x in einem zweiten Array gespeichert!
	    // Also steht dort am Ende 20x der LETZTE Wert 18 drin !!
            feld.speichere(i);
        }

        feld.ausgeben(array);

     }
}
```

zudem: 
  - warum zwei Klassen?
  - besser sprechende Bezeichner
  - in jeder Klasse ein Array namens "array"??
    sehr gefährlich, da Du irgendwann nicht mehr druchblickst, wann Du was mit welchem machst !!

Versuch es mal so :

```
public class FeldProgramm 
{
    public static void main( String[] args ) 
    {
        int iArraySize = 20;
        int[] myIntArray = new int[iArraySize];

        for( i = 0; i < myIntArray.length; i++ )
        {
            myIntArray[i] = i; // den i-ten Werte ins i-te Feld des Arrays schreiben
        }

	// diese Schleife kannst Du auch sparen, in dem Du die Ausgabe gleich in die vorherige schreibst
        for( i = 0; i < myIntArray.length; i++ )
        {
            System.out.println( myIntArray[i] );
        }
     }
}
```

Gruß
Klaus


----------



## nrg (20. Mai 2011)

VfL_Freak hat gesagt.:


> Moin,
> - besser sprechende Bezeichner
> - in jeder Klasse ein Array namens "array"??
> sehr gefährlich, da Du irgendwann nicht mehr druchblickst, wann Du was mit welchem machst !!



also vllt bin ich heute zu kleinlich aber ungarische notation gehört jetzt für mich nicht unbedingt zu sprechenden bezeichnern, eher zu vorgestern 

ich finde es völlig ok, wenn es eine methoden gibt a la 
	
	
	
	





```
doSthWithArray(String[] array)
```
 oder

```
doSth(String[] values)
```
 o.ä.

bei instanz/klassenvariablen geb ich dir schon recht. die sollten sprechend sein aber ich denke dafür ist der code einfach zu sinnfrei.


----------



## VfL_Freak (21. Mai 2011)

Moin,



nrg hat gesagt.:


> also vllt bin ich heute zu kleinlich aber ungarische notation gehört jetzt für mich nicht unbedingt zu sprechenden bezeichnern, eher zu vorgestern
> 
> ich finde es völlig ok, wenn es eine methoden gibt a la
> 
> ...



Sicher kann man darüber streiten - habe mich an den bei uns in der Firma geltenden Richtlinien gehalten !
Sowas wie "*doSth*" würde beim Code-Review garantiert durchfallen!

Und zwei mal "array" in gleichen Kontext wäre wohl ein Kündigungsgrund 

Gruß
Klaus


----------



## nrg (21. Mai 2011)

VfL_Freak hat gesagt.:


> Sowas wie "*doSth*" würde beim Code-Review garantiert durchfallen!



auf den methodennamen wollt ich auch nicht hinaus sondern auf die parametrisierung .


----------

