Felder mit unterschiedl. Typen sortieren

[Holger_83]

Hallo zusammen,

ich bin neu im Forum und wollte das auch gleich mal mit einer Frage feiern 🙂

Erläuterung:
Meine Aufgabe ist es einen kryptografisch verschlüsselten Text zu entschlüsseln.

Der Text sieht ungefähr so aus:
CHF CHDSDS RTHS .... usw (nicht genau so aber so ähnlich, soll nur erklären wie es ausschaut)

Der Text wird aus einer .txt gelesen und von mir als string umgewandelt .
Im nächsten Schritt mache ich aus dem String ein Char Array.

Jeder Buchstabe im Chriffre hat eine eindeutige zuordnung.
Um herraus zu bekommen um welchen Schlüssel es sich handelt muss man die Häufigkeit betrachten, wie oft ein Buchstabe vorkommt.
zBsp kommt das E im deutschen recht häufig vor.

Ein bisschen Quellcode zur Erläuterung
Entschuldigt bitte wenn dieser unsauber ist


Hier speichere ich das vorkommen der Buchstaben im Quelltext in ein int array

for (int i=0; i<alpha.length;i++){    //char alpha []={'A','B',....}
	    	  temp=counter;  //kann ignoriert werden
	    	  counter=0;
		    	for(int d=0; d<datei.length();d++){
		    		if(alpha[i]==beta[d]){ // char beta[] { chars aus der Quelldatei.....}
	     			  counter++;  //zählt die Häufigkeit in der Quelldatei
			    	  vorkommen[i]=counter; //speichert die aktuelle Häufigkeit in Vorkommen
			    		}
			    	}

Nun habe ich 2 Arrays, ein char und ein int, die beide abhängig von einander sind.
Ich habe das Problem zwar gelöst, diese beiden zu sortieren aber recht unschön mMn.

Meine Variante (nicht lachen bitte)

for(int x=0;x<vorkommen.length;x++) //Sortieren nach Häufigkeit
			      {
			    	häufig[x]=vorkommen[x];   //neues Array als hilft Array
			    	  
			      }
			      
			      java.util.Arrays.sort(häufig);
			      
for (int x=0;x<häufig.length;x++)
			      {
			    	  for (int i=0;i<vorkommen.length;i++){
			    		  if(häufig[x]==vorkommen[i]){
			    			  ahäufig[x]=alpha[i];   //neues char Array für finale Ausgabe
			    			  System.out.print(ahäufig[x]+" = " +häufig[x]+" ");
			    		  }
			    	  }
			      }

Ziel ist es später, die Buchstaben im Text zu ersetzten und eine Annäherung an das Original zu bekommen.

Wie Ihr seht habe ich ziemlich viele Felder.
Meine Frage ist nun:
Kann ich ein Feld erzeugen bei dem ich die Werte in alpha[] und die Werte in vorkommen[]
in Abhängigkeit sortiere ?

Beispiel
Buchstabe Häufigkeit
A 60
B 20
C 30
usw...
in :
Buchstabe Häufigkeit
E 300
N 208
usw...


Ich hatte an sowas ähnliches gedacht:
Array[char][int] und nach int sortieren.

Vielen Dank für Tips und Anregungen
Gruß
Holger

 

[Antoras]

Dafür bietet sich eine eigene Klasse und ein Comparator an:

public class ComparatorTest {

	public static void main(final String... args) {
		final List<Letter> l = Arrays.asList(new Letter('A', 37), new Letter('B', 24), new Letter('D', 134), new Letter('E', 62));
		Collections.sort(l);
		System.out.println(l);
	}
}

class Letter implements Comparable<Letter> {
	
	private final char letter;
	private final int occurence;

	public Letter(final char letter, final int occurence) {
		this.letter = letter;
		this.occurence = occurence;
	}

	@Override
	public int compareTo(final Letter o) {
		return o.occurence - occurence;
	}
	
	@Override
	public String toString() {
		return "Letter(" + letter + "," + occurence + ")";
	}
}

Anstatt das Comparable direkt in der Klasse zu implementieren bietet sich auch direkt ein Comparator an, den du der sort-Methode übergeben kannst. Mehr dazu hier.

 

[Holger_83]

Hallo

diese methode verstehe ich nicht ganz...

public int compareTo(final Letter o) {
		return o.occurence - occurence;
	}

Ist es richtig das hier gerechnet (-) wird oder sehe ich das falsch?

 

[Eldorado]

Diese Methode ist zum sortieren gedacht. Sind zwei Werte genau gleich, wird 0 zurück gegeben. Ist der übergebene Wert größer als der Wert in der Klasse wird eine positive Zahl zurück gegeben, ist der übergebene Wert kleiner, wird eine negative Zahl zurück gegeben.

 

[Holger_83]

vielen Dank 🙂

Das kann ich auch nachvollziehen was du gesagt hast.
Eine abschließende Frage nochmal zu dem Ausdruck

 return o.occurence - occurence;

Wird hier ein Object verschoben ?
Danke für die Hilfe zum Verständnis!

 

[Gast2]

Nein, da wird einfach nur subtrahiert.
Siehe auch: Comparable (Java 2 Platform SE 5.0)
(besonders die Rückgabe der Methode)