✔ Array nach eigenem Muster sortieren

Hmmm...ich glaub ich steh immernoch ein wenig auf dem Schlauch!

Hab jetzt folgendes in meiner Methode geändert:
Code: 
protected void fillRadioBox(String text) {
		final String release = text;
		String geomia;
		String ggs;
					
		AuswahlController ac = new AuswahlControllerImpl(text);
		String[]keys=ac.getServerKeys();
		
		int[ ]server = new int[keys.length];
		
		for (int i=0; i<=keys.length; i++){
			if (keys[i].startsWith("geomia")){
				geomia = keys[i].substring(12);
				server[i] = Integer.parseInt(geomia);				
			}
			else {
				ggs = keys[i].substring(9);
				server[i] = Integer.parseInt(ggs);
			}
			
		}
		Arrays.sort(server);
		
		for (String i:keys ) {
			final JRadioButton button = new JRadioButton (i, true);

				button.addActionListener(new ActionListener() {
					@Override
					public void actionPerformed(ActionEvent e) {
							try{								
									ServerAuswahlMenue.namingAendern
										(button.getText(), release);
							} catch (Exception ex) {
								ex.printStackTrace();
							}
						}
				});
			serverAuswahl.add(button);
			panelServerGroup.add(button);
		}		
	}

Ich glaube allerdings, dass das nicht das war, was du gemeint hast, oder!?
Hab es bis jetzt nicht im Comparator eingefügt, weil ich nicht weiß, wie ich die Klasse dann erben soll. Erbe schon JFrame.
Versteh also irgendwie nicht, wie man sich den Comparator anlegen soll, dann auf ihn zugreifen soll.
 
Zuletzt bearbeitet:
Hier mal ein Beispiel meinerseits. Vielleicht nicht der geschickteste Weg, aber ein besserer fällt mir grad auch nich ein.
Java: 
package de.tutorials.tinipieps.array.sort;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Array sortieren.
 * Das Problem ist, dass Arrays.sort() alphabetisch sortieren
 * würde, was nicht den gewünschten Effekt erzielen würde. Ein Array
 * kann man so auch nicht nach eigenem Ermessen sortieren.
 * Kleiner Umweg: Man kann Listen nach eigenem Ermessen sortieren
 * lassen, also kann man den Inhalt des Arrays in eine Liste packen und
 * dann sortieren.
 */
public class SortStringArrayLikeNumbers {
	public static void main(String[] args) {
		String[] strArr = new String[]{
				"Hallo1",
				"tach56",
				"moin2",
				"cYa4",
				"gutentag100"};
		System.out.println("Unsortiert: " + Arrays.toString(strArr));

		// Normal sortieren
		Arrays.sort(strArr);
		System.out.println("Alphabetisch sortiert: " + Arrays.toString(strArr));

		// Array in eine Liste kopieren
		List<String> list = new LinkedList<String>();
		for(String str : strArr) {
			list.add(str);
		}

		// Liste nach Zahlengrößen sortieren
		Collections.sort(list, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				/*
				 * Pattern:
				 * Groß-/Kleinbuchstaben mit einem Vorkommen von 0 ... unendlich
				 * Zahlen mit einem Vorkommen von 1 ... unendlich
				 */
				Pattern p = Pattern.compile("([a-zA-Z]*)([0-9]+)");
				Matcher m;
				int num1 = -1;
				int num2 = -1;

				// num1
				m = p.matcher(o1);
				if(m.find()) {
					// Gruppenindex 0 => Gesamter Fund
					// Gruppenindex 1 => 1. Gruppe (hier die
					// Buchstabenkombination)
					// Gruppenindex 2 => 2. Gruppe (hier die Zahlenkombination)
					num1 = Integer.parseInt(m.group(2));
				}

				// num2
				m = p.matcher(o2);
				if(m.find()) {
					// Gruppenindex 0 => Gesamter Fund
					// Gruppenindex 1 => 1. Gruppe (hier die
					// Buchstabenkombination)
					// Gruppenindex 2 => 2. Gruppe (hier die Zahlenkombination)
					num2 = Integer.parseInt(m.group(2));
				}

				// Vergleichen
				if(num1 < num2) return -1;
				if(num1 > num2) return 1;

				return 0;
			}
		});
		// Sortierte Liste wieder zum Array konvertieren
		strArr = list.toArray(new String[list.size()]);

		System.out.println("Nach Zahlen sortiert: " + Arrays.toString(strArr));
	}
}
Sollte eigentlich selbsterklärend sein ;)

Ausgabe:
Code: 
Unsortiert: [Hallo1, tach56, moin2, cYa4, gutentag100]
Alphabetisch sortiert: [Hallo1, cYa4, gutentag100, moin2, tach56]
Nach Zahlen sortiert: [Hallo1, moin2, cYa4, tach56, gutentag100]
 
Zuletzt bearbeitet:
Hallo Akeshihiro!

Deine Lösung erschien mir perfekt, bloß leider hat es trotz genauem abtippen nicht geklappt.

Hier mein Code:
Code: 
protected void fillRadioBox(String text) {
		final String release = text;
		
		AuswahlController ac = new AuswahlControllerImpl(text);
		String[]keys=ac.getServerKeys();
		
		//nun das Array in Liste kopieren, um es sortieren zu können
		List<String> list = new LinkedList<String>();
		for (String str: keys)
			list.add(str);
		
		//nun wird Liste sortiert
		Collections.sort(list, new Comparator<String>(){
			@Override
			public int compare(String o1, String o2){
				//Attribute
				//Pattern:legt erlaubte Zeichen fest
				Pattern p = Pattern.compile("([a-zA-Z]*)([0-9]+)");
				Matcher m;
				int num1 = -1;
				int num2 = -1;
				
				//num1
				m = p.matcher(o1);
				if(m.find()){
					// Gruppenindex:
					// 0 -> gesamter Fund
					// 1 -> Buchstabenkombination
					// 2 -> Zahlenkombination
					num1 = Integer.parseInt(m.group(2));
				}
				
				//num2
				m = p.matcher(o2);
				if(m.find()){
					num2 = Integer.parseInt(m.group(2));
				}
				
				//Vergleichen
				if (num1 < num2)
					return -1;
				else if (num1 > num2)
					return 1;
							
				return 0;
				
			}
		});
		
		//nun wird sortierte Liste wieder in Array konvertiert
		keys = list.toArray(new String[list.size()]);
		Arrays.sort(keys);
				
		for (String i:keys ) {
			final JRadioButton button = new JRadioButton (i, true);

				button.addActionListener(new ActionListener() {
					@Override
					public void actionPerformed(ActionEvent e) {
							try{								
									ServerAuswahlMenue.namingAendern
										(button.getText(), release);
							} catch (Exception ex) {
								ex.printStackTrace();
							}
						}
				});
			serverAuswahl.add(button);
			panelServerGroup.add(button);
		}		
	}

Was hab ich falsch gemacht?
 
hm... ich habs mir nicht genau angesehen, aber da hast du so eine schöne Methode zum Sortieren, baust aus der sortierten Liste wieder ein Array - und dann sortierst du das sortierte Array wieder mit der Array.sort Methode?
Java: 
keys = list.toArray(new String[list.size()]);
		Arrays.sort(keys);

Ich würde da testweise mal die letzte Zeile rausnehmen ;)

mfg,

RoCMe
 
Genau das wars
DANKE

Nun noch eine letzte Frage:
Kann man deine Sortierung erweitern?

Hab quasi zwei verschiedene Servervarianten:
ggsserver1, ggsserver21 etc + geomiaserver1 (bis jetzt nur einer)

Nun möchte ich, dass erst alle ggsserver abhängig von der numerierten Sortierung aufgeführt werden und der geomiaserver nicht mittendrin, sondern am ende.
 
Ist zwar nicht mein Code, aber ich bin mal so frei :)

Erweitere einfach die compareTo Methode. Vergleiche zuerst den "Buchstaben-Teil" (die erste Gruppe im RegEx-Matcher). Wenn beide gleich sind, gibst du den schon implementierten Nummernvergleich zurück.

Hab gerade keine Zeit für Code-Spielchen, aber das Prinzip sollte klar sein :)
 
Prinzipiell ja, ich würde dafür dann einfach ein Kombination aus der alphabetischen Sortierung und der Sortierung nach Zahlengrößen nehmen. Das hat einfach den Sinn, dass bei gleichen Wörtern allein der Wortanteil identisch wäre und man dann nach Zahlengrößen sortieren müsste. Sind die Wörter aber nicht gleich, kann man sie natürlich alphabetisch sortieren und die Zahlengrößen sind dann nur noch zweitrangig.

Viel ändern musst du dafür auch nicht. Eigentlich kommen nur zwei String-Variabeln hinzu, die natürlich auch an der entsprechenden Stelle intialisiert und zum Schluss eben auch noch überprüft werden müssen.

Der Code sieht dann so aus:
Java: 
package de.tutorials.tinipieps.array.sort;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Array sortieren.
 * Das Problem ist, dass Arrays.sort() alphabetisch sortieren
 * würde, was nicht den gewünschten Effekt erzielen würde. Ein Array
 * kann man so auch nicht nach eigenem Ermessen sortieren.
 * Kleiner Umweg: Man kann Listen nach eigenem Ermessen sortieren
 * lassen, also kann man den Inhalt des Arrays in eine Liste packen und
 * dann sortieren.
 */
public class SortStringArrayLikeNumbers {
	public static void main(String[] args) {
		String[] strArr = new String[]{
				"ggsserver3",
				"ggsserver5",
				"ggsserver1",
				"ggsserver11",
				"geomiaserver1",
				"ggsserver4",
				"ggsserver239",
				"geomiaserver3",
				"geomiaserver2",
				"ggsserver2"};
		System.out.println("Unsortiert: " + Arrays.toString(strArr));

		// Normal sortieren
		Arrays.sort(strArr);
		System.out.println("Alphabetisch sortiert: " + Arrays.toString(strArr));

		// Array in eine Liste kopieren
		List<String> list = new LinkedList<String>();
		for(String str : strArr) {
			list.add(str);
		}

		// Liste nach Zahlengrößen sortieren
		Collections.sort(list, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				/*
				 * Pattern:
				 * Groß-/Kleinbuchstaben mit einem Vorkommen von 0 ... unendlich
				 * Zahlen mit einem Vorkommen von 1 ... unendlich
				 */
				Pattern p = Pattern.compile("([a-zA-Z]*)([0-9]+)");
				Matcher m;
				int num1 = -1;
				int num2 = -1;
				String str1 = ""; // ÄNDERUNG
				String str2 = ""; // ÄNDERUNG

				// str1 & num1
				m = p.matcher(o1);
				if(m.find()) {
					// Gruppenindex 0 => Gesamter Fund
					// Gruppenindex 1 => 1. Gruppe (hier die
					// Buchstabenkombination)
					// Gruppenindex 2 => 2. Gruppe (hier die Zahlenkombination)
					str1 = m.group(1); // ÄNDERUNG
					num1 = Integer.parseInt(m.group(2));
				}

				// str2 & num2
				m = p.matcher(o2);
				if(m.find()) {
					// Gruppenindex 0 => Gesamter Fund
					// Gruppenindex 1 => 1. Gruppe (hier die
					// Buchstabenkombination)
					// Gruppenindex 2 => 2. Gruppe (hier die Zahlenkombination)
					str2 = m.group(1); // ÄNDERUNG
					num2 = Integer.parseInt(m.group(2));
				}

				// Vergleichen
				if(str1.compareTo(str2) != 0) return str1.compareTo(str2); // ÄNDERUNG

				// Gleiche Strings? Also Zahlenwerte prüfen!
				if(num1 < num2) return -1;
				if(num1 > num2) return 1;

				return 0;
			}
		});
		// Sortierte Liste wieder zum Array konvertieren
		strArr = list.toArray(new String[list.size()]);

		System.out.println("Nach Zahlen sortiert: " + Arrays.toString(strArr));
	}
}
Die neuen/geänderten Codestellen sind durch Kommentare markiert und wie du siehst, ist das nicht viel. Zum Vorführen habe ich die Strings in dem Array natürlich entsprechend abgeändert, da vorher ja alle unterschiedlich waren ;)

Ausgabe:
Code: 
Unsortiert: [ggsserver3, ggsserver5, ggsserver1, ggsserver11, geomiaserver1, ggsserver4, ggsserver239, geomiaserver3, geomiaserver2, ggsserver2]
Alphabetisch sortiert: [geomiaserver1, geomiaserver2, geomiaserver3, ggsserver1, ggsserver11, ggsserver2, ggsserver239, ggsserver3, ggsserver4, ggsserver5] <-- blöd sortiert -.-
Nach Zahlen sortiert: [geomiaserver1, geomiaserver2, geomiaserver3, ggsserver1, ggsserver2, ggsserver3, ggsserver4, ggsserver5, ggsserver11, ggsserver239] <-- gut sortiert ^^

EDIT:
RoCMe hat gesagt.:
Ist zwar nicht mein Code, aber ich bin mal so frei :)

Erweitere einfach die compareTo Methode. Vergleiche zuerst den "Buchstaben-Teil" (die erste Gruppe im RegEx-Matcher). Wenn beide gleich sind, gibst du den schon implementierten Nummernvergleich zurück.

Hab gerade keine Zeit für Code-Spielchen, aber das Prinzip sollte klar sein :)
Zum Vergrößern anklicken....
Ja klar, hab nix dagegen ;)
 
Zuletzt bearbeitet:
Vielen Dank!
Deine Lösung hat mir echt weitergeholfen.
Die Implementierung in die if(m.find())-SChleife hatte ich schon selbst erstellt, aber ich kam mit dem Vergleich nicht weiter!
Deshalb nochmal vielen Dank
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück