Enum Kategorien

[DuffCola]

Hallo, ich habe ein Enum "Kategorien" mit den Zuständen "Action", "Romantik", "Drama" usw...
Jetzt will ich ein Enum Kategorien als Objekt anlegen, und diesem Objekt mehrere Zustände zuweisen, also das ein Objekt "filmMatrix" vom Typ Kategorie einmal den Zustand "Action" und "Drama".
Danach will ich schnell überprüfen können, ob dieses Objekt den zustand "Action" beinhaltet oder den Zustand "Drame" usw...
Ich wieß, das ein Objekt des Typs Enum immer nur einen Zustand haben kann, deswegen will ich wissen, welche Lösungsansetzte es für sowas geht, mir kommt es auf jedenfall auf die Performance an.
Habt ihr Ideen?

(Ich würde es schon gerne mit einem Enum lösen, da man dann eine übersichtliche Liste hat)

 

[Tobse]

ich weiss jetzt nicht, was du willst oder wo dein problem liegt.

Enum Kategorie { Action, Drama, Horror };

Kategorie k = Kategorie.Drama;
if (k == Kategorie.Drama) {
}

k = Kategorie.Horror;

 

[DuffCola]

Ne ich meine das so, dass zum Beispiel ja ein Film mehrere Kategorien hat, nicht nur Drama oder Horror sondern vielleicht auch Action und Horror oder Drama und Action.

 

[eRaaaa]

Ne ich meine das so, dass zum Beispiel ja ein Film mehrere Kategorien hat, nicht nur Drama oder Horror sondern vielleicht auch Action und Horror oder Drama und Action.

Dann benutze doch einfach eine Liste?

List<Kategorie> kategorien

Dann kannst du auch mittels contaijs abfragen ob dein Film die jeweilige Kategorie beinhaltet

kategorien.contains(Kategorie.DRAMA)

z.B.

 

[Tobse]

Naja, eine liste wäre da übertrieben finde ich. Ich würde das eher mit masken machen

class Video {
    public static final long DRAMA = 1;
    public static final long ACTION = 2;
    public static final long COMEDY = 4;
    public static final long HORROR = 8;

    protected long categories = 0;

    public boolean isOfCategory(long c)
    {
        return (categories & c) == c;
    }
    public synchronized void addCategorie(long c)
    {
        categories = categories | c;
    }
    public synchronized void removeCategorie(long c)
    {
        categories = ((categories ^ 0xFFFFFFFF) | c) ^ 0xFFFFFFFF;
    }
}

Video v = new Video();
v.addCategorie(Video.DRAMA);
v.addCategorie(Video.HORROR);
assert(v.isOfCategorie(Video.DRAMA | Video.HORROR)); // v ist DRAMA und HORROR
assert(v.isOfCategorie(Video.DRAMA)); // v ist DRAMA

[EDIT]Ist auch einer List<Enum> performance-technisch weit überlegen.[/EDIT]

 

[eRaaaa]

Sorry aber da graut es mir persönlich. Niemand hinter dich daran der Methode isOfCategory, add oder removeCategorie eine Zahl 3, 33, 1337 etc. zu übergeben....null type checking, das ist schlecht. Dagegen hilft dann nur wieder mehr Code zu schreiben und evtl. selbst eine Exception zu werfen, die dann aber wiederum nur zur Runtime erkannt wird ....


Über Performance möchte ich jetzt an dieser Stelle nicht diskutieren :noe: (ist ein EnumSet da besser evtl.? )

 

[Tobse]

Sorry aber da graut es mir persönlich. Niemand hinter dich daran der Methode isOfCategory, add oder removeCategorie eine Zahl 3, 33, 1337 etc. zu übergeben....null type checking, das ist schlecht. Dagegen hilft dann nur wieder mehr Code zu schreiben und evtl. selbst eine Exception zu werfen, die dann aber wiederum nur zur Runtime erkannt wird ....

Naja, dieses Feld ist ja nicht kritisch für irgendwas und [c]3[/c] wäre in unserem Fall ein Action-Drama. Wenn jemand der Methode einen Quatsch mitgiebt muss derjenige sich auch nicht wundern, wenn das Objekt hinterher quatsch macht; ich halte es für ungefährlich, dem Benutzer des Codes darüber die Verantwortung zu geben.

 

[eRaaaa]

Naja, dieses Feld ist ja nicht kritisch für irgendwas und [c]3[/c] wäre in unserem Fall ein Action-Drama. Wenn jemand der Methode einen Quatsch mitgiebt muss derjenige sich auch nicht wundern, wenn das Objekt hinterher quatsch macht; ich halte es für ungefährlich, dem Benutzer des Codes darüber die Verantwortung zu geben.

Ok jedem das seine, ich persönlich würde aber, falls du dich von deiner Bitmask nicht abwendne willst, dennoch ein Enum nutzen, das geht damit nämlich genauso wenn ich dem Enum 1,2,4,8, etc. als Value mitgebe. Dann sieht es von außen schöner aus und ich bin type-sicher!

 

[Tobse]

Ok jedem das seine, ich persönlich würde aber, falls du dich von deiner Bitmask nicht abwendne willst, dennoch ein Enum nutzen, das geht damit nämlich genauso wenn ich dem Enum 1,2,4,8, etc. als Value mitgebe. Dann sieht es von außen schöner aus und ich bin type-sicher!

Naja, dass das geht war mir nicht bewusst, seit ich deswegen mal ne Fehlermeldung bekommen habe. Dann ist natürlich klar, dass man ein Enum nimmt, der Sicherheit wegen.

 

[Ruzmanz]

Tobse hat schon Recht. In diesem Fall wäre ein Bitmap-Index ideal ... Ich hätte das auch über Enums gemacht. Ansatz:

Spoiler: Alt

public enum Genre {
	DRAMA(0b0000_0000_0000_0001),
	HORROR(0b0000_0000_0000_0010);
	
	private int value;
	
	private Genre(int value) {
		this.value = value;
	}
	
	public int getValue() {
		return value;
	}
}

public class BitGenre {
	private int value;
	
	public static void main(String args[]) {
		BitGenre bitGenre = new BitGenre(Genre.DRAMA, Genre.HORROR);
		System.out.println(bitGenre.contains(Genre.DRAMA));
		System.out.println(bitGenre.contains(Genre.HORROR));
		System.out.println(bitGenre.contains(Genre.DRAMA, Genre.HORROR));
		bitGenre = new BitGenre(Genre.HORROR);
		System.out.println(bitGenre.contains(Genre.DRAMA));
		System.out.println(bitGenre.contains(Genre.HORROR));
		System.out.println(bitGenre.contains(Genre.DRAMA, Genre.HORROR));
	}
	
	public BitGenre(Genre... genres) {
		for(Genre genre: genres) {
			value |= genre.getValue();
		}
	}
	
	public boolean contains(Genre...genres) {
		BitGenre bitGenre = new BitGenre(genres);
		return (value & bitGenre.value) == bitGenre.value;
	}
}

*Nochmal ein bisschen überarbeitet:

public static void main(String[] args) {
		BitConstant<Genre> bitEnum = new BitConstant<>(Genre.DRAMA, Genre.HORROR);
		System.out.println(bitEnum.contains(Genre.DRAMA));
		System.out.println(bitEnum.contains(Genre.HORROR));
		System.out.println(bitEnum.contains(Genre.DRAMA, Genre.HORROR));
		BitConstant<Genre> bitEnum2 = new BitConstant<>(Genre.HORROR);
		System.out.println(bitEnum2.contains(Genre.DRAMA));
		System.out.println(bitEnum2.contains(Genre.HORROR));
		System.out.println(bitEnum2.contains(Genre.DRAMA, Genre.HORROR));
	}

public class BitConstant<T extends Enum<T>> {
	private int value;
	
	public BitConstant(T... constants) {
		for(T constant: constants) {
			value |= getValue(constant);
		}
	}
	
	public boolean contains(T constant) {
		return (value & getValue(constant)) > 0;
	}
	
	public boolean contains(T...constants) {
		return contains(new BitConstant<T>(constants));
	}
	
	public boolean contains(BitConstant<T> bitConstant) {
		return (value & bitConstant.value) == bitConstant.value;
	}
	
	private int getValue(T constant) {
		return 1 << constant.ordinal();
	}
}

 

[nvidia]

Ich wieß, das ein Objekt des Typs Enum immer nur einen Zustand haben kann, deswegen will ich wissen, welche Lösungsansetzte es für sowas geht, mir kommt es auf jedenfall auf die Performance an.
Habt ihr Ideen?
[...]

Ich glaube nicht das du dir, im Allgemeinen, Gedanken über die Performance machen musst. Je nach
Datenvolumen sollte dann eben eine adäquate Datenstruktur verwendet werden. Du kannst dir das
Leben jedoch einfacher gestalten indem du die anderen Posts ignorierst und dir stattdessen EnumSet
ansiehst. Dann kannst du auch bei Enums bleiben, die Implementierung ist recht kompakt, schnell und
vor allem getestet. Allgemein solltest du, wenn du ein Problem lösen möchtest, zuerst eruieren ob etwas
in der Standardbibliothek existiert das dir das Leben erleichert.