Java Enum、EnumMap、EnumSet 详解
2017-08-22 13:48
211 查看
除不能 继承
java.lang.Enum 之外，可将其看做一个常规类，甚至可以有main方法
1> 常量
把相关的常量分组到一个枚举类型里，且枚举提供 比常量更多的方法
public enum
Color {
RED,
GREEN,
BLANK,
YELLOW
}
2> switch
switch语句只支持int, char, enum类型，使用枚举，能让我们的代码可读性更强
enum
Signal {
GREEN,
YELLOW,
RED
}
public class
TrafficLight {
Signal
color
= Signal.RED;
public void
change() {
switch
(color) {
case
RED:
color
= Signal.GREEN;
break;
case
YELLOW:
color
= Signal.RED;
break;
case
GREEN:
color
= Signal.YELLOW;
break;
}
}
}
3> 向枚举中添加新方法
自定义自己的方法，必须在 enum实例序列的最后添加一个分号，而且 Java 要求必须先定义 enum 实例，成员变量和枚举中的数据类型的顺序一一对应
如：回对实例自身的描述，而非默认的 toString 返回枚举实例的名字
public enum
Color {
RED("红色",
1),
GREEN("绿色",
2),
BLANK("白色",
3),
YELLO("黄色",
4);
// 成员变量
private
String name;
private int
index;
// 构造方法
private
Color(String name, int
index) {
this.name
= name;
this.index
= index;
}
// 普通方法
public static
String getName(int
index) {
for (Color c : Color.values()) {
if (c.getIndex() == index) {
return
c.name;
}
}
return null;
}
// get set 方法
public
String getName() {
return
name;
}
public void setName(String name) {
this.name
= name;
}
public int getIndex() {
return
index;
}
public void setIndex(int
index) {
this.index
= index;
}
}
注 : 1> 可以调用相应枚举成员的方法来生成相应的对象，比如下面的 OFType，可以这样使用：
OFType t = OFType.HELLO;
t.newInstance();
2> 构造方法的 访问权限 不能是 public
4> 覆盖枚举的方法
下面给出一个toString()方法覆盖的例子
public class
Test {
public enum Color {
RED("红色",
1),
GREEN("绿色",
2),
BLANK("白色",
3),
YELLO("黄色",
4);
// 成员变量
private
String name;
private int
index;
// 构造方法
private
Color(String name, int
index) {
this.name
= name;
this.index
= index;
}
// 覆盖方法
@Override
public
String toString() {
return this.index
+
"_" +
this.name;
}
}
public static void main(String[] args) {
System.out.println(Color.RED.toString());
}
}
注 : 所有的方法或其它必须放在枚举值的下面，且枚举的构造方法必须是 private
5> 实现接口
所有的枚举都继承自 java.lang.Enum类，由于Java 不支持多继承，所以枚举对象不能再继承其他类
public interface
Behaviour {
void print();
String getInfo();
}
public enum
Color
implements Behaviour {
RED("红色",
1),
GREEN("绿色",
2),
BLANK("白色",
3),
YELLO("黄色",
4);
// 成员变量
private
String name;
private int
index;
// 构造方法
private
Color(String name, int
index) {
this.name
= name;
this.index
= index;
}
// 接口方法
@Override
public
String getInfo() {
return this.name;
}
// 接口方法
@Override
public void
print() {
System.out.println(this.index
+
":" +
this.name);
}
}
6> 使用接口组织枚举
public interface
Food {
enum
Coffee
implements Food {
BLACK_COFFEE,
DECAF_COFFEE,
LATTE,
CAPPUCCINO
}
enum
Dessert
implements Food {
FRUIT,
CAKE,
GELATO
}
}
7> 关于枚举集合的使用
java.util.EnumSet 和 java.util.EnumMap 是两个枚举集合，EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而 value 则可以是任意类型
枚举和常量定义的区别
<1> 通常定义常量方法
通常利用 public final static方法 定义的代码如下，分别用1表示红灯，3表示绿灯，2表示黄灯
public class
Light {
/* 红灯 */
public final static int
RED
=
1;
/* 绿灯 */
public final static int
GREEN
=
3;
/* 黄灯 */
public final static int
YELLOW
=
2;
}
<2> 枚举类型定义常量方法
枚举类型的简单定义方法如下，似乎没办法定义每个枚举类型的值。比如定义红灯、绿灯和黄灯的代码可能如下 :
public enum Light {
RED,
GREEN,
YELLOW;
}
只能够表示出红灯、绿灯和黄灯，但是具体的值没办法表示出来。枚举类型提供了构造函数，可以通过构造函数和覆写toString方法来实现。首先给Light枚举类型增加构造方法，然后每个枚举类型的值通过构造函数传入对应的参数，同时覆写toString方法，在该方法中返回从构造函数中传入的参数，改造后的代码如下
:
public enum
Light {
// 利用构造函数传参
RED(1),
GREEN(3),
YELLOW(2);
// 定义私有变量
private int
nCode;
// 构造函数，枚举类型只能为私有
private
Light(int
_nCode) {
this.nCode
= _nCode;
}
@Override
public
String toString() {
return String.valueOf(this.nCode);
}
}
<3> 完整示例代码
枚举类型的完整演示代码如下 :
public class
LightTest {
// 1.定义枚举类型
public enum
Light {
// 利用构造函数传参
RED(1),
GREEN(3),
YELLOW(2);
// 定义私有变量
private int
nCode;
// 构造函数，枚举类型只能为私有
private
Light(int
_nCode) {
this.nCode
= _nCode;
}
@Override
public
String toString() {
return String.valueOf(this.nCode);
}
}
public static void main(String[] args) {
// 1.遍历枚举类型
System.out.println("演示枚举类型的遍历 ......");
testTraversalEnum();
// 2.演示EnumMap对象的使用
System.out.println("演示EnmuMap对象的使用和遍历.....");
testEnumMap();
// 3.演示EnmuSet的使用
System.out.println("演示EnmuSet对象的使用和遍历.....");
testEnumSet();
}
/** 演示枚举类型的遍历 */
private static void
testTraversalEnum() {
Light[] allLight = Light.values();
for (Light aLight : allLight) {
System.out.println("当前灯name："
+ aLight.name());// name() 是对应的大写字母 如：RED，GREEN，YELLOW
System.out.println("当前灯ordinal："
+ aLight.ordinal());// ordinal() 是对应的索引号 基于0
System.out.println("当前灯："
+ aLight);
}
}
/** 演示EnumMap的使用，EnumMap跟HashMap的使用差不多，只不过key要是枚举类型 */
private static void
testEnumMap() {
// 1.演示定义EnumMap对象，EnumMap对象的构造函数需要参数传入,默认是key的类的类型
EnumMap<Light, String> currEnumMap =
new EnumMap<Light, String>(Light.class);
currEnumMap.put(Light.RED,
"红灯");
currEnumMap.put(Light.GREEN,
"绿灯");
currEnumMap.put(Light.YELLOW,
"黄灯");
// 2.遍历对象
for
(Light aLight : Light.values()) {
System.out.println("[key="
+ aLight.name() +
",value=" + currEnumMap.get(aLight) +
"]");
}
}
/** 演示EnumSet如何使用，EnumSet是一个抽象类，获取一个类型的枚举类型内容，可以使用allOf方法 */
private static void
testEnumSet() {
EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);
for (Light aLightSetElement : currEnumSet) {
System.out.println("当前EnumSet中数据为："
+ aLightSetElement);
}
}
}
执行结果如下：
演示枚举类型的遍历 ......
当前灯name：RED
当前灯ordinal：0
当前灯：1
当前灯name：GREEN
当前灯ordinal：1
当前灯：3
当前灯name：YELLOW
当前灯ordinal：2
当前灯：2
演示EnmuMap对象的使用和遍历.....
[key=RED,value=红灯]
[key=GREEN,value=绿灯]
[key=YELLOW,value=黄灯]
演示EnmuSet对象的使用和遍历.....
当前EnumSet中数据为：1
当前EnumSet中数据为：3
当前EnumSet中数据为：2
<4> 通常定义常量方法和枚举定义常量方法区别
1. 代码 :
public class State {
public static final int ON = 1;
public static final Int OFF = 0;
}
这样写有缺陷 :
<1> 不是类型安全的。你必须确保是int
<2> 要确保它的范围是 0 和 1
<3> 很多时候你打印出来的时候，你只看到 1 和 0 ，没有看到代码的人并不知道你的企图，抛弃你所有旧的public
static final常量
2. 可以创建一个enum类，把它看做一个普通的类。除了它不能继承其他类了 (java是单继承，它已经继承了Enum)
可以添加其他方法，覆盖它本身的方法
3. switch()参数可以使用enum了
4. values()方法是编译器插入到enum定义中的static方法，所以，当你将enum实例向上转型为父类Enum是，values()就不可访问。解决办法：在Class中有一个getEnumConstants()方法，所以即便Enum接口中没有values()方法，我们仍然可以通过Class对象取得所有的enum实例
5. 无法从enum继承子类，如果需要扩展enum中的元素，在一个接口的内部，创建实现该接口的枚举，以此将元素进行分组。达到将枚举元素进行分组
6. 使用EnumSet代替标志。enum要求其成员都是唯一的，但是enum中不能删除添加元素
7. EnumMap的key是enum，value是任何其他Object对象
8. enum允许程序员为eunm实例编写方法。所以可以为每个enum实例赋予各自不同的行为
9. 使用enum的职责链(Chain of Responsibility) .这个关系到设计模式的职责链模式。以多种不同的方法来解决一个问题。然后将他们链接在一起。当一个请求到来时，遍历这个链，直到链中的某个解决方案能够处理该请求
10. 使用enum的状态机
11. 使用enum多路分发
12.enum中的元素不能以数字开头，而常量定义方法可以
EnumSet
用来操作 Enum的集合，是一个抽象类，它有两个继承类 : JumboEnumSet 和 RegularEnumSet。其中包含的数据类型必须是 继承自Enum，由于每次add的时候，每个枚举值只占一个长整型的一位，因此其操作速度特别快
EnumMap
Map接口的实现，其key-value映射中的key是Enum类型，效率比HashMap高，可以直接获取数组下标索引并访问到元素
测试案例 :
public class
EnumTest {
public enum PictureType {
BMP("bmp",
0) {
@Override
public
String getInfo() {
return
"这是bmp格式图片";
}
public void getPrint() {
// 没有覆盖的方法无法直接访问
System.out.println("测试添加其他方法");
}
},
JPG("jpg",
1) {
@Override
public
String getInfo() {
return
"这是jpg格式图片";
}
},
JPEG("jpeg",
2) {
@Override
public
String getInfo() {
return
"这是jpeg格式图片";
}
},
PNG("png",
3) {
@Override
public
String getInfo() {
return
"这是png格式图片";
}
},
GIF("gif",
4) {
@Override
public
String getInfo() {
return
"这是gif格式图片";
}
};
private String
name;
private int
index;
/**
* 获取信息
*
*
@return
*/
public
String getInfo() {
return "";
}
// 构造函数不能是 public
private
PictureType(String name,
int index) {
this.name
= name;
this.index
= index;
}
public String getName() {
return
name;
}
public void setName(String name) {
this.name
= name;
}
public int getIndex() {
return
index;
}
public void setIndex(int
index) {
this.index
= index;
}
public static String getName(int
index) {
for (PictureType c : PictureType.values()) {
if
(c.getIndex() == index) {
return
c.name;
}
}
return null;
}
public static PictureType getPictureType(String name) {
for (PictureType c : PictureType.values()) {
if
(c.getName().equals(name)) {
return
c;
}
}
return null;
}
@Override
public
String toString() {
return "name="
+
this.getName() +
";index=" +
this.index;
}
}
public static void main(String[] args) {
// 访问其中某一值
System.out.println(PictureType.BMP.getName()
+ " => "
+ PictureType.BMP.getIndex());
System.out.println(PictureType.GIF.getName()
+ " => "
+ PictureType.GIF.getIndex());
// 遍历
PictureType[] all = PictureType.values();
StringBuilder sb;
for (PictureType a : all) {
sb =
new
StringBuilder();
sb.append("name:").append(a.getName())
.append(" index:").append(a.getIndex())
.append(" ordinal:").append(a.ordinal())
// 系统给出对应的索引号 基于0
.append(" 描述信息:").append(a.getInfo());
System.out.println(sb.toString());
}
// 修改其中的值，可以不提供 set 方法来防止数据被修改
PictureType.GIF.setName("嘻嘻哈哈");
System.out.println(PictureType.GIF
+
" => " + PictureType.GIF.getName());
// EnumSet
EnumSet<PictureType> ofSets = EnumSet.of(PictureType.BMP);
// of 创建一个最初包含指定元素的枚举 set
ofSets.add(PictureType.JPG);
for (PictureType en : ofSets) {
System.out.println("of
=> " + en.toString());
}
EnumSet<PictureType> allSets = EnumSet.allOf(PictureType.class);
// allOf 创建一个包含指定元素类型的所有元素的枚举 set
for
(PictureType en : allSets) {
System.out.println("allOf
=> " + en.toString());
}
EnumSet<PictureType> rangeSets = EnumSet.range(PictureType.BMP,
PictureType.JPEG);
// 创建一个指定范围 set
for
(PictureType en : rangeSets) {
System.out.println("range
=> " + en.toString());
}
EnumSet<PictureType> noneSets = EnumSet.noneOf(PictureType.class);
// 创建一个指定枚举类型的空set
noneSets.add(PictureType.BMP);
noneSets.add(PictureType.JPG);
noneSets.add(PictureType.JPEG);
Iterator<PictureType> iterable = noneSets.iterator();
while (iterable.hasNext()) {
System.out.println("noneOf
=> " + iterable.next().toString());
}
// EnumMap 其中的 key 是 Enum 类型因此操作速度比 HashMap 速度快，其才做方法和 HashMap 基本一样
Map<PictureType, String> map =
new EnumMap<>(PictureType.class);
map.put(PictureType.BMP,
"这是一个 BMP 格式图片");
}
}
enum 与 int、String 之间的转换
enum 的 name()方法，可以将 enum 元素转换成字符串，再通过 valueOf() 方法将 enum元素名称转换成
enum元素
String : enumType.name()
enumType : enum.valueOf(name)
int：enumType.value.ordinal()
enum : enum.values()[i]
java.lang.Enum 之外，可将其看做一个常规类，甚至可以有main方法
1> 常量
把相关的常量分组到一个枚举类型里，且枚举提供 比常量更多的方法
public enum
Color {
RED,
GREEN,
BLANK,
YELLOW
}
2> switch
switch语句只支持int, char, enum类型，使用枚举，能让我们的代码可读性更强
enum
Signal {
GREEN,
YELLOW,
RED
}
public class
TrafficLight {
Signal
color
= Signal.RED;
public void
change() {
switch
(color) {
case
RED:
color
= Signal.GREEN;
break;
case
YELLOW:
color
= Signal.RED;
break;
case
GREEN:
color
= Signal.YELLOW;
break;
}
}
}
3> 向枚举中添加新方法
自定义自己的方法，必须在 enum实例序列的最后添加一个分号，而且 Java 要求必须先定义 enum 实例，成员变量和枚举中的数据类型的顺序一一对应
如：回对实例自身的描述，而非默认的 toString 返回枚举实例的名字
public enum
Color {
RED("红色",
1),
GREEN("绿色",
2),
BLANK("白色",
3),
YELLO("黄色",
4);
// 成员变量
private
String name;
private int
index;
// 构造方法
private
Color(String name, int
index) {
this.name
= name;
this.index
= index;
}
// 普通方法
public static
String getName(int
index) {
for (Color c : Color.values()) {
if (c.getIndex() == index) {
return
c.name;
}
}
return null;
}
// get set 方法
public
String getName() {
return
name;
}
public void setName(String name) {
this.name
= name;
}
public int getIndex() {
return
index;
}
public void setIndex(int
index) {
this.index
= index;
}
}
注 : 1> 可以调用相应枚举成员的方法来生成相应的对象，比如下面的 OFType，可以这样使用：
OFType t = OFType.HELLO;
t.newInstance();
2> 构造方法的 访问权限 不能是 public
4> 覆盖枚举的方法
下面给出一个toString()方法覆盖的例子
public class
Test {
public enum Color {
RED("红色",
1),
GREEN("绿色",
2),
BLANK("白色",
3),
YELLO("黄色",
4);
// 成员变量
private
String name;
private int
index;
// 构造方法
private
Color(String name, int
index) {
this.name
= name;
this.index
= index;
}
// 覆盖方法
@Override
public
String toString() {
return this.index
+
"_" +
this.name;
}
}
public static void main(String[] args) {
System.out.println(Color.RED.toString());
}
}
注 : 所有的方法或其它必须放在枚举值的下面，且枚举的构造方法必须是 private
5> 实现接口
所有的枚举都继承自 java.lang.Enum类，由于Java 不支持多继承，所以枚举对象不能再继承其他类
public interface
Behaviour {
void print();
String getInfo();
}
public enum
Color
implements Behaviour {
RED("红色",
1),
GREEN("绿色",
2),
BLANK("白色",
3),
YELLO("黄色",
4);
// 成员变量
private
String name;
private int
index;
// 构造方法
private
Color(String name, int
index) {
this.name
= name;
this.index
= index;
}
// 接口方法
@Override
public
String getInfo() {
return this.name;
}
// 接口方法
@Override
public void
print() {
System.out.println(this.index
+
":" +
this.name);
}
}
6> 使用接口组织枚举
public interface
Food {
enum
Coffee
implements Food {
BLACK_COFFEE,
DECAF_COFFEE,
LATTE,
CAPPUCCINO
}
enum
Dessert
implements Food {
FRUIT,
CAKE,
GELATO
}
}
7> 关于枚举集合的使用
java.util.EnumSet 和 java.util.EnumMap 是两个枚举集合，EnumSet保证集合中的元素不重复；EnumMap中的 key是enum类型，而 value 则可以是任意类型
枚举和常量定义的区别
<1> 通常定义常量方法
通常利用 public final static方法 定义的代码如下，分别用1表示红灯，3表示绿灯，2表示黄灯
public class
Light {
/* 红灯 */
public final static int
RED
=
1;
/* 绿灯 */
public final static int
GREEN
=
3;
/* 黄灯 */
public final static int
YELLOW
=
2;
}
<2> 枚举类型定义常量方法
枚举类型的简单定义方法如下，似乎没办法定义每个枚举类型的值。比如定义红灯、绿灯和黄灯的代码可能如下 :
public enum Light {
RED,
GREEN,
YELLOW;
}
只能够表示出红灯、绿灯和黄灯，但是具体的值没办法表示出来。枚举类型提供了构造函数，可以通过构造函数和覆写toString方法来实现。首先给Light枚举类型增加构造方法，然后每个枚举类型的值通过构造函数传入对应的参数，同时覆写toString方法，在该方法中返回从构造函数中传入的参数，改造后的代码如下
:
public enum
Light {
// 利用构造函数传参
RED(1),
GREEN(3),
YELLOW(2);
// 定义私有变量
private int
nCode;
// 构造函数，枚举类型只能为私有
private
Light(int
_nCode) {
this.nCode
= _nCode;
}
@Override
public
String toString() {
return String.valueOf(this.nCode);
}
}
<3> 完整示例代码
枚举类型的完整演示代码如下 :
public class
LightTest {
// 1.定义枚举类型
public enum
Light {
// 利用构造函数传参
RED(1),
GREEN(3),
YELLOW(2);
// 定义私有变量
private int
nCode;
// 构造函数，枚举类型只能为私有
private
Light(int
_nCode) {
this.nCode
= _nCode;
}
@Override
public
String toString() {
return String.valueOf(this.nCode);
}
}
public static void main(String[] args) {
// 1.遍历枚举类型
System.out.println("演示枚举类型的遍历 ......");
testTraversalEnum();
// 2.演示EnumMap对象的使用
System.out.println("演示EnmuMap对象的使用和遍历.....");
testEnumMap();
// 3.演示EnmuSet的使用
System.out.println("演示EnmuSet对象的使用和遍历.....");
testEnumSet();
}
/** 演示枚举类型的遍历 */
private static void
testTraversalEnum() {
Light[] allLight = Light.values();
for (Light aLight : allLight) {
System.out.println("当前灯name："
+ aLight.name());// name() 是对应的大写字母 如：RED，GREEN，YELLOW
System.out.println("当前灯ordinal："
+ aLight.ordinal());// ordinal() 是对应的索引号 基于0
System.out.println("当前灯："
+ aLight);
}
}
/** 演示EnumMap的使用，EnumMap跟HashMap的使用差不多，只不过key要是枚举类型 */
private static void
testEnumMap() {
// 1.演示定义EnumMap对象，EnumMap对象的构造函数需要参数传入,默认是key的类的类型
EnumMap<Light, String> currEnumMap =
new EnumMap<Light, String>(Light.class);
currEnumMap.put(Light.RED,
"红灯");
currEnumMap.put(Light.GREEN,
"绿灯");
currEnumMap.put(Light.YELLOW,
"黄灯");
// 2.遍历对象
for
(Light aLight : Light.values()) {
System.out.println("[key="
+ aLight.name() +
",value=" + currEnumMap.get(aLight) +
"]");
}
}
/** 演示EnumSet如何使用，EnumSet是一个抽象类，获取一个类型的枚举类型内容，可以使用allOf方法 */
private static void
testEnumSet() {
EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);
for (Light aLightSetElement : currEnumSet) {
System.out.println("当前EnumSet中数据为："
+ aLightSetElement);
}
}
}
执行结果如下：
演示枚举类型的遍历 ......
当前灯name：RED
当前灯ordinal：0
当前灯：1
当前灯name：GREEN
当前灯ordinal：1
当前灯：3
当前灯name：YELLOW
当前灯ordinal：2
当前灯：2
演示EnmuMap对象的使用和遍历.....
[key=RED,value=红灯]
[key=GREEN,value=绿灯]
[key=YELLOW,value=黄灯]
演示EnmuSet对象的使用和遍历.....
当前EnumSet中数据为：1
当前EnumSet中数据为：3
当前EnumSet中数据为：2
<4> 通常定义常量方法和枚举定义常量方法区别
1. 代码 :
public class State {
public static final int ON = 1;
public static final Int OFF = 0;
}
这样写有缺陷 :
<1> 不是类型安全的。你必须确保是int
<2> 要确保它的范围是 0 和 1
<3> 很多时候你打印出来的时候，你只看到 1 和 0 ，没有看到代码的人并不知道你的企图，抛弃你所有旧的public
static final常量
2. 可以创建一个enum类，把它看做一个普通的类。除了它不能继承其他类了 (java是单继承，它已经继承了Enum)
可以添加其他方法，覆盖它本身的方法
3. switch()参数可以使用enum了
4. values()方法是编译器插入到enum定义中的static方法，所以，当你将enum实例向上转型为父类Enum是，values()就不可访问。解决办法：在Class中有一个getEnumConstants()方法，所以即便Enum接口中没有values()方法，我们仍然可以通过Class对象取得所有的enum实例
5. 无法从enum继承子类，如果需要扩展enum中的元素，在一个接口的内部，创建实现该接口的枚举，以此将元素进行分组。达到将枚举元素进行分组
6. 使用EnumSet代替标志。enum要求其成员都是唯一的，但是enum中不能删除添加元素
7. EnumMap的key是enum，value是任何其他Object对象
8. enum允许程序员为eunm实例编写方法。所以可以为每个enum实例赋予各自不同的行为
9. 使用enum的职责链(Chain of Responsibility) .这个关系到设计模式的职责链模式。以多种不同的方法来解决一个问题。然后将他们链接在一起。当一个请求到来时，遍历这个链，直到链中的某个解决方案能够处理该请求
10. 使用enum的状态机
11. 使用enum多路分发
12.enum中的元素不能以数字开头，而常量定义方法可以
EnumSet
用来操作 Enum的集合，是一个抽象类，它有两个继承类 : JumboEnumSet 和 RegularEnumSet。其中包含的数据类型必须是 继承自Enum，由于每次add的时候，每个枚举值只占一个长整型的一位，因此其操作速度特别快
EnumMap
Map接口的实现，其key-value映射中的key是Enum类型，效率比HashMap高，可以直接获取数组下标索引并访问到元素
测试案例 :
public class
EnumTest {
public enum PictureType {
BMP("bmp",
0) {
@Override
public
String getInfo() {
return
"这是bmp格式图片";
}
public void getPrint() {
// 没有覆盖的方法无法直接访问
System.out.println("测试添加其他方法");
}
},
JPG("jpg",
1) {
@Override
public
String getInfo() {
return
"这是jpg格式图片";
}
},
JPEG("jpeg",
2) {
@Override
public
String getInfo() {
return
"这是jpeg格式图片";
}
},
PNG("png",
3) {
@Override
public
String getInfo() {
return
"这是png格式图片";
}
},
GIF("gif",
4) {
@Override
public
String getInfo() {
return
"这是gif格式图片";
}
};
private String
name;
private int
index;
/**
* 获取信息
*
*
@return
*/
public
String getInfo() {
return "";
}
// 构造函数不能是 public
private
PictureType(String name,
int index) {
this.name
= name;
this.index
= index;
}
public String getName() {
return
name;
}
public void setName(String name) {
this.name
= name;
}
public int getIndex() {
return
index;
}
public void setIndex(int
index) {
this.index
= index;
}
public static String getName(int
index) {
for (PictureType c : PictureType.values()) {
if
(c.getIndex() == index) {
return
c.name;
}
}
return null;
}
public static PictureType getPictureType(String name) {
for (PictureType c : PictureType.values()) {
if
(c.getName().equals(name)) {
return
c;
}
}
return null;
}
@Override
public
String toString() {
return "name="
+
this.getName() +
";index=" +
this.index;
}
}
public static void main(String[] args) {
// 访问其中某一值
System.out.println(PictureType.BMP.getName()
+ " => "
+ PictureType.BMP.getIndex());
System.out.println(PictureType.GIF.getName()
+ " => "
+ PictureType.GIF.getIndex());
// 遍历
PictureType[] all = PictureType.values();
StringBuilder sb;
for (PictureType a : all) {
sb =
new
StringBuilder();
sb.append("name:").append(a.getName())
.append(" index:").append(a.getIndex())
.append(" ordinal:").append(a.ordinal())
// 系统给出对应的索引号 基于0
.append(" 描述信息:").append(a.getInfo());
System.out.println(sb.toString());
}
// 修改其中的值，可以不提供 set 方法来防止数据被修改
PictureType.GIF.setName("嘻嘻哈哈");
System.out.println(PictureType.GIF
+
" => " + PictureType.GIF.getName());
// EnumSet
EnumSet<PictureType> ofSets = EnumSet.of(PictureType.BMP);
// of 创建一个最初包含指定元素的枚举 set
ofSets.add(PictureType.JPG);
for (PictureType en : ofSets) {
System.out.println("of
=> " + en.toString());
}
EnumSet<PictureType> allSets = EnumSet.allOf(PictureType.class);
// allOf 创建一个包含指定元素类型的所有元素的枚举 set
for
(PictureType en : allSets) {
System.out.println("allOf
=> " + en.toString());
}
EnumSet<PictureType> rangeSets = EnumSet.range(PictureType.BMP,
PictureType.JPEG);
// 创建一个指定范围 set
for
(PictureType en : rangeSets) {
System.out.println("range
=> " + en.toString());
}
EnumSet<PictureType> noneSets = EnumSet.noneOf(PictureType.class);
// 创建一个指定枚举类型的空set
noneSets.add(PictureType.BMP);
noneSets.add(PictureType.JPG);
noneSets.add(PictureType.JPEG);
Iterator<PictureType> iterable = noneSets.iterator();
while (iterable.hasNext()) {
System.out.println("noneOf
=> " + iterable.next().toString());
}
// EnumMap 其中的 key 是 Enum 类型因此操作速度比 HashMap 速度快，其才做方法和 HashMap 基本一样
Map<PictureType, String> map =
new EnumMap<>(PictureType.class);
map.put(PictureType.BMP,
"这是一个 BMP 格式图片");
}
}
enum 与 int、String 之间的转换
enum 的 name()方法，可以将 enum 元素转换成字符串，再通过 valueOf() 方法将 enum元素名称转换成
enum元素
String : enumType.name()
enumType : enum.valueOf(name)
int：enumType.value.ordinal()
enum : enum.values()[i]
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 枚举详解 自定义方法 EnumSet，EnumMap 的应用
- JavaSE第六十讲 EnumSet与EnumMap详解
- Java enum的用法详解
- 熟练使用java的Enum、EnumSet、EnumMap
- Java enum的用法详解
- [Java基础] Java enum的用法详解
- Java enum的用法详解
- Java enum的用法详解
- java enum(枚举)使用详解
- Java enum的用法详解
- java enum(枚举)使用详解 + 总结
- java enum(枚举)使用详解 + 总结
- JDK5.0新特性：枚举类型enum、枚举集合EnumSet、枚举映射EnumMap
- java enum(枚举)使用详解 + 总结
- Java enum的用法详解
- EffectiveJava(33) -- EnumMap详解(使用EnumMap代替序数)
- Java enum的用法详解
- Enum、EnumMap、EnumSet的用法讲解
- java enum(枚举)使用详解 + 总结
- Java中的枚举――EnumMap与EnumSet