Apache Commons Lang使用总结
最后更新于
这有帮助吗？
最后更新于
这有帮助吗？
package lang3;
import lang3.util.Log;
import org.apache.commons.lang3.StringUtils;
import org.junit.Test;
import java.util.Locale;
import static org.apache.commons.lang3.StringUtils.*;
/**
* StringUtilsDemo
* <p>
* 空白字符
* 空格 \s
* 回车 \n
* 换行 \r
* 制表 \t
* <p>
*
* @author Feathers
* @date 2018-05-18 14:15
*/
public class StringUtilsDemo {
public static final String NULL = "Null";
public static final String EMPTY = "Empty";
public static final String STR_NULL = null;
public static final String STR_EMPTY = "";
public static final String STR_BLANK = " ";
@Test
public void testConstant() {
String cr = StringUtils.CR; // \r
String lf = StringUtils.LF; // \n
String space = StringUtils.SPACE; // " "
String empty = StringUtils.EMPTY; // ""
}
@Test
public void testLength() {
Log.i(length(null));
}
/**
* 字符串数据类型判断
*/
@Test
public void testIs() {
Log.i("判断字符串是否为Empty", isEmpty(""));
Log.i("判断字符串是否为Blank", isBlank("\n\t "));
Log.i("判断字符是否不是Empty", isNoneEmpty(""));
Log.i("判断字符是否不是Blank", isNoneBlank(" "));
Log.i("判断字符串内容是否为数字 123", isNumeric("123"));
Log.i("判断字符串内容是否为数字 123 ", isNumeric("123 "));
Log.i("判断字符串内容是否为数字 123.4", isNumeric("123.4"));
Log.i("判断字符串内容是否为数字 12 3", isNumeric("12 3"));
Log.i("判断字符串是否为纯Unicode字符组成", isAlpha("啊打发"));
Log.i("判断字符串是否为纯Unicode字符组成 2,\\n, \\s等字符都属于ASCII", isAlpha("啊打发2"));
Log.i("判断字符串是否为纯Unicode字符组成 空字符串/null会返回false", isAlpha(""));
Log.i("判断字符串是否为纯Unicode字符以及空格组成", isAlphaSpace("沙发上 "));
Log.i("判断字符串是否为纯Unicode字符以及数字组成", isAlphanumeric("沙发上123"));
Log.i("判断字符串是否为纯Unicode字符以及数字和空格组成", isAlphanumericSpace("沙发上 123"));
Log.i("判断字符串是否全为小写字母", isAllLowerCase("ad"));
Log.i("判断字符串是否全为小写字母,只允许出现小写字母，如果有其他字符，比如汉字、数字，会返回false", isAllLowerCase("ads123"));
Log.i("判断字符串是否全为大写字母", isAllUpperCase("AD"));
Log.i("判断字符串时大小写混合", isMixedCase("ADa"));
Log.i("判断字符串时大小写混合 可以包含其他中文、数字字符", isMixedCase("ADa 哈"));
}
/**
* trim 操作只会去除字符串两侧的空白字符
* 去空格操作 trim if null then null
* 去空格操作 trimToEmpty if null/"" then ""
*/
@Test
public void testTrim() {
Log.i("---------trim------");
Log.i("a_b", trim("a b"));
Log.i(NULL, trim(STR_NULL));
Log.i("--------trimToNull------");
Log.i(NULL, trimToNull(STR_NULL));
Log.i(EMPTY, trimToNull(STR_EMPTY));
Log.i("--------trimToEmpty------");
Log.i(NULL, trimToEmpty(STR_NULL).length());
Log.i(EMPTY, trimToEmpty(STR_EMPTY).length());
}
/**
* 移除字符串文本末尾出的\n，\r，\n\r 即回车符
*/
@Test
public void testChomp() {
Log.i(chomp("a\n\r"));
}
/**
* 去除指定的字符，如果不传，则默认去除空白字符
* strip 去除两侧占位符
* stripStart 去除字符串开始的指定字符
* stripEnd 去除字符串结束的指定字符
* stripAll 批量处理
* stripAccents 去除字符串中的变音符号 #,b,x,bb,ヰ
*/
@Test
public void testStrip() {
Log.i("---------strip-----------");
String target = " a b ";
Log.i("去除两侧的空白字符\t\t", strip(target));
Log.i("去除两侧的指定字符\t\t", strip(target, "\\s"));
Log.i("去除开始的的指定字符\t", stripStart(target, "\\s"));
Log.i("去除字符串结束的指定字符\t", stripEnd(target, "\\s"));
Log.i("---------stripToEmpty-----------");
// 将空白字符进行strip操作，如果得到""或null 则返回 ""
Log.i(EMPTY, stripToEmpty(STR_BLANK));
Log.i("---------stripToNull-----------");
// 将空白字符进行strip操作，如果得到""或null 则返回 null
Log.i(NULL, stripToNull(STR_BLANK));
Log.i("---------stripAll-----------");
String[] strings1 = stripAll(" \n", " \t");
Log.i("StripAll 去除空白字符", strings1);
String[] strings2 = stripAll(new String[]{"ab", "acb", "adb"}, "b");
Log.i("StripAll 去除指定字符", strings2);
Log.i("----------stripAccents---------");
Log.i(stripAccents("éclair"));
}
/**
* 给字符串设置默认值
* defaultString 如果字符串是 null 则设置默认字符串，默认字符串默认为""空字符串
* defaultIfEmpty 如果字符串是空字符串，则设置默认字符串
* defaultIfBlank 如果字符串是blank字符串，则设置默认字符串
*/
@Test
public void testDefault() {
String defaultText = "我是默认文字";
Log.i("defaultString", defaultString(null));
Log.i("defaultString2", defaultString(null, defaultText));
Log.i("defaultIfEmpty", defaultIfEmpty("", defaultText));
Log.i("defaultIfBlank", defaultIfEmpty(" ", defaultText));
}
/**
* 字符串比较
*/
@Test
public void testEquals() {
Log.i("null eq null", StringUtils.equals(null, null));
Log.i("忽略大小写比较", equalsIgnoreCase("a", "A"));
Log.i("多个字符串与同一字符串比较", equalsAny("abc", "abd", "abc"));
Log.i("多个字符串与同一字符串忽略大小写比较", equalsAnyIgnoreCase("abc", "abd", "ABC"));
}
/**
* 字符串比较（大小比较,字典顺序）
* 当前字符串1的字典顺序高于字符串2是，返回-1 否则返回 1
*/
@Test
public void testCompare() {
Log.i("字符串比较", compare("abc", "abc"));
Log.i("字符串比较", compare("abc", "abd"));
Log.i("字符串比较", compare("abc", "abcd"));
Log.i("字符串比较", compare("abd", "abc"));
Log.i("字符串比较 忽略大小写", compareIgnoreCase("Abd", "abc"));
}
/**
* 字符串查找
*/
@Test
public void testIndexOf() {
Log.i("-------------indexOf-------------");
Log.i("查找字符串a在字符串b中的位置", indexOf("abc", "a"));
Log.i("如果没有查找到，返回-1", indexOf("abc", "d"));
Log.i("如果两个字符串其中有一个未null，则返回-1", indexOf("abc", null));
Log.i("指定位置开始查找", indexOf("abc", "b", 1));
Log.i("查找字符", indexOf("abc", 'a'));
Log.i("-------------indexOfIgnoreCase-------------");
Log.i("忽略大小写查找", indexOfIgnoreCase("abc", "Ab"));
Log.i("--------------ordinalIndexOf------------");
Log.i("查找字符串在目标字符串中出现第ordinal次时的位置", ordinalIndexOf("abcb", "b", 2));
Log.i("--------------indexOfDifference------------");
Log.i("查找两个字符串开始不同的位置", indexOfDifference("abcd", "abde"));
Log.i("---------------indexOfAny-------------------");
Log.i("查找多个字符在目标字符串的位置", indexOfAny("abc", "a", "b"));
Log.i("---------------indexOfAnyBut-------------------");
Log.i("查找字符串不在目标字符串的位置", indexOfAnyBut("abc", "ab"));
Log.i("--------------lastIndexOf-------------");
Log.i("从后往前查找", lastIndexOf("abca", "a"));
Log.i("从后往前忽略大小写查找", lastIndexOfIgnoreCase("abca", "A"));
}
/**
* 字符串包含检查操作 contains
*/
@Test
public void testContains() {
Log.i("检查字符串中是否有某个字符", contains("\na", 'a'));
Log.i("检查字符串中是否有某个字符串", contains("\na", "a"));
Log.i("检查字符串中是否有某些字符", containsAny("aa", 'a', 'c'));
Log.i("检查字符串中是否有某些字符串", containsAny("aa", "c", "d"));
Log.i("检查字符串中是否有空白字符", containsWhitespace(""));
Log.i("检查字符串中是否有空白字符", containsWhitespace("\na"));
Log.i("忽略大小写检查", contains("\na", "A"));
Log.i("检查字符串中是否只包含某个字符", containsOnly("aaa", 'a'));
Log.i("检查字符串中是否只包含某个字符串", containsOnly("aaac", "a"));
Log.i("检查字符串中是否不包含参数二的字符", containsNone("aaac", 'd'));
Log.i("检查字符串中是否不包含参数二的字符串", containsNone("aaac", "c"));
}
/**
* 字符串开始结尾字符判断
*/
@Test
public void testStartEnd() {
Log.i("判断字符串是否以某一字符串开始", startsWith("123_test", "123"));
Log.i("判断字符串是否以任意列表中的字符串结束", startsWithAny("123_test", "123", "124"));
Log.i("忽略大小写判断", startsWithIgnoreCase("123A_test", "123a"));
Log.i("判断字符串是否以某一字符串结束", endsWith("123_test", "test"));
Log.i("判断字符串是否以任意列表字符串字符串结束", endsWithAny("123_test", "test", "ha"));
Log.i("忽略大小写判断", endsWithIgnoreCase("123_test", "Test"));
}
/**
* 字符串截取
*/
@Test
public void testSubstring() {
Log.i("截取[start, ends)的字符串", substring("abcd", 2, 3));
Log.i("从指定位置截取字符", substring("abcd", 2));
Log.i("从指定字符串位置开始截取该字符前面的字符串(从左向右查找该字符串)", substringBefore("abcd", "b"));
Log.i("从指定字符串位置开始截取该字符前面的字符串(从右向左查找该字符串)", substringBeforeLast("abcd", "b"));
Log.i("从指定字符串位置开始截取该字符后面的字符串(从左向右查找该字符串)", substringAfter("abcd", "b"));
Log.i("从指定字符串位置开始截取该字符后面的字符串(从右向左查找该字符串)", substringAfterLast("abcd", "b"));
Log.i("找到两个tag字符之间的字符并截取", substringBetween("abcda", "a"));
Log.i("从指定指定start字符串的位置截取end字符的位置的字符串", substringBetween("abcd", "a", "d"));
Log.i("从指定指定start字符串的位置截取end字符的位置的字符串, 将符合情况的全部输出", substringsBetween("abcdabecd", "a", "d"));
Log.i("-------------left, right, mid----------------");
Log.i("从左开始截取长度为len的字符串", left("abcd", 2));
Log.i("从右开始截取长度为len的字符串", right("abcd", 2));
Log.i("从pos位置开始截取，截取len长度的字符串", mid("abcd", 2, 2));
}
/**
* 字符串截取
*/
@Test
public void testTruncate() {
Log.i("从0开始截取五个字符作为一个字符串",StringUtils.truncate("abcdefghijk", 5));
Log.i("从1开始截取五个字符作为一个字符串",StringUtils.truncate("abcdefghijk", 1,5));
}
/**
* 字符串分割
*/
@Test
public void testSplit() {
Log.i("使用空格将字符串分割为数组", split("a b c "));
Log.i("使用指定字符串将字符串分割为数组", split("a,b,c,", ","));
Log.i("使用指定字符串将字符串分割为数组", split("a,b,c,,", ","));
Log.i("whole使用指定字符串将字符串分割为数组", splitByWholeSeparator("a,b,c,", ","));
Log.i("whole使用指定字符串将字符串分割为数组，默认同样使用空格", splitByWholeSeparator("a b c", null));
Log.i("whole使用指定字符串将字符串分割为数组，空字符串不会被忽略", splitByWholeSeparator("a,b,c,,", ","));
Log.i("whole使用指定字符串将字符串分割为数组，设置数组最大长度", splitByWholeSeparator("a,b,c", ",", 2));
Log.i("whole使用指定字符串将字符串分割为数组，设置数组最大长度 元素1为", splitByWholeSeparator("a,b,c", ",", 2)[1]);
Log.i("按照字符串数据的不同类型进行分割", splitByCharacterType("abcABC!!!123a"));
Log.i("按照字符串数据的不同类型进行分割，并且忽略大小写", splitByCharacterTypeCamelCase("abcABC!!!123a"));
Log.i("splitPreserveAllTokens和whole作用相同，不忽略空白项", splitPreserveAllTokens("a b c "));
}
/**
* 字符串拼接
*/
@Test
public void testJoin() {
String[] as = new String[]{"a", "b", "c"};
Log.i("将数组拼接为字符串，默认以空字符串为连接符", join(as));
Log.i("将数组拼接为字符串，使用指定连接符", join(as, ","));
Log.i("将数组指定位置的元素使用指定连接符拼接为字符串", join(as, ",", 2, 3));
}
/**
* 字符串字符移除操作
*/
@Test
public void testRemove() {
Log.i("移除字符串中的某个字符串(移除所有匹配)", remove("abcabc", "a"));
Log.i("移除字符串中的某个字符串(移除匹配正则的所有字符串,和remove类似)", removePattern("abcabc", "a"));
Log.i("移除字符串中的某个字符串(移除从左到右第一个匹配)", removeFirst("abcabc", "b"));
Log.i("移除字符串中的某个字符串(如果头部有该字符串，则移除)", removeStart("abcabc", "a"));
Log.i("移除字符串中的某个字符串(如果头部有该字符串，则移除，忽略大小写)", removeStartIgnoreCase("abcabc", "A"));
Log.i("移除字符串中的某个字符串(如果尾部有该字符串，则移除)", removeEnd("abcabc", "c"));
Log.i("移除字符串中的某个字符串(如果尾部有该字符串，则移除，忽略大小写)", removeEndIgnoreCase("abcabc", "c"));
}
/**
* 删除方法
*/
@Test
public void testDelete() {
Log.i("删除所有空白符", deleteWhitespace("a b \nd"));
}
/**
* 字符串替换
*/
@Test
public void testReplace() {
Log.i("替换字符串（所有匹配的都会被替换）", replace("abcabc", "a", "e"));
Log.i("替换字符串（所有匹配的都会被替换）", replaceChars("abcabc", "a", "e"));
Log.i("替换字符串（所有匹配的都会被替换）", replaceChars("abcabc", 'a', 'e'));
Log.i("替换字符串（所有匹配的都会被替换, 但是最多替换max次）", replace("abcabc", "a", "e", 1));
Log.i("替换字符串（忽略大小写）", replaceIgnoreCase("abcabc", "A", "e"));
Log.i("替换字符串（忽略大小写，最多被替换max次）", replaceIgnoreCase("abcabc", "A", "e", 1));
Log.i("替换字符串（只替换第一个匹配的）", replaceFirst("abcabc", "a", "e"));
Log.i("替换字符串（只替换一次）", replaceOnce("abcabc", "a", "e"));
Log.i("替换字符串，使用指定的正则表达式", replacePattern("abcabc", "a", "e"));
Log.i("增强替换，只替换一次,如果两个参数数组长度不一致，会抛出非法参数异常",
replaceEach("bcacab", new String[]{"a", "b", "c"}, new String[]{"d", "e", "f"}));
Log.i("增强替换，替换多次，比如将a替换为b，b再替换为c,c替换为d，结果为dddddd",
replaceEachRepeatedly("bcacab", new String[]{"a", "b", "c"}, new String[]{"b", "c", "d"}));
}
/**
* 字符串覆盖
* 如果start和end索引最小值大于当前字符串的长度，则默认覆盖字符串当前长度的位置
* 如果start和end索引最大值小于当前字符串的长度，则默认插入到字符串的0位置
*/
@Test
public void testOverlay() {
Log.i("将字符串的[start,end)位置使用ovrlay字符串覆盖", StringUtils.overlay("abcdef", "zz", 2, 4));
Log.i("将字符串的[start,end)位置使用ovrlay字符串覆盖", StringUtils.overlay("abcdef", "zz", 4, 2));
Log.i("特殊情况1", StringUtils.overlay("abcdef", "zz", -100, 2));
Log.i("特殊情况2", StringUtils.overlay("abcdef", "zz", -100, -200));
Log.i("特殊情况3", StringUtils.overlay("abcdef", "zz", 2, 100));
Log.i("特殊情况4", StringUtils.overlay("abcdef", "zz", 50, 100));
}
/**
* 填充
*/
@Test
public void testPad() {
Log.i("----------左填充----------");
Log.i("左填充，默认使用空格", leftPad("abc", 5));
Log.i("左填充，长度满足不进行填充", leftPad("abc", 2));
Log.i("左填充，指定填充字符", leftPad("abc", 5, "-"));
Log.i("----------右填充----------");
Log.i("右填充，默认使用空格", rightPad("abc", 5));
Log.i("右填充，长度满足不进行填充", rightPad("abc", 2));
Log.i("右填充，指定填充字符", rightPad("abc", 5, "-"));
}
/**
* 居中
*/
@Test
public void testCenter() {
Log.i("字符串居中，默认使用空格", center("abc", 5));
Log.i("字符串居中，指定填充字符", center("abc", 5, "-="));
Log.i("字符串居中，长度不对称", center("abc", 6, "-="));
}
/**
* 重复
*/
@Test
public void testRepeat() {
Log.i("字符重复3次", repeat('a', 3));
Log.i("字符串重复3次", repeat("abc", 3));
Log.i("字符串重复0次", repeat("abc", 0));
Log.i("字符串重复-1次", repeat("abc", -1));
Log.i("重复字符串时，加入分割符", repeat("abc", ",", 3));
}
/**
* 字符串包裹
*/
@Test
public void testWrap() {
Log.i("字符串包裹，无论如何都包裹", wrap("=abc=", "="));
Log.i("字符串包裹，如果不存在才会包裹", wrapIfMissing("=abc=", "="));
Log.i("如果没有suffixes后缀，则添加后缀suffix", appendIfMissing("abc", "~", "-", "="));
Log.i("如果没有suffixes后缀，则添加后缀suffix", appendIfMissing("abc-", "~", "-", "="));
Log.i("prependIfMissing", prependIfMissing("abc", "q:", "Q:", "q:"));
Log.i("解除字符串的包裹", unwrap("==a==", "="));
}
/**
* 反转
*/
@Test
public void testReverse() {
Log.i("字符串反转", reverse("abc"));
Log.i("使用分割符反转", reverseDelimited("a-a,b,c", ','));
}
/**
* 大小写转换
*/
@Test
public void testCase() {
Log.i("大写转换", upperCase("abc"));
Log.i("小写转换", lowerCase("ABC"));
Log.i("大小写反转", swapCase("Abc"));
Log.i("指定时区，从而指定不同语言的大小写字母", upperCase("abc", Locale.CHINA));
Log.i("首字母大写", capitalize("abc"));
Log.i("首字母小写", uncapitalize("ABC"));
}
/**
* 缩短省略
* 比如一个长度特别长的字符串展示时要使用...的方式展示，最短的省略大小为4，否则会抛IllegalArgumentException
*/
@Test
public void testAbbreviate() {
Log.i("获取字符串缩写", abbreviate("中华人民共和国", 6));
Log.i("获取字符串缩写", abbreviate("My Home Page", 8));
Log.i("获取字符串缩写，指定偏移量", abbreviate("我叫李四，今年20岁了，我喜欢很多很多好吃的", 5, 10));
Log.i("获取字符串缩写，缩略中部，上面都是尾部或者头部，可以指定缩略符号", abbreviateMiddle("我叫李四，今年20岁了，我喜欢很多很多好吃的", "...", 10));
}
/**
* 匹配计数
*/
@Test
public void testCount() {
Log.i("匹配计数,查找a在abcabc中出现的次数", countMatches("abcabc", "a"));
Log.i("匹配计数,查找a在abcabc中出现的次数", countMatches("abcabc", 'a'));
}
}
package lang3;
import lang3.util.Log;
import org.apache.commons.lang3.BooleanUtils;
import org.junit.Test;
import static org.apache.commons.lang3.BooleanUtils.*;
import static java.lang.Boolean.*;
/**
* BooleanUtilsDemo
* <p>
*
* @author Feathers
* @date 2018-05-19 1:26
*/
public class BooleanUtilsDemo {
/**
* 判断方法
*/
@Test
public void testIs() {
// 三个方法没有区别，主要在于使用时语义的不同
Log.i("判断是否为true", isTrue(Boolean.TRUE));
Log.i("判断是否不为false", isNotTrue(Boolean.FALSE));
Log.i("判断是否为false", isFalse(Boolean.FALSE));
Log.i("判断是否不为true", isNotFalse(Boolean.TRUE));
}
/**
* 比较
*/
@Test
public void testCompare() {
Log.i("比较 相同返回0", BooleanUtils.compare(false, false));
Log.i("比较", BooleanUtils.compare(true, false));
Log.i("比较", BooleanUtils.compare(false, true));
}
/**
* 将其他类型转换为boolean类型
*/
@Test
public void testToBoolean() {
Log.i("int -> boolean 1", toBoolean(1));
Log.i("int -> boolean -1", toBoolean(-1));
Log.i("int -> boolean 0", toBoolean(0));
Log.i("int -> boolean 定义true值和false值，如果不匹配则会抛出IllegalArgumentException",
toBoolean(100, 100, 200));
Log.i("Integer -> boolean 定义true值和false值，如果不匹配则会抛出IllegalArgumentException",
toBoolean(Integer.valueOf(100), Integer.valueOf(100), Integer.valueOf(200)));
Log.i("string -> boolean true", toBoolean("true"));
Log.i("string -> boolean false", toBoolean("false"));
String str1 = null;
Log.i("string -> boolean abc", toBoolean("abc"));
Log.i("string -> boolean null", toBoolean(str1));
Log.i("string -> boolean (empty string)", toBoolean(""));
Log.i("string -> boolean (blank string)", toBoolean(" "));
Log.i("string -> boolean false 定义true值和false值，如果不匹配则会抛出IllegalArgumentException",
toBoolean("open", "open", "close"));
Log.i("Boolean -> boolean true", toBoolean(Boolean.TRUE));
Log.i("Boolean -> boolean false", toBoolean(Boolean.FALSE));
Log.i("all -> BooleanObject", toBooleanObject(1));
}
/**
* 将boolean类型转换为int类型
* int 默认 0false 1true
*/
@Test
public void testToInteger() {
Log.i("boolean -> int true", toInteger(true));
Log.i("boolean -> int false", toInteger(false));
Log.i("boolean -> Integer true", toIntegerObject(true));
Log.i("Boolean -> Integer false", toIntegerObject(false));
Log.i("boolean -> Integer 定义true和false对应的int值", toInteger(false, 100,200));
}
@Test
public void testToString() {
Boolean nb = null;
Log.i("boolean -> string 必须指定true和false对应的string值,如果为null会抛出空指针异常",
BooleanUtils.toString(true, "open", "close"));
Log.i("boolean -> string 必须指定true和false对应的string值,指定null对应的值",
BooleanUtils.toString(nb, "open", "close", "sorry"));
// 除此之外，还提供了许多默认的返回设置，比如yes/no,on/off等
Log.i("true/false", toStringTrueFalse(true));
Log.i("yes/no", toStringYesNo(true));
Log.i("on/off", toStringOnOff(true));
}
@Test
public void testLogic() {
Log.i("与 and", BooleanUtils.and(new Boolean[]{true, false}));
Log.i("或 or", BooleanUtils.or(new Boolean[]{true, false}));
Log.i("抑或 xor", BooleanUtils.xor(new Boolean[]{true, false}));
}
@Test
public void testDefault() {
Boolean b = null;
Log.i("设置如果为null的默认值",toBooleanDefaultIfNull(b, true));
}
}package lang3;
import lang3.util.Log;
import org.apache.commons.lang3.CharUtils;
import static org.apache.commons.lang3.CharUtils.*;
import org.junit.Test;
/**
* CharUtilsDemo
* <p>
*
* @author Feathers
* @date 2018-05-19 22:10
*/
public class CharUtilsDemo {
/**
* 常量
*/
@Test
public void testConstant() {
char nul = CharUtils.NUL; // \0
char cr = CharUtils.CR; // \r
char lf = CharUtils.LF; // \n
}
/**
* 判断字符类型
*/
@Test
public void testIs() {
Log.i("判断字符是否为ASCII字符", isAscii('a'));
Log.i("判断字符是否为ASCII字母", isAsciiAlpha('a'));
Log.i("判断字符是否为ASCII小写字母", isAsciiAlphaLower('a'));
Log.i("判断字符是否为ASCII大写字母", isAsciiAlphaUpper('A'));
Log.i("判断字符是否为ASCII数字", isAsciiNumeric('1'));
Log.i("判断字符是否为ASCII字母或者数字", isAsciiAlphanumeric('1'));
Log.i("判断字符是否为ASCII打印字符", isAsciiPrintable('\n'));
Log.i("判断字符是否为ASCII控制字符", isAsciiControl('\n'));
}
/**
* 转换
*/
@Test
public void testTo() {
Log.i("string -> one char, 如果string为null或者empty会抛出非法参数异常", toChar("abc"));
Log.i("string -> one char, 如果string为null或者empty输出默认值", toChar("", 'a'));
Log.i("char -> int, 如果字符不是数字，则会抛出非法参数异常", toIntValue('0'));
Log.i("char -> int, 如果字符不是数字，返回默认值", toIntValue('a', 0));
Log.i("char -> string", CharUtils.toString('a'));
Character a = null;
Log.i("char -> string, 如果参数是null返回null", CharUtils.toString(a));
}
/**
* 获取unicode码
*/
@Test
public void testUnicode() {
Log.i("获取字符的unicode码",CharUtils.unicodeEscaped('a'));
}
}
package lang3;
import lang3.util.Log;
import static org.apache.commons.lang3.math.NumberUtils.*;
import org.junit.Test;
/**
* NumberUtilsDemo
* <p>
*
* @author Feathers
* @date 2018-05-19 22:44
*/
public class NumberUtilsDemo {
/**
* 判断方法
* 判断字符串是否是纯数字字符串
* 判断字符串是否可以被解析为数字，小数、负数可以被解析
* 判断字符串是否是一个有效的Java数值，包含0x预选项、八进制、科学计数、标点符等
*/
@Test
public void testIs() {
Log.i("判断字符串是否为纯数字字符串",isDigits("123"));
Log.i("判断字符串是否为纯数字字符串，不可包含小数点",isDigits("123.1"));
Log.i("判断字符串是否为纯数字字符串，不可包含符号",isDigits("-123"));
Log.i("判断字符串是否可以解析为数字,小数可以被解析", isParsable("1123.1"));
Log.i("判断字符串是否可以解析为数字，符数可以被解析", isParsable("-1123.1"));
Log.i("判断字符串是否可以解析为数字，其他包含字母的不可以被解析", isParsable("0x1123.1"));
Log.i("判断字符串是否可以解析为数字，尾部包含字母不可以被解析", isParsable("123a"));
Log.i("判断字符串是否可以被解析为java数字，负数、小数", isCreatable("-1.12"));
Log.i("判断字符串是否可以被解析为java数字，其他进制表示", isCreatable("0x23"));
Log.i("判断字符串是否可以被解析为java数字，科学记数法表示", isCreatable("12e12"));
Log.i("判断字符串是否可以被解析为java数字，尾部包含字母，不可以被解析", isCreatable("-1.12a"));
}
@Test
public void testToByteIntLong() {
Log.i("string -> int 负数字符串可以转换，如果无法解析返回默认值0 ", toInt("-1", 0));
Log.i("string -> int 其他进制不可以转换 ", toInt("0x123", 0));
Log.i("string -> int 小数字符串不可以转换", toInt("12.3", 0));
Log.i("string -> int 尾部不可以包含字母", toInt("123a", 0));
// toByte toShort toLong 类似
}
@Test
public void testFloatDouble() {
Log.i("string -> float，如果无法解析则会返回0.0", toFloat("123.1"));
Log.i("string -> float", toFloat("-123.1", 0f));
Log.i("string -> float", toFloat("-123.1a", 0f));
// toDouble类似
}
@Test
public void testCreate() {
Log.i("string -> number", createNumber("-123.1"));
Log.i("string -> number 支持其他进制", createNumber("0x123"));
Log.i("string -> number 支持科学记数法", createNumber("9e1242"));
// 强大
Log.i("string -> Integer 如果解析失败，会抛出NumberFormatException", createInteger("-123"));
// BigDecimal和BigInteger
Log.i("string -> BigInteger", createBigDecimal("9e1234"));
}
@Test
public void testCompare() {
Log.i("比较", compare(1, 2));
Log.i("最大值", max(1, 4,3.4));
Log.i("最小值", min(1, 2,3));
//int[] arr = null;
//Log.i("如果出现null,则会抛出非法参数异常", max(arr));
}
}
package lang3;
import lang3.util.Log;
import org.apache.commons.lang3.ArrayUtils;
import org.junit.Test;
import java.util.Map;
import static org.apache.commons.lang3.ArrayUtils.*;
/**
* ArrayUtilsDemo
* <p>
*
* @author Feathers
* @date 2018-05-19 0:57
*/
public class ArrayUtilsDemo {
private char[] nullArr = null;
private char[] emptyArr = new char[]{};
/**
* 数组判断工具
* 判断是否为空数组
* 判断数组长度是否相同
* 判断数组是否已经排序
*/
@Test
public void testIs() {
Log.i("判断数组是否为空", isEmpty(emptyArr));
Log.i("判断数组是否不为空", isNotEmpty(emptyArr));
Log.i("判断数组是否为空,如果为null，同样代表数组为空", isEmpty(nullArr));
Log.i("判断数组长度是否一致,提供了Object[]与Object[]的比较，可以比较不同的类型", isSameLength(new char[]{'a', 'b'}, new char[]{'1', '2'}));
Log.i("判断数组长度是否一致,如果两个数组都为null，则代表有相同的length", isSameLength(nullArr, nullArr));
Log.i("判断数组是否排序，使用compare函数进行判断，对象类型需要实现Comparable", isSorted(new char[]{'a', 'b', 'c'}));
}
/**
* 打印数组
*/
@Test
public void testToString() {
Log.i(ArrayUtils.toString(new int[]{1, 2, 3, 4}));
}
/**
* 基本类型数组 转换 对象类型数组
*/
@Test
public void testToObject() {
Integer[] integers = toObject(new int[]{1, 2, 3, 4});
Log.i(integers);
}
/**
* 对象类型数组 转换基本类型数组 ，如果出现null会出现空指针异常
*/
@Test
public void testToPrimitive() {
boolean[] booleans = toPrimitive(new Boolean[]{true, false, true, null});
Log.i(booleans);
}
@Test
public void testToArray() {
Integer[] integers = null;
Log.i("nullToEmpty, 如果数组对象为null，则返回一个空的数组", nullToEmpty(integers));
Log.i("ToArray", toArray("a", "b", "b"));
Log.i("ToStringArray", toStringArray(new String[]{null, null}, "null~"));
}
/**
* 将二维数组转换为map
*/
@Test
public void testToMap() {
String[][] arr = new String[][]{{"a", "b"}, {"aa", "bb"}};
Map<Object, Object> map = toMap(arr);
Log.i("转换为Map", map);
}
/**
* 元素位置查找
*/
@Test
public void testIndex() {
char[] as = new char[]{'a', 'b', 'a'};
Log.i("从前往后查找数组元素a", indexOf(as, 'a'));
Log.i("从前往后查找数组元素a, 指定开始查找位置为1", indexOf(as, 'a', 1));
Log.i("从后往前查找数组元素a", lastIndexOf(as, 'a'));
Log.i("从后往前查找数组元素a, 指定开始查找位置为1", lastIndexOf(as, 'a', 1));
}
/**
* 判断是否包含
*/
@Test
public void testContains() {
char[] as = new char[]{'a', 'b', 'a'};
Log.i("判断元素是否被包含", contains(as, 'a'));
}
/**
* 元素尾部增添
*/
@Test
public void testAdd() {
Log.i("将单个元素添加到数组中", add(new char[]{}, 'a'));
Log.i("将多个元素添加到另一个数组中", addAll(new char[]{}, 'a', 'b'));
}
/**
* 元素插入 插入到指定的位置
*/
@Test
public void testInsert() {
String[] strs = new String[]{"a", "b", "c"};
Log.i("将元素插入到数组的指定位置", insert(1, strs, "c", "c"));
}
/**
* 元素删除
*/
@Test
public void testRemove() {
Log.i("从数组中删除指定下标的元素", remove(new char[]{'a', 'b'}, 1));
Log.i("从数组中删除指定的多个下标的元素", removeAll(new char[]{'a', 'b'}, 0, 1));
Log.i("从数组中删除指定的元素, 只会删除第一个", removeElement(new char[]{'a', 'b', 'a'}, 'a'));
Log.i("从数组中删除多个指定的元素, 只会删除第一个", removeElements(new char[]{'a', 'b', 'a'}, 'a', 'b'));
Log.i("从数组中删除所有的指定的元素", removeAllOccurences(new char[]{'a', 'b', 'a'}, 'a'));
}
@Test
public void testOpr() {
int[] ints = new int[]{1, 2, 4, 5};
reverse(ints);
Log.i("反转数组", ints);
int[] ints1 = new int[]{1, 2, 4, 5};
shift(ints1, 1);
Log.i("移动数组，数组后移1位", ints1);
shift(ints1, -1);
Log.i("移动数组，数组前移1位", ints1);
int[] ints2 = new int[]{1, 2, 4, 5};
shuffle(ints2);
Log.i("随机打乱数组", ints2);
int[] ints3 = new int[]{1, 2, 4, 5};
swap(ints3, 1, 2);
Log.i("数组交换", ints3);
swap(ints3, 1, 2,1);
Log.i("数组交换，指定偏移量", ints3);
Log.i("截取数组", subarray(new int[]{1, 2, 3, 4, 5}, 1, 3));
}
}
Calendar: 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
TimeZone: 表示时区偏移量。
Locale： 表示了特定的地理、政治和文化地区。需要 Locale 来执行其任务的操作称为语言环境敏感的操作，它使用 Locale 为用户量身定制信息。
SimpleDateFormat: 主要是用来格式化Date，用过之后就会发现，它其实不完善，对Calendar提供的支持很少.
经历几个项目发现apache提供的第三方扩展类库，org.apache.commons.lang.time包比较好用，可以将程序中时间处理变的简单一点，提高你的开发效率，下面介绍下常用的方法和具体使用。
org.apache.commons.lang.time 包括以下几个类：
DateFormatUtils 【格式化Calendar与Date并依赖于 FastDateFormat】
DateUtils 【围绕Calendar与Date的实用方法】
DurationFormatUtils 【毫秒数格式化Calendar与Date】
FastDateFormat 【线程安全的SimpleDateFormat】
StopWatch 【提供一个方便的定时的API 】
package lang3.date;
/**
* 时间相关常量
* <p>
*
* @author Feathers
* @date 2017-12-07 11:40
*/
public class TimeConstant {
/**
* yyyy-MM-dd HH:mm:ss
*/
public static final String TARGET_1 = "yyyy-MM-dd HH:mm:ss";
/**
* yyyy-MM-dd HH:mm
*/
public static final String TARGET_2 = "yyyy-MM-dd HH:mm";
/**
* yyyy-MM-dd
*/
public static final String TARGET_3 = "yyyy-MM-dd";
/**
* yyyy年MM月dd日
*/
public static final String TARGET_4 = "yyyy年MM月dd日";
/**
* yyyy年MM月dd日 HH:mm
*/
public static final String TARGET_5 = "yyyy年MM月dd日 HH:mm";
/**
* yyyy年MM月dd日 HH:mm:ss
*/
public static final String TARGET_6 = "yyyy年MM月dd日 HH:mm:ss";
/**
* yyyyMMddHHmmss
*/
public static final String TARGET_7 = "yyyyMMddHHmmss";
}
package lang3.date;
import lang3.util.Log;
import org.apache.commons.lang3.time.FastDateFormat;
import org.junit.Test;
import java.util.Date;
/**
* FastDateFormatDemo
* <p>
*
* @author Feathers
* @date 2018-05-21 17:49
*/
public class FastDateFormatDemo {
@Test
public void test() {
FastDateFormat fdf = FastDateFormat.getInstance("yyyy-MM-dd");
String format = fdf.format(new Date());
Log.i(format);
}
@Test
public void testPattern() {
// 使用fast date format 直接格式化日期
FastDateFormat fastDateFormat = FastDateFormat.getInstance(TimeConstant.TARGET_7);
System.out.println(fastDateFormat.format(new Date()));
}
}
package lang3.date;
import lang3.util.Log;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.junit.Test;
import java.util.Calendar;
import java.util.Date;
/**
* DateFormatUtilsDemo
* 日期格式化工具类
* <p>
*
* @author Feathers
* @date 2018-05-21 16:55
*/
public class DateFormatUtilsDemo {
private static final String DATE_FORMAT_PATTERN = "yyyy-MM-dd-HH-mm-ss-SSS";
@Test
public void test() {
Log.i("Date类型格式化", DateFormatUtils.format(new Date(), DATE_FORMAT_PATTERN));
Log.i("Calender类型格式化", DateFormatUtils.format(Calendar.getInstance(), DATE_FORMAT_PATTERN));
Log.i("时间戳类型格式化", DateFormatUtils.format(new Date().getMinutes(), DATE_FORMAT_PATTERN));
}
@Test
public void testPattern() {
// DateFormatUtils 提供了几种时间格式
Date date = new Date();
System.out.println("ISO_8601_EXTENDED_DATE_FORMAT:" + DateFormatUtils.format(date, DateFormatUtils.ISO_8601_EXTENDED_DATE_FORMAT.getPattern()));
System.out.println("ISO_8601_EXTENDED_DATETIME_FORMAT:" + DateFormatUtils.format(date, DateFormatUtils.ISO_8601_EXTENDED_DATETIME_FORMAT.getPattern()));
System.out.println("ISO_8601_EXTENDED_DATETIME_TIME_ZONE_FORMAT:" + DateFormatUtils.format(date, DateFormatUtils.ISO_8601_EXTENDED_DATETIME_TIME_ZONE_FORMAT.getPattern()));
System.out.println("ISO_8601_EXTENDED_TIME_TIME_ZONE_FORMAT:" + DateFormatUtils.format(date, DateFormatUtils.ISO_8601_EXTENDED_TIME_TIME_ZONE_FORMAT.getPattern()));
System.out.println("SMTP_DATETIME_FORMAT:" + DateFormatUtils.format(date, DateFormatUtils.SMTP_DATETIME_FORMAT.getPattern()));
// 上面的代码等同于
System.out.println(DateFormatUtils.ISO_8601_EXTENDED_TIME_TIME_ZONE_FORMAT.format(date));
}
}
package lang3.date;
import lang3.util.Log;
import org.junit.Test;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import static org.apache.commons.lang3.time.DateUtils.*;
/**
* DateUtilsDemo
* 常用日期操作工具类
* <p>
*
* @author Feathers
* @date 2018-05-20 9:32
*/
public class DateUtilsDemo {
@Test
public void testConstant() {
// 毫秒数
Object[] MILLIS = new Object[]{
MILLIS_PER_SECOND, // 每秒的毫秒数
MILLIS_PER_MINUTE, // 每分钟的毫秒数
MILLIS_PER_HOUR, // 每小时的毫秒数
MILLIS_PER_DAY // 每天的毫秒数
};
}
/**
* 判断方法
*/
@Test
public void testIs() {
Log.i("是否是同一天", isSameDay(new Date(), new Date()));
Log.i("判断即时时间，即毫秒值是否相同", isSameInstant(new Date(), new Date()));
Log.i("判断两个日历本地时间是否相同", isSameLocalTime(Calendar.getInstance(), Calendar.getInstance()));
}
@Test
public void testParseDate() {
try {
Date date = parseDate("2018-01-03", "yyyy-MM-dd", "yyyyMMdd");
Log.i("将字符串使用相应的一个或者多个pattern解析为对象", date);
Date date1 = parseDate("1995年09月02日", Locale.CHINA, "yyyy年MM月dd日");
Log.i("将字符串使用相应的一个或者多个pattern解析为date对象，并且指定Locale，如果locale为null，则使用系统默认的locale", date1);
Date date2 = parseDateStrictly("2018-01-03", "yyyy-MM-dd", "yyyyMMdd");
Log.i("使用严格模式解析,解析器解析严格不允许的日期， 如：\"February 942, 1996\" ", date2);
} catch (ParseException e) {
e.printStackTrace();
}
}
/**
* 日期修改 add
*/
@Test
public void testAdd() {
Log.i("获取去年今天", addYears(new Date(), -1));
Log.i("获取明年今天", addYears(new Date(), 1));
Log.i("获取上个月今天", addMonths(new Date(), -1));
Log.i("获取下个月今天", addMonths(new Date(), 1));
Log.i("获取上周今天", addWeeks(new Date(), -1));
Log.i("获取下周今天", addWeeks(new Date(), 1));
Log.i("获取昨天", addDays(new Date(), -1));
Log.i("获取明天", addDays(new Date(), 1));
Log.i("获取一小时前", addHours(new Date(), -1));
Log.i("获取一小时后", addHours(new Date(), 1));
Log.i("获取一分钟前", addMinutes(new Date(), -1));
Log.i("获取一分钟后", addMinutes(new Date(), 1));
Log.i("获取一秒钟前", addSeconds(new Date(), -1));
Log.i("获取一秒钟后", addSeconds(new Date(), 1));
Log.i("获取一毫秒前", addMilliseconds(new Date(), -1));
Log.i("获取一毫秒后", addMilliseconds(new Date(), 1));
}
/**
* 根据阈值向上舍入 ceiling
*/
@Test
public void testCeiling() {
Log.i("舍入到年", ceiling(new Date(), Calendar.YEAR));
Log.i("舍入到月", ceiling(new Date(), Calendar.MONTH));
}
/**
* 根据阈值四舍五入
*/
@Test
public void testRound() {
Log.i("四舍五入到年", round(new Date(), Calendar.YEAR));
Log.i("四舍五入到月", round(new Date(), Calendar.MONTH));
}
/**
* 截取时间
*/
@Test
public void testTruncate() {
Log.i("截取到年", truncate(new Date(), Calendar.YEAR));
Log.i("截取到月", truncate(new Date(), Calendar.MONTH));
}
/**
* 比较
*/
@Test
public void testEquals() {
Log.i("判断两个日期的月是否相同", truncatedEquals(new Date(), new Date(), Calendar.MONTH));
Log.i("比较两个日期的月份的大小，相同返回0", truncatedCompareTo(new Date(), new Date(), Calendar.MONTH));
}
/**
* 获取方法
* 返回指定范围内的xx数，比如指定年的月数
*/
@Test
public void testGet() {
Log.i("获取一年中的天数", getFragmentInDays(new Date(), Calendar.YEAR));
}
}
package lang3;
import lang3.util.Log;
import org.apache.commons.lang3.ClassPathUtils;
import org.junit.Test;
/**
* ClassPathUtilsDemo
* 路径相关操作
* <p>
*
* @author Feathers
* @date 2018-05-22 10:13
*/
public class ClassPathUtilsDemo {
@Test
public void test() {
String s = ClassPathUtils.toFullyQualifiedName(ClassPathUtilsDemo.class, "test.properties");
Log.i("获取与ClassPathUtils本类相同路径下的静态文件的全限定名", s);
String s1 = ClassPathUtils.toFullyQualifiedName(ClassPathUtils.class.getPackage(), "test.properties");
Log.i("获取与ClassPathUtils本类相同包下的静态文件的全限定名", s1);
String s2 = ClassPathUtils.toFullyQualifiedPath(ClassPathUtilsDemo.class, "test.properties");
Log.i("获取与ClassPathUtils本类相同路径下的静态文件的路径", s2);
String s3 = ClassPathUtils.toFullyQualifiedPath(ClassPathUtils.class.getPackage(), "test.properties");
Log.i("获取与ClassPathUtils本类相同包下的静态文件的路径", s3);
}
}package lang3;
import lang3.util.Log;
import org.apache.commons.lang3.ClassUtils;
import org.junit.Test;
import static org.apache.commons.lang3.ClassUtils.*;
/**
* ClassUtilsDemo
* 不直接操作反射就可以处理class
* <p>
*
* @author Feathers
* @date 2018-05-22 10:27
*/
public class ClassUtilsDemo {
/**
* 常用常量
*/
@Test
public void testConstant() {
Log.i("内部类分隔符 string类型", ClassUtils.INNER_CLASS_SEPARATOR);
Log.i("内部类分隔符 char类型", ClassUtils.INNER_CLASS_SEPARATOR_CHAR);
Log.i("包分隔符 string类型", ClassUtils.PACKAGE_SEPARATOR);
Log.i("包分隔符 char类型", ClassUtils.PACKAGE_SEPARATOR_CHAR);
}
/**
* 获取方法
*/
@Test
public void testGet() throws Exception {
Log.i("使用默认类加载器，获取已经初始化的class实例", ClassUtils.getClass("java.util.List"));
Log.i("使用默认类加载器，获取未初始化的class实例", ClassUtils.getClass("java.util.List", false));
/*
注： commons lang getClass方法 也提供了参数classLoader对象，用来设置加载器
*/
}
}
package lang3;
import lang3.util.Log;
import org.junit.Test;
import static org.apache.commons.lang3.RandomUtils.*;
/**
* RandomUtilsDemo
* 随机生成工具类
* <p>
*
* @author Feathers
* @date 2018-05-19 22:34
*/
public class RandomUtilsDemo {
@Test
public void testBoolean() {
Log.i("随机生成一个boolean值", nextBoolean());
}
@Test
public void testInt() {
Log.i("随机生成一个int值", nextInt());
Log.i("随机生成一个int值，设置范围[start, end)", nextInt(1, 10));
}
@Test
public void testLong() {
Log.i("随机生成一个long值", nextLong());
Log.i("随机生成一个long值，设置范围[start, end)", nextLong(1, 10));
}
@Test
public void testFloat() {
Log.i("随机生成一个float值", nextFloat());
Log.i("随机生成一个float值，设置范围[start, end)", nextFloat(10.1f, 12.3f));
}
@Test
public void testDouble() {
Log.i("随机生成一个double值", nextFloat());
Log.i("随机生成一个double值，设置范围[start, end)", nextDouble(10.1, 12.3));
}
@Test
public void testBytes() {
Log.i("随机生成一个bytes数组，指定长度为count", nextBytes(2));
}
}
package lang3.builder;
import org.apache.commons.lang3.builder.ToStringBuilder;
/**
* ToStringBuilderDemo
* <p>
*
* @author Feathers
* @date 2018-06-07 14:14
*/
class ToStringBuilderDemo {
public static void main(String[] args) {
Dog dog = new Dog();
dog.setId(1);
dog.setName("旺财");
dog.setAge("1");
System.out.println(dog);
}
}
class Dog {
private int id;
private String name;
private String age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
@Override
public String toString() {
return new ToStringBuilder(this)
.append("id", id)
.append("name", name)
.append("age", age)
.toString();
}
}
package lang3.builder;
import org.apache.commons.lang3.builder.CompareToBuilder;
import java.util.ArrayList;
import java.util.Comparator;
/**
* CompareToBuildDemo
* 比较构建
* <p>
*
* @author Feathers
* @date 2018-06-07 11:44
*/
class CompareToBuildDemo {
public static void main(String[] args) {
Employee boss = new Employee(1001, "王老板", Position.BOSS);
Employee manager1 = new Employee(1002, "张经理", Position.MANAGER);
Employee manager2 = new Employee(1004, "赵经理", Position.MANAGER);
Employee stuff1 = new Employee(1003, "李小二", Position.STUFF);
Employee stuff2 = new Employee(1005, "王小二", Position.STUFF);
ArrayList<Employee> employees = new ArrayList<Employee>() {{
this.add(stuff1);
this.add(manager2);
this.add(stuff2);
this.add(manager1);
this.add(boss);
}};
employees.sort(new PositionCompare());
System.out.println(manager1.compareTo(manager2));
System.out.println(employees);
}
}
class Employee implements Comparable<Employee> {
// 根据进入公司的先后顺序编码的
private int id;
private String name;
private Position position;
public Employee(int id, String name, Position position) {
this.id = id;
this.name = name;
this.position = position;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Position getPosition() {
return position;
}
public void setPosition(Position position) {
this.position = position;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("Employee{");
sb.append("id=").append(id);
sb.append(", name='").append(name).append('\'');
sb.append(", position=").append(position);
sb.append('}');
return sb.toString();
}
// 默认的比较器，按照自立排序
@Override
public int compareTo(Employee o) {
return new CompareToBuilder()
.append(id, o.id) // 先按照资历排序, 倒叙切换两个参数的位置
.toComparison();
}
}
// 定义按照职位的比较器
class PositionCompare implements Comparator<Employee> {
@Override
public int compare(Employee o1, Employee o2) {
return new CompareToBuilder()
.append(o1.getPosition(), o2.getPosition())
.append(o1.getId(), o2.getId())
.toComparison();
}
}
enum Position {
BOSS, MANAGER, STUFF
}