# Arrays verknüpfen



## KlausWovo (13. Nov 2017)

Einen wunderschönen guten Tag!

Ich studiere Informatik (ganz frisch) und "muss" mich jetzt an Java rantasten.

Dafür habe ich ein paar Aufgaben aus meiner Uni.

Ich habe hier eine Beispielaufgabe:


> public static void main(String[] args) {
> 
> int[] daten = new int[0]; daten = join(new int[] {12,213,42,523,123}, daten);
> print(daten);
> ...



Praktisch ist meine Aufgabe, dass ich die gegeben Arrays miteinander "verknüpfen" soll. Also halt so, dass ich am Ende

12,213,42,523,123,19,1991,1999,9919,9199,

stehen habe.

Ich dachte dabei eigentlich an sowas wie:

int[]myArray = new int [neu.length+daten.length]; aber das funktioniert nicht so recht.

Also mein Gedanke ist halt: Nimm die Länge vom ersten Array und die Länge des zweiten Arrays und verknüpfe Sie. Aber das ist wohl zu einfach gedacht?

Leider streicht er mir dabei "neu" und "daten" an. Wieso kann ich denn diese nicht mit length verknüpfen?


----------



## Robat (13. Nov 2017)

Was ist denn die genaue Fehlermeldung?


----------



## KlausWovo (13. Nov 2017)

Er sagt mir dabei "daten cannot be resolved to a variable" und das selbe mit "neu". 

Muss ich diese dann neu deklarieren? Also das ich davor schreibe int neu = ... ? Aber ich hab diese doch als Parameter... da müsste ich diese doch eigentlich nicht nochmal deklarieren oder?


----------



## Robat (13. Nov 2017)

Zeig mal deinen kompletten Code.


----------



## SchwarzWeiß (13. Nov 2017)

Also wenn du die von dir vorgeschlagene Zeile in die join-Methode einfügst sollte das eigentlich funktionieren...


----------



## KlausWovo (13. Nov 2017)

Na mein Programmcode ist vorgegeben bzw die erste Methode ist vorgegeben und ich soll dann halt 2 gegebene Arrays miteinander verknüpfen und zurückgeben. Hier:

Ich habe es mal als Bild gemacht, damit es übersichtlicher ist für euch ^^

Und in der


> static int[] join(int[] neu, int[] daten) {



Methode habe ich halt mein besagtes:

        int[]myArray = new int [neu.length+daten.length];

reingeschrieben, aber dann kriege ich "daten/neu cannot be resolved to a variable"


----------



## Robat (13. Nov 2017)

Irgendwie passt die Fehlermeldung nicht zum Code.
Sicher, dass du keinen Tippfehler drin hattest?
Schreib dein Code noch mal und dann schick ihn ohne ihn zu verändern. Dann sieht man wirklich was du geschrieben hast 

PS: Code bitte in [code=Java]CODE[/code]-Tags


----------



## KlausWovo (13. Nov 2017)

```
public static void main(String[] args) {
        // TODO Auto-generated method stub

        int[] daten = new int[0];
      
        daten = join(new int[] {12,213,42,523,123}, daten);
        print(daten);
      
        daten = join(new int[] {19,1991,1999,9919,9199}, daten);
        print(daten);
        }
        /**
        * hängt das gegebene neu-Array an das daten-Array an und gibt es zurück.
        * @param neu
        * @param daten
        * @return
        */
  
  
        static int[] join(int[] neu, int[] daten) {
        }
      
      
        int[]myArray = new int [neu.length+daten.length];
          
      
        /**
        * hängt das gegebene neu-Array an das daten-Array an und gibt es zurück.
        * @param neu
        * @param daten
        * @return
        */
  
        static void print(int[] daten) {
  
            /**
            * Diese Methode gibt das gegebene Array auf der Konsole aus
            * @param daten
            */
      
        }
    }
```

Mehr habe ich nicht geschrieben. Hab jetzt auch einfach nur kopiert und eingefügt ^^


----------



## SchwarzWeiß (13. Nov 2017)

Das ist ja außerhalb der Methode, du musst das vor dem } schreiben

```
static int[] join(int[] neu, int[] daten) {
        int[]myArray = new int [neu.length+daten.length];
 }
```


----------



## KlausWovo (13. Nov 2017)

AH Gott ohjeeeee so ein dummer Fehler. Das wäre mir ewig nicht aufgefallen haha.

Danke... Ich bin schon fast verzweifelt


----------



## KlausWovo (13. Nov 2017)

Da ich schon mal ein Thread aufhabe: Mich verwirrt etwas.

Mein Code: 

```
public static void main(String[] args) {
        // TODO Auto-generated method stub

        int[] daten = new int[0];
       
        daten = join(new int[] {12,213,42,523,123}, daten);
        print(daten);
       
        daten = join(new int[] {19,1991,1999,9919,9199}, daten);
        print(daten);
        }
        /**
        * hängt das gegebene neu-Array an das daten-Array an und gibt es zurück.
        * @param neu
        * @param daten
        * @return
        */

        static int[] join(int[] neu, int[] daten) {
   
           
            int myArray = neu.length + daten.length;
            int[] zusammen = new int[myArray];

            return zusammen;
        }
       

       
        /**
        * hängt das gegebene neu-Array an das daten-Array an und gibt es zurück.
        * @param neu
        * @param daten
        * @return
        */
   
        static void print(int[] daten) {
   
           
            System.out.print(daten);
 
           
            /**
            * Diese Methode gibt das gegebene Array auf der Konsole aus
            * @param daten
            */
       
        }
    }
```

Wie kann ich ihm denn jetzt sagen, dass er die Arrays nacheinander ausgeben kann, wie auf dem Bild?

Ich habe in der "print" Methode ja nur "daten" ?


----------



## Robat (13. Nov 2017)

Iterier über das Array, gib die Zahlen (mit einem Komma getrennt) aus und mach am Ende ein Zeilenumbruch.
Nicht verwirren lassen.. die Ausgabe kommt nicht aus einem print-Aufruf sondern aus 2 aufrufen.


KlausWovo hat gesagt.:


> *public* *static* *void* main(String[] args) {
> .....
> print(daten);  // <--- erster Aufruf
> ....
> ...


----------



## KlausWovo (13. Nov 2017)

@Robat

Ja, dass verwirrt mich etwas, dass ich 2 Arrays habe die beide "daten" heißen ^^ Das ist für jemand neues etwas schwer zu verstehen.

Ich soll die einfach aufrufen? Nach diesem Prinzip hier?


```
int[] a = { 12,213,42,523,123 };
        int[] b = {19,1991,1999,9919,9199 };
       System.out.println((a,b));
```

So in etwa? Oder bin ich komplett falsch?


----------



## Robat (13. Nov 2017)

Nein.
Du bekommst in der Methode `print(int[] daten)` ein Array namens daten übergeben.
Mit einer for-Schleife kannst du dort jedes Element ansprechen und ausgeben lassen.


----------



## KlausWovo (13. Nov 2017)

Ah mit einer Schleife. 

Also

```
for(i=0; i<daten.length; i++) {
system.out.print(daten[i]); 
}
```

Kommt das so mehr hin?


----------



## Robat (13. Nov 2017)

Probier es aus und sag du es mir 
Kleiner Tipp: eine Kleinigkeit fehlt


----------



## KlausWovo (13. Nov 2017)

Hm irgendwo habe ich ein Fehler, weil ich so nur "000000000000000" rausbekomme


----------



## Robat (13. Nov 2017)

1. Füg ein Leerzeichen ein nachdem du eine Zahl ausgibst (Tipp: Strings und Zahlen können mit einem + verknüpft werden)
2. In deiner join-Methode machst du noch nicht viel außer dein leeres Array (mit 0 gefüllt) anlegen und das zurückgeben. Du musst dort noch die Zahlen aus dem neu-Array reinstecken. (Tipp: for-Schleife)


----------



## KlausWovo (13. Nov 2017)

Hm ich überlege und überlege 

Also ich bin ja bei:


```
static int[] join(int[] neu, int[] daten) {
          
          
          
            int myArray = neu.length + daten.length;
            int[] zusammen = new int[myArray];
             for(i=0; i < myArray.length; i++);
             zusammen[neu][daten] = i;    // hier weiß ich leider nicht

      
      
          
            return zusammen;
        }
```

Da hänge ich jetzt, weil er mir sagt, dass er myArray dafür nicht nehmen kann, aber das muss ich doch nutzen, oder nicht? Das ist doch mein "Hauptarray" was ich vorher deklariert habe und gesagt habe, dass es die "größe" von neu und "daten" hat.


----------



## SchwarzWeiß (13. Nov 2017)

1. Du brauchst kein zweidimensionales Array
2. das i ist ja der Index der dem Array sagt, an welcher Stelle es beschrieben werden soll, also muss es auf die linke Seite der Zuweisung
3. du musst das i erstmal deklarieren
4. die Syntax für die for-Schleife bzgl. Semikolon und geschweiften Klammern war vorhin richtig, jetzt nicht mehr


----------



## KlausWovo (13. Nov 2017)

Hach. Das ist nicht leicht in Java reinzukommen. 

Also von vorne: 


```
int i; //muss es deklarieren
int myArray = neu.length + daten.length;
int[] zusammen = new int[myArray];
 for(i=0; i<zusammen.length; i++) {        // das ist mein Zähler
               
                 //Hier weiß ich nicht wie ich ihm sagen kann, dass er von Daten in zusammen füllen soll
            
    }
```

Sry, ich gebe mir wirklich mühe, aber meine Uni schmeißt einen von 0 auf 100 einfach ins Wasser


----------



## SchwarzWeiß (13. Nov 2017)

Du kannst das i auch einfach direkt im Schleifenkopf deklarieren:


```
int myArray = neu.length + daten.length;
int[] zusammen = new int[myArray];
 for(int i=0; i<zusammen.length; i++) {        // das ist mein Zähler
             
                 //Hier weiß ich nicht wie ich ihm sagen kann, dass er von Daten in zusammen füllen soll
          
    }
```

So jetzt musst du "zusammen" füllen, also erst mit dem einen Array und dann mit dem anderen.


----------



## KlausWovo (13. Nov 2017)

Und wie mache ich das? Also den Schritt habe ich verstanden, dass ich das machen muss. Mir würde halt spontan nur sowas wie das einfallen:


```
int myArray = neu.length + daten.length;
int[] zusammen = new int[myArray];
 for(int i=0; i<zusammen.length; i++) {       // das ist mein Zähler
            
   zusammen[I] = ?;           // also das mit zusammen[I] denke ich aber ich weiß halt nicht wie ich ihm neu und daten zuweisen kann. Einfach nach dem Prinzip
    }
```

Ergibt das so etwas Sinn?[/I][/I]


----------



## Robat (13. Nov 2017)

Das Element im array *neu* an Stelle i packst du in das array *zusammen* an Stelle i


----------



## KlausWovo (13. Nov 2017)

@Robat  Gott, ihr tut mir richtig leid, dass ich euch so damit nerve 

Das Element im Array "neu" an Stelle i packe ich in das Array zusammen?


```
zusammen[neu] = i;
```

Habe ich dich so richtig verstanden?


----------



## SchwarzWeiß (13. Nov 2017)

nein, neu hat ja immer den selben Wert, du musst das i in die Klammern setzen. Du willst ja den Wert erst an der Stelle 0 dann an 1, 2 usw zuweisen und genau das passiert dann in der Schleife.


----------



## KlausWovo (13. Nov 2017)

Dann war also


```
zusammen[i] = ?
```

Nicht falsch. Mich hat Robat nur etwas verwirrt  Weil ich sehe doch gar kein Array "neu". Das "Neu Array" habe ich doch nicht in der join Methode. Das wird mir doch bereits übergeben.

Ich dachte jetzt an sowas wie: 

```
zusammen[i] = neu[i];
```


----------



## SchwarzWeiß (13. Nov 2017)

ja so stimmt es, aber Robat hat trotzdem recht, dadurch dass du es übergibst, hast du es ja in der join-Methode zur Verfügung  bzw. du hast deren Werte zur Verfügung, sonst könntest du die Zuweisung ja gar nicht machen.


----------



## KlausWovo (13. Nov 2017)

Ja ich habe es jetzt so geschrieben:


```
public static void main(String[] args) {
        // TODO Auto-generated method stub

        int[] daten = new int[0];
     
        daten = join(new int[] {12,213,42,523,123}, daten);
        print(daten);
     
        daten = join(new int[] {19,1991,1999,9919,9199}, daten);
        print(daten);
        }
        /**
        * hängt das gegebene neu-Array an das daten-Array an und gibt es zurück.
        * @param neu
        * @param daten
        * [USER=49078]@Return[/USER]
        */
 
 
        static int[] join(int[] neu, int[] daten) {
         
         
         
            int myArray = neu.length + daten.length;
            int[] zusammen = new int[myArray];
            for(int i=0; i<zusammen.length; i++)
            zusammen[I] = neu[I]  ;
             
       
       
           
            return zusammen;
        }
       
   
       
       
        /**
        * hängt das gegebene neu-Array an das daten-Array an und gibt es zurück.
        * @param neu
        * @param daten
        * [USER=49078]@Return[/USER]
        */
   
        static void print(int[] daten) {
   
            int i;
            for(i=0; i<daten.length; i++) {
               
                System.out.print( daten[I]); 
                }
            /**
            * Diese Methode gibt das gegebene Array auf der Konsole aus
            * @param daten
            */
       
        }
    }
```

Aber wenn ich es ausführe kriege ich nur: "1221342523123Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5"

Was bedeutet denn das? Das Programm starten kann ich. Also ich kriege am Rand keine rote Anzeige, dass etwas falsch ist. 

Ja, ich bin mir auch definitiv sicher, das Robat recht hat. Nur leider ist es für mich als Neuling nicht so leicht zu verstehen [/I][/I][/I]


----------



## Robat (13. Nov 2017)

KlausWovo hat gesagt.:


> for(int i=0; i<zusammen.length; i++)


Du darfst hier nicht als Grenze zusammen.length nehmen sondern neu.length.

PS : Code Tags lauten  [code=Java] code[/code]


----------



## KlausWovo (13. Nov 2017)

@Robat Ahhhhhhhhhhhhhhhhhhhhhh

Gott. Ist das schön zu sehen. Ich liebe euch beide so sehr für eure Hilfe und Geduld mit einem unwissenden...

Aber eine Frage habe ich noch!

Bei mir schreibt er das jetzt alles nacheinander ohne Komma. Also so: "122134252312319199119999919919900000"

Und auch 5x eine extra 0... Wie kann ich das denn begrenzen mit Kommas und woher kommen plötzlich diese Nullen?


----------



## SchwarzWeiß (13. Nov 2017)

auf Groß- und Kleinschreibung achten, du musst i statt I schreiben


----------



## KlausWovo (13. Nov 2017)

@SchwarzWeiß

Ja, keine Sorge. Das hat er auf dieser Seite irgendwie automatisch gemacht. Im Programm selber habe ich alles klein geschrieben.

Aber würde dies denn erklären, warum er das ohne Komma schreibt?


----------



## SchwarzWeiß (13. Nov 2017)

Wenn du ein Komma haben willst, musst du ihm das auch mitteilen  also in die Ausgabe nicht nur daten sondern auch ein Komma, du verknüpft mit + also_ *... + ", " + ...*_


----------



## KlausWovo (13. Nov 2017)

Ahhhhhhhhhhh oh ist das schön. Ich bin richtig froh gerade. 

Aber woher kommen die 5 Nullen plötzlich am Ende?

Weil das ist mein Ergebnis: 12,213,42,523,123,19,1991,1999,9919,9199,0,0,0,0,0,


----------



## SchwarzWeiß (13. Nov 2017)

Die Aufgabe ist ja, zwei Arrays zu verknüpfen. Momentan hast du aber nur das eine Array drangehängt aber das andere noch nicht. Schick am besten nochmal deinen jetzigen Code, damit wir wissen, wie du es umgesetzt hast.


----------



## Robat (13. Nov 2017)

Die Nullen kommen aus der join Methode.
Du erhöhst zwar jedes mal die Länge des Arrays und schreibst die neuen Daten aus `neu` ab.. aber die alten Daten aus `daten` berücksichtigst du nicht.


----------



## KlausWovo (13. Nov 2017)

```
public static void main(String[] args) {
        // TODO Auto-generated method stub

        int[] daten = new int[0];
    
        daten = join(new int[] {12,213,42,523,123}, daten);
        print(daten);
    
        daten = join(new int[] {19,1991,1999,9919,9199}, daten);
        print(daten);
        }
        /**
        * hängt das gegebene neu-Array an das daten-Array an und gibt es zurück.
        * @param neu
        * @param daten
        * @return
        */
 
 
        static int[] join(int[] neu, int[] daten) {
        
        
        
            int myArray = neu.length + daten.length;
            int[] zusammen = new int[myArray];
            for(int i=0; i<neu.length; i++)
            zusammen[i] = neu[i]  ;
          
    
 
            return zusammen;
        }
    
 

    
        /**
        * hängt das gegebene neu-Array an das daten-Array an und gibt es zurück.
        * @param neu
        * @param daten
        * @return
        */
 
        static void print(int[] daten) {
 
            int i;
            for(i=0; i<daten.length; i++) {
            
                System.out.print( daten[i] + ",");
                }
            /**
            * Diese Methode gibt das gegebene Array auf der Konsole aus
            * @param daten
            */
    
        }
    }
```



@Robat Das heißt, weil ich "daten" nicht berücksichtige, gibt er mir die Nullen?


----------



## KlausWovo (13. Nov 2017)

Ich muss das erste Array ja auch ausgeben... kann ich das nicht manuell einfach ausgeben mit den einzelnen Stellen zeigen?

Und wie kriege ich die Nullen weg?


----------



## Robat (13. Nov 2017)

Hier mal ein wenig Pseudocode:

```
join(neu : int[], daten : int[]) : int[] 
{
     resArr = int[neu_len + daten_len]
     FOR i = 0 TO daten_len
          resArr[i] = daten[i]
     FOR i = daten_len TO resArr.length
          resArr[i] = neu[i - daten_len]
     return resArr
}
```


----------



## KlausWovo (13. Nov 2017)

@Robat 

Das ist sehr nett von dir! Aber den Java-Begriff „TO“ ist mir noch unbekannt 

Gibt es da keinen leichteren Weg die Nullen wegzubekommen? 

Aber dennoch danke werde es mir ganz genau anschauen um es zu verstehen


----------



## Robat (13. Nov 2017)

Das ist kein Befehl.. das ist Pseudocode.
Das ganze musst du noch in Java-Syntax umsetzen


----------



## KlausWovo (13. Nov 2017)

Das werde ich definitiv nachher mal probieren! Sollte ich es nicht schaffen, werde ich morgen wahrscheinlich hier mich wieder melden 

Aber bis hierhin erstmal danke! Du warst unheimlich hilfreich!


----------



## KlausWovo (13. Nov 2017)

Also ich habe mir mal deinen "Pseudocode" angeschaut und habe verstanden worauf du hinaus willst. Bei meinem jetzigen Code, gehe ich nur auf das "neu" ein aber nicht auf "daten". Wie du bereits gesagt hast. Also muss ich "daten" auch in eine Schleife setzen?

Ich habe das so gemacht: 


```
static int[] join(int[] neu, int[] daten) {
           
           
           
            int myArray = neu.length + daten.length;
            for(int i= 0; i<daten.length;i++);
           
            myArray[i] = daten[i]  ;
           
            int[] zusammen = new int[myArray];
            for(int i=0; i<neu.length; i++)
            zusammen[i] = neu[i]  ;
             
       
   
            return zusammen;
        }
```

Aber er gibt mir eine Fehlermeldung bei 

```
myArray[i] = daten[i]  ;
```

Da sagt er mir: "i cannot be resolved to a variable" und "The type of the expression must be an array type but it resolved to int"

Warum kann ich denn nicht "i" für meine Schleife benutzen?


----------



## Robat (13. Nov 2017)

Grundlagen, Grundlagen Grundlagen 

- Eine for-Schleife solltest du immer Klammern
- for-Schleifen werden nicht mit einem Semikolon beendet
- Schau dir noch mal die Grenzen aus dem Pseudocode an (das was hinter TO steht)


----------



## KlausWovo (13. Nov 2017)

Gott... das mit den Schleifen vergesse ich immer wieder...Das muss ich mir echt angewöhnen.

Du meinst die Grenzen hinter dem TO, also "daten_len" ? Na die Grenze ist damit die Länge des Arrays Daten und bei dem anderen TO(also resArr.length) ist die Grenze die Länge von Neu und Daten

Und am Ende ziehst du die Länge des Arrays "Daten" von Neu ab... So habe ich es jetzt verstanden ^^


----------



## Robat (13. Nov 2017)

Dann setz es doch auch um 
Übrigens: zwischendurch das Array neu zu initialisieren macht wenig Sinn


----------



## KlausWovo (13. Nov 2017)

Haha, du hast leicht reden. Du bist ein Java-Genie.  Für dich ist das wie sprechen. Für mich ist das  teilweise ein reines Gewirr. Ich kann die Theorie im Kopf, wie ich Schritt für Schritt vorgehen muss aber weiß nicht, wie ich es schreiben muss ^^

Wo habe ich es denn neu initialisiert? Ich habe eigentlich nur die for Schleife hinzugefügt und myArray_ = daten.
_
Ich habe doch aber die Grenzen richtig gemacht, oder nicht?

Gott ich verzweifel langsam 


Ahhhh kann es sein, dass das nach myArray kein Sinn macht? Meinst du das?

_


		Java:In die Zwischenablage kopieren


 myArray = daten[i]  ;

_
Also wohl eher so? Damit sage ich ihm: myArray ist so lang, wie Daten.

Ich habe meine join Methode jetzt so geschrieben: 

_


		Java:In die Zwischenablage kopieren


        static int[] join(int[] neu, int[] daten) {
           
           
           
            int myArray = neu.length + daten.length;
            for(int i= 0; i<daten.length;i++) {
            myArray = daten[i]  ;
            }
            int[] zusammen = new int[myArray];
            for(int i=0; i<neu.length; i++) {
            zusammen[i] = neu[i - daten.length] ;
             
       
            }
            return zusammen;
        }


Aber da bekomme ich leider eine Fehlermeldung mit: "12,213,42,523,123,Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -5"
_


----------



## Robat (13. Nov 2017)

1. Punkt: Momentan hast du 2 Arrays: myArray und zusammen und speicherst verschiedene Werte in die Arrays. Du willst aber alle Werte in *ein* Array schreiben.
2. Punkt: Schau dir noch mal genau den Pseudocode an (wie i initialisiert ist und die Abbruchbedingung der 2. for-Schleife ist. [neu.length ist nicht die Grenze sondern resArray.length .. also dein neues Array wo alle Daten reinkommen] ) .. dann fliegt auch keine Exception mehr

--


KlausWovo hat gesagt.:


> *int* myArray = neu.length + daten.length;
> *for*(*int* i= 0; i<daten.length;i++) {
> myArray = daten[i] ;
> }


Denkst du dir bei dem Code was? Warum willst du daten.length - mal den Wert von einem int überschreiben?


----------



## KlausWovo (13. Nov 2017)

Ich habe es jetzt nach meiner Meinung auch richtig! Dein Pseudocode wurde mir klar, nachdem ich selber gecheckt habe, dass das "zusammen" Array völlig unnütz ist.

Dadurch habe ich es dann so geschrieben:


```
static int[] join(int[] neu, int[] daten) {
    
    
    
            int[] myArray = new int [neu.length + daten.length];
            for(int i= 0; i<daten.length;i++) {
            myArray[i] = daten[i]  ;
      
            }
                
            for(int i=0; i<neu.length; i++) {
            myArray[i + daten.length] = neu[i] ;
      
 
            }
            return myArray;
        }
```

Es scheint auch zu funktionieren, weil die Nullen endlich weg sind!

Aber ein Fehler habe ich noch... Er scheint das erste Array zu wiederholen.


Das ist mein Ergebnis: "12,213,42,523,123,12,213,42,523,123,19,1991,1999,9919,9199,"

Da steckt eindeutig ein "{12,213,42,523,123}" zu viel drin ^^ Was im übrigen auch nicht falsch ist! Ich soll ja zuerst das erste Array ausgeben und dann im Zeilenumbruch die beiden Arrays zusammen noch mal.

Ist es möglich, dass ich nach dem ersten "{12,213,42,523,123}" ein Zeilenumbruch machen kann?

Also das es so aussieht, wie auf dem Bild?


----------



## Robat (14. Nov 2017)

Ich glaube nicht dass dein Algorithmus falsch ist, sondern deine Ausgabe.
Setz am ende deiner print-Methode mal noch folgende Zeile: `System.out.println("");` um am Ende ein Zeilenumbruch zu machen.


----------



## KlausWovo (14. Nov 2017)

Du meinst so? 


```
static void print(int[] daten) {
   
            int i;
            for(i=0; i<daten.length; i++) {
               
               
                System.out.print(+ daten[i] + ","); 
                System.out.println("");
                }
     
        }
    }
```

Dann gibt er es mir aber so aus: 


```
12,
213,
42,
523,
123,
12,
213,
42,
523,
123,
19,
1991,
1999,
9919,
9199,
```


----------



## KlausWovo (14. Nov 2017)

Ahhh ich habs! Habe es aus Versehen in die Klammer gesetzt! Jetzt habe ich es! 

AH Gott ich danke dir! Ich liebe dich. DU bist der Beste. Ohne dich hätte ich das nie geschafft!


----------

