# Array.sort // Arrays ausgeben



## _Paranormal (7. Mai 2011)

Hallo, habe ein Problem 


```
import java.util.*; 
import java.io.*;

public class Sortarray {
	
	public static int N = 2;

	public static void main(String[] args) {
		int[] array = new int [N];
		System.out.println("Wie viele Punkte: ");
		Scanner sc = new Scanner(System.in);
		int number = sc.nextInt();
		
		for (int i = 0; i < N; ++i) {
			array[i] = (int) (Math.random() * 10);
		}
	
		for (int i = 1; i < array.length; ++i) {
			System.out.println( java.util.Arrays.toString( array ));
		}
		
		System.out.println("Wie soll sortiert werden (1) nach x-Koordinaten," +
				"(2) nach y-Koordinaten oder (3) blockweise?");
		
		Scanner scan = new Scanner(System.in);
		int sort = scan.nextInt();
		java.util.Arrays.sort( array );
        
		System.out.println( java.util.Arrays.toString( array ));
	}
	
}
```

Der int wert "number" soll die Anzahl für die Arrays sein. Krieg es aber irgendwie nicht hin.. Auch mit einer 2. for-Schleife nicht. 

Danke schonmal.


----------



## Final_Striker (7. Mai 2011)

_Paranormal hat gesagt.:


> Der int wert "number" soll die Anzahl für die Arrays sein



Was ist denn die Anzahl eines Arrays?

Meinst du damit vielleicht die Arraygröße?

Edit:

Außerdem, benutzt du die Variable number doch nirgendwo.


----------



## _Paranormal (8. Mai 2011)

Ja genau, ich frage wie viele Punkte es geben soll. Nur leider wird mir nur ein Array ausgegeben. Aber ich möchte gern so viele Arrays, wie der benutzer in der variable number eingibt erhalten.

Es sollte ungefähr so aussehen:
"wie viele Punkte?"
//Abfrage über Kommandozeile

//Ausgabe der zufalls-Arrays
[8,2]
[2,9]
[8,3]
[...]
...


----------



## XHelp (8. Mai 2011)

Dann musst du auch ein 2 Dimensionales array erstellen:

```
int[][] array = new int[number][N]
```


----------



## _Paranormal (8. Mai 2011)

Ich erstelle doch ein 2-dim-Array mit


```
public static int N = 2;
```

und 


```
int[] array = new int [N];
```

oder nicht?


----------



## XHelp (8. Mai 2011)

Da erstellst du eindimensionales Array der Länge 2.


----------



## _Paranormal (8. Mai 2011)

Achso.. Stimmt..


```
System.out.println("Wie viele Punkte: ");
		Scanner sc = new Scanner(System.in);
		int number = sc.nextInt();
		int[][] array = new int [N][number];
		for (int i = 1; i < N; ++i) {
			for (int j = 1; j < number; ++j){
			
				array[i][j] = (int) (Math.random() * 10);
			}
		}
```

Nun bekomm ich aber so eine doofe Ausgabe:
[[I@10b30a7, [I@1a758cb]


----------



## XHelp (8. Mai 2011)

In dem geposteten Code ist überhaupt keine Ausgabe da, deswegen kann man nur vermuten was falsch ist... vermutlich machst du sowas wie:

```
for (int i=0;i<array.length;i++) {
  System.out.println(array[i]);
}
```
Das ist falsch. Vielmehr sollte da sowas wie:

```
for (int i=0;i<array.length;i++) {
  for (int j=0;j<array[i].length;j++) {
    System.out.print(array[i][j]+";");
  }
  System.out.println();
}
```
stehen


----------



## _Paranormal (8. Mai 2011)

Ah, danke, hat mir schon sehr geholfen.

Jetzt sieht mein Code wie folgt aus

```
import java.util.*; 
import java.io.*;

public class Sortarray {
	
	public static int N = 2;

	public static void main(String[] args) {
		
		System.out.println("Wie viele Punkte: ");
		Scanner sc = new Scanner(System.in);
		int number = sc.nextInt();					//number = Anzahl Arrays
		int[][] array = new int [number][N];		//2-dim-Array erstellen
		for (int i = 1; i < N; ++i) {
			array[number][N] = (int) (Math.random() * 10);
													//Zufallszahlen von 0-9 in das Array packen
			
		}
		//hier fehlt mir die Zuweisung für:
		//number * arraysErstellen
		
													//Array ausgeben
		for (int i=0;i<array.length;i++) {
			  for (int j=0;j<array[i].length;j++) {
			    System.out.print(array[i][j]+";");
			  }
			  System.out.println();
		}
```

Allerdings hab ich immer noch das Problem, dass ich keine n-beliebigen Arrays erstellen kann


----------



## XHelp (8. Mai 2011)

Du solltest die Schleife in Zeile 14 noch mal überdenken. Die Eingabe sollte ähnlich wie die Ausgabe sein.


----------



## _Paranormal (8. Mai 2011)

Gut, das hab ich jetzt schonmal raus. 

Allerdings geht meine Sortieung nicht mehr.. ^^ 




```
import java.util.*; 
import java.io.*;

public class Sortarray {
	
	public static int N = 2;

	public static void main(String[] args) {
		
		System.out.println("Wie viele Punkte: ");
		Scanner sc = new Scanner(System.in);
		int number = sc.nextInt();					//number = Anzahl Arrays
		int[][] array = new int [number][N];		//2-dim-Array erstellen
		for (int i = 0; i < array.length; ++i) {
			for (int j = 0; j < array[i].length; j++) {
						
			array[i][j] = (int) (Math.random() * 10);
													//Zufallszahlen von 0-9 in das Array packen
			}
		}
		
													//Array ausgeben
		for (int i=0;i<array.length;i++) {
			  for (int j=0;j<array[i].length;j++) {
			    System.out.print(array[i][j]+";");
			  }
			  System.out.println();
		}

		
		System.out.println("Wie soll sortiert werden (1) nach x-Koordinaten," +
				"(2) nach y-Koordinaten oder (3) blockweise?");
		
		Scanner scan = new Scanner(System.in);
		int sort = scan.nextInt();
									//nach x-Koordinate sortieren
		Arrays.sort( array );
				    
		System.out.println( Arrays.toString( array ));
	}
	
}
```

Kann ich die y-Koordinate nur sortieren, indem ich die Arrays in mehrere aufteile und dann vergleiche und am Ende wieder zusammensetze? Oder gibt es da eine einfache Möglichkeit


----------



## faetzminator (8. Mai 2011)

Wenn du ein 1D Array (oder noch besser eine List) mit einer Klasse [c]Point[/c] verwenden würdest, könntest du dort einfach [c]compareTo()[/c] überschreiben und beliebig nach x und/oder y sortieren.

Edit: hab gerade gesehen, dass das der Benutzer steuern soll. Da kannst du einen Comparator verwenden. Diesen kannst du natürlich auch mit int[] statt Point verwenden. Ist aber nicht hübsch und funktioniert nicht mit Generics...


----------



## _Paranormal (8. Mai 2011)

Ich hab das mal so halbwegs so umgesetzt. Leider weiß ich nicht, ob mein Ansatz richtig ist. Und mit dem Comparator hab ich so meine Probleme. 


```
import java.util.*; 
import java.io.*;

class Koordinaten {
	int[] x;
	int[] y;
	
	public void setX(int[] x) {
		this.x = x;
	}
	
	public int[] getX() {
		return this.x;
	}
	
	public void setY(int[] y) {
		this.y = y;
	}
	
	public int[] getY() {
		return this.y;
	}
}

class Sortieren implements Comparator {
	
	public int compare() {
	
	//.... Weiß ich nicht weiter
	}
}
public class Sortarray {
	
	public static int N = 2;

	public static void main(String[] args) {
		
		System.out.println("Wie viele Punkte: ");
		Scanner sc = new Scanner(System.in);
		int number = sc.nextInt();					//number = Anzahl Arrays
		int[][] array = new int [number][N];		//2-dim-Array erstellen
		for (int i = 0; i < array.length; ++i) {
			for (int j = 0; j < array[i].length; j++) {
						
			array[i][j] = (int) (Math.random() * 10);
													//Zufallszahlen von 0-9 in das Array packen
			}
		}
		
													//Array ausgeben
		for (int i=0;i<array.length;i++) {
			  for (int j=0;j<array[i].length;j++) {
			    System.out.print(array[i][j]+";");
			  }
			  System.out.println();
		}
		
		System.out.println("Wie soll sortiert werden (1) nach x-Koordinaten," +
				"(2) nach y-Koordinaten oder (3) blockweise?");
		
		Scanner scan = new Scanner(System.in);
		int sortNumber = scan.nextInt();
									
	}
}
```

Vielleicht kannst du mir noch einen Tipp geben, wie ich weiter machen könnte.


----------



## XHelp (8. Mai 2011)

Warum hat eine Koordinate ein Array von x-Werten? Und warum wird die Klasse nicht mal benutzt?


----------



## _Paranormal (8. Mai 2011)

Naja, ich habe ja eine X-Koordinate und eine Y-Koordinate. Und dann wollte ich eigentlich den ersten Wert von dem Array an X übergeben und den zweiten Wert an Y damit ich dann nur X mit X vergleichen muss und Y mit Y. 

Oder ist der Ansatz zu kompliziert?


----------



## faetzminator (8. Mai 2011)

schau dir mal mein kleines Beispiel an:


```
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Sortarray {

    public static void main(String[] args) {

        System.out.println("Wie viele Punkte: ");
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt(); // number = Anzahl Arrays
        List<Point> points = new ArrayList<Point>(number);
        while (number-- > 0) {
            int x = (int) (Math.random() * 10);
            int y = (int) (Math.random() * 10);
            points.add(new Point(x, y));
        }

        // Array ausgeben
        for (Point p : points) {
            System.out.println(p);
        }

        System.out.println("Wie soll sortiert werden (1) nach x-Koordinaten,"
                + "(2) nach y-Koordinaten oder (3) blockweise?");

        Scanner scan = new Scanner(System.in);
        final int sortNumber = scan.nextInt();

        if (sortNumber == 1) {
            Collections.sort(points, new Comparator<Point>() {
                @Override
                public int compare(Point p1, Point p2) {
                    return p1.getX() - p2.getX();
                }
            });
        }
        // ...
        
        // Array ausgeben
        for (Point p : points) {
            System.out.println(p);
        }
    }
}

class Point {
    final int x;

    final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return this.x;
    }

    public int getY() {
        return this.y;
    }

    @Override
    public String toString() {
        return getX() + ";" + getY();
    }
}
```

ist dein Code, nur etwas umgeschrieben.


----------



## _Paranormal (8. Mai 2011)

Jetzt noch eine ganz doofe Frage wahrscheinlich.
Du hast das Array ja als Liste erstellt. 

Kann ich das auch mit 


```
int[][] array = new int[number][N]
```

machen und am Ende mit 

```
Arrays.sort(array);
```

machen?


----------



## faetzminator (8. Mai 2011)

Natürlich kannst du statt [c]List<Point>[/c] auch [c]Point[][/c] und [c]Arrays.sort(Point[], Comparator<Point>)[/c] verwenden - wenn du [c]Point[/c] hast musst du "gegen aussen" nicht mehr mit [c]int[/c] arbeiten.


----------



## _Paranormal (8. Mai 2011)

Irgendwie hab ich den falschen Gedanken..


```
int[] point = new int[number];
```

Das ist doch falsch?


```
point.add(int x, int y);
```

Und das scheint auch nicht so zu gehen..


Jetzt hab ichs so.. Aber irgendwie gehts immer noch nicht..


```
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
 
public class Sortarray {
 
    public static void main(String[] args) {
 
        System.out.println("Wie viele Punkte: ");
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt(); // number = Anzahl Arrays
       // List<Point> points = new ArrayList<Point>(number);
        int[] point = new int[number];
        while (number-- > 0) {
            int x = (int) (Math.random() * 10);
            int y = (int) (Math.random() * 10);
        }
        for (int i = 0; i < point.length; i++){
        	System.out.print(point[i]+";");
        }
            System.out.println();

        
/*
 
        // Array ausgeben
        for (Point p : point) {
            System.out.println(p);
        }
 */
        System.out.println("Wie soll sortiert werden (1) nach x-Koordinaten,"
                + "(2) nach y-Koordinaten oder (3) blockweise?");
 
        Scanner scan = new Scanner(System.in);
        final int sortNumber = scan.nextInt();

        
        if (sortNumber == 1) {
            Arrays.sort(point, new Comparator<Point>() {
                @Override
                public int compare(Point p1, Point p2) {
                    return p1.getX() - p2.getX();
                }
            });
        } else {
        if (sortNumber == 2) {
        	Arrays.sort(point, new Comparator<Point>() {
                public int compare(Point p1, Point p2) {
                    return p1.getY() - p2.getY();
                }
        	});
        
        	
        
        
        // Array ausgeben
        for (Point p : points) {
            System.out.println(p);
        }
    }
}
 
class Point {
    final int x;
 
    final int y;
 
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    public int getX() {
        return this.x;
    }
 
    public int getY() {
        return this.y;
    }
 
    @Override
    public String toString() {
        return getX() + ";" + getY();
    }
}
```


Hilfeee... :/


----------



## faetzminator (8. Mai 2011)

Wie gesagt, warum int's? Du willst nur ein Array, keine ints...
Wenn du von meiner geposteten Lösung lediglich die Zeilen beginnend mit [c]List<Point> points = ...[/c] durch

```
Point[] points = new Point[number];
for (int i = 0; i < points.length; i++) {
    int x = (int) (Math.random() * 10);
    int y = (int) (Math.random() * 10);
    points[i] = new Point(x, y);
}
```
und [c]Collections.sort()[/c] durch [c]Arrays.sort()[/c] ersetzt, hast du alles mit einem Array.


----------



## _Paranormal (8. Mai 2011)

Aaaaah, vielen, vielen Dank  Habs nun hinbekommen.


----------



## faetzminator (8. Mai 2011)

Nur noch eine Anmerkung: Wenn das mit dem Array keine Hausaufgabe o.ä. war, dann würde ich dir aber die [c]List[/c] empfehlen.


----------

