Arrays mit Schleife füllen

[Tobser]

Hi alle zusammen,
ich hab hier ein "kleines " Anfängerproblem. Ich möchte in einer Klasse mit Hilfe einer For-Schleife ein dreidimensionales Array füllen. Wie ich das fülle, weiß ich bereits. Nun habe ich das Problem, dass das Array nach dem Füllen leer ,also null,ist. Ich habe dieses Array als Klassenvariable definiert, also mit static int Array.
Ich rätsel nun schon ne Weile daran rum. Kann mir jemand helfen?

 

[Robat]

Kannst du deinen Code posten?
Hier will keiner raten..

 

[Tobser]

public class Berechnung {

   static int Inz[][][];

   public static void main(String args[]) {

       //Inzidenzmatrizen aufstellen
       for(int i=0;i<Modell.Elementanzahl;i++){
           if(i<Modell.Elementanzahl-1){
               for(int j=0;j<4;j++){
                   for(int k=0;k<2;k++){
                       Inz[i][j][k]=0;
                   }
               }
           }else{
               Inz[i][0][0]=1;
               Inz[i][0][1]=0;
               Inz[i][1][0]=0;
               Inz[i][1][1]=0;
               Inz[i][2][0]=0;
               Inz[i][2][1]=1;
               Inz[i][3][0]=0;
               Inz[i][3][1]=0;
           }
       }
       System.out.println(Inz[0][0][0]);
}

 

[Tobser]

Ich hab hier alles Nebensächliche aus dem Code rausgenommen. Oder soll ich den gesammten Code posten?
Bei den Inz fehlt hier im Code jeweils noch ein i in eckigen Klammern . Das wird irgendwie nicht mit übernommen

 

[Tobser]

Das Problem liegt darin, dass wenn ich mit dem print-Befehl mir eine Komponente des Arrays ausgeben lassen will, der Fehler Sorce not found kommt.

 

[VfL_Freak]

Moin,

Code-Tags bitte

Außerdem: soll Dein Array nun zwei- oder dreidimensional sein ??

static int Inz[][][];
Inz[0][0]=1;


Gruß Klaus

 

[Viktim]

Außerdem: soll Dein Array nun zwei- oder dreidimensional sein ??

static int Inz[][][];
Inz[0][0]=1;

Hat er doch gesagt

Bei den Inz fehlt hier im Code jeweils noch ein i in eckigen Klammern . Das wird irgendwie nicht mit übernommen

Die Frage ist eher wo das i steht

 

[Robat]

Man berichtige mich wenn ich quatsch erzähle aber:

Arrays müssen in Java eine feste Länge haben. sowas wie int[][] x = new int[][]; funktioniert also nicht. Dafür gibt es ArrayListen.
Sobald du weißt wie groß die einzelnen Dimensionen sind musst du also dein Array initialisieren.

Es fehlt also in etwa sowas

Inz = new int[Modell.Elementenanzahl-1][4][2];
[Werte aus dem Codebeispiel entnommen].

Gruß
Robert

 

[Viktim]

Man berichtige mich wenn ich quatsch erzähle

Stimmt, ist also kein Quatsch und das was du meintest fehlt wirklich

 

[VfL_Freak]

Moin,

Hat er doch gesagt

naja, so wie der etwas hingeklatschte Code ausschaut, hätte ich jetzt eher vermutet, dass hier das Wort drei der Tippfehler ist:

Ich möchte in einer Klasse mit Hilfe einer For-Schleife ein dreidimensionales Array füllen

Gruß Klaus

 

[Flown]

Bitte Code-Tags verwenden, dann wird das [i] auch nicht geschluckt: [code=java]//JAVA CODE HERE[/code]

Achtung Erbsenzähleralarm:

Dafür gibt es ArrayListen.

Listen im Allgemeinen, muss keine ArrayList sein.

Zusätzlich gilt, dass in Java mehrdimensionale Arrays nicht rechteckig sein müssen:

import java.util.Arrays;

public class Test {
  public static void main(String... args) {
    int[][] steps = new int[5][];
    for (int i = 0; i < steps.length; i++) {
      steps[i] = new int[i + 1];
      Arrays.fill(steps[i], i);
    }
    for (int[] step : steps) {
      System.out.println(Arrays.toString(step));
    }
  }
}

 

[Tobser]

Hier jetzt mal der gesamte Code

public class Berechnung {
 
   static int Ke[][][];
   static int A[][][];
   static int Faktor [];
   static int Inz[][][];
   static int Ksys[][];
 
   public static void main(String args[]) {
    

       //1. Elementsteifigkeitsmatrizen verschaffen und (2.) Aktualisieren
       //1.1 Matrizen der Elementsteifigkeifigkeitsmatrix verschaffen
       for(int i=0;i<Modell.AnzahlElemente;i++){
           int Le=Modell.Elem[i].Elementlaenge;
           //erste Zeile
           A[i][0][0]=6;
           A[i][0][1]=-6;
           A[i][0][2]=-3*Le;
           A[i][0][3]=-3*Le;
           //zweite Zeile
           A[i][1][0]=-6;
           A[i][1][1]=6;
           A[i][1][2]=3*Le;
           A[i][1][3]=3*Le;
           //dritte Zeile
           A[i][2][0]=-3*Le;
           A[i][2][1]=3*Le;
           A[i][2][2]=2*Le*Le;
           A[i][2][3]=Le*Le;
           //vierte Zeile
           A[i][3][0]=-3*Le;
           A[i][3][1]=3*Le;
           A[i][3][2]=Le*Le;
           A[i][3][3]=2*Le*Le;
       }
    
       //1.2 Vorfaktor der Elementsteifigkeitsmatrizen verschaffen
       for(int i=0;i<Modell.Elementanzahl;i++){
           Faktor[i]=2 * Modell.Elem[i].ElementEModul * Modell.Elem[i].Elementflaechenmoment / Modell.Elem[i].Elementlaenge;
       }
    
       //1.3 Matrix und Vorfaktoren zu Elementsteifigkeitsmatrizen zusammensetzen
       Ke=Produkt(Faktor,A);
    
       //Inzidenzmatrizen aufstellen
       for(int i=0;i<Modell.Elementanzahl;i++){
           if(i<Modell.Elementanzahl-1){
               for(int j=0;j<4;j++){
                   for(int k=0;k<2;k++){
                       Inz[i][j][k]=0;
                   }
               }
           }else{
               Inz[i][0][0]=1;
               Inz[i][0][1]=0;
               Inz[i][1][0]=0;
               Inz[i][1][1]=0;
               Inz[i][2][0]=0;
               Inz[i][2][1]=1;
               Inz[i][3][0]=0;
               Inz[i][3][1]=0;
           }
       }
       System.out.println(Inz[0][0][0]);
       //Systemsteifigkeitsmatrix zusammenbauen
       Ksys=getKsys(Skalarprod(Skalarprod(Transpose(Inz),Ke),Inz));

   }
 
   //######################################################################################################################################
   //Operationen
   static int[][][]Produkt(int Faktor[],int Matrix[][][]){
       for(int i=0;i<Modell.Elementanzahl;i++){
           for (int j=0;j<=Matrix.length;j++){
               for(int k=0;k<=Matrix.length;k++){
                   Matrix[i][j][k]=Faktor[i]*Matrix[i][j][k];
               }
           }
       }
       return Matrix;
   }
 
   static int [][] getKsys(int A[][][]){
       int C[][]=new int [A[0].length][A[0][0].length];
       for(int i=0;i<A[0].length;i++){
           for(int j=0;j<A[0][0].length;j++){
               for(int k=0;k<A.length;k++){
                   if(k==0){
                       C[i][j]=A[k][i][j];
                   }else{
                       C[i][j]=C[i][j]+A[k][i][j];
                   }
               }
           }
       }
       return C;
   }
 
   static int[][][]Transpose(int [][][]A){
       int [][][]C=new int[A.length][A[0][0].length][A[0].length];
       for(int i=0;i<A.length;i++){
           for(int j=0;j<A[0].length;j++){
               for(int k=0;k<A[0][0].length;k++){
                   C[i][k][j]=A[i][j][k];
               }
           }
       }
       return C;
   }
 
   static int [][][]Skalarprod(int [][][]A,int[][][]B){
       int [][][]C=new int [A.length][A[0].length][B[0][0].length];
       //A242,B244,C242
       for(int i=0;i<A.length;i++){
           for(int j=0;j<A[0].length;j++){
               for(int k=0;k<B[0][0].length;k++){
                   for(int l=0;l<B[0].length;l++){
                       if(l==0){
                           C[i][j][k]=A[i][j][l]*B[i][l][k];
                       }else{
                           C[i][j][k]=C[i][j][k]+A[i][j][l]*B[i][l][k];
                       }
                   }
               }
           }
       }

       return C;
    
   }
 
}

Das Problem liegt, wie bereits erwähnt, darin, dass das Array Inz nur innerhalb des Schleifenblocks gefllt ist. Außerhalb ist sie null.