# Strings im Array nach Namen sortieren



## Schwupsi (13. Nov 2014)

Hi Leute, brauche bis morgen früh diese Aufgabe, hoffe jemand ist noch auf!

*** String* personen[][] = 
*** { 
***** // Name**** Vorname* Wohnort 
***** {"Meier",** "Sepp",* "Mannheim"}, 
***** {"Huber",** "Anton", "Regensburg"}, 
***** {"Berger",* "Franz", "Passau"}, 
***** {"Winkler", "Hans",* "Regensburg"}, 
***** {"Maler",** "Horst", "Passau"} 
*** };

Dieses Array muss nach den Vornamen sortiert werden. Kämpfe schon seit Tagen mit der Aufgabe, mein Ansatz ist folgender:


```
for(int zeile = 0; zeile < personen.length; zeile++){
		
		String s1 = personen [zeile][1];
		String s2 = personen [zeile][1];
		
		for (int a = 0; a < personen.length; a++)
			s1.compareTo(s2);
			System.out.println(s1.compareTo(s2));
		
		}
```

Freue mich über hilfreiche Tipps


----------



## Gucky (13. Nov 2014)

Dein Ansatz ist, wenn ich das mal so sagen darf, dürftig. Du rufst zwei mal compareTo() auf, eines lässt du verwehen und das Zweite gibst du aus. Wo ist das Sortieren?
Hast du schon gegooglet? In solchen Situationen sollten Google, Bing und Konsorten deine erste Anlaufstelle sein. Hättest du nämlich gegooglet, wärest du sehr schnell auf den BubbleSort Algorithmus gestoßen.
Hier so angewandt, dass du nur die Vornamen vergleichst.

Tipp: 2D String Arrays bestehen aus einem Array vom Typ Stringarray und Stringarrays. Folglich kannst du die Unterarrays umherkopieren.


----------



## Schwupsi (13. Nov 2014)

Bin in der Zwischenzeit auch auf Bubblesort gestoßen! Habe selber eine vor Wochen gelöst ist aber nicht genau das selbe wie hier mit den String Arrays.

Ich weiß wie ich die einzelnen Namen vergleiche, indem ich sie jeweils mit personen [][] aufrufe und miteinander vergleiche, dann kommt irgendwas raus, und dann?


----------



## Schwupsi (14. Nov 2014)

```
int zeile = 0;
	
	String s1 = personen [zeile][1];
	String s2 = personen [zeile+1][1];
	String hilfsstring;
	
	for(int a = 0; a <= personen.length; a++){
	s1.compareTo(s2);
	if (s1.compareTo(s2)>0){
		hilfsstring = personen [zeile+1][1];
	personen [zeile+1][1] = personen [zeile][1];
	personen [zeile][1] = hilfsstring;
	}
	System.out.println(personen[zeile][1]);
	zeile++;
	}
```

Hab das hier erstmal raus, nur gibt er mir den letzten Namen nicht aus, Fehler: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5


----------



## Gucky (14. Nov 2014)

Du hast eine Laufvariable a und benutzt trotzdem die Variable zeile. Das ist unnötig.

Arrays sind null basiert. Wenn du auf den index array.length zugreifst, greifst du auf einen nicht existenten Index zu (<= Bedingung im Schleifenkopf).

Du greifst auf personen[zeile + 1] zu. Das kann nicht funktionieren, weil zeile+ 1 zu groß ist. Genaugenommen einen zu groß.


Wende den BubbleSort doch auf die Unterarrays und dann nur auf den zweiten Eintrag an.


----------



## Nana Le (11. Nov 2017)

Obwohl ich zu spät kommentiere, hoffe ich, dass es nützlich für die anderen ist

```
// hier kommt der Algorithmus zum Sortieren rein:
        for (int zeile = 1; zeile < personen.length; zeile++) {
            for (int spalten = 0; spalten < personen[0].length; spalten++) {
                String vn1 = personen[zeile - 1][1];
                String vn2 = personen[zeile][1];
                if (vn1.compareTo(vn2) > 0) {
                    String hilfsstring = personen[zeile - 1][spalten];
                    personen[zeile - 1][spalten] = personen[zeile][spalten];
                    personen[zeile][spalten] = hilfsstring;
                }
            }
        }

        // Alle Zeilen ausgeben
        for (int zeilen = 0; zeilen < personen.length; zeilen++) {
            for (int spalten = 0; spalten < personen[0].length; spalten++)
                System.out.print(personen[zeilen][spalten] + " ");
            System.out.println();
        }
```


----------



## Javinner (12. Nov 2017)

@Nana Le
So stimmt es aber nicht, denn dein Algorithmus läuft nur ein Mal durch. Siehe Konsolenausgabe:

```
/** Original */
Meier Sepp Mannheim
Huber Anton Regensburg
Berger Franz Passau
Winkler Hans Regensburg
Maler Horst Passau
/** Dein Code */
Huber Anton Mannheim
Berger Franz Passau
Meier Hans Regensburg
Maler Horst Passau
Winkler Sepp Regensburg
```

Aber auch das Durchlaufen des Arrays nach BubbleSort bringt nichts
als Chaos, denn dann werden Namen, Nachnamen und Wohnorte ohne Abhängigkeit sortiert. Denn plötzlich wohnt in Mannheim nicht Sepp Meier, sondern Berger Anton. Siehe Konsolenausgabe:


```
/** Original */
Meier Sepp Mannheim
Huber Anton Regensburg
Berger Franz Passau
Winkler Hans Regensburg
Maler Horst Passau
/** BubbleSort (sortiert nur Spalten) */
Berger Anton Mannheim
Huber Franz Passau
Maler Hans Passau
Meier Horst Regensburg
Winkler Sepp Regensburg
```

Fazit:
Ich würde Person als Klasse programmieren, weil eben dann die Möglichkeit besteht, nach Namen, Nachnamen und Wohnort zu sortieren:

```
Person[] personen = new Person[5];
personen[0] = new Person("Sepp", "Meier", "Mannheim");
personen[1] = new Person("Anton", "Huber", "Regensburg");
personen[2] = new Person("Franz", "Berger", "Passau");
personen[3] = new Person("Hans", "Winkler", "Regensburg");
personen[4] = new Person("Horst", "Maler", "Passau");

System.out.println("Original");
druckeInfoPerson(personen);
sortiereNachName(personen);
druckeInfoPerson(personen);
sortiertNachNachname(personen);
druckeInfoPerson(personen);
sortiertNachWohnort(personen);
druckeInfoPerson(personen);
/** Konsolenausgabe */
run:
Original
Name: Sepp, Nachname: Meier, Wohnort: Mannheim
Name: Anton, Nachname: Huber, Wohnort: Regensburg
Name: Franz, Nachname: Berger, Wohnort: Passau
Name: Hans, Nachname: Winkler, Wohnort: Regensburg
Name: Horst, Nachname: Maler, Wohnort: Passau
Sortiert: nach Name
Name: Anton, Nachname: Huber, Wohnort: Regensburg
Name: Franz, Nachname: Berger, Wohnort: Passau
Name: Hans, Nachname: Winkler, Wohnort: Regensburg
Name: Horst, Nachname: Maler, Wohnort: Passau
Name: Sepp, Nachname: Meier, Wohnort: Mannheim
Sortiert: nach Nachname
Name: Franz, Nachname: Berger, Wohnort: Passau
Name: Anton, Nachname: Huber, Wohnort: Regensburg
Name: Horst, Nachname: Maler, Wohnort: Passau
Name: Sepp, Nachname: Meier, Wohnort: Mannheim
Name: Hans, Nachname: Winkler, Wohnort: Regensburg
Sortiert: nach Wohnort
Name: Sepp, Nachname: Meier, Wohnort: Mannheim
Name: Franz, Nachname: Berger, Wohnort: Passau
Name: Horst, Nachname: Maler, Wohnort: Passau
Name: Anton, Nachname: Huber, Wohnort: Regensburg
Name: Hans, Nachname: Winkler, Wohnort: Regensburg
BUILD SUCCESSFUL (total time: 0 seconds)
```



Spoiler: Klasse Person





```
class Person
{

    private String name;
    private String nachname;
    private String wohnort;

    public Person()
    {

    }

    public Person(String name, String nachname, String wohnort)
    {
        this.name = name;
        this.nachname = nachname;
        this.wohnort = wohnort;
    }

    public String getName()
    {
        return name;
    }

    public String getNachname()
    {
        return nachname;
    }

    public String getWohnort()
    {
        return wohnort;
    }

    public void setWohnort(String wohnort)
    {
        this.wohnort = wohnort;
    }

    @Override
    public String toString()
    {
        return "Name: " + this.name + ", Nachname: " + this.nachname + ", Wohnort: " + this.wohnort;
    }

}
```





edit: Da gibt es sicher noch weitere Lösungen, wie zum Beispiel diese Vorgehensweise: http://openbook.rheinwerk-verlag.de/javainsel/javainsel_08_001.html


----------



## Nana Le (12. Nov 2017)

@Javine
Vielen Dank fuer Ihre Korrektur.
Das ist mein Fehler, ich habe nur "Vorname" gesehen.
Jetzt mache ich besser.

```
String[][] personen = {
                // Name Vorname Wohnort
                { "Meier", "Sepp", "Mannheim" }, // personen[0]
                { "Huber", "Anton", "Regensburg" }, // personen[1]
                { "Berger", "Franz", "Passau" }, // personen[2]
                { "Winkler", "Hans", "Regensburg" }, // personen[3]
                { "Maler", "Horst", "Passau" } // personen[4]
        };

        // hier kommt der Algorithmus zum Sortieren rein:
        for (int zeile = 1; zeile < personen.length; zeile++) {
            for (int spalten = 0; spalten < personen[0].length; spalten++) {
                String vn1 = personen[zeile - 1][1];
                String vn2 = personen[zeile][1];
                if (vn1.compareTo(vn2) > 0) {
                    String[] hilfsstring = personen[zeile - 1];
                    personen[zeile - 1] = personen[zeile];
                    personen[zeile] = hilfsstring;
                }
            }
        }

        // Alle Zeilen ausgeben
        for (int zeilen = 0; zeilen < personen.length; zeilen++) {
            for (int spalten = 0; spalten < personen[0].length; spalten++)
                System.out.print(personen[zeilen][spalten] + " ");
            System.out.println();
        }
    }
```


----------



## Javinner (12. Nov 2017)

Nana Le hat gesagt.:
			
		

> Jetzt mache ich besser


Nein, machst du nicht. Weißt du wie ein BoobleSort geht?

```
package javaapplication216;


public class JavaApplication216
{

 
    public static void main(String[] args)
    {
        String[][] personen = {
            // Name Vorname Wohnort
            {"Meier", "Sepp", "Mannheim"}, // personen[0]
            {"Huber", "Anton", "Regensburg"}, // personen[1]
            {"Berger", "Franz", "Passau"}, // personen[2]
            {"Winkler", "Hans", "Regensburg"}, // personen[3]
            {"Maler", "Horst", "Passau"} // personen[4]
        };
      
        //Hier bilde ich das Original-Array personen ab;
        for (int zeilen = 0; zeilen < personen.length; zeilen++) {
            for (int spalten = 0; spalten < personen[0].length; spalten++) {
                System.out.print(personen[zeilen][spalten] + " ");
            }
            System.out.println();
        }
      
        System.out.println("------------------------------------------------------");
      

        // hier kommt der Algorithmus zum Sortieren rein:
        for (int zeile = 1; zeile < personen.length; zeile++) {
            for (int spalten = 0; spalten < personen[0].length; spalten++) {
                String vn1 = personen[zeile - 1][1];
                String vn2 = personen[zeile][1];
                if (vn1.compareTo(vn2) > 0) {
                    String[] hilfsstring = personen[zeile - 1];
                    personen[zeile - 1] = personen[zeile];
                    personen[zeile] = hilfsstring;
                }
            }
        }

        // Alle Zeilen ausgeben
        for (int zeilen = 0; zeilen < personen.length; zeilen++) {
            for (int spalten = 0; spalten < personen[0].length; spalten++) {
                System.out.print(personen[zeilen][spalten] + " ");
            }
            System.out.println();
        }
    }
}
/** Konsolenausgabe */
run:
Meier Sepp Mannheim
Huber Anton Regensburg
Berger Franz Passau
Winkler Hans Regensburg
Maler Horst Passau
------------------------------
Huber Anton Regensburg
Berger Franz Passau
Winkler Hans Regensburg
Maler Horst Passau
Meier Sepp Mannheim
BUILD SUCCESSFUL (total time: 0 seconds)
```
edit:
Ändere doch einfach ein Namen und teste:

```
String[][] personen = {
            // Name Vorname Wohnort
            {"Meier", "Sepp", "Mannheim"}, // personen[0]
            {"Huber", "Anton", "Regensburg"}, // personen[1]
            {"Berger", "Franz", "Passau"}, // personen[2]
            {"Winkler", "Anatolij", "Regensburg"}, // personen[3]
            {"Maler", "Horst", "Passau"} // personen[4]
        };
/** Konsolenausgabe */
run:
Meier Sepp Mannheim 
Huber Anton Regensburg 
Berger Franz Passau 
Winkler Anatolij Regensburg 
Maler Horst Passau 
------------------------------------------------------
Huber Anton Regensburg 
Berger Franz Passau 
Winkler Anatolij Regensburg /** Hier! */
Maler Horst Passau 
Meier Sepp Mannheim 
BUILD SUCCESSFUL (total time: 0 seconds)
```


----------



## Javinner (12. Nov 2017)

Man könnte die Ausgabe durchaus verfeinern:
Hier ziehe ich mir zur Hilfe ein Enum Auswahl

```
Person verwalter = new Person();
Person[] personen = new Person[5];
personen[0] = new Person("Sepp", "Meier", "Mannheim");
personen[1] = new Person("Anton", "Huber", "Regensburg");
personen[2] = new Person("Franz", "Berger", "Passau");
personen[3] = new Person("Hans", "Winkler", "Regensburg");
personen[4] = new Person("Horst", "Maler", "Passau");
     
System.out.println("Original");
verwalter.druckeInfoPerson(personen, Auswahl.UNSORTIERT);
verwalter.sortiereNachName(personen);
verwalter.druckeInfoPerson(personen,Auswahl.NAME);
verwalter.sortiertNachNachname(personen);
verwalter.druckeInfoPerson(personen, Auswahl.NACHNAME);
verwalter.sortiertNachWohnort(personen);
verwalter.druckeInfoPerson(personen, Auswahl.WOHNORT);

/** Konsolenausgabe */

run:
Original
Name: Sepp, Nachname: Meier, Wohnort: Mannheim
Name: Anton, Nachname: Huber, Wohnort: Regensburg
Name: Franz, Nachname: Berger, Wohnort: Passau
Name: Hans, Nachname: Winkler, Wohnort: Regensburg
Name: Horst, Nachname: Maler, Wohnort: Passau
Sortiert: nach Name
Name: Anton, Nachname: Huber, Wohnort: Regensburg
Name: Franz, Nachname: Berger, Wohnort: Passau
Name: Hans, Nachname: Winkler, Wohnort: Regensburg
Name: Horst, Nachname: Maler, Wohnort: Passau
Name: Sepp, Nachname: Meier, Wohnort: Mannheim
Sortiert: nach Nachname
Nachname: Berger, Name: Franz, Wohnort: Passau
Nachname: Huber, Name: Anton, Wohnort: Regensburg
Nachname: Maler, Name: Horst, Wohnort: Passau
Nachname: Meier, Name: Sepp, Wohnort: Mannheim
Nachname: Winkler, Name: Hans, Wohnort: Regensburg
Sortiert: nach Wohnort
Wohnort: Mannheim, Name: Sepp, Nachname: Meier
Wohnort: Passau, Name: Franz, Nachname: Berger
Wohnort: Passau, Name: Horst, Nachname: Maler
Wohnort: Regensburg, Name: Anton, Nachname: Huber
Wohnort: Regensburg, Name: Hans, Nachname: Winkler
BUILD SUCCESSFUL (total time: 0 seconds)
```



Spoiler: Enum: Auswahl





```
public enum Auswahl
{
    NAME, NACHNAME, WOHNORT, UNSORTIERT;
}
```


----------



## Nana Le (12. Nov 2017)

Javinner hat gesagt.:


> Nein, machst du nicht. Weißt du wie ein BoobleSort geht?
> Aufgabe: Dieses Array muss nach den Vornamen sortiert werden
> Ausgabe: war richtig
> Ich bin Anfängerin
> Wie kann ich anders schreiben.


----------



## Javinner (12. Nov 2017)

http://www.java-uni.de/index.php?Seite=85


----------

