JDK基础类库java.util包下那些你可能不知道的工具们大盘点（一）EnumMap、EnumSet【享学Java】（上）

public enum Color {
    RED, BLACK, WHITE, GREEN
}
public class Main {
    public static void main(String[] args) {
        // 它没有空构造，必须制定枚举class类型。当然构造函数也可以接收一个Mapnew EnumMap<>(EnumMap/Map);
        Map<Color, String> map = new EnumMap<>(Color.class);
        map.put(Color.RED, "红色");
        map.put(Color.BLACK, "黑色");
        map.put(Color.WHITE, "白色");
        map.put(Color.WHITE, "白色"); // 故意重复放一个
        // 遍历：发现EnumMap它的存储是有序的
        map.forEach((k, v) -> System.out.print(k + ":" + v + "   "));
        System.out.println();
        // 可以看到，它并不会发生并发修改异常ConcurrentModificationException
        map.forEach((k, v) -> {
            if (k == Color.WHITE) {
                map.put(Color.GREEN, "绿色");
            }
            System.out.print(k + ":" + v + "   ");
        });
        // key不允许为null  java.lang.NullPointerException
        map.put(null,"未知");
    }
}

RED:红色   BLACK:黑色   WHITE:白色   
RED:红色   BLACK:黑色   WHITE:白色   GREEN:绿色   
红色
Exception in thread "main" java.lang.NullPointerException
  at java.util.EnumMap.typeCheck(EnumMap.java:743)
  at java.util.EnumMap.put(EnumMap.java:267)
  at java.util.EnumMap.put(EnumMap.java:79)
  at com.fsx.maintest.Main.main(Main.java:40)

// @since 1.5  继承自AbstractMap，所以它也能够当作Map来使用
public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V> implements java.io.Serializable, Cloneable {
  // 所有key都必须这个类型
    private final Class<K> keyType; 
    // 简单的说它把所有的key（枚举）都缓存起来  此处用的数组
    private transient K[] keyUniverse;
  // 所有的值  也是数组  它的length和keyUniverse是相同的
    private transient Object[] vals;
  // 它的get方法，直接根据ordinal()去数组找了  这就是它快最为核心的原因
    public V get(Object key) {
        return (isValidKey(key) ? unmaskNull(vals[((Enum<?>)key).ordinal()]) : null);
    }
}

public class ColorMap extends EnumMap<Color, String> {
    public ColorMap() {
        super(Color.class);
    }
}
public class Main {
    public static void main(String[] args) {
        Map<Color, String> map = new ColorMap();
        map.put(Color.BLACK, "黑色");
        System.out.println(map.get(Color.BLACK)); //黑色
    }
}

public class Main {
    public static void main(String[] args) {
        Set<Color> set = EnumSet.allOf(Color.class);
        System.out.println(set); //[RED, BLACK, WHITE, GREEN]
        set = EnumSet.noneOf(Color.class);
        System.out.println(set); //[]
        // 添加元素
        set.add(Color.RED);
        set.add(Color.BLACK);
        System.out.println(set); //[RED, BLACK]
        // 自己人工指定
        set = EnumSet.of(Color.WHITE, Color.BLACK, Color.WHITE);
        System.out.println(set); //[BLACK, WHITE]  请注意这个顺序并不是上面add的顺序  毕竟自己去重了
        // 根据区间来创建
        set = EnumSet.range(Color.BLACK, Color.GREEN);
        //set = EnumSet.range(Color.GREEN, Color.BLACK); // 这样抛出异常了， java.lang.IllegalArgumentException: GREEN > BLACK
        System.out.println(set); //[BLACK, WHITE, GREEN] 可以看到含头含尾的
        // 相当于取差集的意思~
        System.out.println(EnumSet.complementOf((EnumSet) set)); //[RED]
        // copyOf方法克隆一个（请注意是克隆，并不是返回的一个视图）
        System.out.println(EnumSet.copyOf((EnumSet) set)); //[BLACK, WHITE, GREEN]
    }
}

[RED, BLACK, WHITE, GREEN]
[]
[RED, BLACK]
[BLACK, WHITE]
[BLACK, WHITE, GREEN]
[RED]
[BLACK, WHITE, GREEN]

// @since 1.5
public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E> implements Cloneable, java.io.Serializable { ... }
//@since 1.5  访问权限非public 属于内建类
class RegularEnumSet<E extends Enum<E>> extends EnumSet<E> {
    public boolean add(E e) {
        typeCheck(e);
        long oldElements = elements;
        elements |= (1L << ((Enum<?>)e).ordinal());
        return elements != oldElements;
    }
}

public class Main {
    public static void main(String[] args) {
    // 它只能靠构造函数把分隔符传进去
    // 若不指定分隔符，默认使用" \t\n\r\f"去分割
        StringTokenizer st1 = new StringTokenizer("Hello Geeks How are you", " ");
        while (st1.hasMoreTokens())
            System.out.println(st1.nextToken());
        StringTokenizer st2 = new StringTokenizer("JAVA : Code : String", " :");
        while (st2.hasMoreTokens())
            System.out.println(st2.nextToken());
        StringTokenizer st3 = new StringTokenizer("JAVA : Code : String", " :", true);
        while (st3.hasMoreTokens())
            System.out.println(st3.nextToken());
    }
}

public class Main {
    public static void main(String[] args) {
        String[] strs = {"wo", "ai", "ni"};
        // 使用原始的StringBuider方式~
        StringBuilder sb = new StringBuilder();
        Arrays.stream(strs).forEach(s -> {
            sb.append(s);
            sb.append(",");
        });
        System.out.println(sb.substring(0, sb.lastIndexOf(","))); //wo,ai,ni
    // String内置的工具类方式  它底层还是使用的StringBuilder
        System.out.println(StringUtils.arrayToDelimitedString(strs, ",")); //wo,ai,ni
        //使用StringJoiner
        StringJoiner sj = new StringJoiner(",");
        Arrays.stream(strs).forEach(x -> sj.add(x));
        System.out.println(sj); //wo,ai,ni
    }
}