stream流、数学类、String类的常用方法、date、密码等

一、API

1、基本概念

英文全称Application Programming Interface，翻译为“应用程序编程接口”。是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。

2、接口interface

3、格式Format

4、协议Protocol

协议是规定了各部分之间如何进行交流的一系列规则的集合。各部分之间想要完成交互就必须理解并且遵守同一个协议

5、API端点

在同一个接口中提供特定功能子集的服务提供者。不同的端点可以有不同的协议和不同的格式。

6、分页pagination

可以节省带宽和服务器资源，因为你不需要一次获取数据集中的所有内容

7、过滤filtering

总结起来：接口是不同组件进行交互的地方。协议是一系列规定了他们之间怎样进行交互的规则。格式定义了他们通过什么进行交流（JSON或者是XML），端点可以在同一个接口里面提供不同的功能。

特点：

API能够确认所有的操作都是合法的

在发生错误的时候，API会根据错误报告机制发出指示，减轻开发人员的负担

API中内置授权和访问控制，以确保只有授权人员才能访问特定的数据

API实施速率限制来控制服务器资源的使用，以确保用户不会滥用服务

二、Stream

1、基本概念

Stream 是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作，

开发者可以更容易地使用Lambda表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等。

Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的

Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用

户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字

母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。

Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比

流水从面前流过，一去不复返。

而和迭代器又不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作。顾名思义，当使用串行方

式去遍历时，每个 item 读完后再读下一个 item。而使用并行去遍历时，数据会被分成多个段，其中每一个都在不

同的线程中处理，然后将结果一起输出。

Stream和Collection的区别主要有：

1.stream本身并不存储数据，数据是存储在对应的collection里，或者在需要的时候才生成的；

2.stream不会修改数据源，总是返回新的stream；

3.stream的操作是懒执行(lazy)的：仅当最终的结果需要的时候才会执行

2、Lambda表达式

lambda的语法介绍

在Java语言中引入了一个操作符**“->”**，该操作符被称为Lambda操作符或箭头操作符。它将Lambda分为两个部分：

左侧：指定了Lambda表达式需要的所有参数

右侧：制定了Lambda体，即Lambda表达式要执行的功能。

lambda的特点

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

Lambda表达式的参数列表的数据类型可以省略不写，因为JVM可以通过上下文推断出数据类型，即“类型推断”。

类型推断：在执行javac编译程序时，JVM根据程序的上下文推断出了参数的类型。Lambda表达式依赖于上下文环境。

3、构建stream方法

1、计算集合里空字符串的数量（filter）

 @Testpublic void test01() {List<String> list = Arrays.asList("aa", "aae", "bb", "cc", "", "dd");// 计算空字符串的数量long count = list.stream().filter(a -> a.isEmpty()).count();System.out.println("空字符串的数量是>>>" + count + "个");}

空字符串的数量是>>>1

2、找出集合中长度为2的字符串数量（filter）

 @Testpublic void test02() {List<String> list = Arrays.asList("aa", "aae", "bb", "cc", "", "dd"); // 计算列表中指定长度的字符串long count1 = list.stream().filter(a -> a.length() == 2).count();System.out.println("字符串长度为2的数量是>>>" + count1 + "个");}

字符串长度为2的是>>>4

3、将集合中的空字符串删除（filter）

@Testpublic void test03() {List<String> list = Arrays.asList("aa", "aae", "bb", "cc", "", "dd");
// 删除空的字符串List<String> collect = list.stream().filter(a ->                         !a.isEmpty()).collect(Collectors.toList());System.out.println("筛选后的字符串是>>>" + collect);}

筛选后的字符串是>>>[aa, aae, bb, cc, dd]

4、合并字符串并用逗号隔开，删除集合中的空字符串（filter）

@Testpublic void test04() {List<String> list = Arrays.asList("aa", "aae", "bb", "cc", "", "dd");String collect2 = list.stream().filter(a -> !a.isEmpty()).collect(Collectors.joining(", "));System.out.println("合并后的字符串>>>" + collect2);}

合并后的字符串>>>aa, aae, bb, cc, dd

5、计算集合中元素的平方（map）

@Testpublic void test05() {// 创建一个集合List<Integer> list1 = Arrays.asList(2, 3, 4, 8, 7, 15);// 计算列表中元素的平方List<Integer> collect1 = list1.stream().map(i -> i * i).distinct().collect(Collectors.toList());System.out.println("列表中元素的平方是" + collect1);}

列表中元素的平方是[4, 9, 16, 64, 49, 225]

6、用不同的方法进行计算

@Testpublic void test06() {// 创建一个集合List<Integer> list1 = Arrays.asList(2, 3, 4, 8, 7, 15);      System.out.println("集合中的元素是" + list1);System.out.println("集合中最大的数是" + statistics.getMax());System.out.println("集合中最小的数是" + statistics.getMin());System.out.println("集合中求和" + statistics.getSum());}

集合中的元素是[2, 3, 4, 8, 7, 15]
集合中最大的数是15
集合中最小的数是2
集合中求和39

7、对集合中重复的数据进行去重（distinct）

@Testpublic void distinctStream() {// 创建一个字符串的集合Stream<String> distinctStream = Stream.of("bj","shanghai","tianjin","bj","shanghai").distinct();Stream<String> sortedStream = distinctStream.sorted(Comparator.comparing(String::length));sortedStream.forEach(x -> System.out.print(x + " "));}

bj tianjin shanghai

8、把0-9的偶数挑出来，每个偶数乘以2，在将结果相加

@Testpublic void test07() {Stream<Integer> stream = Stream.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);Integer integer = stream.filter(num -> num % 2 == 0).map(num -> num * 2).reduce((num1, num2) -> {return num1 + num2;}).get();System.out.println("最后的值是>>>" + integer);}
}

最后的值是>>>40

三、数学类Math

Math类是 final 修饰的不允许继承。

1、求最大值和最小值

    @Testpublic void test01(){// 求两个整数最大值maxSystem.out.println(Math.max(10,20));// 求两个整数的最小值minSystem.out.println(Math.min(10,20));}

20
10

2、ceil向上取整，返回浮点型数据

不管小数点后面的数是多少，都会向上取整

  @Testpublic void test02(){double a1 = 3.15;double b1 = 3.85;// ceil向上取整，返回浮点型数据System.out.println(Math.ceil(a1));System.out.println(Math.ceil(b1));}

4.0
4.0

3、floor向下取整，返回浮点型数据

floor方法：小数点后面的数不管有多大，都会舍掉

 @Testpublic void test03(){double a1 = 3.15;double b1 = 3.85;// ceil向上取整，返回浮点型数据类型System.out.println(Math.ceil(a1));// floor向下取整，返回浮点型数据类型System.out.println(Math.floor(b1));}

4.0
3.0

4、 round方法：四舍五入，跟数学中的一样

    @Testpublic void test04(){double a1 = 3.15;double b1 = 3.85;// round可以四舍五入，里面有float double两种System.out.println(Math.round(a1));System.out.println(Math.round(b1));}

3
4

5、伪随机数

    @Testpublic void test05(){for (int i = 0; i < 5; i++) {// 返回0-1之间且不包含1的浮点数，返回值是一个double类型// Math.random这个方法产生的随机数是伪随机数// 该算法为固定算法，以当前时间为种子计算// 如果遇到两个时间点相同的种子算出的随机数是相同的double random = Math.random();System.out.println(random);}}

0.9140862742401126
0.35729250625221987
0.03605944985662335
0.15469068384537843
0.8199574614837676

四、Random的简单了解

1、Random

 @Testpublic void test() {// random.nextInt()小括号里面传值// 随机生成一个小于参数值得非负整数// 也就是0到参数之间的随机整数Random random = new Random();for (int i = 0; i < 10; i++) {System.out.println(random.nextInt(10));}}

    @Testpublic void tes01(){//random.nextInt()小括号里面不传值// 会生成5个随机数，这5个随机数有可能是正数或者负数Random random01 = new Random();for (int j = 0; j < 5; j++) {System.out.println(random01.nextInt());}

2、ThreadLocalRandom

public class ThreadLocalRandomTest {@Testpublic void test(){for (int i = 0; i < 10; i++){// 随机生成10--20之间的随机数System.out.println(ThreadLocalRandom.current().nextInt(10,20));}}@Testpublic void test01(){for (int i = 0; i < 10; i++){// 随机生成10以内的随机数System.out.println(ThreadLocalRandom.current().nextInt(10));}}
}

五、String类的常用方法

1、字符串的比较

  @Testpublic void test01() {/*** 字符串的比较* .equals(str02)           返回值是布尔类型* .compareTo(str02)        返回值是整数型比较的是asc码标* .compareToIgnoreCase()   返回值是整数型比较的是asc码标，对大小写不敏感*  ==号比较                 返回值是布尔类型*  .hashCode()             返回值是二进制的哈希值*/String str01 = "会飞的鱼A";String str02 = "会飞的鱼a";// equals传进来的参数一样，返回trueSystem.out.println(str01.equals(str02));// compareTo方法是比较内容是否一致，内容一致返回0，不一致返回非0的整数System.out.println(str01.compareTo(str02));// compareToIgnoreCase方法是比较内容是否一致，内容一致返回0，对大小写不敏感System.out.println(str01.(str02));// == 比较的是哈希值System.out.println(str01 == str02);System.out.println(str01.hashCode());System.out.println(str02.hashCode());}

false
-32
0
false
-1577296571
-1577296539

字符串的比较（二）

 @Testpublic void test02() {// new String在内存中创建了几个新对象 答：一个或者两个// 常量区中如果有，则只需要将它拷贝到堆内存中// 常量区中如果没有，需要先创建，在进行拷贝到新内存中String str01 = new String("会飞的鱼");String str02 = new String("会飞的鱼");// equals传进来的参数一样，返回trueSystem.out.println(str01.equals(str02));// compareTo方法是比较内容是否一致，内容一致返回0，不一致0返回非0的整数System.out.println(str01.compareTo(str02));// == 除了比较内容，还要比较的是内存地址System.out.println(str01 == str02);System.out.println(str01.hashCode());System.out.println(str02.hashCode());}

true
0
false
641856124
641856124

2、字符串的拼接

    @Testpublic void test04() {int a = 10, b = 20, c;c = a + b;// 进行加法运算System.out.println(c);String str = "" + 50;// instanceof方法是java中的双目运算符，用来测试一个对象是否为一个类的实例System.out.println(str instanceof String);// concat方法是将两个字符串拼接在一起String s = "a".concat("b");System.out.println(s);}

30
true
ab

字符串的拼接（二）

    @Testpublic void test05() {String str01 = "会跑的鸟";System.out.println(str01);System.out.println(str01.hashCode());// 将两个字符串拼接在一起str01 += "在吐泡泡";System.out.println(str01);System.out.println(str01.hashCode());}

会跑的鸟
639137874
会跑的鸟在吐泡泡
579314522

字符串的拼接（三）

@Test
public void test06() {String str01 = "会跑的鸟";str01 = str01.concat("在吐泡泡");// 将两个字符串拼接在一起System.out.println(str01);System.out.println(str01.hashCode());
}

会跑的鸟在吐泡泡
579314522

3、比较ASCII码标的值

 @Testpublic void test07() {// 这里比较的是ASC码标System.out.println("aaaaab".compareTo("aaaaab..."));// -3System.out.println("ab".compareTo("bc"));// -1System.out.println("ac".compareTo("zb"));// -25System.out.println("ba".compareTo("zcvsfd"));// -25}
}

4、将数组中的字符生成字符串

@Test
public void test01() {char[] Value = {'会', '飞', '的', '小', '鸟'};// 利用构造方法生成字符串String s = new String(Value);System.out.println(s);// 利用String.valueOf()方法生成字符串，将value字符数组传进去String s1 = String.valueOf(Value);System.out.println(s1);
}

会飞的小鸟
会飞的小鸟

5、字符串的判断

@Test
public void test02() {String str = "鱼爱吐泡泡";// .contains("鱼")是判断字符串中是否包含另外一个字符串// 返回值是布尔型booleanSystem.out.println(str.contains("鱼"));System.out.println(str.contains("猫"));
}

true
false

5、根据字符串输出某个元素的下标

@Test
public void test03() {String str = "鱼爱吐泡泡";// .indexOf("")是判断字符串中是否包含另外一个字符串第一次出现的indexSystem.out.println(str.indexOf("泡"));// .lastIndexOf("")是判断字符串中是否包含另外一个字符串最后一次出现的indexSystem.out.println(str.lastIndexOf("泡"));// 如果不包含，则返回一个（-1）System.out.println(str.indexOf("猫"));
}

3
4
-1

6、.charAt()方法根据下标找字符串中的某个字符

@Test
public void test04() {String str = "优雅永不过时";System.out.println(str.charAt(2));// .length()方法 计算字符串的长度System.out.println(str.length());
}

永
6

.charAt( )方法（二）

将字符串里每一个字符输出

@Test
public void test05() {String str = "阴谋是爱情最大的敌人";String str01 = "";// 用for循环去遍历字符串for (int i = 0; i < str.length(); i++) {       System.out.println(str.charAt(i));}
}

阴
谋
是
爱
情
最
大
的
敌
人

7、将字符串逆序输出

@Test
public void test06() {   String str = "阴谋是爱情最大的敌人";String str01 = "";// 用for循环去遍历字符串// 输出的顺序是从最大下标到最小下标，最大下标减1for (int i = str.length() - 1; i >= 0; i--) {// 将遍历出来的值依次传进新的字符串中str01 += str.charAt(i);}System.out.println(str01);
}

人敌的大最情爱是谋阴

将字符串逆序输出（二）

public class StringBuilderTest {@Testpublic void test() {/*** reverse()方法是java中的反转函数，可以使字符串反转也就是逆序输出*/StringBuilder builder = new StringBuilder();builder.append("高");builder.append("康");builder.append("翔");String s = builder.toString();System.out.println("正序>>>" + s);System.out.println("倒序>>>" + builder.reverse().toString());}
}

正序>>>高康翔
倒序>>>翔康高

8、字符串大小写的转换

@Test
public void test07() {/*** 字符串大小写的转换* .toLowerCase()方法 大写转小写* .toUpperCase()方法 小写转大写*/String str = "阴谋是爱情最大的敌人AAA";String str01 = "阴谋是爱情最大的敌人aaa";// 将字符串里的大写字母转换为小写System.out.println(str.toLowerCase());// 将字符串里的小写字母转换为大写System.out.println(str01.toUpperCase());
}

阴谋是爱情最大的敌人aaa
阴谋是爱情最大的敌人AAA

字符串大小写转换（二）

@Test
public void test08() {   // Character.toLowerCase('A')// 括号里放一个大写的字符，可以转换为小写   System.out.println(Character.toLowerCase('A'));
}

9、字符串的截取

@Test
public void test01() {/*** 字符串的截取* .substring()方法 里面放一个数字下标是开始截取的位置到结尾* .substring()方法 里面放两个数字下标是开始截取的位置和结束的位置* 注意：前包后不包*/String str = "苦心人天不负，卧薪尝胆，三千越甲可吞吴";System.out.println(str.substring(6));// 前包后不包System.out.println(str.substring(6, 11));
}

，卧薪尝胆，三千越甲可吞吴
，卧薪尝胆

字符串的截取（二）

@Test
public void test06() {/*** 将后缀名.jpg截取出来*/String str = "照片.jpg";int lastIndexOf = str.lastIndexOf(".jpg");// 截取下标0开始到最后一个下标 前包后不包System.out.println(str.substring(0, lastIndexOf));// 截取.jpgSystem.out.println(str.substring(lastIndexOf));
}

照片
.jpg

10、字符串的替换

@Test
public void test02() {/*** 字符串的替换：* replace(char oldChar, char newChar)方法* 是替换所有被选定的字符** replaceFirst(String regex, String replacement)方法* 是替换第一个出现的字符**  replaceAll(String regex, String replacement)方法*  替换所有*/String str = "abcdefgabca";// 将字符串里的所有的字符a替换成bSystem.out.println(str.replace('a', 'b'));// 将字符串里第一个出现的字符替换System.out.println(str.replaceFirst("a", "x"));// 替换所有System.out.println(str.replaceAll("abc", "h"));
}

bbcdefgbbcb
xbcdefgabca
hdefgha

11、字符串的拆分

@Test
public void test03() {/*** split(String regex)方法 根据匹配给定的正则表达式来拆分字符串。* regex -- 正则表达式分隔符*/String str = "2022-4-13";String[] split = str.split("-");// 使用增强for循环进行遍历for (String splits : split) {System.out.println(splits);}
}

2022
4
13

字符串的拆分（二）

@Test
public void test04() {/*** split(String regex)方法 根据匹配给定的正则表达式来拆分字符串。* regex -- 正则表达式分隔符*/String str = "2022-4-13 22:40";String[] split = str.split(" ");// 使用增强for循环进行遍历for (String splits : split) {System.out.println(splits);}System.out.println("************************");String[] split1 = split[0].split("-");String[] split2 = split[1].split(":");for (String s : split1) {System.out.println(s);}for (String s1 : split2) {System.out.println(s1);}
}

2022-4-13
22:40
************************
2022
4
13
22
40

12、删除字符串头尾的空白符

@Test
public void test05() {/*** trim()方法： 用于删除字符串的头尾空白符。*/String str = " a b c d ";// 计算字符串的长度System.out.println(str.length());// 删除字符串头尾的空白符System.out.println(str.trim());// 去掉全部的空格System.out.println(str.replaceAll(" ", ""));
}

9
a b c d
abcd

13、随机生成字符串

@Test
public void test07() {/*** UUID.randomUUID()方法* 随机生成一串字符串*/String str = "婚礼.rmvb";int lastIndexOf = str.lastIndexOf(".");UUID uuid = UUID.randomUUID();// 将字符串进行拼接输出System.out.println(uuid + str.substring(lastIndexOf));// 替换随机生成的字符串里面的"-"，替换成一个空字符串System.out.println(uuid.toString().replace("-","");
}

43ad450e-0dd9-41ab-b952-b19b48082021.rmvb
43ad450e0dd941abb952b19b48082021

六、Date

1、日期和时间的格式化编码

时间模式字符串用来指定时间格式。在此模式中，所有的 ASCII 字母被保留为模式字母，定义如下：

字母	描述	示例
G	纪元标记	AD
y	四位年份	2001
M	月份	July or 07
d	一个月的日期	10
h	A.M./P.M. (1~12)格式小时	12
H	一天中的小时 (0~23)	22
m	分钟数	30
s	秒数	55
S	毫秒数	234
E	星期几	Tuesday
D	一年中的日子	360
F	一个月中第几周的周几	2 (second Wed. in July)
w	一年中第几周	40
W	一个月中第几周	1
a	A.M./P.M. 标记	PM
k	一天中的小时(1~24)	24
K	A.M./P.M. (0~11)格式小时	10
z	时区	Eastern Standard Time
’	文字定界符	Delimiter
"	单引号	`

2、使用printf格式化日期

printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。

转换符	说明	示例
c	包括全部日期和时间信息	星期六十月 27 14:21:20 CST 2007
F	"年-月-日"格式	2007-10-27
D	"月/日/年"格式	10/27/07
r	"HH:MM:SS PM"格式（12时制）	02:25:51 下午
T	"HH:MM:SS"格式（24时制）	14:28:16
R	"HH:MM"格式（24时制）	14:28

3、Date的应用

1、默认的时间

@Test
public void test01() {// 默认的时间Date date = new Date();System.out.println(date);
}

2、输出当下的时间

public class DateTest {@Test
public void test02() {/** 在计算机year中，有两个标准的起始时间* 1900年 UTC * 1970年 GMT 格林威治时间*/// UTC 1900-1-1 00:00:00Date date = new Date();// 获取当前的年份int year = date.getYear() + 1900;// 获取当前的月份 因为国外的月份是从0开始计数，所以要加1int month = date.getMonth() + 1;// 获取当前的哪月的哪一天int date1 = date.getDate();// 获取当前的小时int hours = date.getHours();// 获取当前的分钟数int minutes = date.getMinutes();// 获取当前的秒数int seconds = date.getSeconds();String weekday = "星期";// getDay的返回值是0-6 0代表星期日 1代表星期一 以此类推..switch (date.getDay()) {case 1:weekday += "一";break;case 2:weekday += "二";break;case 3:weekday += "三";break;case 4:weekday += "四";break;case 5:weekday += "五";break;case 6:weekday += "六";break;default:weekday += "日";break;}System.out.println(year + "年" + zeroCompensation(month) + "月"+ zeroCompensation(date1) + "日\t"+ zeroCompensation(hours) + "时"+ zeroCompensation(minutes) + "分"+ zeroCompensation(seconds) + "秒\t  "+ weekday);
}// 这是一个返回值是string类型的方法public String zeroCompensation(int time) {/*** 时间零占位* @param time 当前时间* @return 是否补零占位后的时间字符串*/if (time < 10) {return "0" + time;}return String.valueOf(time);}
}

2022年04月16日    16时37分50秒   星期六

3、获取一周前此时此刻的时间

@Test
public void test03() {// GMT 1970-1-1 00:00:00Date date = new Date();// 获取当下时间的毫秒数System.out.println(date.getTime());System.out.println(System.currentTimeMillis());// 7天 * 24小时 * 60分钟 * 60秒 * 1000毫秒long time02 = 7 * 24 * 60 * 60 * 1000l;// 当前时间的毫秒数 - 7天时间的毫秒数 = 7天前此时此刻的时间long time = date.getTime() - time02;Date date1 = new Date(time);System.out.println(date1);
}

1650100543333
1650100543333
Sat Apr 09 17:15:43 CST 2022

4、时间字符串模板

@Test
public void test04() {// 系统默认的时间格式Date date = new Date();// 实例化一个时间字符串格式化对象 传入时间字符串模板SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 将字符串模板格式化String format = dateFormat.format(date);System.out.println(format);String str = "2022-04-16 17:55:30";// 将字符串进行解析生成一个时间对象Date parse = null;try {parse = dateFormat.parse(str);} catch (ParseException e) {e.printStackTrace();}System.out.println(parse);
}

2022-04-16 17:55:16
Sat Apr 16 17:55:30 CST 2022

5、当前时间和自定义时间做比较

.before 在…之前

.after 在…之后

@Test
public void test05() {//进行时间的比较SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String str = "2022-04-15 11:39:30";try {Date parse = dateFormat.parse(str);// 当前时间和自定义时间作比较，判断是否在自定义时间之前boolean before = new Date().before(parse);// 当前时间和自定义时间作比较，判断是否在自定义时间之后boolean after = new Date()(parse);System.out.println(before);System.out.println(after);} catch (ParseException e) {e.printStackTrace();}
}

false
true

6、当前时间和格林威治时间

@Test
public void test06() {Date date = new Date();// 当前时间System.out.println(date);// 格林威治时间String s = date.toGMTString();System.out.println(s);
}

Sat Apr 16 18:02:49 CST 2022
16 Apr 2022 10:02:49 GMT

7、自定义时区

@Test
public void test07(){// 输出当前时区的默认时间 id="Asia/Shanghai"System.out.println(TimeZone.getDefault());SimpleDateFormat seoul = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 格式化时间设置时区seoul.setTimeZone(TimeZone.getTimeZone("Asia/Seoul"));Date date = new Date();// 输出首尔的此刻时间System.out.println(seoul.format(date));
}

sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null]
首尔此刻的时间是>>>2022-04-16 19:08:47

七、密码工具类

1、AES加密

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.crypto.symmetric.SymmetricAlgorithm;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import org.junit.jupiter.api.Test;/*** @author 高康翔* @version 1.0.0* @Date 2022/4/14  20:18*/
public class AesTest {@Testpublic void test01(){/*** 密码工具类* AES加密* .encrypt("需要加密的内容") 进行加密* .decrypt()    进行解密*/String str = "花开花落花满天";// 准备16位的秘钥byte[] bytes = new String("aaaaaaaaaaaaaaaa").getBytes();// 构建对象 AES算法SymmetricCrypto crypto = new SymmetricCrypto(SymmetricAlgorithm.AES, bytes);//进行加密byte[] encrypt = crypto.encrypt(str);// 输出加密后的结果System.out.println(new String( encrypt));// 进行解密byte[] decrypt = crypto.decrypt(encrypt);// 解密后的结果System.out.println(new String(decrypt));// 加密位16进制的字符串String s = crypto.encryptHex(str);// 输出加密后的结果System.out.println(s);// 进行解密String s1 = crypto.decryptStr(s, CharsetUtil.CHARSET_UTF_8);// 输出解密后的结果System.out.println(s1);}
}

1、第一次加密后会生成一些乱码

2，解密后会还原

3，第二次加密后会生成一个16进制的字符串

4、解密后会还原

+aV�8i�7� ۼ~����9K�N"
L��
花开花落花满天
2b6156bd3869dc37e01c20dbbc7ea60702d2c4de7f1239124bc94e220a4cb3d0
花开花落花满天

2、Base64加密

import org.junit.jupiter.api.Test;
import java.io.UnsupportedEncodingException;
import java.util.Base64;/*** @author 高康翔* @version 1.0.0* @Date 2022/4/14  22:03*/
public class Base64Test {/*** @author Base64* 在大部分情况下用于图片加密*/@Testpublic void test() {// 获取Base64的加密对象Base64.Encoder encoder = Base64.getEncoder();// 获取Base64的解密对象Base64.Decoder decoder = Base64.getDecoder();String str = "花好月圆";// 加密后的byte数组byte[] encode = new byte[0];try {encode = encoder.encode(str.getBytes("UTF-8"));// 输出加密后的数组System.out.println("加密后的数组是>>>" + new String(encode));// 加密后的字符串String s = encoder.encodeToString(str.getBytes("UTF-8"));//输出加密后的字符串System.out.println("加密后的字符串是>>>" + s);// 解密后的数组byte[] decode = decoder.decode(encode);// 输出解密后的数组System.out.println("解密后的数组是>>>" + new String(decode));//解密后的字符串byte[] decode1 = decoder.decode(s);// 输出解密后的字符串System.out.println("解密后的字符串是>>>" + new String(decode1));} catch (UnsupportedEncodingException e) {e.printStackTrace();}}
}

加密后的数组是>>>6Iqx5aW95pyI5ZyG
加密后的字符串是>>>6Iqx5aW95pyI5ZyG
解密后的数组是>>>花好月圆
解密后的字符串是>>>花好月圆

3、DES加密

需要准备64位的秘钥

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.crypto.symmetric.SymmetricAlgorithm;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import org.junit.jupiter.api.Test;/*** @author 高康翔* @version 1.0.0* @Date 2022/4/14  21:23* 密码工具类*/
public class DesTest {@Testpublic void test() {String str = "菩提本无树，明镜亦非台";// 准备64位秘钥byte[] key = new String("aaaaaaaabbbbbbbbccccccccddddddddeeeeeeeeffffffffgggggggghhhhhhhh").getBytes();// 创建对象SymmetricCrypto crypto = new SymmetricCrypto(SymmetricAlgorithm.DES,key);// 进行加密byte[] encrypt = crypto.encrypt(str);// 输出加密后的结果System.out.println(new String(encrypt));// 进行解密byte[] decrypt = crypto.decrypt(encrypt);// 输出解密后的内容System.out.println(new String(decrypt));// 使用16进制进行加密String s = crypto.encryptHex(str);System.out.println(s);// 进行解密String s1 = crypto.decryptStr(s, CharsetUtil.CHARSET_UTF_8);System.out.println(s1);}
}

N�dQ:Y|kSQ�p�Z1~ŕ_Xb?%�bߗg9��[OI$i���
菩提本无树，明镜亦非台
4ec864513a597c6b5351c070f35a31027ec5955f58623f259262df9767399fc25b4f492469fefb99
菩提本无树，明镜亦非台

4、Md5加密

import cn.hutool.crypto.digest.DigestAlgorithm;
import cn.hutool.crypto.digest.Digester;
import org.junit.jupiter.api.Test;/*** @author 高康翔* @version 1.0.0* @Date 2022/4/14  19:53*/
public class Md5Test {@Testpublic void test(){/*** MD5消息摘要算法，属Hash算法一类。MD5算法对输入任意长度的消息进行运行，* 产生一个128位的消息摘要(32位的数字字母混合码--16进制数)。* 不可逆，相同数据的MD5值肯定一样，不同数据的MD5值不一样*/Digester digester = new Digester(DigestAlgorithm.MD5);// 对传进来的值进行加密String s = digester.digestHex("花前月下");System.out.println(s);}
}

9c800f9a94ce31ddc61fb233aa22edf4