Eigenen "Aufzählungstyp" erstellen - mit enum ?

[ernst]

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

 

[Robat]

Meinst du sowas?

public enum Foo {
    R, Z, A, ZERO, NINE, S, T;
   public Foo next() {
         return values()[(ordinal()+1) % values().length];
    }
}

 

[ernst]

Meinst du sowas?

public enum Foo {
    R, Z, A, ZERO, NINE, S, T;
   public Foo next() {
         return values()[(ordinal()+1) % values().length];
    }
}

ja, ich glaube das ist das, was ich braucnen kann.
Vielen Dank.

mfg
Ern

 

[ernst]

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

enum Werte {
    a, b, c;

    public Werte last;
    
    private Werte(){
        last= values()[values().length-1];
    }
    
    public Werte next() {
        return values()[(ordinal() + 1) % values().length];
    }
}

 

[Robat]

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.

 

[ernst]

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

 

[ernst]

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

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];
    }
}

 

[mrBrown]

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?

 

[Flown]

Feingranularer könntest du es so gestalten:

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;
    }
}

 

[ernst]

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

 

[mrBrown]

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:

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());
    }

}

 

[ernst]

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

 

[mrBrown]

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 ?

Durch Komma trennen und Semikolon ans Ende.

 

[ernst]

Durch Komma trennen und Semikolon ans Ende.

Hier gibt es bei mir aber die Fehlermeldung: "Illegal start of type"
a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y,
z, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;


mfg
Ern

 

[mrBrown]

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

 

[ernst]

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

 

[mrBrown]

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.

Filename - Wikipedia

en.wikipedia.org

 

[mihe7]

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:

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());
        }
    }
}

 

[ernst]

Danke für den Tipp.
Habe etwas Ähnliches gemacht.

mfg
Ern

class Counter {
    // Basis des Zählers = Anzahl des Alphabets.
    // Beispiel: Alphabet = "abc" , also Basis = 3
    // 0,1,2, 00,01,02, 10,11,12,20,21,22, 000,001,002, ...

    private ArrayList<Integer> zählerstand;
    private int first;
    private int last;
    private final char[] alphabet;

    public Counter() {
        String alphabet = "abc";
        this.alphabet = alphabet.toCharArray();
        zählerstand = null;
        first = 0;
        last = this.alphabet.length - 1;

    }

    // Ein Kilometerzähler zur Bais n wird um 1 hochgezählt.
    public String getAndIncrementZählerstand() {
        int anz;
        int i;
        // Es gibt keinen Überlauf
        boolean überlauf = false;
        int lastPos = -1;
        ArrayList<Character> listeNeu;
        String zählerstandString = null;

        if (zählerstand == null) {
            zählerstand = new ArrayList();
            // am Anfang ein first (0) einfügen
            zählerstand.add(0, first);
            zählerstandString = zählerstandAlsString();
            return zählerstandString;
        }

        // Anzahl der Stellen des Zählers
        anz = zählerstand.size();

        // Bestimme letzte Stelle des Zählers , deren Wert noch erhöht werden
        // kann, ohne dass es einen Überlauf gibt.
        überlauf = true;
        for (i = anz - 1; i >= 0; i--) {
            if (zählerstand.get(i) != last) {
                lastPos = i;
                überlauf = false;
                break;
            }
        }

        // Alle Elemente sind mit last belegt d.h. es gibt einen Überlauf
        // ganz vorne an der 0-ten Stelle
        if (überlauf == true) {
            // alle Stellen mit first (0) belegen
            for (i = 0; i < anz; i++) {
                zählerstand.set(i, first);
            }
            // am Anfang ein first (0) einfügen
            zählerstand.add(0, first);
        } else { // Es gibt keinen Überlauf
            // alle Elemente ab lastPos+1 mit first belegen und lastPos um 1
            // erhöhen.
            for (i = lastPos + 1; i < anz; i++) {
                zählerstand.set(i, first);
            }
            int wert = zählerstand.get(lastPos);
            zählerstand.set(lastPos, wert + 1);

        }
        zählerstandString = zählerstandAlsString();
        return zählerstandString;
    }

    public String zählerstandAlsString() {
        StringBuffer sb = new StringBuffer();
        int index;
        for (int i = 0; i < zählerstand.size(); i++) {
            index = zählerstand.get(i);
            char c;
            c = alphabet[index];
            sb.append(c);
        }
        return sb.toString();
    }

    public String toString() {
        String temp;
        temp = zählerstand.toString();
        // vorsichtshalber Schrott entfernen
        temp = temp.replace("[", "");
        temp = temp.replace("]", "");
        temp = temp.replace(",", "");
        temp = temp.replace(" ", "");
        return temp;
    }

}
[QUOTE="mihe7, post: 1197582, member: 58041"]
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:

[code=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());
        }
    }
}

[/QUOTE]

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:

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());
        }
    }
}