前言

Github:https://github.com/HealerJean

博客:http://blog.healerjean.com

JavaUtil包:http://gitbook.net/java/util/index.html

1、java.util;

1.1、EnumSet

package java.util;

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
    implements Cloneable, java.io.Serializable
{
1 static > EnumSet allOf(Class elementType) 此方法创建一个包含所有在指定元素类型的元素的枚举set。
2 EnumSet clone() 此方法返回这个集合的一个副本。
3 static > EnumSet complementOf(EnumSet s) 此方法创建一个枚举设置相同的元素类型与指定枚举set,最初包含此类型的所有未包含指定集合中的元素。
4 static > EnumSet copyOf(Collection c) 此方法创建一个枚举集从指定集合初始化。
5 static > EnumSet copyOf(EnumSet s) 此方法创建一个枚举设置相同的元素类型与指定枚举set,最初包含相同的元素(如果有的话)。
6 static > EnumSet noneOf(Class elementType) 此方法创建一个空的枚举set具有指定元素类型。
7 static > EnumSet of(E e) 此方法创建一个最初包含指定元素的枚举set。
8 static > EnumSet of(E first, E… rest) 此方法创建一个最初包含指定元素的枚举set。可变参数效率会低一些
9 static > EnumSet of(E e1, E e2) 此方法创建一个最初包含指定元素的枚举set。
10 static > EnumSet of(E e1, E e2, E e3) 此方法创建一个最初包含指定元素的枚举set。
11 static > EnumSet of(E e1, E e2, E e3, E e4) 此方法创建一个最初包含指定元素的枚举set。
12 static > EnumSet of(E e1, E e2, E e3, E e4, E e5) 此方法创建一个最初包含指定元素的枚举set。
13 static > EnumSet range(E from, E to) 此方法创建最初包含由两个指定端点所定义范围的元素的枚举set。
public enum DayEnum {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

1.1.1、EnumSet.noneOf

noneOf返回的Set为空


@Test
public void noneOf(){
  //
  Set<DayEnum> days = EnumSet.noneOf(DayEnum.class);
  log.info("Set<DayEnum> = {} ", days);
  days.add(DayEnum.SATURDAY);
  days.add(DayEnum.SUNDAY);
  log.info("Set<DayEnum> = {} ", days);

  // []
  // [SATURDAY, SUNDAY]
}

1.1.2、EnumSet.of

创建一个最初包含指定元素的枚举set

@Test
public void of(){
  Set<DayEnum> days = EnumSet.of(DayEnum.MONDAY, DayEnum.THURSDAY);
  log.info("Set<DayEnum> = {} ", days);
  // Set<DayEnum> = [MONDAY, THURSDAY]
}

1.1.3、EnumSet.allOf

获取所有的枚举,放入set集合

@Test
public void allOf(){
  Set<DayEnum> days = EnumSet.allOf(DayEnum.class);
  log.info("Set<DayEnum> = {} ", days);
  // Set<DayEnum> = [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
}

1.1.4、EnumSet.range

枚举内顺序导出数据

@Test
public void range(){
  Set<DayEnum> range = EnumSet.range(DayEnum.TUESDAY, DayEnum.FRIDAY);
  log.info("Set<DayEnum> = {} ", range);
  // Set<DayEnum> = [TUESDAY, WEDNESDAY, THURSDAY, FRIDAY]
}

1.1.5、EnumSet.complementOf

从其补充初始化枚举设置此枚举set

@Test
public void (){
  EnumSet<DayEnum> days = EnumSet.of(DayEnum.MONDAY, DayEnum.THURSDAY);
  log.info("Set<DayEnum> = {} ", days);
  // Set<DayEnum> = [MONDAY, THURSDAY]
  EnumSet<DayEnum> days2 = EnumSet.complementOf(days);
  log.info("Set<DayEnum> = {} ", days2);
  // Set<DayEnum> = [TUESDAY, WEDNESDAY, FRIDAY, SATURDAY, SUNDAY]
}

1.1.6、EnumSet.copyOf

从集合类中复制数据


@Test
public void copyOf(){
  List<DayEnum> dayList = ImmutableList.of(DayEnum.MONDAY, DayEnum.THURSDAY, DayEnum.THURSDAY);
  EnumSet<DayEnum> daySet = EnumSet.copyOf(dayList);
  // Set<DayEnum> = [MONDAY, THURSDAY]
  log.info("Set<DayEnum> = {} ", dayList);
  // Set<DayEnum> = [MONDAY, THURSDAY, THURSDAY]
}


1.2、Collections

1.2.1、Collections.emptyList()


@Test
public void newArrayList1(){
  List<Integer> list = Collections.emptyList();
  log.info("list:{}", list );
  
  //list:[]
}

1.2.2、Collections.singletonList("A")

@Test
public void test(){
  List<String> strList2 = Collections.singletonList("A");
  strList2.add("B");
  log.info("strList2:{}", strList2 );
  //抛出异常,因为是不可变的
}

2、com.google.common.collect


2.1、ImmutableMap

不可改变的Map,修改会报错

2.1.1、ImmutableMap.of

@Test
public void test() {
  Map<String, String> map = ImmutableMap.of("keyA", "A", "keyB", "B");
  log.info("ImmutableMap.of = {}", map);
  //ImmutableMap.of = {keyA=A, keyB=B}

  map.put("keyN" ,"N");
  //抛出异常,因为是不可变的
}

2.2、ImmutableSet

不可变的set

@Test
public void test() {
  Set<String> immutalbleSet = ImmutableSet.of("A", "B", "C");
  log.info("ImmutableSet.of ={}" , immutalbleSet);
  //ImmutableSet.of =[A, B, C]

  immutalbleSet.add("C");
  //抛出异常,因为是不可变的
}

3.3、Lists

3.3.1、newArrayList

/**
  * 1、构建一个空的ArrayList
  */
@Test
public void newArrayList1(){
  List<Integer> list = Lists.newArrayList();
  log.info("list:{}", list );
}

/**
  * 2、直接创建
  */
@Test
public void newArrayList2(){
  List<String> list = Lists.newArrayList("a", "b");
  log.info("list:{}", list );
}

3.4、ImmutableList

不可变的list

/**
  * 3、不可变的List
  */
@Test
public void test3(){
  List<String> list = ImmutableList.of("a", "b");
  log.info("list:{}", list );

  list.add("c");
  //抛出异常,因为是不可变的

}

3、org.apache.commons

3.1、Pair

元素对

3.1.1、ImmutablePair

3.1.1.1、ImmutablePair.of

ImmutablePair不可变的左右元素对

ImmutablePair<Integer, Double> result = ImmutablePair.of(ASSISTANT_SHOULD_CLOSE, distance);

3.2、MapUtils

3.2.1、MapUtils.isNotEmpty

MapUtils.isNotEmpty(actionTimeMap)

3.2.2、getBooleanValuegetBoolean

public static boolean getBooleanValue(Map map, Object key) {
  Boolean booleanObject = getBoolean(map, key);
  return booleanObject == null ? false : booleanObject;
}

public static boolean getBooleanValue(Map map, Object key, boolean defaultValue) {
  Boolean booleanObject = getBoolean(map, key);
  return booleanObject == null ? defaultValue : booleanObject;
}



public static Boolean getBoolean(Map map, Object key) {
  if (map != null) {
    Object answer = map.get(key);
    if (answer != null) {
      if (answer instanceof Boolean) {
        return (Boolean)answer;
      }

      if (answer instanceof String) {
        return new Boolean((String)answer);
      }

      if (answer instanceof Number) {
        Number n = (Number)answer;
        return n.intValue() != 0 ? Boolean.TRUE : Boolean.FALSE;
      }
    }
  }

  return null;
}

3.2.3、getLongValuegetLong

public static long getLongValue(Map map, Object key) {
  Long longObject = getLong(map, key);
  return longObject == null ? 0L : longObject;
}

public static long getLongValue(Map map, Object key, long defaultValue) {
  Long longObject = getLong(map, key);
  return longObject == null ? defaultValue : longObject;
}


public static Long getLong(Map map, Object key) {
  Number answer = getNumber(map, key);
  if (answer == null) {
    return null;
  } else {
    return answer instanceof Long ? (Long)answer : new Long(answer.longValue());
  }
}



public static Number getNumber(Map map, Object key) {
  if (map != null) {
    Object answer = map.get(key);
    if (answer != null) {
      if (answer instanceof Number) {
        return (Number)answer;
      }

      if (answer instanceof String) {
        try {
          String text = (String)answer;
          return NumberFormat.getInstance().parse(text);
        } catch (ParseException var4) {
        }
      }
    }
  }

  return null;
}

3.2.4、getObject

public static Object getObject(Map map, Object key) {
  return map != null ? map.get(key) : null;
}


public static Object getObject(Map map, Object key, Object defaultValue) {
  if (map != null) {
    Object answer = map.get(key);
    if (answer != null) {
      return answer;
    }
  }

  return defaultValue;
}

3.2.5、getString

  public static String getString(Map map, Object key) {
        if (map != null) {
            Object answer = map.get(key);
            if (answer != null) {
                return answer.toString();
            }
        }

        return null;
    }
public static String getString(Map map, Object key, String defaultValue) {
  String answer = getString(map, key);
  if (answer == null) {
    answer = defaultValue;
  }

  return answer;
}


public static String getString(Map map, Object key) {
  if (map != null) {
    Object answer = map.get(key);
    if (answer != null) {
      return answer.toString();
    }
  }

  return null;
}

ContactAuthor