Java常用类库
前言
Github:https://github.com/HealerJean
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、Map
2.1.1、Maps
2.1.1.1、Maps.newHashMap
/**
* 1、创建一个空的Map
*/
@Test
public void test(){
Map<String, String> map = Maps.newHashMap();
map.put("name", "HealerJean");
log.info("map:{}", map);
}
2.1.1、ImmutableMap
不可改变的
Map
,修改会报错
2.1.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.1.3、常用方法
2.1.3.1、computeIfAbsent
computeIfAbsent()
方法对hashMap
中指定key
的值进行重新计算,如果不存在这个key
,则添加到hashMa
p 中。返回值:如果
key
对应的value
不存在,则使用获取remappingFunction
重新计算后的值,并保存为该key
的value
,否则返回value
。
/**
* 2、computeIfAbsent
*/
@Test
public void test02(){
Map<String, List<String>> map = Maps.newHashMap();
map.put("a", Lists.newArrayList("aVal"));
// "a" 已经存在, 则追加 "aNewVal" 到list中
map.computeIfAbsent("a", (v) -> new ArrayList<>()).add("aNewVal");
// "b" 不存在, 则创建新List "aNewVal" 到list中
map.computeIfAbsent("b", (v) -> new ArrayList<>()).add("bVal");
System.out.println(map);
// "c" valul为空, 则创建新 List "aNewVal" 到list中
map.put("c", null);
map.computeIfAbsent("c", (v) -> new ArrayList<>()).add("cVal");
System.out.println(map);
// {a=[aVal, aNewVal], b=[bVal], c=[cVal]}
}
2.1.3.2、putIfAbsent
putIfAbsent()
方法会先判断指定的键(key
)是否存在,不存在则将键/值对插入到HashMap
中。返回值:如果所指定的
key
已经在HashMap
中存在,返回和这个key
值对应的value
, 如果所指定的key
不在HashMap
中存在,则返回null
。
/**
* 3、putIfAbsent
*/
@Test
public void test03(){
Map<String,String> map = Maps.newHashMap();
map.put("a", "aVal");
// "a"已经存在,则不会覆盖
map.putIfAbsent("a", "aNewVal");
// "b"不存在,则放入
map.putIfAbsent("b", "bVal");
// "c" value null,则放入
map.put("c", null);
map.putIfAbsent("c", "cVal");
System.out.println(map);
// {a=aVal, b=bVal, c=cVal}
}
2.1.3.3、一行代码构建map
Map<String, String> map = new HashMap<String, String>() ;
2.2、Set
2.2.1、Sets
2.2.1.1、构建和转化
/**
* 1、构建一个空的Set
*/
@Test
public void test1(){
Set<String> set = Sets.newHashSet();
}
/**
* 2、构建有值的Set
*/
@Test
public void test2(){
Set<String> set = Sets.newHashSet("a", "a", "b");
log.info("set:{}", set);
}
/**
* 3、list转Set
*/
@Test
public void test3(){
List<String> list = Lists.newArrayList("a", "a", "b");
Set<String> set = Sets.newHashSet(list);
log.info("set:{}", set);
}
2.2.1.2、并集、交集、差集
// 差集
Sets.SetView<String> difference = Sets.difference(orderIdSet, existOrderIdSet);
2.2.2、ImmutableSet
2.2.1.2、ImmutableSet.of
不可变的
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");
//抛出异常,因为是不可变的
}
2.3、List
2.3.1、Lists
3.3.1.1、Lists.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、set转list
*/
@Test
public void test3(){
Set<String> set = Sets.newHashSet("a", "a", "b");
List<String> list = Lists.newArrayList(set);
log.info("list:{}", list );
}
2.3.1.2、Lists.partition
List<List> list1 =Lists.partition(list, 1000);
2.3.2、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、getBooleanValue
、getBoolean
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、getLongValue
、getLong
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;
}
3.3、CollectionUtils
3.3.1、并集 CollectionUtils.union
public static void main(String[] args) {
String[] arrayA = new String[] { "1", "2", "3", "4"};
String[] arrayB = new String[] { "3", "4", "5", "6" };
List<String> listA = Arrays.asList(arrayA);
List<String> listB = Arrays.asList(arrayB);
//1、并集 union
System.out.println(CollectionUtils.union(listA, listB));
//输出: [1, 2, 3, 4, 5, 6]
}
3.3.2、交集 CollectionUtils.intersection
、CollectionUtils.containsAny
public static void main(String[] args) {
String[] arrayA = new String[] { "1", "2", "3", "4"};
String[] arrayB = new String[] { "3", "4", "5", "6" };
List<String> listA = Arrays.asList(arrayA);
List<String> listB = Arrays.asList(arrayB);
//2、交集 intersection
System.out.println(CollectionUtils.intersection(listA, listB));
//输出:[3, 4]
// true
System.out.println(CollectionUtils.containsAny(listA, listB));
}
3.3.3、差集 CollectionUtils.subtract
public static void main(String[] args) {
String[] arrayA = new String[] { "1", "2", "3", "4"};
String[] arrayB = new String[] { "3", "4", "5", "6" };
List<String> listA = Arrays.asList(arrayA);
List<String> listB = Arrays.asList(arrayB);
//4、差集(扣除)
System.out.println(CollectionUtils.subtract(listA, listB));
//输出:[1, 2]
}
3.3.4、交集的补集 CollectionUtils.disjunction
public static void main(String[] args) {
String[] arrayA = new String[] { "1", "2", "3", "4"};
String[] arrayB = new String[] { "3", "4", "5", "6" };
List<String> listA = Arrays.asList(arrayA);
List<String> listB = Arrays.asList(arrayB);
//3、交集的补集(析取)disjunction
System.out.println(CollectionUtils.disjunction(listA, listB));
//输出:[1, 2, 5, 6]
}
4、cn.hutool
hutool-aop | JDK 动态代理封装,提供非 IOC 下的切面支持 |
hutool-bloomFilter | 布隆过滤,提供一些 Hash 算法的布隆过滤 |
hutool-cache | 缓存 |
hutool-core | 核心,包括 Bean 操作、日期、各种 Util 等 |
hutool-cron | 定时任务模块,提供类 Crontab 表达式的定时任务 |
hutool-crypto | 加密解密模块 |
hutool-db | JDBC 封装后的数据操作,基于 ActiveRecord 思想 |
hutool-dfa | 基于 DFA 模型的多关键字查找 |
hutool-extra | 扩展模块,对第三方封装(模板引擎、邮件等) |
hutool-http | 基于 HttpUrlConnection 的 Http 客户端封装 |
hutool-log | 自动识别日志实现的日志门面 |
hutool-script | 脚本执行封装,例如 Javascript |
hutool-setting | 功能更强大的 Setting 配置文件和 Properties 封装 |
hutool-system | 系统参数调用封装(JVM 信息等) |
hutool-json | JSON 实现 |
hutool-captcha | 图片验证码实现 |
4.1、DesensitizedUtil
4.1.1、脱敏
方法 | 说明 |
---|---|
mobilePhone(phone) |
手机号 输出:137****1234 |
bankCard(bankCard) |
银行卡号 输出:6217 **** **** *** 5666 |
idCardNum(idCardNum, 4, 2) |
身份证号 输出:4110************21 |
password(password) |
密码 输出:**************** |
email(email) |
邮箱 输出:h*********@gmail.com |
desensitized(address, DesensitizedUtil.DesensitizedType.ADDRESS) |
地址 输出:我******** |
StrUtil.hide(any, 2, 7) |
脱敏任意长度 输出:我******** |
/**
* 脱敏
* 1、手机号 输出:137****1234
* 2、银行卡号 输出:6217 **** **** *** 5666
* 3、身份证号 输出:4110************21
* 4、密码 输出:****************
* 5、邮箱 输出:h*********@gmail.com
* 6、地址 输出:我********
* 7、脱敏任意长度 输出:我********
*
*/
@Test
public void test() {
// 1、手机号 输出:137****1234
String phone = "13723231234";
System.out.println(DesensitizedUtil.mobilePhone(phone));
// 2、银行卡号 输出:6217 **** **** *** 5666
String bankCard = "6217000130008255666";
System.out.println(DesensitizedUtil.bankCard(bankCard));
// 3、身份证号 输出:4110************21
String idCardNum = "411021199901102321";
//只显示前4位和后2位
System.out.println(DesensitizedUtil.idCardNum(idCardNum, 4, 2));
// 4、密码 输出:****************
String password = "www.jd.com_35711";
System.out.println(DesensitizedUtil.password(password));
// 5、邮箱 输出:h*********@gmail.com
String email = "healerjean@gmail.com";
System.out.println(DesensitizedUtil.email(email));
// 6、地址 输出:我********
String address = "我家在那山沟沟里面";
String desensitizedAddress = DesensitizedUtil.desensitized(address,
DesensitizedUtil.DesensitizedType.ADDRESS);
System.out.println(desensitizedAddress);
// 7、脱敏任意长度 输出:我********
String any ="1234567890";
System.out.println(StrUtil.hide(any, 2, 7));
}
4.2、StrUtil
4.2.1、StrUtil.format
/**
* StrUtil
* 1、StrUtil.format.
*/
@Test
public void test001(){
String result = StrUtil.format("Hello, {0}", "world");
System.out.println(result);
// 输出:Hello, world
}
4.3、DateUtil
4.3.1、DateUtil.format
、DateUtil.parse
方法 |
---|
DateUtil.format(date, "yyyy-MM-dd HH:mm:ss"); |
DateUtil.parse(dateStr, "yyyy-MM-dd HH:mm:ss") |
/**
* DateUtil
* 1、DateUtil.format、DateUtil.parse
*/
@Test
public void test101() {
Date date = new Date();
String format = DateUtil.format(date, "yyyy-MM-dd HH:mm:ss");
System.out.println(format);
// 输出:2023-03-15 10:30:15
String dateStr = "2023-03-15 10:30:15";
date = DateUtil.parse(dateStr, "yyyy-MM-dd HH:mm:ss");
System.out.println(date);
// 输出:Tue Mar 15 10:30:15 CST 2023`
}
4.4、NumberUtil
方法 | 说明 |
---|---|
add(Number a, Number b) |
加法 |
sub(Number a, Number b) |
减法 |
mul(Number a, Number b) |
乘法 |
div(Number a, Number b) |
除法 |
div(Number v1, Number v2, int scale, RoundingMode roundingMode) |
除法,保留小数和进位规则 |
round(Number num, int decimalPlaces) |
保留指定位数小数,四舍五入 |
isNumber(String str) |
判断字符串是否是数字 |
isInteger(String str) |
判断是否是 Integer |
isDouble(String str) |
判断是否是 Double |
4.5、PageUtil
方法 | 说明 |
---|---|
totalPage(int total, int size) |
根据总记录数和每页容量计算总页数 |