Problem bei Arrays mit Char

[marius87]

So habe da noch ein Problem mit den Arrays...
Meine Aufgabe ist: ich soll Buchstaben in ein Feld einfügen und diese Sortieren

import java.util.*;

class Flag
{
    public static void main(String []args)
    {
        int j;
        char i;
        Scanner sc=new Scanner(System.in);
        System.out.println("Wieviele Kugel befinden sich im Topf?");
        j=sc.nextInt();
        char [] Flagge=new char [j];
        for(int k=0;k<Flagge.length;k++)
        {
           
            System.out.println("Geben Sie nun die Kugelfarben der Holländischen Flagge an:");
            String x=sc.nextLine();
            Flagge[k]=x;
            System.out.println(Arrays.toString(Flagge));
            
            
            
        }
        
        
    }
}

1)Also wenn ich mit Strings arbeite kann ich mein Array mit Buchstaben füllen aber geht das auch mit char???
2)Ich will mein Feld sortieren nach dem Prinzip der Vertauschung(will aber das sich die Buchstaben in der Reihenfolge R,W,B sortiert werden. Das Prinzip der Vertauschung ist mir klar nur wie geht das mit dem Typen char??

Für Hilfestellungen wäre ich sehr dankbar

 

[0x7F800000]

0) Variablennamen werden klein geschrieben
1) unverständlich. Die zeile 18 ist jedenfalls nicht kompilierbar, da man selbstverständlich keine Strings in char[]-Arrays packen darf
2) ich bin mir ziemlich sicher, dass ich alle einigermaßen brauchbare sortieralgorithmen kenne, und die meisten davon mehrfach implementiert habe. Was auch immer "Prinzip der Vertauschung" sein soll: ein Sortieralgo ist es nicht. Schreib also lieber alles in Character[] um und nimm gleich Arrays::sort(Character[], Comparator<Character>).

 

[marius87]

zu 0) Die variablen Namen habe ich jetzt klein geschrieben Danke nochmal...
zu 1) Habe den Typ auf Character umgeschrieben habe aber trotzdem Probleme in Zeile 17(18).
Ich weiss leider nicht wie ich Werte vom Typen Character mit dem Scanner-Befehl eingeben kann
zu 2) Ich meinte natürlich Bubblesort als Sortieralgo. Ich weiss leider nur nicht wie ich den auf den Typten Character anwende...
Was genau bedeutet : Arrays::sort(Character[], Comparator<Character>)???

Schon mal danke für deine hilfe

 

[0x7F800000]

zu 1) Habe den Typ auf Character umgeschrieben habe aber trotzdem Probleme in Zeile 17(18).

Weil man auch in Character-Arrays selbstverständlich keine Strings reinpacken darf. Ebenso nicht in Integer-Arrays, Sockets-Arrays, ExecutorService-Arrays und keine Nashörner-Arrays. In Character Arrays gehören eben nur Character rein.
Beispielsweise würde es evtl. noch einigermaßen Sinn ergeben, wenn du so etwas schreiben würdest:

Character[] flagge = new Character[j];
// ...
            Flagge[k]=sc.nextLine().charAt(0);
// ...

So ist das Programm aber höchst instabil, und schmeißt bei jeder falschen Eingabe exceptions...

zu 2) Ich meinte natürlich Bubblesort als Sortieralgo. Ich weiss leider nur nicht wie ich den auf den Typten Character anwende...

Lahm. In der Standard API sind bessere Algos bereits implementiert, eben [c]Arrays.sort[/c], schlag doch einfach inder API nach:

http://java.sun.com/javase/6/docs/api/java/util/Arrays.html#sort%28T[],%20java.util.Comparator%29

Was genau bedeutet : Arrays::sort(Character[], Comparator<Character>)???

Öhm... ich verstehe nicht so recht, nach welchem Kriterium du die Buchstaben sortieren willst. Was bedeutet "will aber das sich die Buchstaben in der Reihenfolge R,W,B sortiert werden"?

Wie wär's mit sowas (hingehackt)?

import java.util.*;
import static java.lang.System.*;
import static java.util.Collections.*;

class PartialReorderingComparator<T extends Comparable<T>> implements Comparator<T>{
	private HashMap<T,T> permutation;
	public PartialReorderingComparator(List<T> reordered){
		List<T> ordered = new ArrayList<T>(reordered);
		sort(ordered);
		
		permutation = new HashMap<T,T>();
		for(Iterator<T> ordIt = ordered.iterator(),
						reordIt = reordered.iterator();
			ordIt.hasNext();){
			permutation.put(reordIt.next(),ordIt.next());
		}
	}
	
	public PartialReorderingComparator(T... reordered){
		this(Arrays.asList(reordered));
	}
	
	private T eval(T t){
		if(permutation.containsKey(t)){
			return permutation.get(t);
		}else{
			return t;
		}
	}
	@Override
	public int compare(T a, T b){
		T aa = eval(a), bb = eval(b);
		return aa.compareTo(bb);
	}
}

public class PartialReorderingComparatorExample {
	public static void main(String... _) {
		{
		//hier sollte sowas wie [cbadefg] rauskommen, 
		//weil die ersten drei buchstaben in die verdrehte reihenfolge gezwungen werden
		Character[] c = {'e','f','b','a','g','c','d'};
		Arrays.sort(c,new PartialReorderingComparator<Character>('c','b','a'));
		out.println(Arrays.toString(c));
		}
		
		{
		//nochmal dasselbe, nur sind die buchstaben nicht in einem block, sondern verteilt, 
		//hier sind die ergebnisse eher chaotisch, gewiss ist nur: g kommt vor a usw.
		Character[] c = {'e','f','b','a','g','c','d'};
		Arrays.sort(c,new PartialReorderingComparator<Character>('g','a','e','h','n'));
		out.println(Arrays.toString(c));
		}
		
		{
		//alphabet sortieren, KWB verdrehen
		List<Character> alphabet = new LinkedList<Character>();
		for(char i='A'; i<='Z'; i++) alphabet.add(i);
		sort(alphabet,new PartialReorderingComparator<Character>('K','W','B'));
		out.println(alphabet);
		}
	}
}

bist du dir überhaupt sicher, dass du da irgendwelche Buchstaben haben willst, und nicht etwa eine kleine übersichtliche Menge von Enums?

Edit: aach, ich weiß, ich bin gemein, arrogant und faul -.-
Ich versuch mal zu erklären, was ich da gebastelt habe:
Comparator<T> ist ein Interface, welcher eine Ordnung zwischen Instanzen vom Typ T definiert. Dieses Interface wird von allen möglichen Sortieralgos benutzt, etwa von Collections.sort() oder Arrays.sort(). Alternativ können noch zwei varianten auftreten:
- primitive Typen werden mehr oder weniger einfach nach ihrem numerischen Wert sortiert
- es gibt klassen mit einer "offensichtlichen, natürlichen" Ordnung, diese implementieren dann sofort Comparable<T>, und die Sache mit dem Comparator<T> erübrigt sich, es sei denn man möchte eine eigene merkwürdige Ordnung definieren (wie in deinem Fall: Alphabetische Ordnung wäre "natürlich", du willst irgendwas schräges)
Dieser spezielle comparator den ich da gebaut habe, nimmt eine Sequenz von (bereits "natürlich vergleichbaren") Objekten, und zwingt sie in eine "unnatürliche Reihenfolge", so würde beispielsweise

new PartialReorderingComparator<Character>('K','W','B')

dafür sorgen, dass das normale Alphabet wie folgt sortiert wird:

[A, K, C, D, E, F, G, H, I, J, W, L, M, N, O, P, Q, R, S, T, U, V, B, X, Y, Z]

Im übrigen will ich ausdrücklich davon abraten, jegliche Art von Arrays einzusetzen, es sei denn man hat es sich gut überlegt und weiß was man tut. Collections ersparen einem fast immer Menge Ärger.