Eigenen "Aufzählungstyp" erstellen - mit enum ?

Hallo allerseits,
mein Ziel ist eine Art eigener Datentyp, bzw. viel einfacher:
ein "Aufzählungstyp", bei dem man die Elemente aufzählen kann.
Beispiel:
r, z, a, 0, 9, s, t
Daruf brauche ich eine Methode next(), die zu jedem Element das nachfolgende berechnet:
also:
nexz(r) = z
next(z) = a;
usw.
Natürlich könnte man sich eine eigene Klasse mit entsprechenden Methoden basteln.
Bei 7 Elementen ist das auch kein Aufwand.
Gibt es in Java schon einen vorgefertigten Datentyp, der so was für eine beliebige endliche Menge von vorgegebenen Elementen kann?
Mit enum habe ich es nicht hinbekommen.

mfg
Ern
 
Meinst du sowas?
Java:
public enum Foo {
    R, Z, A, ZERO, NINE, S, T;
   public Foo next() {
         return values()[(ordinal()+1) % values().length];
    }
}
 
Ein Problem habe ich noch:
Ich will den Wert der letzten Konstanten (hier c) in eimem Attribut speichern.
Leider wirft mir das Programm unten eine Exception.
Was muss man machen, dass es funktioniert?

mfg
Ern

Java:
enum Werte {
    a, b, c;

    public Werte last;
    
    private Werte(){
        last= values()[values().length-1];
    }
    
    public Werte next() {
        return values()[(ordinal() + 1) % values().length];
    }
}
 
Wozu brauchst du das denn? Letztendlich kannst du im Konstruktor nicht auf `values()` zugreifen, da das Enum noch kompiliert wird und `values()` somit `null` sein sollte.
 
Wozu brauchst du das denn? Letztendlich kannst du im Konstruktor nicht auf `values()` zugreifen, da das Enum noch kompiliert wird und `values()` somit `null` sein sollte.
Ich brauche es, um einen etwas "allgemeineren" Zähler zu implementieren.
Dazu muß ich feststellen, wann es einen Überlauf gibt.
Den gibt es bei Wert last.
Wie implementiert man last am einfachsten ?
Meine Idee mit dem Konstruktor funktioniert ja nicht.


mfg
Ern
 
Habe es jetzt so gelöst:
Was meinst du dazu ?

Java:
enum Werte {
    a, b, c;

    public static Werte last;
    
    private Werte(){
        //last= values()[values().length-1];
    }
    
    public static void init(){
        last= values()[values().length-1];
    }
    
    public Werte next() {
        //System.out.println(this.ordinal());
        //last= values()[values().length-1];        
        return values()[(ordinal() + 1) % values().length];
    }
}
 
Du musst nur in @Robat's Code next so anpassen, dass es nicht bei einem Überlauf von vorn anfängt, sondern eben irgendwas anderes macht.

Je nachdem was du vor hast, ist aber u.U. etwas anderes als Enums besser geeignet - was willst du damit denn machen?
 
Feingranularer könntest du es so gestalten:
Java:
enum MyEnum {

    a {
        @Override
        public MyEnum next() {
            return b;
        }

    }, b {
        @Override
        public MyEnum next() {
            return c;
        }
    }, c {
        @Override
        public MyEnum next() {
            return null;
        }

        @Override
        public boolean isLast() {
            return true;
        }
    };

    public abstract MyEnum next();

    public boolean isLast() {
        return false;
    }
}
 
Du musst nur in @Robat's Code next so anpassen, dass es nicht bei einem Überlauf von vorn anfängt, sondern eben irgendwas anderes macht.

Je nachdem was du vor hast, ist aber u.U. etwas anderes als Enums besser geeignet - was willst du damit denn machen?
Einen allgemeinen Zähler.
Beispiel:
Die Grundelemnet des Zähler sind z.B. irgendeine geordnete Menge von Zeichen, wie z.B:
a, b, c

Damit wir ddann gezählt:
a,b,c,aa,ab,ac,abbb,cb, ...
Mit obigem Vorschlag hat es funktioniert.
Gibt es dazu etwas Besseres als enum ?

mfg
Ern
 
Die Beschreibung klingt für mich zumindest nicht nach enum (das kommt aber tendenziell aus der Domäne, wenn man die nicht kennt wird das sowieso schwierig), die klingt bisher sehr abstrakt nach "irgendwas zählen".

Die Grundelemnet des Zähler sind z.B. irgendeine geordnete Menge von Zeichen, wie z.B:
a, b, c
Das kann man einfach als Liste darstellen

Einen allgemeinen Zähler.
Und dies als allgemeinen Zähler, der einfach eine Liste von Elementen bekommt. Nicht groß was anderes machst du mit dem Enum grad, aus einem aktuellem Element und einer Liste von allen ermittelst du das nächste Element.


Im aller simpelsten Fall:
Java:
public class Counter<T> {

    private int index = 0;

    private final T[] elems;

    public Counter(final T... elems) {
        this.elems = elems;
    }

    public T get() {
        return elems[index];
    }

    public T incrementAndGet() {
        index++;
        if (index >= elems.length) {
            index = 0;
        }
        return elems[index];
    }

    public static void main(String[] args) {
        Counter<Integer> stringCounter = new Counter<>(0, 1, 2, 3, 4);
        System.out.println(stringCounter.get());
        System.out.println(stringCounter.incrementAndGet());
        System.out.println(stringCounter.incrementAndGet());
        System.out.println(stringCounter.incrementAndGet());
        System.out.println(stringCounter.incrementAndGet());
    }

}
 
Die Beschreibung klingt für mich zumindest nicht nach enum (das kommt aber tendenziell aus der Domäne, wenn man die nicht kennt wird das sowieso schwierig), die klingt bisher sehr abstrakt nach "irgendwas zählen".


Das kann man einfach als Liste darstellen


Und dies als allgemeinen Zähler, der einfach eine Liste von Elementen bekommt. Nicht groß was anderes machst du mit dem Enum grad, aus einem aktuellem Element und einer Liste von allen ermittelst du das nächste Element.
Ja, die Idee mit einer eigenen Klasse ist gut.
Daran hatte ich nicht mehr gedacht.

Eine Frage noch.
In einem enum kann man die Konstanten angeben, z.B:
a,b,c;

Ich habe aber sehr viele Konstanten.
Aus optischen Gründen will ich die auf mehrere Zeilen verteilen.
Das gefällt dem Compiler aber nicht.
Was muss ich machen ?

mfg
Ern
 
0 ist kein gültiger Bezeichner in Java (genau wie alle anderen Literale.

Wie schon unterschwellig angedeutet: ich halte da die Nutzung eines Enums für falsch. Die einzelnen Werte sollen vermutlich einfach nur die jeweilen Zeichen darstellen - also nutzt man am besten auch einfach die Zeichen, zB in einer Liste, wie etwa in #11
 
0 ist kein gültiger Bezeichner in Java (genau wie alle anderen Literale.

Wie schon unterschwellig angedeutet: ich halte da die Nutzung eines Enums für falsch. Die einzelnen Werte sollen vermutlich einfach nur die jeweilen Zeichen darstellen - also nutzt man am besten auch einfach die Zeichen, zB in einer Liste, wie etwa in #11
Ich benutzte also a,b, ..., z
Diese werden nachhner benutzt, um Ordner (bzw. Dateien) umzubenennnen.
Was erlaubt das Betriebsystem für Ordnernamen (bzw.) Dateinamen sonst noch außer a,....z

Später werde ich deinen Ratsclag berücksichtigen, eine eigene Klasse für einen Zähler zu bauen.

mfg
Ern
 
Ich benutzte also a,b, ..., z
Diese werden nachhner benutzt, um Ordner (bzw. Dateien) umzubenennnen.
[...]
Später werde ich deinen Ratsclag berücksichtigen, eine eigene Klasse für einen Zähler zu bauen.
Dafür Enums zu nutzen ist völliger Unfug, fang damit bitte garnicht erst an...

Was erlaubt das Betriebsystem für Ordnernamen (bzw.) Dateinamen sonst noch außer a,....z
Das 0-9 in einem Enum nicht erlaubt sind, hat nichts mit Dateinamen zu tun, sondern ist rein Java-Seitig. Für Dateinamen gelten völlig andere Beschränkungen.

 
Diese werden nachhner benutzt, um Ordner (bzw. Dateien) umzubenennnen.
Ich gehe mal nicht davon aus, dass Du mehr als 2 Mrd. Dateinamen brauchst, oder? Dann reicht ein einfaches int um die Namen durchzuzählen.

Wenn Du die Zahl auf einen Strings abbilden willst, die aus einem Alphabet mit n Symbolen aufgebaut sind, dann betrachtest Du den String einfach als Zahl zur Basis n, also etwa:

Java:
public class Counter {
    private final char[] alphabet;
    private int value;

    public Counter(String alphabet) {
        this.alphabet = alphabet.toCharArray();
    }

    public String getAndIncrement() {
        String result = toString();
        value++;
        return result;
    }
    
    @Override
    public String toString() {
        StringBuilder b = new StringBuilder();
        int cur = value;
        int n = alphabet.length;

        while (cur > 0) {
            b.insert(0, alphabet[cur % n]);
            cur /= n;
        }
        
        if (b.length() == 0) {
            b.append(alphabet[0]);
        }
        
        return b.toString();
    }

    public static void main(String[] args) {
        Counter c = new Counter("abcdefghijklmnopqrstuvwxyz0123456789");
        for (int i = 0; i < 10000; i++) {
            System.out.println(i + ": " + c.getAndIncrement());
        }
    }
}
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben