✔ Sortieren aber anders

Man kann auch enum's mit einem Comparator vergleichen, ist ja nur ein Interface:

Java: 
package de.tutorials.work;

public enum Farbe {

    ROT("Rot"), BLAU("Blau"), GRUEN("Grün"), WEISS("Weiss"), GELB("Gelb"), SCHWARZ("Schwarz"), VIOLET("Violet");

    private String farbe;

    private Farbe(final String farbe) {
        this.farbe = farbe;
    }

    public String toString() {
        return this.farbe;
    }
}

Java: 
package de.tutorials.work;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Worker {
    /**
     * Comparator für das Sortieren nach Farb-Wert innerhalb des enum
     */
    private class FarbWertSortierer implements Comparator<Farbe> {
        @Override
        public int compare(Farbe o1, Farbe o2) {
            return o1.ordinal() < o2.ordinal() ? -1 : (o1.ordinal() > o2.ordinal() ? 1 : 0);
        }
    }

    /**
     * Comparator für das Sortieren nach Farb-Namen (Buchstaben aufsteigend)
     */
    private class FarbNameSortierer implements Comparator<Farbe> {
        @Override
        public int compare(Farbe o1, Farbe o2) {
            return o1.toString().compareTo(o2.toString());
        }

    }

    /**
     * Den Farb-String nach Farben auftrennen
     * 
     * @param farbMischung
     *            Die Zeichenkette, welche die Farben enthält
     * @return List der identifizierten Farben
     */
    private List<Farbe> scanneFarben(final String farbMischung) {

        String tempFarbString = new String(farbMischung);
        List<Farbe> farben = new ArrayList<Farbe>();

        while (tempFarbString.length() > 0) {
            boolean gefunden = false;
            for (Farbe f : Farbe.values()) {
                if (tempFarbString.startsWith(f.toString())) {
                    farben.add(f);
                    tempFarbString = tempFarbString.replaceFirst(f.toString(), "").trim();
                    gefunden = true;
                    break;
                }
            }
            if (!gefunden) {
                throw new RuntimeException("Etwas stimmt mit der Eingabe " + tempFarbString
                        + " nicht, es konnte keine gültige Farbe am Anfang der Zeichenkette gefunden werden");
            }
        }

        return farben;
    }

    /**
     * Sortiere die Farb-Liste anhand des angebenen Comparators
     * 
     * @param farben
     *            Liste der zu sortierenden Farben
     * @param c
     *            Der Comparator
     * @return sortierte Liste der Farben
     */
    private List<Farbe> sortiereFarben(final List<Farbe> farben, Comparator<Farbe> c) {
        List<Farbe> ergebnis = new ArrayList<Farbe>();
        ergebnis.addAll(farben);
        Collections.sort(ergebnis, c);
        return ergebnis;
    }

    /**
     * Sortiere die Liste der Farben anhand ihres Werts innerhalb der
     * Enumeration
     * 
     * @param farben
     *            Liste der zu sortierenden Farben
     * @return sortierte Liste der Farben
     */
    private List<Farbe> sortiereNachWert(final List<Farbe> farben) {
        return sortiereFarben(farben, new FarbWertSortierer());
    }

    /**
     * Sortiere die Liste der Farben anhand ihres Namens
     * 
     * @param farben
     *            Liste der zu sortierenden Farben
     * @return sortierte Liste der Farben
     */
    private List<Farbe> sortiereNachNamen(final List<Farbe> farben) {
        return sortiereFarben(farben, new FarbNameSortierer());
    }

    /**
     * Füge die Liste der Farben zu einer Zeichenkette zusammen
     * 
     * @param farben
     *            Liste der zu kombinierenden Farben
     * @return Zeichenkette die alle Farben in der Reihenfolge der Liste enthält
     */
    private String kombiniereFarben(final List<Farbe> farben) {
        String ergebnis = "";
        for (Farbe f : farben) {
            ergebnis = ergebnis + f.toString();
        }
        return ergebnis;
    }

    /**
     * Main-Funktion
     * 
     * @param args
     */
    public static void main(final String[] args) {
        Worker worker = new Worker();

        String s1 = "GrünGrünRotWeissVioletSchwarz";
        String s2 = "GrünWeissWeissVioletBlauGelbWeissRotGrün";

        System.out.println("Farbe 1 unsortiert  " + s1);
        System.out.println(
                "Farbe 1 nach Namen  " + worker.kombiniereFarben(worker.sortiereNachNamen(worker.scanneFarben(s1))));
        System.out.println(
                "Farbe 1 nach Wert   " + worker.kombiniereFarben(worker.sortiereNachWert(worker.scanneFarben(s1))));

        System.out.println(System.lineSeparator());

        System.out.println("Farbe 2 unsortiert  " + s2);
        System.out.println(
                "Farbe 2 nach Namen  " + worker.kombiniereFarben(worker.sortiereNachNamen(worker.scanneFarben(s2))));
        System.out.println(
                "Farbe 2 nach Wert   " + worker.kombiniereFarben(worker.sortiereNachWert(worker.scanneFarben(s2))));
        System.out.println(System.lineSeparator());
    }
}

EDIT: Bisschen Fehlerbehandlung und Javadoc-Kommentare eingefügt
 
Zuletzt bearbeitet:
Vielen dank für Ihre Hilfe aber Sie haben offensichtlich die Fragestellung missverstanden: die Wörter sollen unter sich sortiert werden und nicht die substrings jedes Wortes sortiert werden.
 
So letzter Versuch ^^

Java: 
package tut;

public class Main {

   
   public static void main(String []args){
     
     String[] values = new String[6];
     values[0] = "GrünGrünRotWeissVioletSchwarz";
     values[1] = "GrünWeissWeissVioletBlauGelbWeissRotGrün";
     values[2] = "GrünGrünRotWeiss";
     values[3] = "GrünWeissVioletBlauGelbWeissRotGrün";
     values[4] = "GrünWeissVioletBlauGelbWeissRotGrünVioletBlauGelbWeissRotGrün";
     values[5] = "GelbGelb";
   
     StrValueSorter sorter = new StrValueSorter(values);
     
     System.out.println("Unsortiert:");
     sorter.printValuesToSearch();
     
     
     sorter.sortValuesToSearch();
     
     System.out.println("\nSortiert:");
     sorter.printValuesToSearch();
   
   }
   

}

Java: 
package tut;

public class StrValue implements Comparable<StrValue> {
   private Integer value;
   private String name;

   public StrValue(String name, int value) {
     this.value = value;
     this.name = name;
   }

   public Integer getValue() {
     return value;
   }

   public void setValue(Integer value) {
     this.value = value;
   }

   public String getName() {
     return name;
   }

   public void setName(String name) {
     this.name = name;
   }

   @Override
   public int compareTo(StrValue strValue) {
     if (strValue == null) {
       return -1;
     }
     return this.getValue().compareTo(strValue.getValue());
   }
   @Override
   public String toString(){
     return this.getValue()  + "\t(" + this.getName() + ")";
   }

}
Java: 
package tut;

import java.util.Arrays;

public class StrValueSorter {
   public enum Colour{
     RED("Rot"), BLUE("Blaue"), GREEN("Grün"), WHITE("Weiss"), YELLOW("Gelb"), BLACK("Schwarz"), VIOLET("Violet");
     private final String name;
     Colour(String name) {
       this.name = name;
     }
     public String getName() {
       return name;
     }
   }

   private StrValue[] valuesToSearch;

   public StrValue[] getValuesToSearch() {
     return valuesToSearch;
   }

   public StrValueSorter(String[] values) {

     valuesToSearch = new StrValue[values.length];
     for (int i = 0; i < values.length; i++) {
       valuesToSearch[i] = new StrValue(values[i], 0);
     }

     for (int j = 0; j < valuesToSearch.length; j++) {
       valuesToSearch[j].setValue(valuesToSearch[j].getValue() + getSortValue(valuesToSearch[j].getName()));
     }

   }

   public void sortValuesToSearch() {
     if (valuesToSearch != null)
       Arrays.sort(valuesToSearch);
   }

   public void printValuesToSearch() {
     if (valuesToSearch != null) {
       for (int i = 0; i < valuesToSearch.length; i++) {
         System.out.println(valuesToSearch[i]);
       }
     }
   }

   public static int getSortValue(String input) {
     int lastIndex = 0;
     int count = 0;
     for (int i = 0; i < Colour.values().length; i++) {
       lastIndex = 0;
       while (lastIndex != -1) {
         lastIndex = input.indexOf(Colour.values()[i].getName(), lastIndex);
         if (lastIndex != -1) {
           count += (Colour.values()[i].ordinal() + 1);
           lastIndex += Colour.values()[i].getName().length();
         }
       }
     }
     return count;
   }
}

Viele Grüße
Youza
 
Und von mir noch mal mit Comparator:

Java: 
package de.tutorials.work;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Worker {

    /**
     * Comparator zum Sortieren zweier Farb-Listen
     */
    private class FarbMischungSortierer implements Comparator<List<Farbe>> {
        @Override
        public int compare(List<Farbe> o1, List<Farbe> o2) {

            int hoechstes = o1.size();

            if (o2.size() < hoechstes) {
                hoechstes = o2.size();
            }

            for (int i = 0; i < hoechstes; i++) {
                Farbe links = o1.get(i);
                Farbe rechts = o2.get(i);

                int linksOrd = links.ordinal();
                int rechtsOrd = rechts.ordinal();

                if (linksOrd > rechtsOrd) {
                    return -1;
                } else if (rechtsOrd > linksOrd) {
                    return 1;
                }
            }

            return 0;
        }
    }

    /**
     * Den Farb-String nach Farben auftrennen
     *
     * @param farbMischung
     *            Die Zeichenkette, welche die Farben enthält
     * @return List der identifizierten Farben
     */
    private List<Farbe> scanneFarben(final String farbMischung) {

        String tempFarbString = new String(farbMischung);
        List<Farbe> farben = new ArrayList<Farbe>();

        while (tempFarbString.length() > 0) {
            boolean gefunden = false;
            for (Farbe f : Farbe.values()) {
                if (tempFarbString.startsWith(f.toString())) {
                    farben.add(f);
                    tempFarbString = tempFarbString.replaceFirst(f.toString(), "").trim();
                    gefunden = true;
                    break;
                }
            }
            if (!gefunden) {
                throw new RuntimeException("Etwas stimmt mit der Eingabe " + tempFarbString
                        + " nicht, es konnte keine gültige Farbe am Anfang der Zeichenkette gefunden werden");
            }
        }

        return farben;
    }

    /**
     * Füge die Liste der Farben zu einer Zeichenkette zusammen
     *
     * @param farben
     *            Liste der zu kombinierenden Farben
     * @return Zeichenkette die alle Farben in der Reihenfolge der Liste enthält
     */
    private String kombiniereFarben(final List<Farbe> farben) {
        String ergebnis = "";
        for (Farbe f : farben) {
            ergebnis = ergebnis + f.toString();
        }
        return ergebnis;
    }

    /**
     * Sortiert die Liste aller Farben anhand ihres Wertes in der Enumeration
     *
     * @param alleFarben
     *            Liste aller Farben aufgeteilt in Farb-Werte
     *
     * @return sortierte Liste
     */
    private List<List<Farbe>> sortiereAlleFarben(final List<List<Farbe>> alleFarben) {
        List<List<Farbe>> sortiert = new ArrayList<List<Farbe>>();
        sortiert.addAll(alleFarben);

        Collections.sort(sortiert, new FarbMischungSortierer());

        return sortiert;
    }

    /**
     * Main-Funktion
     *
     * @param args
     */
    public static void main(final String[] args) {
        Worker worker = new Worker();

        List<List<Farbe>> listeAllerFarben = new ArrayList<List<Farbe>>();
        listeAllerFarben.add(worker.scanneFarben("GrünGrünRotWeissVioletSchwarz"));
        listeAllerFarben.add(worker.scanneFarben("GrünWeissWeissVioletBlauGelbWeissRotGrün"));
        listeAllerFarben.add(worker.scanneFarben("GrünGrünRotWeiss"));
        listeAllerFarben.add(worker.scanneFarben("GrünWeissVioletBlauGelbWeissRotGrün"));
        listeAllerFarben.add(worker.scanneFarben("GrünWeissVioletBlauGelbWeissRotGrünVioletBlauGelbWeissRotGrün"));
        listeAllerFarben.add(worker.scanneFarben("GelbGelb"));
        listeAllerFarben.add(worker.scanneFarben("GrünGelb"));

        System.out.println("Unsortiert");
        for (List<Farbe> farbe : listeAllerFarben) {
            System.out.println(worker.kombiniereFarben(farbe));
        }

        System.out.println(System.lineSeparator());

        List<List<Farbe>> sortiert = worker.sortiereAlleFarben(listeAllerFarben);

        System.out.println(System.lineSeparator());

        System.out.println("Sortiert");
        for (List<Farbe> farbe : sortiert) {
            System.out.println(worker.kombiniereFarben(farbe));
        }
    }
}

Ausgabe:

Code: 
Sortiert
GelbGelb
GrünGelb
GrünWeissVioletBlauGelbWeissRotGrün
GrünWeissVioletBlauGelbWeissRotGrünVioletBlauGelbWeissRotGrün
GrünWeissWeissVioletBlauGelbWeissRotGrün
GrünGrünRotWeissVioletSchwarz
GrünGrünRotWeiss
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück