# zweidim. Array zu eindimensionalen Array machen



## Stadtwerk (6. Feb 2008)

hallo,
ich häng gerade schon mal wieder an ner aufgabe. ich soll aus einem beliebigen zweidimensionalen Array ein eindimensionales machen, das als Werte die Summen aus den Spalten des zweidimensionalen besitzt. die genaue aufgabenstellung hab ich mal hier hochgeladen:
http://www.file-upload.net/view-654987/IMG_0001.jpg.html
mein quelltext sieht bis jetzt so aus:

class Komplett {
	public static void main (String [] args){
		int [][] arrayalt = new int [][] {{1375, 1466},{3232,2525},{565,4365}};

		int [] arrayneu = verdichten (arrayalt);

		for (int i=0;i<arrayneu.length;i++){
			System.out.println (arrayneu_);
			}
		}

	public static int [] verdichten (int [][]arrayalt){

		int neu [] = new int [arrayalt.length];		
		for (int k = 0; k<arrayalt.length;k++){		
			neu [k]= arrayalt[k][0];
		}

			int x = 0;
		for (int l=0; l<neu.length; l++){
			x = x + neu [l];
		}


		int neu2 [] = new int [arrayalt.length];
		for (int m=0; m<arrayalt.length; m++){
			neu2 [m]= arrayalt [m][1];
		}
		 	int y = 0;
		 for (int n=0; n<neu2.length; n++){
		 	y = y + neu2 [n];
		 }


		 int [] neu3 = new int [] {x, y}; 

		 return neu3;
		 }
	}




nun funktioniert der text auch recht schön für ne beliebige anzahl von zeilen aber sobald ich ne neue spalte, also bei 
"int [][] arrayalt = new int [][] {{1375, 1466},{3232,2525},{565,4365}};"
noch jeweils eine zahl in jedem Klammerausdruck hinzufüge funktioniert der Quelltext nicht mehr. ich müsst halt irgendwie noch die spaltenanzahl in der methode verdichten berücksichtigen, aber ich hab leider absolut keinen plan wie ichs anstellen soll. kann mir vielleicht jemand helfen? schon mal vielen dank im voraus _


----------



## Pappenheimer++ (6. Feb 2008)

Die Lösung sieht so aus (hast wohl nicht genügend modelliert, höhö.)

```
class Testklasse 
{
public static void main (String [] args)
{
	int [][] arrayalt = new int [][] {{1375,1466,1},{3232,2525,1},{565,4365,1}};
	int [] arrayneu = verdichten (arrayalt);

	for (int i=0;i<arrayneu.length;i++)
	{
		System.out.println (arrayneu[i]);
	}
}

public static int [] verdichten (int [][]arrayalt)
{
	int neu [] = new int [arrayalt.length];
	for (int k = 0; k<arrayalt.length;k++)
	{
		for(int j=0; j<arrayalt[k].length; j++)
		neu [k]+= arrayalt[k][j];
	}

return neu;
}
}
```

Wenn du mich fragst, lag es daran, dass du 1.) lieber gleich drauflosprogrammiert hast und 2.) dich dein unformatierter Code zusätlich verwirrt hat^^ Naja viel Spaß damit


----------



## Ariol (6. Feb 2008)

Dein Ausgangs-Array macht die Sache unnötig kompliziert.
Schreib das mal so:

```
int[][] arrayalt = new int[][]
		{
		{ 1375, 3232, 565 },
		{ 1466, 2525, 4365 } };
```

Dann hast du es gleich schon nach Produkten sortiert.

Dann brauchst du nur noch eine verschachtelte Schleife zum addieren der Werte und kannst diese Werte in dein neues Array schreiben.


Wenn dieser Weg nicht erlaubt ist wird's etwas schwieriger^^


----------



## Stadtwerk (6. Feb 2008)

mmh. ja danke. 
aber die methode die du gepostet hast, addiert jeweils den klammerausdruck, also auf die Aufgabe bezogen, die Verkaufszahlen aus jeder Filliale. Ich will aber das er mir für jedes Produkt die Summe aus allen Filialen zurückbringt. mmh.


----------



## Ariol (6. Feb 2008)

Pappenheimer++ hat gesagt.:
			
		

> Die Lösung sieht so aus (hast wohl nicht genügend modelliert, höhö.)
> 
> ```
> class Testklasse
> ...




Die Lösung klappt aber auch nur, wenn du für 3 Fillialen genau 3 Produkte hast.
Variiert die Anzahl klappt es schon nicht mehr.

Abgesehen davon ist das Ergebnis falsch, weil du die Anzahl aller Produkte je Filliale rechnest, statt (siehe Aufgabenstellung) die Gesamtmenge je Produkt für alle Fillialen.

Wenn, dann so:

```
class Komplett{

	public static void main(String[] args){

		int[][] arrayalt = new int[][]{		{ 1375, 3232, 565 },
								   { 1466, 2525, 4365 } };

		int[] arrayneu = verdichten(arrayalt);

		for (int i = 0; i < arrayneu.length; i++){
			System.out.println(arrayneu[i]);
		}
	}

	public static int[] verdichten(int[][] arrayalt){

		int neu[] = new int[arrayalt.length];

		for (int i = 0; i < arrayalt.length; i++){			
			for (int j = 0; j < arrayalt[i].length; j++){
				neu[i] += arrayalt[i][j];
			}
		}

		return neu;
	}
}
```


----------



## Stadtwerk (6. Feb 2008)

wow. herzlichen dank Ariol. wenn du mir jetz nur noch erklärst, wie die zeile "neu_ += arrayalt[j];" ausgeschrieben heißt, also ohne Abkürzung +=.. , dann bist echt mein Held des Tages 

neu  = neu  + arrayalt[j] ???
also is das jetz wohl irgendwie rekursiv? wahrscheinlich. 
kannst du mir das viell. an dem bsp. hier erklären? 

man will ja neu an der stelle i bestimmen. also fängt die schleife an, neu an der stelle null = neu an der stelle null plus den wert des arrays in der zeile 0 - spalte 0. 
mmh mmmh mmmmh. ich kappiers nicht._


----------



## Stadtwerk (7. Feb 2008)

hohoho.
oh mein gott. jetz bin ich komplett verwirrt.

wieso passiert, wenn ich die methode folgendermaßen veränder:

  public static int[] verdichten(int[][] arrayalt){

      int neu[] = new int[arrayalt.length];

      for (int i = 0; i < arrayalt.length; i++){         
         for (int j = 0; j < arrayalt_.length; j++){
            neu  = arrayalt[j] ;
         }
      }
      System.out.println (neu[0]);


folgendes, dass er mir für den Wert neu[0], 565 ausgibt und nicht 1375. Ich bin verwirrt und außerdem is jetzt Schlafenszeit. Gute Nacht euch.  :gaen:_


----------



## Ariol (7. Feb 2008)

Stadtwerk hat gesagt.:
			
		

> wow. herzlichen dank Ariol. wenn du mir jetz nur noch erklärst, wie die zeile "neu_ += arrayalt[j];" ausgeschrieben heißt, also ohne Abkürzung +=.. , dann bist echt mein Held des Tages
> 
> neu  = neu  + arrayalt[j] ???
> _


_

Genau das!

funktioniert auch mit -,*,/ und halt eben mit +

x += y --> x = x + y
x -= y --> x = x - y
usw.



			
				Stadtwerk hat gesagt.:
			
		


			also is das jetz wohl irgendwie rekursiv? wahrscheinlich. 
kannst du mir das viell. an dem bsp. hier erklären?
		
Zum Vergrößern anklicken....


Nee, da ist nix rekursives dabei.



			
				Stadtwerk hat gesagt.:
			
		


			man will ja neu an der stelle i bestimmen. also fängt die schleife an, neu an der stelle null = neu an der stelle null plus den wert des arrays in der zeile 0 - spalte 0. 
mmh mmmh mmmmh. ich kappiers nicht.
		
Zum Vergrößern anklicken....


Du hast ein Array, das nach den Produkten aufgeteilt ist:

Produkt 1:
- Filliale 1 = 1375 Stück
- Filliale 2 = ...
Produkt 2:
- Filliale 1 = ...
usw.



		Code:In die Zwischenablage kopieren


for (int i = 0; i < arrayalt.length; i++){

Durchläuft das Array nach den Produkten.
Wenn also i = 0 ist bist du bei Produkt 1. i = 1 entspricht Produkt 2, usw.

Das Ganze läuft solange wie i < arrayalt.length ist. Sprich bis alle Produkte abgearbeitet sind.

Dein neues Array zeigt ja die Produkte von arrayalt auf und muss demzufolge genauso groß sein (gleiche Anzahl Produkte):


		Code:In die Zwischenablage kopieren


int neu[] = new int[arrayalt.length];


Nun durchläufst du die einzelnen Fillialen für dein gewähltes Produkt (du erinnerst dich? i!) ...


		Code:In die Zwischenablage kopieren


for (int j = 0; j < arrayalt[i].length; j++){

...und nehmen uns die dort hinterlegte Stückzahl.


		Code:In die Zwischenablage kopieren


arrayalt[i][j]

Sprich wir gehen für Produkt i in Filliale j und lassen uns dort die Stückzahl zurückgeben.

(Das Ganze ist nur insofern kompliziert, das wir Menschen bei 1 anfangen zu zählen und der PC bei 0. Das hatten wir oben schonmal:

i = 0 --> Produkt1, i =1 --> Produkt2, usw.

Gleiches gilt nun auch für die Fillialen:

j = 0 --> Filliale1, j = 1 --> Filliale2, usw.

Eigentlich garnicht so schwer.)

So - die nun ermittelte Stückzahl der Filliale zählen wir jetzt im neuen Array an dem entsprechenden Platz hinzu


		Code:In die Zwischenablage kopieren


neu[i]


Jetzt sollte das hier auch nicht mehr so schwer zu verstehen sein:


		Code:In die Zwischenablage kopieren


neu[i] += arrayalt[i][j];


Wir nehmen also von Produkt i aus Filliale j die Stückzahl und addieren diese zu der Gesamtstückzahl(neues Array) von Produkt i hinzu._


----------



## Ariol (7. Feb 2008)

Stadtwerk hat gesagt.:
			
		

> hohoho.
> oh mein gott. jetz bin ich komplett verwirrt.
> 
> wieso passiert, wenn ich die methode folgendermaßen veränder:
> ...



Weil du so den Wert in neu_ überschreibst.
Es wird also immer nur der Wert der letzten Filliale nach neu geschrieben.


Ach ja, benutz bitte mal Code-Tags - das macht das Ganze besser lesbar.^^_


----------



## Stadtwerk (7. Feb 2008)

super, ich danke euch. mein fertiger quellcode für die methode sieht nun folgendermaßen aus:

   public static int[] verdichten(int[][] arrayalt){

      int neu[] = new int[arrayalt[0].length];



      for (int i = 0; i < arrayalt[0].length; i++){  
      	  int x = 0;      
         for (int j = 0; j < arrayalt.length; j++){
         	x = x + arrayalt[j]_;
         }
         neu =x;
      }

      return neu;
   }


somit brauch ich also nicht mehr Zeilen mit Spalten vertauschen und es funktioniert trotzdem 
nochmal Danke  :toll: [/code]_


----------



## Ariol (7. Feb 2008)

Naja, das mit den Codetags hat wohl nicht so geklappt.

Ein kleines Problem bei deinem Code ist, dass es nicht richtig funktioniert, wenn 
1.)Produkt1 in mehr Fillialen vorkommt als Produkt2. (ArrayIndexOutOfBoundsException)
2.) genau umgekehrt (es wird nicht die komplette Summe von Produkt 2 ermittelt)
3.) eine Kombination aus beidem bei mehr als 2 Fillialen vorkommt.

Kannst ja mal versuchen was dann passiert:

Zu 1.)

```
int [][] arrayalt = new int [][] {{1375, 1466,1111},{3232,2525},{565,4365}};
```
Zu 2.

```
int [][] arrayalt = new int [][] {{1375, 1466},{3232,2525,1111},{565,4365}};
```
Zu 3.

```
int [][] arrayalt = new int [][] {{1375, 1466,1111},{3232,2525,1111,2222},{565,4365}};
```


----------

