heads = http.getRespHeads();
// 获取指定响应头,例如HOST
String host = http.getRespHead("HOST");
// 获取响应体
String body = http.getRespBody();
```
# 线程管理器
> 此部分诞生是因为本人写程序遇到了一些不能解决的问题，且非代码问题。
>
> 我使用到了 JVisualVM 工具观察到我程序的某个线程状态从正常运行变为了等待（在我程序稳定运行一个月后出现）
>
> 代码内无任何关于线程等待的代码，因为是死循环，所以想到了使用守护线程的方式来监测，当线程等待自动中断让此线程继续运行。
shendi.kit.thread
SK 1.1新增
目前此包仅用于处理线程状态莫名变成等待的情况，后续扩展
```java
// 打开线程管理器
ThreadManager.open();
// 将需要被管理的线程添加进管理器,且设置期望被管理的类型(目前只提供永不等待类型,参考枚举 ThreadType)
Thread t = new Thread(() -> {
Object obj = new Object();
try {
synchronized (obj) {
// 线程状态变为等待后会被线程管理器中断
obj.wait();
}
} catch (Throwable e) {
}
System.out.println("我从等待中出来了");
});
ThreadManager.add("测试线程", t, ThreadType.NO_WATTING);
// 线程管理器是以守护线程的方式运行,所以程序内必须要有一个存活的用户线程,否则将自行结束.
```
# 工具类
## StreamUtils
>流处理工具类
>下面演示此类的少量方法,更多请直接参考此类
```java
// 读取一行,String readLine(InputStream);
String line = StreamUtils.readLine(input);
// 读取一行,字节形式 bybte[] readLineRByte(InputStream)
byte[] bLine = StreamUtils.readLineRByte(input);
/* 读取数据直到指定结尾,byte[] readByEnd(InputStream, byte[]);,其中第二个 参数是要指定的结尾 */
/* 其中支持设置读取的最大数据长度(在网络编程中会接收到一些爬虫等连接,假设一直发送数据则会导致一直读取数据,导致内存占用过高)
* StreamUtils.readByEnd(input, byte[], int 设置接受数据的最大大小); */
byte[] data = StreamUtils.readByEnd(input, "\n".getBytes());
/* 读取一个文件的数据,byte[] getFile(String)或getFile(File) */
byte[] fData = StreamUtils.getFile("C:/1.txt");
```
## SKClassLoader
类加载器
用于将外部class文件定义可使用的类
## HttpUtil
Http工具类
在 SK 1.1 中,此类被移至 shendi.kit.net.http 包中,文档也移动,请参考 [HTTP工具](#HTTP工具包)
## Math
数学工具类
SK 1.1中新增
### 单位转换
```java
// 单位转换,如果后两参数传递的浮点型则返回的结果也带小数
String[] names = {"厘米", "分米", "米"};
// 第一个参数为单位,从小到大,第二个参数为进制,第三个为实际数值
String s = Math.unitConvert(names, 10, 10);
s == "1分米"
String s = Math.unitConvert(names, 10, 1011);
s == "10米 1分米 1厘米"
```
### 计算指定字符数的指定最大长度可排列数
```java
// 例如计算指定字符列表可生成的最大随机字符数
// 例如字符0和1, 最大长度2, 可排列为 0,1,00,01,10,11
// 参数1为字符数量,0和1是两个, 参数2为最大长度,两位数就2, 因为计算结果值可能会非常大,所以使用BigDecimal
BigDecimal num = Math.charLenComposeNum(2, 2);
// num == 6
// 计算数字字母(大小写) 32长度可排列的数
String chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
num = Math.charLenComposeNum(chars.length(), 32);
// num == 2309914571127845629705327490900126861476998063576338098410
```
## IsNullUtil
>判空工具类
>SK 1.1中新增
通常在写函数的时候会有很多参数
首先会对其进行判断
例如
if (account == null || "".equals(account)) {}
当参数一多,就要写很长的代码,或者重复很多次上述操作
于是此类就这样诞生了
对于上述操作,判断 null 和 "" 为空的
可以直接通过 {@link #strsIsNull(String...)} 来判断
例如
String account = null;
String password = "hello";
IsNullUtil.strsIsNull(account, password)
== true
account = "world";
IsNullUtil.strsIsNull(account, password)
== false
当然,也可以自己设定判空条件,使用 {@link #isNull(Object[], Object...)} 函数
在写 Java Web 项目通常参数会为 "null"
if (IsNullUtil.isNull(new String[] {"", "null"}, account, password)) {
...
}
有时我们只需要判断是否为 null,所以提供了此函数的重载 isNull(Object...)
因为有此重载,则此函数传递的第一个参数不能为数组,否则将会被解析成 isNull(Object[], Object...)
此函数等价于调用 isNull(null, Object...);
## ByteUtil
字节工具类
SK 1.1中新增
```java
// 将字节数组插入到另一个字节数组中
// ByteUtil.insert(byte[], int, byte[], int, int);
// 参数分别为,字节数组,数组的开始偏移,被插入的字节数组,插入的位置,插入多少个
byte[] source = {1, 2, 3};
byte[] data = {4, 5};
byte[] result = ByteUtil.insert(data, 0, source, source.length, data.length);
result == {1, 2, 3, 4, 5};
source = {1, 3, 4};
data = {2};
result = ByteUtil.insert(data, 0, source, 1, data.length);
result == {1, 2, 3, 4};
// 查找指定字节数组在字节数组中第一次出现的位置
// ByteUtil.indexOf(byte[], String);
// ByteUtil.indexOf(byte[], byte[]);
byte[] data = "hello,world".getBytes();
int result = indexOf(data, ",".getBytes());
result -> 5
result = indexOf(data, "llo");
result -> 2
result = indexOf(data, "what are you doing?");
result -> -1
// 截取字节数组
// ByteUtil.subByte(byte[], int)
// ByteUtil.subByte(byte[], int, int)
byte[] data = "hello,world".getBytes();
byte[] result = subByte(data, 2);
result -> "llo,world"
byte[] result = subByte(data, 2, data.length);
result -> "llo,world"
// 将字节数组连接成新数组
// ByteUtil.concat(byte[]...)
byte[] data1 = "hello".getBytes();
byte[] data2 = ",world".getBytes();
byte[] result = concat(data1, data2);
result -> "hello,world"
result = concat("hello".getBytes(), ",Java.".getBytes(), "I'm".getBytes(), " Shendi".getBytes());
result -> "hello,Java.I'm Shendi"
data1 = "I like ".getBytes();
data2 = new byte[0];
data3 = "this kit!".getBytes();
result = concat(data1, data2, data3);
result -> "I like this kit!"
// 将字节数组连接成新数组并插入分隔数组
// ByteUtil.concatSplit(byte[], byte[]...)
byte[] split = ",".getBytes();
byte[] data1 = "hello".getBytes();
byte[] data2 = "world".getBytes();
byte[] result = concatSplit(split, data1, data2);
result -> "hello,world"
result = concatSplit(split, "red".getBytes(), "green".getBytes(), "blue".getBytes(), "shendi".getBytes());
result -> "red,green,blue,shendi"
result = concatStr(split, "hello, world".getBytes());
result -> "hello, world"
data1 = "I like".getBytes();
data2 = new byte[0];
data3 = "this kit!".getBytes();
result = concatSplit(split, data1, data2, data3);
result -> "I like,this kit!"
// 将字节数组按照指定字节数组进行分割
// ByteUtil.split(byte[], byte[])
// ByteUtil.split(byte[], byte[], int)
byte[] data = "hello,world".getBytes();
byte[] split = ",".getBytes();
byte[] result = split(data, split);
result -> ["hello", "world"]
data = "red,green,blue,shendi".getBytes();
result = split(data, split);
result -> ["red", "green", "blue", "shendi"]
data = "I like,,this kit!".getBytes();
result = split(data, split);
result -> ["I like", "this kit!"]
data = "123,456,789,012".getBytes();
result = split(data, split, 3)
result -> ["123", "456", "789"]
// 字节数组是否以指定数据开头
// ByteUtil.startsWith(byte[], byte[])
// ByteUtil.startsWith(byte[], byte[], int)
byte[] data = {1,2,3,4,5,6,7,1,2,3,4};
byte[] start = {1,2,3};
boolean isStartsWith = ByteUtil.startsWith(data, start);
isStartsWith -> true
isStartsWith = ByteUtil.startsWith(data, start, 0);
isStartsWith -> true
isStartsWith = ByteUtil.startsWith(data, start, 7);
isStartsWith -> true
isStartsWith = ByteUtil.startsWith(data, start, -1);
isStartsWith -> false
// 字节数组是否以指定数据结尾
// ByteUtil.endsWith(byte[], byte[])
// ByteUtil.endsWith(byte[], int, byte[])
byte[] data = {1,2,3,4,5,6,7,1,2,3,4};
byte[] end = {2,3,4};
boolean isEndWith = ByteUtil.endsWith(data, end);
isEndWith -> true
isEndWith = ByteUtil.endsWith(data, data.length, end);
isEndWith -> true
isEndWith = ByteUtil.endsWith(data, 4, end);
isEndWith -> true
isEndWith = ByteUtil.endsWith(data, -1, end);
isEndWith -> false
```
## BitUtil
>位工具类
>SK 1.1中新增
/**
* 获取指定数值占多少位,数字符号位占一位.
* int sizeOf(long);
* sizeOf(0) -> 2
* sizeOf(1) -> 2
* sizeOf(2) -> 3
*/
int bitNum = BitUtil.sizeOf(1);
/**
* 获取指定位数的最大十进制值,不带符号位
* long bitMax(int);
* bitMax(0) -> 0
* bitMax(1) -> 1
* bitMax(2) -> 3
* bitMax(3) -> 7
*/
int max = BitUtil.bitMax(1);
## FileUtil
>文件工具类
>SK 1.1中新增
```java
// 使用指定数据更新/创建指定文件,update(String, byte[])
FileUtil.update("C:/1.txt", "hello".getBytes());
// 同上,参数一为相对路径,updateByPro(String, byte[])
// 例如将项目下的1.txt内容更改
FileUtil.updateByPro("/1.txt", "hello.getBytes());
```
## StringUtil
> 字符串工具类
>
> SK 1.1新增
```java
// 字符串去除指定字符串的前后空格
StringUtil.trimByStr("1 . 2. 3", "."); // 1.2.3
// 1.1.3新增
// 重复字符串，同 JDK11 的 String.repeat
StringUtil.repeat("test", 3); // testtesttest
```
## PatternUtil
正则工具类，将各种常用正则封装其中
SK 1.1.1 新增
测试用例类：`TestPatternUtil`
```java
// 示例：校验手机
PatternUtil.PHONE.matcher("13333333333").matches();
// NUMBER - 数字
// URI - 匹配数字,字母,斜杠,点
// EMAIL - 邮箱
// MONEY - 金额
```
## InfoUtil
信息工具类，提供一些常用的信息操作，如脱敏等
SK 1.1.3 新增
```java
// 保留前三位和后四位
String phone = InfoUtil.priv("13333333333", 3, 4); // 133****3333
```