hutool test

package test;

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.lang.annotation.Annotation;
import java.math.BigDecimal;
import java.nio.file.Path;
import java.nio.file.WatchEvent;
import java.security.KeyPair;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.junit.jupiter.api.Test;
import org.springframework.web.bind.annotation.RequestMapping;

import com.macro.mall.model.PmsBrand;

import cn.hutool.aop.ProxyUtil;
import cn.hutool.aop.aspects.TimeIntervalAspect;
import cn.hutool.cache.Cache;
import cn.hutool.cache.CacheUtil;
import cn.hutool.cache.file.LFUFileCache;
import cn.hutool.captcha.CaptchaUtil;
import cn.hutool.captcha.CircleCaptcha;
import cn.hutool.captcha.LineCaptcha;
import cn.hutool.captcha.ShearCaptcha;
import cn.hutool.core.annotation.AnnotationUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.codec.Base64;
import cn.hutool.core.collection.BoundedPriorityQueue;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.convert.ConverterRegistry;
import cn.hutool.core.date.BetweenFormater.Level;
import cn.hutool.core.date.ChineseDate;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.Month;
import cn.hutool.core.date.TimeInterval;
import cn.hutool.core.io.FileTypeUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.watch.WatchMonitor;
import cn.hutool.core.io.watch.Watcher;
import cn.hutool.core.lang.Console;
import cn.hutool.core.lang.Dict;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.HexUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.cron.CronUtil;
import cn.hutool.cron.task.Task;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.SmUtil;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.RSA;
import cn.hutool.crypto.asymmetric.SM2;
import cn.hutool.crypto.asymmetric.Sign;
import cn.hutool.crypto.asymmetric.SignAlgorithm;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import cn.hutool.dfa.WordTree;
import cn.hutool.extra.emoji.EmojiUtil;
import cn.hutool.extra.qrcode.QrCodeUtil;
import cn.hutool.extra.qrcode.QrConfig;
import cn.hutool.extra.template.Template;
import cn.hutool.extra.template.TemplateConfig;
import cn.hutool.extra.template.TemplateEngine;
import cn.hutool.extra.template.TemplateUtil;
import cn.hutool.extra.tokenizer.Result;
import cn.hutool.extra.tokenizer.TokenizerEngine;
import cn.hutool.extra.tokenizer.TokenizerUtil;
import cn.hutool.extra.tokenizer.Word;
import cn.hutool.extra.tokenizer.engine.hanlp.HanLPEngine;
import cn.hutool.http.HttpUtil;
import cn.hutool.http.useragent.UserAgent;
import cn.hutool.http.useragent.UserAgentUtil;
import cn.hutool.http.webservice.SoapClient;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import cn.hutool.system.SystemUtil;
import io.swagger.annotations.Api;
import junit.framework.Assert;

public class hutoolTest {

@Test
public void convertTest() {
	// 转换为字符串
	int a = 1;
	String aStr = Convert.toStr(a);
	// 转换为指定类型数组
	String[] b = { "1", "2", "3", "4" };
	Integer[] bArr = Convert.toIntArray(b);
	Console.log(Arrays.toString(bArr));
	// 转换为日期对象
	String dateStr = "2017-05-06";
	Date date = Convert.toDate(dateStr);
	// 转换为列表
	String[] strArr = { "a", "b", "c", "d" };
	List<String> strList = Convert.toList(String.class, strArr);
	System.out.println(strList.toString());

	String b2 = "123456789";
	// 结果为："１２３４５６７８９"
	String sbc = Convert.toSBC(b2);
	Console.log(sbc + " sbc");

	b2 = "我是一个小小的可爱的字符串";
	// 结果："e68891e698afe4b880e4b8aae5b08fe5b08fe79a84e58fafe788b1e79a84e5ad97e7aca6e4b8b2"
	String hex = Convert.toHex(b2, CharsetUtil.CHARSET_UTF_8);
	Console.log(hex + " hex");

	hex = "e68891e698afe4b880e4b8aae5b08fe5b08fe79a84e58fafe788b1e79a84e5ad97e7aca6e4b8b2";

	String raw = Convert.hexToStr(hex, CharsetUtil.CHARSET_UTF_8);
	Console.log(raw + " raw");

	// 结果为："\\u6211\\u662f\\u4e00\\u4e2a\\u5c0f\\u5c0f\\u7684\\u53ef\\u7231\\u7684\\u5b57\\u7b26\\u4e32"
	String unicode = Convert.strToUnicode(b2);
	// 结果为："我是一个小小的可爱的字符串"
	raw = Convert.unicodeToStr(unicode);
	Console.log("{} {}", unicode, raw);

	Object[] a2 = { "a", "你", "好", "", 1 };
	List<?> list = Convert.convert(List.class, a2);
	// 从4.1.11开始可以这么用
	List<?> list2 = Convert.toList(a);

	double a3 = 67556.32;

	// 结果为："陆万柒仟伍佰伍拾陆元叁角贰分"
	String digitUppercase = Convert.digitToChinese(a3);
	Console.log(digitUppercase + " digitUpper");

	ConverterRegistry converterRegistry = ConverterRegistry.getInstance();
	String result = converterRegistry.convert(String.class, a);
	Assert.assertEquals("3423", result);
}

@Test
public void dateTest() throws InterruptedException {
	// Date、long、Calendar之间的相互转换
	// 当前时间
	Date date = DateUtil.date();
	// Calendar转Date
	date = DateUtil.date(Calendar.getInstance());
	// 时间戳转Date
	date = DateUtil.date(System.currentTimeMillis());
	// 自动识别格式转换
	String dateStr = "2017-03-01";
	date = DateUtil.parse(dateStr);
	System.out.println(date + " date");
	// 自定义格式化转换
	date = DateUtil.parse(dateStr, "yyyy-MM-dd");
	// 格式化输出日期
	String format = DateUtil.format(date, "yyyy-MM-dd");
	// 获得年的部分
	int year = DateUtil.year(date);
	// 获得月份，从0开始计数
	int month = DateUtil.month(date);
	// 获取某天的开始、结束时间
	Date beginOfDay = DateUtil.beginOfDay(date);
	Console.log(beginOfDay + " begin");
	Date endOfDay = DateUtil.endOfDay(date);
	Console.log(endOfDay + " end");
	// 计算偏移后的日期时间
	Date newDate = DateUtil.offset(date, DateField.DAY_OF_MONTH, 2);
	Console.log(newDate + " new date");
	// 计算日期时间之间的偏移量
	long betweenDay = DateUtil.between(date, newDate, DateUnit.DAY);
	String formatBetween = DateUtil.formatBetween(betweenDay, Level.MINUTE);
	// 输出：31天1小时
	Console.log(formatBetween + " between");

	TimeInterval timer = DateUtil.timer();

	Thread.sleep(2000);
	// ---------------------------------
	// -------这是执行过程
	// ---------------------------------
	Console.log(timer.interval() + " time");
	timer.intervalRestart();// 返回花费时间，并重置开始时间
	timer.intervalMinute();// 花费分钟数

	// 年龄
	DateUtil.ageOfNow("1990-01-30");

	// 是否闰年
	DateUtil.isLeapYear(2017);

	Date date2 = new Date();

	// new方式创建
	DateTime time = new DateTime(date2);
	Console.log(time + " time");

	// of方式创建
	DateTime now = DateTime.now();
	DateTime dt = DateTime.of(date);

	DateTime dateTime = new DateTime("2017-01-05 12:34:23", DatePattern.NORM_DATETIME_FORMAT);

	// 年，结果：2017
	int year2 = dateTime.year();

	// 月份，结果：Month.JANUARY
	Month month2 = dateTime.monthEnum();

	// 日，结果：5
	int day = dateTime.dayOfMonth();

	Console.log("{} {} {}", year2, month2, day);

	DateTime dateTime2 = new DateTime("2017-01-05 12:34:23", DatePattern.NORM_DATETIME_FORMAT);
	// 结果：2017-01-05 12:34:23
	String dateStr2 = dateTime.toString();
	Console.log("{} {}", dateTime2, dateStr2);

	ChineseDate date4 = new ChineseDate(DateUtil.parseDate("2020-01-25"));
	// 一月
	date4.getChineseMonth();
	// 正月
	date4.getChineseMonthName();
	// 初一
	date4.getChineseDay();
	// 庚子
	date4.getCyclical();
	// 鼠
	date4.getChineseZodiac();
	// 春节
	date4.getFestivals();
	// 庚子鼠年 正月初一
	date4.toString();

}

@Test
public void strTest() {
	// 判断是否为空字符串
	String str = "test";
	StrUtil.isEmpty(str);
	StrUtil.isNotEmpty(str);
	// 去除字符串的前后缀
	StrUtil.removeSuffix("a.jpg", ".jpg");
	StrUtil.removePrefix("a.jpg", "a.");
	// 格式化字符串
	String template = "这只是个占位符:{}";
	String str2 = StrUtil.format(template, "我是占位符");
	Console.log("/strUtil format:{}", str2);
}

@Test
public void numTest() {
	double n1 = 1.234;
	double n2 = 1.234;
	double result;
	// 对float、double、BigDecimal做加减乘除操作
	result = NumberUtil.add(n1, n2);
	result = NumberUtil.sub(n1, n2);
	result = NumberUtil.mul(n1, n2);
	result = NumberUtil.div(n1, n2);
	// 保留两位小数
	BigDecimal roundNum = NumberUtil.round(n1, 2);
	String n3 = "1.234";
	// 判断是否为数字、整数、浮点数
	NumberUtil.isNumber(n3);
	NumberUtil.isInteger(n3);
	NumberUtil.isDouble(n3);
}

@Test
public void mapTest() {
	PmsBrand brand = new PmsBrand();
	brand.setId(1L);
	brand.setName("小米");
	brand.setShowStatus(0);
	// Bean转Map
	Map<String, Object> map = BeanUtil.beanToMap(brand);
	Console.log("beanUtil bean to map:{}", map);
	// Map转Bean
	PmsBrand mapBrand = BeanUtil.mapToBean(map, PmsBrand.class, false);
	Console.log("beanUtil map to bean:{}", mapBrand);
	// Bean属性拷贝
	PmsBrand copyBrand = new PmsBrand();
	BeanUtil.copyProperties(brand, copyBrand);

	Console.log("beanUtil map to bean:{}", copyBrand);
}

@Test
public void collTest() {
	// 数组转换为列表
	String[] array = new String[] { "a", "b", "c", "d", "e" };
	List<String> list = CollUtil.newArrayList(array);
	// join：数组转字符串时添加连接符号
	String joinStr = CollUtil.join(list, ",");
	Console.log("collUtil join:{}", joinStr);
	// 将以连接符号分隔的字符串再转换为列表
	List<String> splitList = StrUtil.split(joinStr, ',');
	Console.log(splitList + " list");
	// 创建新的Map、Set、List
	HashMap<Object, Object> newMap = CollUtil.newHashMap();
	HashSet<Object> newHashSet = CollUtil.newHashSet();
	ArrayList<Object> newList = CollUtil.newArrayList();
	// 判断列表是否为空
	CollUtil.isEmpty(list);

	// 将多个键值对加入到Map中
	Map<Object, Object> map = MapUtil
			.of(new String[][] { { "key1", "value1" }, { "key2", "value2" }, { "key3", "value3" } });
	// 判断Map是否为空
	MapUtil.isEmpty(map);
	MapUtil.isNotEmpty(map);
}

@Test
public void annotationTest() {
	// 获取指定类、方法、字段、构造器上的注解列表
	Annotation[] annotationList = AnnotationUtil.getAnnotations(hutoolTest.class, false);
	Console.log("annotationUtil annotations:{}", annotationList);
	// 获取指定类型注解
	Api api = AnnotationUtil.getAnnotation(hutoolTest.class, Api.class);
	Console.log("annotationUtil api value:{}", api.description());
	// 获取指定类型注解的值
	Object annotationValue = AnnotationUtil.getAnnotationValue(hutoolTest.class, RequestMapping.class);
}

@Test
public void md5Test() {
	// MD5加密
	String str = "123456";
	String md5Str = SecureUtil.md5(str);
	Console.log("secureUtil md5:{}", md5Str);

	byte[] data = "我是一段测试字符串".getBytes();
	Sign sign = SecureUtil.sign(SignAlgorithm.MD5withRSA);
	// 签名
	byte[] signed = sign.sign(data);
	// 验证签名
	boolean verify = sign.verify(data, signed);
	Console.log(verify + " verify");

	String text = "我是一段测试aaaa";

	// 结果为：136ce3c86e4ed909b76082055a61586af20b4dab674732ebd4b599eef080c9be
	String digestHex = SmUtil.sm3("aaaaa");
	System.out.println(digestHex + " hex");

	String content = "test中文";
	SymmetricCrypto sm4 = SmUtil.sm4();
	byte[] sec = sm4.getSecretKey().getEncoded();
	System.out.println(HexUtil.encodeHexStr(sec));
	String encryptB64 = sm4.encryptBase64(content);

	String decryptStr = sm4.decryptStr(encryptB64, CharsetUtil.CHARSET_UTF_8);

	String PRIVATE_KEY = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAIL7pbQ+5KKGYRhw7jE31hmA"
			+ "f8Q60ybd+xZuRmuO5kOFBRqXGxKTQ9TfQI+aMW+0lw/kibKzaD/EKV91107xE384qOy6IcuBfaR5lv39OcoqNZ"
			+ "5l+Dah5ABGnVkBP9fKOFhPgghBknTRo0/rZFGI6Q1UHXb+4atP++LNFlDymJcPAgMBAAECgYBammGb1alndta"
			+ "xBmTtLLdveoBmp14p04D8mhkiC33iFKBcLUvvxGg2Vpuc+cbagyu/NZG+R/WDrlgEDUp6861M5BeFN0L9O4hz"
			+ "GAEn8xyTE96f8sh4VlRmBOvVdwZqRO+ilkOM96+KL88A9RKdp8V2tna7TM6oI3LHDyf/JBoXaQJBAMcVN7fKlYP"
			+ "Skzfh/yZzW2fmC0ZNg/qaW8Oa/wfDxlWjgnS0p/EKWZ8BxjR/d199L3i/KMaGdfpaWbYZLvYENqUCQQCobjsuCW"
			+ "nlZhcWajjzpsSuy8/bICVEpUax1fUZ58Mq69CQXfaZemD9Ar4omzuEAAs2/uee3kt3AvCBaeq05NyjAkBme8SwB0iK"
			+ "kLcaeGuJlq7CQIkjSrobIqUEf+CzVZPe+AorG+isS+Cw2w/2bHu+G0p5xSYvdH59P0+ZT0N+f9LFAkA6v3Ae56OrI"
			+ "wfMhrJksfeKbIaMjNLS9b8JynIaXg9iCiyOHmgkMl5gAbPoH/ULXqSKwzBw5mJ2GW1gBlyaSfV3AkA/RJC+adIjsRGg"
			+ "JOkiRjSmPpGv3FOhl9fsBPjupZBEIuoMWOC8GXK/73DHxwmfNmN7C9+sIi4RBcjEeQ5F5FHZ";

	RSA rsa = new RSA(PRIVATE_KEY, null);

	String a = "2707F9FD4288CEF302C972058712F24A5F3EC62C5A14AD2FC59DAB93503AA0FA17113A020EE4EA35EB53F"
			+ "75F36564BA1DABAA20F3B90FD39315C30E68FE8A1803B36C29029B23EB612C06ACF3A34BE815074F5EB5AA3A"
			+ "C0C8832EC42DA725B4E1C38EF4EA1B85904F8B10B2D62EA782B813229F9090E6F7394E42E6F44494BB8";

	byte[] aByte = HexUtil.decodeHex(a);
	byte[] decrypt = rsa.decrypt(aByte, KeyType.PrivateKey);
	System.out.println(StrUtil.str(decrypt, CharsetUtil.CHARSET_UTF_8));
	Assert.assertEquals("虎头闯杭州,多抬头看天,切勿只管种地", StrUtil.str(decrypt, CharsetUtil.CHARSET_UTF_8));
}

	@Test
	public void Captcha() {

		LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(200, 100);

//图形验证码写出，可以写出到文件，也可以写出到流
		lineCaptcha.write("d:/line.png");
//输出code
		Console.log(lineCaptcha.getCode());
//验证图形验证码的有效性，返回boolean值
		Console.log(lineCaptcha.verify("1234"));

//重新生成验证码
		lineCaptcha.createCode();
		lineCaptcha.write("d:/line.png");
//新的验证码
		Console.log(lineCaptcha.getCode());
//验证图形验证码的有效性，返回boolean值
		lineCaptcha.verify("1234");

	}

@Test
public void qrCode() {
	QrConfig config = new QrConfig(300, 300);
	// 设置边距，既二维码和背景之间的边距
	config.setMargin(3);
	// 设置前景色，既二维码颜色（青色）
	config.setForeColor(Color.CYAN.getRGB());
	// 设置背景色（灰色）
	config.setBackColor(Color.GRAY.getRGB());
	// 生成二维码到文件，也可以到流
	java.io.File file = QrCodeUtil.generate(
			"eID0000IDCORRECTAPP0000000072Yc89/Y/XIh2K2GV0W5l7qXEwUt133ZB6YSn564IQEfh9+9pPciPXKntqTVq03EKetP6q8RKeloKKLh2/igHQ==",
			config, FileUtil.file("d:/qrcode.jpg"));
	System.out.println(FileUtil.file("d:/qrcode.jpg").exists());
	String decode = QrCodeUtil.decode(file);
	Console.log(decode + " decodeF");
}

@Test
public void fileType() {
	File file = FileUtil.file("d:/qrcode.jpg");
	String type = FileTypeUtil.getType(file);
	// 输出 jpg则说明确实为jpg文件
	Console.log(type);
}

@Test
public void HttpUtilsTest() {
	String url = "http://www.sogou.com";
	Map<String, Object> paramMap = new HashMap<>();
	paramMap.put("query", 10086);
	// 无参GET请求
	String result = HttpUtil.get(url);
	System.out.println(result + " res");
	// 带参GET请求
	String result2 = HttpUtil.get(url, paramMap);

	System.out.println(result2 + " res");

	paramMap = new HashMap<>();
	paramMap.put("city", "北京");
	result = HttpUtil.post("https://www.baidu.com", paramMap);
	Console.log(result + " res");
	// 文件上传只需将参数中的键指定（默认file），值设为文件对象即可，对于使用者来说，文件上传与普通表单提交并无区别
	paramMap.put("file", FileUtil.file("D:\\qrcode.jpg"));
	result = HttpUtil.post("https://www.baidu.com", paramMap);
	Console.log(result + " res");

//		String fileUrl = "http://mirrors.sohu.com/centos/7.3.1611/isos/x86_64/CentOS-7-x86_64-DVD-1611.iso";
//		// 将文件下载后保存在E盘，返回结果为下载文件大小
//		long size = HttpUtil.downloadFile(fileUrl, FileUtil.file("d:/cent.iso"));
//		System.out.println("Download size: " + size);

	String uaStr = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.163 Safari/535.1";

	UserAgent ua = UserAgentUtil.parse(uaStr);
	ua.getBrowser().toString();// Chrome
	ua.getVersion();// 14.0.835.163
	ua.getEngine().toString();// Webkit
	ua.getEngineVersion();// 535.1
	ua.getOs().toString();// Windows 7
	ua.getPlatform().toString();// Windows

	SoapClient client = SoapClient.create("http://www.webxml.com.cn/WebServices/IpAddressSearchWebService.asmx")
			// 设置要请求的方法，此接口方法前缀为web，传入对应的命名空间
			.setMethod("web:getCountryCityByIp", "http://WebXml.com.cn/")
			// 设置参数，此处自动添加方法的前缀：web
			.setParam("theIpAddress", "218.21.240.106");
	// 发送请求，参数true表示返回一个格式化后的XML内容
	// 返回内容为XML字符串，可以配合XmlUtil解析这个响应
	Console.log(client.send(true));
}

@Test
public void cache() {
	Cache<String, String> fifoCache = CacheUtil.newFIFOCache(3);
	// 加入元素，每个元素可以设置其过期时长，DateUnit.SECOND.getMillis()代表每秒对应的毫秒数，在此为3秒
	fifoCache.put("key1", "value1", DateUnit.SECOND.getMillis() * 3);
	fifoCache.put("key2", "value2", DateUnit.SECOND.getMillis() * 3);
	fifoCache.put("key3", "value3", DateUnit.SECOND.getMillis() * 3);
	// 由于缓存容量只有3，当加入第四个元素的时候，根据FIFO规则，最先放入的对象将被移除
	fifoCache.put("key4", "value4", DateUnit.SECOND.getMillis() * 3);
	// value1为null
	String value1 = fifoCache.get("key1");
	System.out.println(value1);
	System.out.println(fifoCache.get("key4"));

	LFUFileCache cache = new LFUFileCache(1000, 500, 2000);
	byte[] bytes = cache.getFileBytes("d:/qrcode.jpg");
	Console.log(Base64.encode(bytes));
}

@Test
public void json() {
	JSONObject json1 = JSONUtil.createObj();
	json1.put("a", "value1");
	json1.put("b", "value2");
	json1.put("c", "value3");
	Console.log(JSONUtil.toJsonStr(json1));

	String jsonStr = "{\"b\":\"value2\",\"c\":\"value3\",\"a\":\"value1\"}";
	// 方法一：使用工具类转换
	JSONObject jsonObject = JSONUtil.parseObj(jsonStr);
	Console.log(jsonObject.toString());

	// 方法1
	JSONArray array = JSONUtil.createArray();
	array.add("value1");
	array.add("value2");
	array.add("value3");
	// 转为JSONArray字符串
	Console.log(array.toString() + " arr");
}

@Test
public void DFA() {
	WordTree tree = new WordTree();
	tree.addWord("大");
	tree.addWord("大土豆");
	tree.addWord("土豆");
	tree.addWord("刚出锅");
	tree.addWord("出锅");

	String text = "我有一颗大土豆，刚出锅的";
	List<String> matchAll = tree.matchAll(text, -1, false, false);
	Console.log(matchAll.toString());
	Assert.assertEquals(matchAll.toString(), "[大, 土豆, 刚出锅]");

	matchAll = tree.matchAll(text, -1, true, false);
	Console.log(matchAll.toString());
	Assert.assertEquals(matchAll.toString(), "[大, 土豆, 刚出锅, 出锅]");

	matchAll = tree.matchAll(text, -1, false, true);
	Console.log(matchAll.toString());
	Assert.assertEquals(matchAll.toString(), "[大, 大土豆, 刚出锅]");
}

@Test
public void taskTest() {
	CronUtil.schedule("*/2 * * * * *", new Task() {
		@Override
		public void execute() {
			Console.log("Task excuted. hellod");
		}
	});
	// 支持秒级别定时任务
	CronUtil.setMatchSecond(true);
	CronUtil.start();
}

@Test
public void template() {
	// 自动根据用户引入的模板引擎库的jar来自动选择使用的引擎
	// TemplateConfig为模板引擎的选项，可选内容有字符编码、模板路径、模板加载方式等，默认通过模板字符串渲染
	TemplateEngine engine = TemplateUtil.createEngine(new TemplateConfig());
	// 假设我们引入的是Beetl引擎，则：
	Template template = engine.getTemplate("Hello ${name}");
	// Dict本质上为Map，此处可用Map
	String result = template.render(Dict.create().set("name", "Hutool"));
	// 输出：Hello Hutool
}

@Test
public void Emoji() {
	String alias = EmojiUtil.toAlias("😄");// :smile:
	String emoji = EmojiUtil.toUnicode(":smile:");// 😄
	String alia2s = EmojiUtil.toHtml("😄");// &#128102;
	Console.log("{} {} {}", alias, emoji, alia2s);
}

@Test
public void TokenizeTest() {
	// 自动根据用户引入的分词库的jar来自动选择使用的引擎
	TokenizerEngine engine = TokenizerUtil.createEngine();
	// 解析文本
	String text = "这两个方法的区别在于返回值";
	Result result = engine.parse(text);
	// 输出：这 两个 方法 的 区别 在于 返回 值
	String resultStr = CollUtil.join((Iterator<Word>) result, " ");
	Console.log(resultStr);

	engine = new HanLPEngine();
	// 解析文本
	text = "这两个方法的区别在于返回值";
	result = engine.parse(text);
	// 输出：这 两个 方法 的 区别 在于 返回 值
	resultStr = CollUtil.join((Iterator<Word>) result, " ");
}

class Dog {
	public String eat() {
		Console.log("狗吃肉");
		return "hello";
	}
}

@Test
public void AOPTEST() {
	Dog dog = ProxyUtil.proxy(new Dog(), TimeIntervalAspect.class);
	String result = dog.eat();

	Console.log(result);
}

@Test
public void sysInfo() {
	Console.log(SystemUtil.getJvmSpecInfo());
}

@Test
public void monitor() {
	File file = FileUtil.file("example.properties");
	// 这里只监听文件或目录的修改事件
	WatchMonitor watchMonitor = WatchMonitor.create(file, WatchMonitor.ENTRY_MODIFY);
	watchMonitor.setWatcher(new Watcher() {
		@Override
		public void onCreate(WatchEvent<?> event, Path currentPath) {
			Object obj = event.context();
			Console.log("创建：{}-> {}", currentPath, obj);
		}

		@Override
		public void onModify(WatchEvent<?> event, Path currentPath) {
			Object obj = event.context();
			Console.log("修改：{}-> {}", currentPath, obj);
		}

		@Override
		public void onDelete(WatchEvent<?> event, Path currentPath) {
			Object obj = event.context();
			Console.log("删除：{}-> {}", currentPath, obj);
		}

		@Override
		public void onOverflow(WatchEvent<?> event, Path currentPath) {
			Object obj = event.context();
			Console.log("Overflow：{}-> {}", currentPath, obj);
		}
	});
	// 设置监听目录的最大深入，目录层级大于制定层级的变更将不被监听，默认只监听当前层级目录
	watchMonitor.setMaxDepth(3);
	// 启动监听
	watchMonitor.start();
}

@Test
public void CollTest() {
	String[] col = new String[] { "a", "b", "c", "d", "e" };
	List<String> colList = CollUtil.newArrayList(col);
	String str = CollUtil.join(colList, "#"); // str -> a#b#c#d#e
	Console.log(str);

	// Integer比较器
	Comparator<Integer> comparator = new Comparator<Integer>() {
		@Override
		public int compare(Integer o1, Integer o2) {
			return o1.compareTo(o2);
		}
	};
	// 新建三个列表，CollUtil.newArrayList方法表示新建ArrayList并填充元素
	List<Integer> list1 = CollUtil.newArrayList(1, 2, 3, 10);
	List<Integer> list2 = CollUtil.newArrayList(4, 5, 6);
	List<Integer> list3 = CollUtil.newArrayList(7, 8, 9);
	// 参数表示把list1,list2,list3合并并按照从小到大排序后，取0~2个（包括第0个，不包括第2个），结果是[1,2]
	@SuppressWarnings("unchecked")
	List<Integer> result = CollUtil.sortPageAll(0, 20, comparator, list1, list2, list3);
	System.out.println(result);
}

@Test
public void BounedQue() {
	// 初始化队列，设置队列的容量为5（只能容纳5个元素），元素类型为integer使用默认比较器，在队列内部将按照从小到大排序
	BoundedPriorityQueue<Integer> queue = new BoundedPriorityQueue<Integer>(5);
	// 初始化队列，使用自定义的比较器
	queue = new BoundedPriorityQueue<>(5, new Comparator<Integer>() {
		@Override
		public int compare(Integer o1, Integer o2) {
			return o1.compareTo(o2);
		}
	});
	// 定义了6个元素，当元素加入到队列中，会按照从小到大排序，当加入第6个元素的时候，队列末尾（最大的元素）将会被抛弃
	int[] array = new int[] { 5, 7, 9, 2, 3, 8 };
	for (int i : array) {
		queue.offer(i);
	}
	// 队列可以转换为List哦~~
	ArrayList<Integer> list = queue.toList();
	System.out.println(queue);
}
}