will einfach nicht sortieren!

[Hoppelbärchen]

Hallo und guten morgen
ich hoff ihr könnt mir schnell bei meinem Problemchen helfen. Muss morgen mein programm abgeben, klappt "eigentlich" alles, nur....
nunja unsre aufgabe war es, teilnehmer(mit namen,vornamen,..)aufzunehmen (klappt!) sie dann in gruppen einzuteilen(klappt) und DANN eine Liste auszugeben auf wunsch, in der alle teilnehmer nach nachnamen (und bei gleichem nachnamen,nach vornamen) sortiert sein sollen. Und das macht er mir nicht. jedes mal wenn ich den Befehl eingebe, er soll mir die Liste ausgeben, kommt eine fehlermeldung.

was fehlt, oder gar stimmt nicht.
man hat mir auch schon gesagt ne zweite schleife müsst her, habe jedoch keinen plan warum und vorallem wohin.
andre sagen mit if else wurds auch gehen, nur hab ich da das selbe problem....

hilfe.
danke

private TeilnehmendePerson[] sortiereTeilnehmerlisteNurNachNachnamen(TeilnehmendePerson[] zuSortierendeListe)  {
		
			TeilnehmendePerson[]sortBereich = null;
			/*
			 * schaut nach ob die nachnamen schon sortiert sind, ansonsten werden sie sortiert
			 */
			sortBereich = new TeilnehmendePerson [zuSortierendeListe.length];
		
			System.arraycopy(zuSortierendeListe, 0, sortBereich, 0, zuSortierendeListe.length);
			int i,j;//Variablen die man zum vergleichen braucht
			TeilnehmendePerson teilnehmer;
			

 /*
  * sobald man mindestens zwei namen eingegeben hat, wird mit dem sortieren angefangen.
  */
			for ( i=0; i<sortBereich.length-1; i++) {
			teilnehmer = sortBereich[i]; 
			j=i;
			
/*
 * es wird nach nachnamen geschaut und sortiert
 */
		
				
			
			
			while (sortBereich[j-1].getNachname().compareToIgnoreCase(teilnehmer.getNachname())<0)  {
			sortBereich[j]=sortBereich[j-1];
			j--;
			}
		
			sortBereich[j]=teilnehmer;
			}
			//der erste teilnehmer wird dann ausgeschlossen und nicht wieder verglichen.
			System.arraycopy(sortBereich, 1, zuSortierendeListe, 0, zuSortierendeListe.length);
			

		
return zuSortierendeListe ;}

 

[WieselAc]

Wenn du nicht einen speziellen Algorithmus verwenden sollst, würd ich dir empfehlen den folgenden Thread mal anzuschauen. Da steht sehr sehr gut erklärt wie man Arrays (und alles andere) sortiert:

www.java-forum.org/de/viewtopic.php?p=251024

 

[Hoppelbärchen]

bin mir nicht sicher ob ihr meine ganze Klasse benötigt, darum geb ich sie lieber mal

package gpiUebungen;

/**
 * Ein Objekt dieser Klasse stellt alle Uebungsgruppen dar. Hier wird der
 * Teilnehmer in eine Gruppe aufgenommen. Außerdem werden die Listen nach
 * Nachnamen alphabetisch sortiert
 * 
 *
 * @version 1.3 vom 14.01.2007
 */
public class Uebungsgruppen {

	/**
	 * Festlegung der maximalen Anzahl von Gruppen.
	 */
	public final static int MAX_ANZAHL_GRUPPE = 3;

	/**
	 * Festlegung der maximalen Anzahl von Teilnehmer einer Gruppe.
	 */
	public final static int MAX_ANZAHL_TEILNEHMER = 20;

	
	/**
	 * Konstante,welche zu Beginn alle Gruppengroeßen auf null setzt.
	 */
	private int anzahlTeilnehmer = 0;

	/**
	 * Hier werden die TeilnehmendenPersonen Objekte gespeichert, jedoch nicht
	 * dauerhaft. Die größe des Arrays ist festgelegt durch die
	 * MAX_ANZAHL_TEILNEHMER * MAX_ANZAHL_GRUPPE
	 */
	TeilnehmendePerson[] teilnehmerliste = new TeilnehmendePerson[MAX_ANZAHL_TEILNEHMER
			* MAX_ANZAHL_GRUPPE];

	/**
	 * Beitritt eines neuen Teilnehmers in eine Gruppe
	 * 
	 * @param naechsteTeilnehmendePerson
	 *            Person die einer Gruppe beitreten will.
	 * @return eingabeOK wenn ein Teilnehmer aufgenommen werden konnte wird
	 *         dieser uebergeben
	 */
	public boolean beitritt(TeilnehmendePerson naechsteTeilnehmendePerson) {
		boolean eingabeOK;
		if (anzahlTeilnehmer < teilnehmerliste.length) {
			teilnehmerliste[anzahlTeilnehmer] = naechsteTeilnehmendePerson;

			anzahlTeilnehmer++;
			eingabeOK = true;
		} else {
			eingabeOK = false;
		}
		return eingabeOK;

	}

	/**
	 * Diese Methode ermoeglicht eine alphabetische Sortierung der Teilnehmer
	 * nach Nachnamen, bei gleichem Nachnamen nach Vornamen.
	 * 
	 * @param zuSortierendeListe
	 *            Liste von Teilnehmern, die sortiert werden soll
	 * @return alphabetisch nach Nachnamen sortierte Liste
	 */

		
		private TeilnehmendePerson[] sortiereTeilnehmerlisteNurNachNachnamen(TeilnehmendePerson[] zuSortierendeListe)  {
		
			TeilnehmendePerson[]sortBereich = null;
			/*
			 * schaut nach ob die nachnamen schon sortiert sind, ansonsten werden sie sortiert
			 */
			sortBereich = new TeilnehmendePerson [zuSortierendeListe.length];
		
			System.arraycopy(zuSortierendeListe, 0, sortBereich, 0, zuSortierendeListe.length);
			int i,j;//Variablen die man zum vergleichen braucht
			TeilnehmendePerson teilnehmer;
			

 /*
  * sobald man mindestens zwei namen eingegeben hat, wird mit dem sortieren angefangen.
  */
			for ( i=0; i<sortBereich.length-1; i++) {
			teilnehmer = sortBereich[i]; 
			j=i;
			
/*
 * es wird nach nachnamen geschaut und sortiert
 */
		
				
			
			
			while (sortBereich[j-1].getNachname().compareToIgnoreCase(teilnehmer.getNachname())<0)  {
			sortBereich[j]=sortBereich[j-1];
			j--;
			}
		
			sortBereich[j]=teilnehmer;
			}
			//der erste teilnehmer wird dann ausgeschlossen und nicht wieder verglichen.
			System.arraycopy(sortBereich, 1, zuSortierendeListe, 0, zuSortierendeListe.length);
			
		
return zuSortierendeListe ;}


	
		/**
		 * Diese Methode ermoeglicht eine Sortierung nach Nachnamen und zusaetzlich nach den Gruppen
		 * @return gruppenListe welche auch alphabetisch sortiert wurde
		 */
		public TeilnehmendePerson[] sortiereTeilnehmerZusaetzlichNachGruppen(){
			
			
			
			
			
			return null;
		}
		

	/**
	 * array um alle aufgenommenen Teilnehmer aller Gruppen zu verwalten
	 * 
	 * @return alle aufgenommenen Teilnehmer der Gruppen
	 */
	public TeilnehmendePerson[] getAlleTeilnehmer() {
		this.sortiereTeilnehmerlisteNurNachNachnamen(teilnehmerliste);
		return teilnehmerliste;
	}
	
	/**
	 * @param uebungsgruppe uebungsgruppe in welcher die einzelnen Teilnehmer sind
	 * @return alle Teilnehmer der Gruppen
	 */
public TeilnehmendePerson[] getTeilnehmerNachGruppen(int uebungsgruppe){
	return null;
}
	/**
	 * Die aktuelle Anzahl der Teilnehmer wird uebergeben
	 * 
	 * @param uebungsgruppe
	 * @return die aktuelle Anzahl der einzelnen Gruppen
	 */

	public int getAnzahlAllerTeilnehmerEinerGruppe(int uebungsgruppe) {
		return 0;
	}

	

}// end class Uebungsgruppen

 

[Hoppelbärchen]

Wenn du nicht einen speziellen Algorithmus verwenden sollst, würd ich dir empfehlen den folgenden Thread mal anzuschauen. Da steht sehr sehr gut erklärt wie man Arrays (und alles andere) sortiert:

www.java-forum.org/de/viewtopic.php?p=251024

Ich darf nur leider keinen fertigen algorithmus verwenden

 

[WieselAc]

Ok, dann mal hier eine richtige Version des Bubbelsort (glaub zumindest das du den versucht hast). Ist zwar nicht gerade optimal und lässt sich noch optimieren, aber es klappt auf jeden fall. hab es mal mit Strings probiert:

    public static void main(String[] args) {
        String[] namen = { "Aman", "Cman", "Zman", "Bfrau", "Aman", "Fman", "dfrau", "Bman" };
        for (int i = 0; i < namen.length; i++) {
            System.out.println(namen[i]);
        }
        System.out.println();
        namen = sortiereTeilnehmerlisteNurNachNachnamen(namen);
        System.out.println();
        for (int i = 0; i < namen.length; i++) {
            System.out.println(namen[i]);
        }
    }

    private static String[] sortiereTeilnehmerlisteNurNachNachnamen(
            String[] zuSortierendeListe) {
        for (int i = 0; i < zuSortierendeListe.length; i++) {
            for (int j = i; j < zuSortierendeListe.length; j++) {
                if (zuSortierendeListe[i]
                        .compareToIgnoreCase(zuSortierendeListe[j]) > 0) {
                    String tmp = zuSortierendeListe[i];
                    zuSortierendeListe[i] = zuSortierendeListe[j];
                    zuSortierendeListe[j] = tmp;
                }
            }
        }
        return zuSortierendeListe;
    }

 

[Hoppelbärchen]

hm, da is bei mir (natürlich) einiges rot. muss beides in eine klasse? nee oder? denn die main methode habe ich ja in der "benutzerkommunikation"

 

[WieselAc]

Ok warte mal kurz bau die die namen so das es mit copy und paste klappt ....

 

[WieselAc]

aber demnächst wird sowas selber gemacht!!!!!

    private static TeilnehmendePerson[] sortiereTeilnehmerlisteNurNachNachnamen(
            TeilnehmendePerson[] zuSortierendeListe) {
        for (int i = 0; i < zuSortierendeListe.length; i++) {
            for (int j = i; j < zuSortierendeListe.length; j++) {
                if (zuSortierendeListe[i].getNachname()
                        .compareToIgnoreCase(zuSortierendeListe[j].getNachname()) > 0) {
                    TeilnehmendePerson tmp = zuSortierendeListe[i];
                    zuSortierendeListe[i] = zuSortierendeListe[j];
                    zuSortierendeListe[j] = tmp;
                }
            }
        }
        return zuSortierendeListe;
    }

 

[Hoppelbärchen]

oke danke!
nur noch etwas...
Null Pointer Exception heißt was?

nix is rot :x

 

[WieselAc]

das heißt das du auf etwas zugreifst, das noch nicht initialisiert wurde.

EDIT:

Kommt bestimmt daher, dass du sagst in deinem Array sind 20 Elemente drin. Das bedeutet, dein Array hat die Größe 20. Allerdings musst du dann auch alle 20 Plätze mit Personen füllen. Ansonsten gekommst du Probleme (NullPointerException), wenn du auf ein Objekt zugreifst, das noch null ist.


Lösung:
Wenn du dein Array nicht durch eine dynamische Liste austauschen willst/kannst, musst du immer abfragen ob dein array an der gewünschten Stelle ungleich null ist.

 

[Hoppelbärchen]

das heißt das du auf etwas zugreifst, das noch nicht initialisiert wurde.

EDIT:

Kommt bestimmt daher, dass du sagst in deinem Array sind 20 Elemente drin. Das bedeutet, dein Array hat die Größe 20. Allerdings musst du dann auch alle 20 Plätze mit Personen füllen. Ansonsten gekommst du Probleme (NullPointerException), wenn du auf ein Objekt zugreifst, das noch null ist.


Lösung:
Wenn du dein Array nicht durch eine dynamische Liste austauschen willst/kannst, musst du immer abfragen ob dein array an der gewünschten Stelle ungleich null ist.

WOW SPITZE ES SORTIERT
TAUSEND DANK

 

[Hoppelbärchen]

nur wenn der nachname gleich is....

muss man da dann noch das =0 überprüfen?



EDIT

habs durch probieren hinbekommen

 

[WieselAc]

Sehr gut.

Dan bekommst du jetzt einen kleinen Tipp von mir, sortier direkt den ganzen Namen:

    private static TeilnehmendePerson[] sortiereTeilnehmerlisteNurNachNachnamen(
            TeilnehmendePerson[] zuSortierendeListe) {
        for (int i = 0; i < zuSortierendeListe.length; i++) {
            String name1 = zuSortierendeListe[i].getNachname() + zuSortierendeListe[i].getVorname();
            for (int j = i; j < zuSortierendeListe.length; j++) {
                String name2 = zuSortierendeListe[j].getNachname() + zuSortierendeListe[j].getVorname();
                if (name1.compareToIgnoreCase(name2) > 0) {
                    TeilnehmendePerson tmp = zuSortierendeListe[i];
                    zuSortierendeListe[i] = zuSortierendeListe[j];
                    zuSortierendeListe[j] = tmp;
                }
            }
        }
        return zuSortierendeListe;
    }

 

[Hoppelbärchen]

wow cool, das funktioniert ja auch (ach nee)

vllt hast ja im code schon gesehen, ich muss auch in ner andren liste nach gruppen sortieren. da nehm ich wohl den gleichen code, und tu danach dann nochmals nach gruppen sortieren?
kann ich dann einfach sagen: hm, ja wie mach ich das. weil dann muss ich ja nach "int" sortieren? weil die uebeungsgruppen ja keine Strings sind.

 

[WieselAc]

Ich glaub das schaffst du allein


if der if abfrage wird ja überprüft welches größer ist. Und diese Überprüfung ist bei Strings ja schwerer als bei ints. Von daher probieren

 

[Hoppelbärchen]

ich bekomm einfach dieses NullPointerException nicht weg

hab java ist auch eine insel durchgeblättert
und das forum hier durchstöbert.

wie kann man "dem array sagen, schauen wos null is??" hä

 

[WieselAc]

du machst eine abfrage if auf null



=>

    private static TeilnehmendePerson[] sortiereTeilnehmerlisteNurNachNachnamen(
            TeilnehmendePerson[] zuSortierendeListe) {
        for (int i = 0; i < zuSortierendeListe.length; i++) {
            if(zuSortierendeListe[i] == null) {
                continue;
            }
            String name1 = zuSortierendeListe[i].getNachname() + zuSortierendeListe[i].getVorname();
            for (int j = i; j < zuSortierendeListe.length; j++) {
                if(zuSortierendeListe[j] == null) {
                     continue;
                }
                String name2 = zuSortierendeListe[j].getNachname() + zuSortierendeListe[j].getVorname();
                if (name1.compareToIgnoreCase(name2) > 0) {
                    TeilnehmendePerson tmp = zuSortierendeListe[i];
                    zuSortierendeListe[i] = zuSortierendeListe[j];
                    zuSortierendeListe[j] = tmp;
                }
            }
        }
        return zuSortierendeListe;
    }

Ist allerdinsg nicht gerade üblich. Normlerweise würd man in so einem Fall eine Liste nehmen, ich denke aber mal das ist ein bischen viel für den Anfang, von daher sollte da reichen. Hab es allerdings nicht getestet.

Es soll jedenfalls so funktionieren. Wenn er versucht ein Feld zu nehmen, in dem noch keine Person steht (welches also null ist), dann sortiere für dieses Feld nicht weiter (continue) und prüfe das nächste. Alternative könntest du, statt nur den aktuelen schleifendurchlauf zu beenden (continue), die ganze schleife beeenden(break). Musst du selber entscheiden.

 

[Hoppelbärchen]

oke danke
leider sortiert er jetzt nicht mehr

aber das is en andres problem. bei meiner gruppenliste gibt er mir jeden teilnehemer in jeder gruppe.
dh er nimmt die menschen nicht in die gruppen auf

public TeilnehmendePerson[] getTeilnehmerNachGruppen(int uebungsgruppe) {

		Uebungsgruppen.sortiereTeilnehmerlisteNurNachNachnamen(teilnehmerliste);
		return teilnehmerliste;
		//hier muss man noch nach gruppen sortieren. und ein array herstellen für die gruppen.

	}

wenn ich mir eine liste fuer die gruppen geben lasse, gibt er mir alle namen dreimal aus, weils drei gruppen sind. obwohl ich die person eigenlich zb in gruppe1 getan habe

 

[Hoppelbärchen]

bekomm einfach kein betreuer...

vllt findet man ja schnell den fehler warum er aufeinmal nicht mehr sortiert??

package gpiUebungen;

/**
 * Ein Objekt dieser Klasse stellt alle Uebungsgruppen dar. Hier wird der
 * Teilnehmer in eine Gruppe aufgenommen. Außerdem werden die Listen nach
 * Nachnamen alphabetisch sortiert
 * 
 *
 */
public class Uebungsgruppen {

	/**
	 * Festlegung der maximalen Anzahl von Gruppen.
	 */
	public final static int MAX_ANZAHL_GRUPPE = 3;

	/**
	 * Festlegung der maximalen Anzahl von Teilnehmer einer Gruppe.
	 */
	public final static int MAX_ANZAHL_TEILNEHMER = 20;
	
	/**
	 * 
	 */
	public final static int MAX_SEMESTER = 10;


	/**
	 * Konstante,welche zu Beginn alle Gruppengroeßen auf null setzt.
	 */
	private int anzahlTeilnehmer = 0;

	/**
	 * Hier werden die TeilnehmendenPersonen Objekte gespeichert, jedoch nicht
	 * dauerhaft. Die größe des Arrays ist festgelegt durch die
	 * MAX_ANZAHL_TEILNEHMER * MAX_ANZAHL_GRUPPE
	 */
	/*
	 * wichtig ist hier, dass man die richtige größe des Arrays festlegt. ist
	 * das array naemlich noch nicht voll, sortiert er nihct bzw gibt eine
	 * NullPointerException aus
	 */

	
	 TeilnehmendePerson[] teilnehmerliste = new
	 TeilnehmendePerson[MAX_ANZAHL_TEILNEHMER * MAX_ANZAHL_GRUPPE];
	
	//TeilnehmendePerson[] teilnehmerliste = new TeilnehmendePerson[3];



	/**
	 * Beitritt eines neuen Teilnehmers in eine Gruppe
	 * 
	 * @param naechsteTeilnehmendePerson
	 *            Person die einer Gruppe beitreten will.
	 * @return eingabeOK wenn ein Teilnehmer aufgenommen werden konnte wird
	 *         dieser uebergeben
	 */
	public boolean beitritt(TeilnehmendePerson naechsteTeilnehmendePerson) {
		boolean eingabeOK;
		if /*
			 * (naechsteTeilnehmendePerson.getUebungsgruppe() <=
			 * MAX_ANZAHL_TEILNEHMER)
			 */
		(anzahlTeilnehmer < teilnehmerliste.length) {
			teilnehmerliste[anzahlTeilnehmer] = naechsteTeilnehmendePerson;

			anzahlTeilnehmer++;
			eingabeOK = true;
		} else {
			eingabeOK = false;
		}
		return eingabeOK;

	}

	/**
	 * Diese Methode ermoeglicht eine alphabetische Sortierung der Teilnehmer
	 * nach Nachnamen, bei gleichem Nachnamen nach Vornamen.
	 * 
	 * @param zuSortierendeListe
	 *            Liste von Teilnehmern, die sortiert werden soll
	 * @return alphabetisch nach Nachnamen sortierte Liste
	 */

	/*
	 * private static TeilnehmendePerson[]
	 * sortiereTeilnehmerlisteNurNachNachnamen( TeilnehmendePerson[]
	 * zuSortierendeListe) { for (int i = 0; i < zuSortierendeListe.length; i++) {
	 * for (int j = i; j < zuSortierendeListe.length; j++) { if
	 * (zuSortierendeListe[i].getNachname().compareToIgnoreCase(
	 * zuSortierendeListe[j].getNachname()) > 0) { TeilnehmendePerson tmp =
	 * zuSortierendeListe[i]; zuSortierendeListe[i] = zuSortierendeListe[j];
	 * zuSortierendeListe[j] = tmp; }
	 *  // bei gleichem Nachnamen wird nach Vornamen sortiert.
	 * 
	 * else if (zuSortierendeListe[i] .getVorname()
	 * .compareToIgnoreCase(zuSortierendeListe[j].getVorname()) > 0) {
	 * TeilnehmendePerson tmp = zuSortierendeListe[i]; zuSortierendeListe[i] =
	 * zuSortierendeListe[j]; zuSortierendeListe[j] = tmp; } } } return
	 * zuSortierendeListe; }
	 */
	private static TeilnehmendePerson[] sortiereTeilnehmerlisteNurNachNachnamen( 
            TeilnehmendePerson[] zuSortierendeListe) { 
        for (int i = 0; i < zuSortierendeListe.length; i++) { 
            if(zuSortierendeListe[i] == null) { 
                continue; 
            } 
            String name1 = zuSortierendeListe[i].getNachname() + zuSortierendeListe[i].getVorname(); 
            for (int j = i; j < zuSortierendeListe.length; j++) { 
                if(zuSortierendeListe[j] == null) { 
                     continue; 
                } 
                String name2 = zuSortierendeListe[j].getNachname() + zuSortierendeListe[j].getVorname(); 
                if (name1.compareToIgnoreCase(name2) > 0) { 
                    TeilnehmendePerson tmp = zuSortierendeListe[i]; 
                    zuSortierendeListe[i] = zuSortierendeListe[j]; 
                    zuSortierendeListe[j] = tmp; 
                } 
            } 
        } 
        return zuSortierendeListe; 
    } 

	
	
	


	/**
	 * array um alle aufgenommenen Teilnehmer aller Gruppen zu verwalten
	 * 
	 * @return alle aufgenommenen Teilnehmer der Gruppen
	 */
	public TeilnehmendePerson[] getAlleTeilnehmer() {
		// Uebungsgruppen.sortiereTeilnehmerlisteNurNachNachnamen(teilnehmerliste);
		return teilnehmerliste;
	}

	/**
	 * Methode zur Rueckgabe der Teilnehmer in einer Gruppe
	 * 
	 * @param uebungsgruppe
	 *            uebungsgruppe in welcher die einzelnen Teilnehmer sind
	 * @return alle Teilnehmer der Gruppe
	 */
	public TeilnehmendePerson[] getTeilnehmerNachGruppen(int uebungsgruppe) {

		Uebungsgruppen.sortiereTeilnehmerlisteNurNachNachnamen(teilnehmerliste);
		return teilnehmerliste;
		//hier muss man noch nach gruppen sortieren. und ein array herstellen für die gruppen.

	}

	/**
	 * Die aktuelle Anzahl der Teilnehmer wird uebergeben
	 * 
	 * 
	 * @return die aktuelle Anzahl der einzelnen Gruppen
	 */

	public int getAnzahlAllerTeilnehmer() {

		return anzahlTeilnehmer;

	}

}// end class Uebungsgruppen

 

[Hoppelbärchen]

also ich weiß jetzt dass ich die methode die beide aufeinmal sortiert nich machen darf. ich muss diese nehemen:

private static TeilnehmendePerson[]
	 sortiereTeilnehmerlisteNurNachNachnamen( TeilnehmendePerson[]
	 zuSortierendeListe) { for (int i = 0; i < zuSortierendeListe.length; i++) {
	  for (int j = i; j < zuSortierendeListe.length; j++) { if
	  (zuSortierendeListe[i].getNachname().compareToIgnoreCase(
	  zuSortierendeListe[j].getNachname()) > 0) { TeilnehmendePerson tmp =
	  zuSortierendeListe[i]; zuSortierendeListe[i] = zuSortierendeListe[j];
	  zuSortierendeListe[j] = tmp; }
	   // bei gleichem Nachnamen wird nach Vornamen sortiert.
	  
	  else if (zuSortierendeListe[i] .getVorname()
	  .compareToIgnoreCase(zuSortierendeListe[j].getVorname()) > 0) {
	  TeilnehmendePerson tmp = zuSortierendeListe[i]; zuSortierendeListe[i] =
	  zuSortierendeListe[j]; zuSortierendeListe[j] = tmp; } } } return
	  zuSortierendeListe; }

nur leider fehlt da die bedingung dass er den gleichen nachnamen hat??

 

[WieselAc]

habs jetzt nochmal was umgebaut, das mit den null elementen verträgt sich itt sogut mit dem sortieren...

Auf jeden Fall gehts jetzt. Allerdings müssen die null Elemente alle hintereinander am Ende sein (Sollte bei dir der Fall sein).

    public static TeilnehmendePerson sortiereTeilnehmerlisteNurNachNachnamen(
            TeilnehmendePerson[] zuSortierendeListe) {

        for (int i = zuSortierendeListe.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if(zuSortierendeListe[j]==null || zuSortierendeListe[j+1]== null){
                    break;
                }
                String name1 = zuSortierendeListe[j].getNachname()
                        + zuSortierendeListe[j].getVorname();
                String name2 = zuSortierendeListe[j + 1].getNachname()
                        + zuSortierendeListe[j + 1].getVorname();
                if (name1.compareToIgnoreCase(name2) > 0) {
                    TeilnehmendePerson temp = zuSortierendeListe[j];
                    zuSortierendeListe[j] = zuSortierendeListe[j + 1];
                    zuSortierendeListe[j + 1] = temp;
                }
            }
        }
        return zuSortierendeListe;
    }

 

[Hoppelbärchen]

uich darf nur leider nicht dieses nehmen.

weil der dann nicht weiß wann der string vorbei is

 

[WieselAc]

Hmm das ist aber seltsam, dann wird es noch komplizierter. Dann musst du zuerst alle nachnamen sortieren und DANNACH nochmal überprüfen ob im sortieren zustand doppelte vornamen vorkommen. Dann musst du den index des ersten und des letzten doppelten haben und dazwischen wieder sortieren...

 

[Hoppelbärchen]

toll, dann blickts mein betreuer mal wieder nich. gut dann mach ichs jetzt einfach so weidda
hauptsache es machts