Arrays verknüpfen

[KlausWovo]

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);

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) {

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]

Was ist denn die genaue Fehlermeldung?

 

[KlausWovo]

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]

Zeig mal deinen kompletten Code.

 

[SchwarzWeiß]

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

 

[KlausWovo]

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]

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]

    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ß]

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]

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

Danke... Ich bin schon fast verzweifelt

 

[KlausWovo]

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]

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.

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

 

[KlausWovo]

@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]

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]

Ah mit einer Schleife.

Also

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

Kommt das so mehr hin?

 

[Robat]

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

 

[KlausWovo]

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

 

[Robat]

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]

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ß]

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]

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ß]

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]

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]

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

 

[KlausWovo]

@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ß]

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]

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ß]

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]

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]

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]

@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ß]

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

 

[KlausWovo]

@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ß]

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]

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ß]

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]

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]

    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]

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]

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]

@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]

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

 

[KlausWovo]

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]

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]

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]

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]

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

 

[KlausWovo]

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?

 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:

        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]

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

--

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]

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?