Enum
๊ธฐ๋ณธ์ ์ผ๋ก c๋ c++์ enum๊ณผ ๊ฐ์ ๊ธฐ๋ฅ์ ์ํํ๋ ํด๋์ค
๋ก JDK 1.5
์ดํ์ ์๊ธด ํด๋์ค์ด๋ค.
c์ธ์ด์ C99
์ด์ ์๋ boolean
ํ์
์ ์ ๊ณตํ์ง ์์๊ธฐ ๋๋ฌธ์ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉํ๊ณ ๋ ํ์๋ค.
typedef enum _boolean {
FALSE,
TRUE
} boolean;
#define FALSE 0
#define TRUE 1
Java์์์ Enum ํน์ง
Enum ๋น๊ต์์ ๊ฐ์ด ์๋ ํ์
๊น์ง๋ ์ฒดํฌ
๊ฐ ๊ฐ๋ฅํ๊ณ Enum์ ์์๊ฐ์ด ์ฌ์ ์ ๋์ด๋ ๋ค์ ์ปดํ์ผํ์ง ์๋๋ค.
enum ์ ์ํ๋ ๋ฐฉ๋ฒ
enum Money { DOLLAR, WON, POUND, EURO, YEN, YUAN }
enum ํค์๋๋ฅผ ์ด์ฉํ์ฌ ์ ์๋ฅผ ํ ์ ์๊ณ ์ ์๋ฅผ ์ด๋์ ํ๋๋์ ๋ฐ๋ผ ๋ถ๋ฅ๋ฅผ ํด๋ณด์๋ฉด 3๊ฐ์ง์ ๋๋ก ๋ถ๋ฅํ ์ ์๋ค.
1. ๋ณ๋์ Java ํ์ผ๋ก ์ ์
[Money.java]
public enum Money {
DOLLAR, WON, POUND, EURO, YEN, YUAN
}
[example.java]
public class example {
public static void main(String[] args) {
Money dollar = Money.DOLLAR;
System.out.println(dollar);
}
}
2. ํด๋์ค ์์ ์ ์
public class example {
public enum Money {
DOLLAR, WON, POUND, EURO, YEN, YUAN
}
public static void main(String[] args) {
Money dollar = Money.DOLLAR;
System.out.println(dollar);
}
}
3. ํด๋์ค ๋ฐ์ ์ ์
enum Money {DOLLAR, WON, POUND, EURO, YEN, YUAN}
public class example {
public static void main(String[] args) {
Money dollar = Money.DOLLAR;
System.out.println(dollar);
}
}
์ ์ ์์น์ ๋ฐ๋ผ enum๊ฐ์ฒด๊ฐ ์์ฑ๋ ์์น๊ฐ ๋ค๋ฅธ ๊ฒ์ ๋ณผ ์ ์๋ค.
enum ์ฌ์ฉ
Money.DOLLAR
์ ๊ฐ์ด Enum์ด๋ฆ.์์๋ช
์ผ๋ก ์ฌ์ฉ์ ํ ์ ์์ผ๋ฉฐ Money money = Money.DOLLAR
์ ๊ฐ์ด ๋ณ์์ ํ ๋น ํด์ค ์๋ ์๋ค.
#include <stdio.h>
enum Money { DOLLAR, WON, POUND, EURO, YEN, YUAN }
int main() {
enum Money dollar = DOLLAR;
enum Money won = WON;
if (dollar == 0) {
printf("์ถ๋ ฅ1"); //์ถ๋ ฅ
}
if (won > dollar) {
printf("์ถ๋ ฅ2"); //์ถ๋ ฅ
}
return 0;
}
C์ enum์ ๊ฐ ์์๊ฐ intํ์ผ๋ก ์ ์ฅ๋์ด ์ฐ์ ์ฐ์ฐ๋ ๊ฐ๋ฅํ๊ณ ์๋์ ๊ฐ์ด ์์๋ฆฌํฐ๋ด๊ณผ ๋น๊ตํด๋ ๊ฐ๊ฒ ๋์ค๋ ๋ฌธ์ ๋ ์๊ธด๋ค.
public class example {
private final static int DOLLAR = 0;
private final static int WON = 1;
private final static int POUND = 2;
private final static int EURO = 3;
private final static int YEN = 4;
public static void main(String[] args) {
System.out.println(DOLLAR == 0);
}
}
Enum์ด ์์ ๋ Java์์๋ ์ด์ ๋น์ทํ๊ฒ class์ private final static int
๋ฅผ ์ด์ฉํด์ ์์๊ฐ์ ์ ์ ํ ์ ์์๋ค.
ํ์ง๋ง ์ด ๋ฐฉ๋ฒ์ ๊ฐ๋ ์ฑ์๋ ์ข์ง ์๊ณ ๋ณ์๋ช ์ด ๊ฒน์น ์ ์๊ฑฐ๋ ์์๋ฆฌํฐ๋ด๊ณผ ๋น๊ต๊ฐ ๋๋ค๋ ๋ฌธ์ ์ ์ด ์๋ค.
public class example {
public static void main(String[] args) {
Money dollar = Money.DOLLAR;
Money won = Money.WON;
System.out.println(dollar > won); //error
System.out.println(dollar == 0); //error
}
}
Java์ Enum์ ๊ฐ ์์๊ฐ ์์ ๊ทธ ์์ฒด๋ก์จ ์๋์ ํ๊ณ ์๋ฃํ์ด ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ์๋์ ๊ฐ์ด ๋น๊ตํ๋ ค๊ณ ํ๋ฉด compile error๊ฐ ๋ฌ๋ค.
์์์ ๋ค๋ฅธ ๊ฐ ์ถ๊ฐ
enum Money {
DOLLAR("๋ฌ๋ฌ"),
WON("์"),
POUND("ํ์ด๋"),
EURO("์ ๋ก"),
YEN("์"),
YUAN("์์");
private String hanguelName;
private Money(){}
private Money(String hanguelName){this.hanguelName = hanguelName;}
public String getHanguelName(){
return hanguelName;
}
}
public class example {
public static void main(String[] args) {
Money dollar = Money.DOLLAR;
Money won = Money.WON;
System.out.println(dollar.getHanguelName());
System.out.println(won.getHanguelName());
}
}
ํด๋์ค์ ์์ฑ์
์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ๊ฐ์ ํ ๋น ํด์ค ์ ์์ผ๋ฉฐ, getter๋ฅผ ์ ์ํด์ ๊ฐ์ ์ฐธ์กฐ ํ ์๋ ์๋ค.
์ด๋ ์์ฑ์๋ PRIVATE ์์ฑ์ผ๋ก ์์ฑํด์ฃผ์ด์ผ ํ๋ค.
enumํ์
์ ๊ณ ์ ๋ ์์๋ค์ ์งํฉ์ด๋ฏ๋ก ์ปดํ์ผ ํ์
์ ๋ชจ๋ ๊ฐ์ ์๊ณ ์์ด์ผํ๊ธฐ ๋๋ฌธ์ ๋ค๋ฅธ ํด๋์ค์์ ๋์ ์ผ๋ก ๊ฐ์ ์ ํด์ค ์ ์๊ธฐ ๋๋ฌธ์ ์์ฑ์๋ฅผ private๋ก ์ค์ ํด์ผ ํ๊ณ final
๊ณผ ๋ค๋ฆ์ด ์์ด์ง๋ค.
enum์ด ์ ๊ณตํ๋ ๋ฉ์๋
values()
Enum์ ๋ชจ๋ ์์๋ฅผ ๋ฐฐ์ด๋ก ๋ง๋ค์ด ๋ฐํํด์ฃผ๋ ํจ์
public class example {
public static void main(String[] args) {
for(Money money : Money.values()){
System.out.println(money); //์ฐจ๋ก๋๋ก ์ถ๋ ฅ
}
System.out.println(Money.values()[1]); //WON ์ถ๋ ฅ
System.out.println(Money.values() instanceof Object); //true
}
}
Money[]
ํํ์ ํ์
์ผ๋ก ๋ฐํ์ด ๋๋ค.
valuesOf()
๋งค๊ฐ๋ณ์๋ก String
ํ์ด ์ค๋ฉฐ ์ด ๋งค๊ฐ๋ณ์์ ๋์ผํ ์ด๋ฆ์ ์์๋ฅผ ์ฐพ์ ์์๋ฅผ ๋ฐํ ํ๊ณ ์๋ค๋ฉด IllegalArgumentException
์์ธ๋ฅผ ๋ฐ์์ํจ๋ค.
public class example {
public static void main(String[] args) {
System.out.println(Money.valueOf("WON")); //WON ์ถ๋ ฅ
System.out.println(Money.valueOf("Rupee")); //IllegalArgumentException error
}
}
ordianal()
enum ์์๊ฐ 0๋ถํฐ ์์ํ์ฌ ์ ์๋ ์์๋ฅผ ๋ฐํ(int)ํ๋ ํจ์
public class example {
public static void main(String[] args) {
Money dollar = Money.DOLLAR;
System.out.println(dollar.ordinal()); //0
}
}
ordinal์ Enum์ ์ ์ํ ์์๋ฅผ ๋ฐํํ๊ธฐ ๋๋ฌธ์ c๋์ฒ๋ผ ์์๋ผ๊ณ ์๊ฐํ๋ฉฐ ์ฌ์ฉํ์ง ๋ง์.
ordinal์ EnumSet์ด๋ EnumMap, JPA์์ ์ ๊ทผํ๊ธฐ ์ํ ๋ด๋ถ ํจ์๋ก ๊ฐ๋ฐ์๋ ๊ฑฐ์ ์ฌ์ฉํ ์ผ์ด ์๋ ๋ฉ์๋์ด๋ค.
์ ์ ์์๊ฐ ๋ฐ๋๊ฑฐ๋ ๊ฐ์ด ์ถ๊ฐ ๋๋ฉด ์ ํ ๋ค๋ฅธ ๊ฒฐ๊ณผ๊ฐ ๋์ค๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ๋ฐ ์ด์ ๋ก Spring Data JPA์์ default๋ ordinal์ด๊ธฐ ๋๋ฌธ์ Enum์์๊ฐ ๋ฐ๋๋ค๋ฉด ๊ฐ์ด ์์ ๋ฌ๋ผ์ง๋ค. ์ปฌ๋ผ์ผ๋ก Enum์ ์ฌ์ฉํ๋ฉด @Enumerated๋ฅผ ์ด์ฉํด String์ผ๋ก ์ฌ์ฉํ์.
java.lang.Enum
enum ํด๋๋ ๊ธฐ๋ณธ์ ์ผ๋ก java.lang.Enum
๋ผ๋ ๋ถ๋ชจ ํด๋์ค๋ฅผ ์์ ๋ฐ๊ณ ์๊ณ ์ด๋ Object
๋ฅผ ์์๋ฐ๊ณ Comparable
๊ณผ Serializable
๋ฅผ implementsํ๊ณ ์๋ค.
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
protected
ํ์ผ๋ก ์์ฑ์๋ฅผ ํ๋ ๊ฐ์ง๊ณ ์๋๋ฐ ์ด๋ ๊ฐ๋ฐ์๊ฐ ํธ์ถํ ์ ์๊ณ ์ปดํ์ผ๋ฌ์ ์ํด enum ํค์๋
์ ๋ฐ์ํ์ฌ ์์ฑํ๊ธฐ ์ํจ์ด๋ค.
public String toString() {
return name;
}
์ด ํด๋์ค ๋ด์ ์๋ public
๋ฉ์๋ ์ค Override
ํด์ ์ฌ์ฉํ ๋งํ ๋ฉ์๋๋ก ๊ธฐ๋ณธ์ ์์ ์ด๋ฆ
์ ๋ฐํํ์ง๋ง, enum
์ ์์ฑ์ ์ถ๊ฐ ๊ฐ
์ ์ง์ ํ์ฌ ์์ฑํ๋ค๋ฉด ์ด๋ฅผ Override
ํด์ค ์ ์๋ค.
์ปดํ์ผ ์์ ๊ฐ์ฒด ์์ฑ
final class Money extends Enum<Money> {
private Money(String name, int ordinal) {
super(name, ordinal);
}
public static final Status DOLLAR = new Status("DOLLAR", 0);
public static final Status WON = new Status("WON", 1);
public static final Status POUND = new Status("POUND", 2);
public static final Status EURO = new Status("EURO", 3);
public static final Status YEN = new Status("YEN", 4);
private static final Status ENUM$VALUES[] = { DOLLAR, WON, POUND, EURO, YEN };
}
enum ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ด๊ฑฐํ์ ์์ฑํ๋ฉด ์ปดํ์ผ ์์ ์์ ๊ฐ์ด ์ ์๊ฐ ๋๋ค.
EnumSet
Set ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํ
EnumSet์ abstract
ํค์๋๊ฐ ์์ ๋ถ์ด ๊ฐ์ฒด ์์ฑ์ด ๋ถ๊ฐ๋ฅํ๊ณ of()
์ ๊ฐ์ ์ถ์ ํฉํ ๋ฆฌ ๋ฉ์๋์์ ์ฌ์ฉํ๋ noneOf(class<E> elementType)
๋ฉ์๋๊ฐ ์กด์ฌํ์ฌ ์ด๋ฅผ ํตํด ๊ตฌํ ๊ฐ์ฒด
๋ฅผ ๋ฐ์ ์ ์๋ค.
public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
Enum<?>[] universe = getUniverse(elementType);
if (universe == null)
throw new ClassCastException(elementType + " not an enum");
if (universe.length <= 64)
return new RegularEnumSet<>(elementType, universe);
else
return new JumboEnumSet<>(elementType, universe);
}
noneOf() ๋ฉ์๋
๋ฅผ ๋ณด๋ฉด ์๊ฒ ์ง๋ง EnumSet
๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ๊ฒ์ด ์๋ ์ด๋ฅผ ์์๋ฐ์ ํด๋์ค๋ค
์ ๋ฐํํ๊ณ ์๋ค.
์ด ๋ ํด๋์ค ๋ชจ๋ private
์์ฑ์ด๋ฏ๋ก ์ง์ ์ฌ์ฉํ ์ ์๋ค.
์ฌ์ฉํ ํฌ๊ธฐ์ ๋ง๊ฒ ์ ํฉํ ๊ตฌํ ๊ฐ์ฒด๋ฅผ ๊ณจ๋ผ ์ค๋ค.
Enum์ ์์๋ค์ ํ๋ํ๋ Set์ ๋ด๋ ํ์๋ฅผ ํผํ ์ ์๋ค.
EnumSet ๋ด๋ถ ํํ์
๋นํธ ๋ฒกํฐ
๋ก ํํ๋๋ค. (์์ ๊ฐ์๊ฐ 64๊ฐ ์ดํ๋ผ๋ฉดlong
๋ณ์ ํ๋๋ก ํํํ๋ค.)Enum ์์๊ฐ ์ ์ธ๋ ์์, ์ฆ ordinal() ๋ฉ์๋์ ๋ฐํ๋ ์์๋ก ์ํํ๋ค.
EnumSet iterator๋ ์ฝํ ์ผ๊ด์ฑ์ ์ ์งํ์ฌ
ConcurrentModificationException
์ ๋ฐ์์ํค์ง ์๋๋ค.null ์์๋ ์ฝ์ ์ด ๋์ง ์๋๋ค.
๋๊ธฐํ
๊ฐ ๋์ง ์๋๋ค.
๋ฉ์๋
EnumSet.allOf(Class elementType) : ๋งค๊ฐ๋ณ์์ ํ์ ์ ๋ชจ๋ ์์๋ฅผ ํฌํจํ
EnumSet
์ ๋ฐํEnumSet.noneOf(Class elementType) : ๋งค๊ฐ๋ณ์์ ํ์ ์ ๋น์ด์๋
EnumSet
๋ฐํEnumSet.of(E e1, E e2 ...) : ์ง์ ํ ๋งค๊ฐ๋ณ์๋ฅผ ํฌํจํ
EnumSet
์ ๋ฐํ๊ทธ ์ธ
java.util.AbstractSet
,java.util.AbstractCollection
,java.lang.Object
,java.util.Set
์ผ๋ก ๋ถํฐ ๋ฉ์๋๋ค์ ์์๋ฐ๊ณ ์๋ค.์ค๋ณต ๊ฒ์ฌ๋ฅผ ์ํ
equals()
,hashCode()
,add()
,remove()
,size()
,toArray() => Object[] ๋ฐํ
,iterator()
๋ฑ ์ฌ์ฉ ๊ฐ๋ฅ
EnumMap
Map ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํ
Enum์ Key๋ก ์ด์ฉํ๋ Map์ด๋ค.
Enum ์์๋ก null์ ๊ฐ์ ์ ์๊ธฐ ๋๋ฌธ์ null์ key๋ก ๊ฐ์ง ๋ชปํ๋ค.
Enum์ ์ ํด์ง ์์๋ฅผ ์ฌ์ฉํ๊ณ ๋จ์ผ ๊ฐ์ฒด์ด๊ธฐ ๋๋ฌธ์ ํด์ฑํ์ง ์๊ณ ์ด๋ฏธ ์์๊ฐ ์ ํด์ ธ์์ด ์ฑ๋ฅ์ด ์ข๋ค.
key์ value๊ฐ ๋ฐฐ์ด๋ก ๊ตฌ์ฑ๋์ด์๋ค.
EnumMap์ key๋
ordianl
๋ก ๊ด๋ฆฌ ๋๊ธฐ ๋๋ฌธ์ iterator๋ ์ฝํ ์ผ๊ด์ฑ์ ์ ์งํ์ฌConcurrentModificationException
์ ๋ฐ์์ํค์ง ์๋๋ค.๋๊ธฐํ
๊ฐ ๋์ง ์๋๋ค.
๋ฉ์๋
์์ฑ์ :
new
ํค์๋๋ฅผ ์ด์ฉํด ์์ฑํ ์ ์๊ณ ์ผ๋ฐ Map๋ค๊ณผ ๋ค๋ฅด๊ฒenum ํ์
์ ํ๋ผ๋ฏธํฐ๋ก ๋๊ฒจ์ฃผ์ด์ผ ํ๋ค.Map<Money,Integer> map = new EnumMap<>(Money.class);
clear() : ๋ชจ๋ ์์ ์ญ์
get(Object key) : key์ ํด๋นํ๋ value ๋ฆฌํด
put(K key, V value) : map์ ๋ฐ์ดํฐ ์ ๋ ฅ
remove(Object key) : ํด๋นํ๋ key๊ฐ ์๋ค๋ฉด ์ญ์
equals(Object object) : ๊ธฐ์ค Map๊ณผ ๊ฐ์์ง ๋น๊ต
containsKey(Object key) / containsValue(Object value) : ํด๋นํ๋ key์ value ๊ฐ ์๋ค๋ฉด true ๋ฐํ
size() : Map์ ์์ ๊ฐ์ ๋ฐํ
keySet() : Map์ ์๋ ๋ชจ๋ key๋ค์ Set view๋ฅผ ๋ฐํํ๋ค. (๋ชจ๋ key๋ค์ ๋ณด์ฌ์ค๋ค.)
values() : Map์ ์๋ value๋ค์ Collection view๋ฅผ ๋ฐํํ๋ค. (๋ชจ๋ ๊ฐ๋ค์ ๋ณด์ฌ์ค๋ค.)
์ถ๊ฐ ๋ด์ฉ
type safety
Runtime์ด ์๋ Complieํ์์ ๋ฌธ์ ๋ฅผ ์ก์ ์ ์๋ ๊ฒ์ผ๋ก JVM์ ์ปดํ์ผํ ๋, ํน์ ๋ฐ์ดํฐ ํ์ ์ ์ ์ ์์ผ๋ RUN์์ ํน์ ๋ฐ์ดํฐ๊ฐ ์กด์ฌ ํ์ง ์๋๋ค๊ฑฐ๋ ํ๋ ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์๋ค.
Enum์ ์ฌ์ฉํ๋ฉด ์คํ๋ฐฉ์ง๋ฅผ ํ ์ ์๊ณ , ์ปดํ์ผํ์์ ์๋ฌ๋ฅผ ์ก์์ฃผ๊ธฐ ๋๋ฌธ์ ๋๋ฒ๊น ๋ ์ฌ์์ง๋ค.
Enum์์ ๊ฐ ์
ํ
ํ
Enum์ ๊ฐ์ ์ถ๊ฐํด์ค ๋ 1,2,3๊ฐ์ด ์ข์ ์ซ์์ ๋ฒ์๊ฐ ์๋ 10,20,30 ๊ฐ์ด ๋ฒ์๋ฅผ ๋๊ณ ์ ์ธํด์ฃผ์.
์ธ์ ์ด๋ค์ด์ ์์ Enum์ ๊ฐ์ ์ฌ์ด์ ์ถ๊ฐ ํด์ค์ง ๋ชจ๋ฅด๊ธฐ ๋๋ฌธ์ด๋ค.
Reference
https://www.nextree.co.kr/p11686/
http://cris.joongbu.ac.kr/course/java/api/java/lang/Enum.html
https://javarevisited.blogspot.com/2014/03/how-to-use-enumset-in-java-with-example.html#axzz6kSbFjAwM
Last updated