Java常用类库
StringBuffer类
每一个字符串的常量都属于一个String类的匿名对象，并且不可更改；· String有两个常量池：静态常量池、运行时常量池； String类对象实例化，使用直接赋值的形式完成，可以将对象保存对象池中重用 String类不允许修改
String类
String 是被 final 修饰的类，不能被继承；String实现了 Serializable 和 Comparable 接口，表示String支持序列化和可以比较大小；String底层是通过char类型的数据实现的，并且被final修饰，所以字符串的值创建之后就不可以被修改，具有不可变性。
StringBuffer类
StringBuffer对象代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列，但都不会产生新的对象。通过StringBuffer生成的字符串，可以调用toString()方法将其转换为一个String对象
StringBuilder类
StringBuilder类也代表可变字符串对象。实际上，StringBuilder和StringBuffer基本相似，他们的原理与操作一样，两个类的构造器和方法也基本相同。不同的是：StringBuffer是线程安全的，而StringBuilder则没有实现线程安全功能，所以性能略高。
CharSequence 接口
CharSequence 是一个描述字符串结构的接口,这个接口有三种常用子类：String 类、StringBuffer 类、StringBuikder 类
只要有字符串，就可以被 CharSequence 接口识别并接收
CharSequence str="ww.mldn.cn" 子类实例向父接口转型。
CharSequence 本身是一个接口，在该接口之中也定义有如下操作方法:
获取指定索引字符:public char charAt(int index);
获取字符串的长度:public int length():
截取部分字符串:public CharSequence subSequence(int start, int end);
AutoCloseable 接口
进行资源开发的处理上，实现资源的自动关闭(释放) AutoCloseable 接口要和异常捆绑在一起使用才能起作用
public class AutoCloseableDemo {
public static void main(String[] args) throws Exception{
try (Message m = new Message("消息内容");){
m.send();
}catch (Exception e){
}
}
}
interface IMessage extends AutoCloseable{
public void send();
}
class Message implements IMessage {
private String msg;
public Message() {
}
public Message(String msg){
this.msg = msg;
}
// 实现信息处理机制
public boolean open(){
System.out.println("【OPEN】获取消息发送连接资源。");
return true;
}
@Override
public void close(){
System.out.println("【CLOSE】关闭消息发送通道。");
}
@Override
public void send() {
if (this.open()) {
System.out.println( "【***发送消息***】" + this.msg);
}
}
}
Runtime类
单例设计模式，通过类的getRunTime方法获取实例化对象
exec(String name):执行名称为name的程序. 只认识C:/Window/System32文件夹中的.exe文件,给name传入实参时，不需要写后缀名
GC 垃圾回收器，是可以由系统自动调用的垃圾释放功能，Runtime 类的 gc()手工调用
public class RunTimeDemo {
public static void main(String[] args) {
// 单例设计模式，通过类的getRunTime方法获取实例化对象
Runtime rt = Runtime.getRuntime();
System.out.println("@1=======");
System.out.println("cpu内核数(可用进程数):"+rt.availableProcessors());
System.out.println("获取最大可用内存空间:"+rt.maxMemory()+
", 获取可用内存空间:"+rt.totalMemory()+
", 获取空闲内存空间"+rt.freeMemory());
String str = "";
for (int x =0; x<30000; x++){
str += x ; // 产生大量的垃圾空间
}
System.out.println("@2=======");
System.out.println("获取最大可用内存空间:"+rt.maxMemory()+
", 获取可用内存空间:"+rt.totalMemory()+
", 获取空闲内存空间"+rt.freeMemory());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
rt.gc();
System.out.println("@3=======");
System.out.println("获取最大可用内存空间:"+rt.maxMemory()+
", 获取可用内存空间:"+rt.totalMemory()+
", 获取空闲内存空间"+rt.freeMemory());
rt.exec("calc");//效果：启动计算器程序
}
}
System类
数组拷贝：public static void arraycopy(Object sre. int srcPos, Object dest, int destPos, int length);
获取当前的日期时间数值：public static long currentTimeMillis();
System 类也提供有一个 gc 方法，但是这个继续调用 Runtime 类中的 gc() 操作 (Runtime getRuntime（).gc();)。
public class SystemDemo {
public static void main(String[] args) {
/*
* System.out: 得到PrintStream类型的对象
* out.println: 调用PrintStream类型对象的println(参数)方法
*/
int[] ary = {1,6,3,1,8,2};
int[] ary2 = new int[10];
/*
* 需求：把ary数组中的第二个到第四个元素，复制到ary2数组中作为最后3个元素
* arraycopy(源数组，从源数组开始复制的下标，目标数组，从目标数组中开始粘贴的元素下标，复制的长度)
*/
System.arraycopy(ary, 1, ary2, ary2.length-1-2, 3);
System.out.println(Arrays.toString(ary2));
long start = System.currentTimeMillis();
String str = "";
for (int x =0; x<20000; x++){
str += x ; // 产生大量的垃圾空间
}
long end = System.currentTimeMillis();
System.out.println("@1======="+ (end-start));
System.gc();
}
}
Cleaner类
jdk1.9后提供的对象清理的操作，进行finialize()方法的替代 从 JDK1.9 开始建议开发者使用 AutoCloseable 或者使用 java.lang .ref.Cleaner 类进行回收处理( Cleaner 也支持有 AutoCloseable 处理)
public class CleanerDemo2 {
public static void main(String[] args) throws Exception {
try(CleanerExample ce = new CleanerExample()){
}catch (Exception e){
}
}
}
class Member2 implements Runnable{
public Member2() {
System.out.println("【构造】在一个雷电交加的日子里面，人类诞生了。");
}
@Override
public void run() {
System.out.println("【回收】最终人一定要死的。");
}
}
class CleanerExample implements AutoCloseable{ // 实现清除的处理
private static final Cleaner cleaner = Cleaner.create();
private Cleaner.Cleanable cleanable; // 创建一个清除处理
private Member2 member ;
public CleanerExample() {
this.member = new Member2();
this.cleanable = cleaner.register(this, this.member);// 注册使用的对象
}
@Override
public void close() throws Exception {
this.cleanable.clean(); // 启动多线程
}
}
对象克隆
使用已有对象内容创建一个新的对象，如果要想进行对象克隆需要使用到 Object 类中提供的 clone()方法 所有类都会继承Object类，自然也就拥有clone方法，都不一定都能实现对象克隆 想实现对象克隆，需要实现-一个Cloneable接口，此接口并没有任何的方法提供，它描述的只是一种能力
public class cloneObj {
public static void main(String[] args) throws Exception{
UserInfo u = new UserInfo("nangong", 26);
UserInfo obj = (UserInfo) u.clone();
System.out.println(u);
System.out.println(obj);
}
}
class UserInfo implements Cloneable{
private String name;
private int age;
public UserInfo(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return super.toString()+"UserInfo{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); // 调用父类中提供的 clone() 方法
}
}
Math类
字段： Math.PI : 数学中的π
常用方法：
max(参数1，参数2) 返回更大的参数。
min(参数1，参数2） 返回更小的参数。
static double pow(double a, double b) : 返回 a的b次方 的double类型值
static double random() ： 返回 [0.0,1.0) 范围的double类型值
public class MathDemo {
public static void main(String[] args) {
System.out.println(MathUtil.round(19.8494, 2));
}
}
class MathUtil {
public static double round(double number, int privicsion){
return Math.round(number * Math.pow(10, privicsion)) / Math.pow(10, privicsion);
}
}
Random类
①Math.random()：
获取随机小数范围：[0.0,1.0) ==> 返回的值是double类型
②Random类
构造方法：Random() : 建议使用无参构造方法
方法：int nextInt(int n) : 获取 [0,n) 范围的随机整数,产生一个不大于边界的随机正整数
③ThreadLocalRandom （jdk1.7开始出现）
创建对象： static ThreadLocalRandom current()
方法：int nextInt(int a,int b) : 获取 [a,b) 范围的随机整数
④UUID类
方法：static UUID randomUUID()：获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。获取随机的字符串，该字符串每次获取都不会重复
/**
* 随机生成36选7彩票号（不能出现0且数字不能重复）
* @Author luo
* @Date 2022/8/5 - 23:49
*/
public class RandomDemo {
public static boolean validate(int number, int data[]){
if (number == 0){
return false;
}
for (int datum : data) {
if(datum == number) {
return false;
}
}
return true;
}
public static void main(String[] args) {
int i1 = (int) (Math.random()*21-10);//Math.random():获取[0.0,1.0)的随机小数
System.out.println(i1);
Random random1 = new Random();
int i2 = random1.nextInt(21) - 10;//random.nextInt(21)：获取[0,21)的随机整数
System.out.println(i2);
ThreadLocalRandom tlr = ThreadLocalRandom.current();
int i3 = tlr.nextInt(-10, 10);//获取[-10,10)的随机整数
System.out.println(i3);
UUID uuid = UUID.randomUUID();
String uuidStr = uuid.toString();
System.out.println(uuidStr);
System.out.println("===============");
Random random = new Random();
int arr[] = new int [7];
Random r = new Random();
int count = 0;
while (count < 7){
int num = r.nextInt(37);
if(validate(num, arr)){
arr[count++] = num;
}
}
Arrays.sort(arr);
for (int i : arr) {
System.out.println(i+", ");
}
}
}
大数字处理类
BigInteger类
BigInteger ：能够存取比Long更大的整数，可以任意大小 构造方法 ： BigInteger(String val) : 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。 数学运算的方法： BigInteger add(BigInteger bi) : 加法运算 BigInteger subtract(BigInteger val) : 减法运算 BigInteger multiply(BigInteger val) : 乘法运算 BigInteger divide(BigInteger val) : 除法运算 BigInteger divideAndRemainder：求余除法
public class BigIntegerDemo {
public static void main(String[] args) {
BigInteger bigA = new BigInteger("234134234234234");
BigInteger bigB = new BigInteger("23423423");
System.out.println("加法操作："+bigA.add(bigB));
System.out.println("减法操作："+bigA.subtract(bigB));
System.out.println("乘法操作："+bigA.multiply(bigB));
System.out.println("除法操作："+bigA.divide(bigB));
System.out.println("求余操作："+bigA.divideAndRemainder(bigB)[0]+", "+ bigA.divideAndRemainder(bigB)[1]);
}
}
BigDecimal类
BigDecimal ：可以存任意精度的浮点型 构造方法： BigDecimal(double b) : 会丢失精度 BigDecimal(String s) : 不会丢失精度 方法： add(BigInteger b) ： 加法运算 subtract(BigInteger b) ： 减法运算 multiply(BigInteger b) ： 乘法运算 divide(BigInteger b)： 除法运算 （注意：除不尽的时候会抛出异常）
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal bigA = new BigDecimal("32890234890");
BigDecimal bigB = new BigDecimal("1892039");
System.out.println("加法计算："+bigA.add(bigB));
BigDecimal result [] = bigA.divideAndRemainder(bigB);
System.out.println("除法计算，商，"+result[0]+"、余数，"+result[1]);
System.out.println(MathTool.round(19.6352,2));
}
}
class MathTool {
public static double round(double number, int privicsion){
return new BigDecimal(number)
.divide(new BigDecimal("1.0"), privicsion, RoundingMode.HALF_UP)
.doubleValue();
}
}
日期处理类
Date 类中只是对 long 数据的一种包装。date 类中一定提供日期与 long 数据类型转换的方法
SimpleDateFormat日期处理类
SimpleDateFormat : 可以选择任何用户定义的日期-时间格式的模式 "yyyy-MM-dd HH:mm:ss:SSS"
1.格式化：Date --》String
String format(Date date) 将Date格式化为日期/时间字符串
2.解析：String --》Date
Date parse(String source) 将符合格式的指定字符串转换为Date
public class dateDemo {
public static void main(String[] args) throws ParseException {
Date date = new Date();
long current = date.getTime();
current += 864000*1000; // +10天
System.out.println(new Date(current));
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
System.out.println( simpleDateFormat.format(new Date(current)));
// 调用parse()方法时 注意 传入的格式必须符合simpleDateFormat对象的格式，即"yyyy-MM-dd HH:mm:ss:SSS" 否则会报错！！
String string = "2022-08-06 09-07-58";
System.out.println(simpleDateFormat.parse(string));
}
正则表达式
正则表达式的构造摘要
| 构造 | 匹配 |
|---|---|
| 字符 | 单个字符 |
| \\ | 反斜线字符 |
| x | 字符 x |
| \n | 匹配新行（换行）符 ('\u000A') |
| \t | 匹配制表符 ('\u0009') |
| \ | 匹配\ |
| \r | 回车符 ('\u000D') |
| \f | 换页符 ('\u000C') |
| \a | 报警 (bell) 符 ('\u0007') |
| \e | 转义符 ('\u001B') |
| \cx | 对应于 x 的控制符 |
| \0n | 带有八进制值 0 的字符 n (0 <= n <= 7) |
| \0nn | 带有八进制值 0 的字符 nn (0 <= n <= 7) |
| \0mnn | 带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7） |
| \xhh | 带有十六进制值 0x 的字符 hh |
| \uhhhh | 带有十六进制值 0x 的字符 hhhh |
| 字符类 | |
| [abc] | a、b 或 c（简单类） |
| [^abc] | 任何字符，除了 a、b 或 c（否定） |
| [a-zA-Z] | a 到 z 或 A 到 Z，两头的字母包括在内（范围） |
| [0-9] | 一位数字组成 |
| [a-d[m-p]] | a 到 d 或 m 到 p：[a-dm-p]（并集） |
| [a-z&&[def]] | d、e 或 f（交集） |
| [a-z&&[^bc]] | a 到 z，除了 b 和 c：[ad-z]（减去） |
| [a-z&&[^m-p]] | a 到 z，而非 m 到 p：[a-lq-z]（减去） |
| 预定义字符类 | |
| . | 任何字符（与行结束符可能匹配也可能不匹配） |
| \d | 数字：[0-9] |
| \D | 非数字： [^0-9] |
| \s | 空白字符：[ \t\n\x0B\f\r] |
| \S | 非空白字符：[^\s] |
| \w | 单词字符：[a-zA-Z_0-9] |
| \W | 非单词字符：[^\w] |
| 边界匹配器 | |
| 行的开头 | |
| $ | 行的结尾 |
| \b | 单词边界 |
| \B | 非单词边界 |
| \A | 输入的开头 |
| \G | 上一个匹配的结尾 |
| \Z | 输入的结尾，仅用于最后的结束符（如果有的话） |
| \z | 输入的结尾 |
| Greedy 数量词 | 数量表示，默认情况下只有添加上了数量单位才可以匹配多位字符 |
| 表达式? | 该正则可以出现 0 次或 1 次; |
| 表达式* | 该正则可以出现 0 次、1 次或多次; |
| 表达式+ | 该正则可以出现 1 次或多次; |
| 表达式{n} | 表达式的长度正好为 n 次; |
| 表达式{n} | 表达式的长度为 n 次以上 |
| 表达式{n,m} | 表达式的长度在 n~m 次; |
| Reluctant数量词 | |
| X?? | X，一次或一次也没有 |
| X*? | X，零次或多次 |
| X+? | X，一次或多次 |
| X{n}? | X，恰好 n 次 |
| X{n,}? | X，至少 n 次 |
| X{n,m}? | X，至少 n 次，但是不超过 m 次 |
| Possessive数量词 | |
| X?+ | X，一次或一次也没有 |
| X*+ | X，零次或多次 |
| X++ | X，一次或多次 |
| X{n}+ | X，恰好 n 次 |
| X{n,}+ | X，至少 n 次 |
| X{n,m}+ | X，至少 n 次，但是不超过 m 次 |
| Logical 运算符 | 逻辑表达式:可以连接多个正则 |
| 表达式 X 表达式 Y | :X 表达式之后紧跟上 Y 表达式; |
| 表达式 X | 表达式 Y | 有一个表达式满足即可 |
| POSIX 字符类（仅 US-ASCII） | |
| \p{Lower} | 小写字母字符：[a-z] |
| \p{Upper} | 大写字母字符：[A-Z] |
| \p{ASCII} | 所有 ASCII：[\x00-\x7F] |
| \p{Alpha} | 字母字符：[\p{Lower}\p{Upper}] |
| \p{Digit} | 十进制数字：[0-9] |
| \p{Alnum} | 字母数字字符：[\p{Alpha}\p{Digit}] |
| \p{Punct} | 标点符号：!"#$%&'()*+,-./:;<=>?@[]^_`{ |
| \p{Graph} | 可见字符：[\p{Alnum}\p{Punct}] |
| \p{Print} | 可打印字符：[\p{Graph}\x20] |
| \p{Blank} | 空格或制表符：[ \t] |
| \p{Cntrl} | 控制字符：[\x00-\x1F\x7F] |
| \p{XDigit} | 十六进制数字：[0-9a-fA-F] |
| \p{Space} | 空白字符：[ \t\n\x0B\f\r] |
String 类对正则的支持
| No. | 方法名称 | 类型 | 描述 |
|---|---|---|---|
| 01 | public boolean matches(String regex) | 普通 | 将指定字符串进行正则判断。 |
| 02 | public String replaceAll(String regex, String replacement) | 普通 | 替换全部 |
| 03 | public String replaceFirst(String regex, String replacement): | 普通 | 替换首个 |
| 04 | public String[] split(String regex) | 普通 | 正则拆分 |
| 05 | public String[] split(String regex, int limit) | 普通 | 正则拆分 |
public class RegExpDemo {
public static void main(String[] args) throws ParseException {
System.out.println("实现字符串的拆分=======");
String str1 = "ewr231d234df34d422d2r32";
String reg1 = "\\d+";
String res[] = str1.split(reg1);
for (String re : res) {
System.out.println(re + ",");
}
System.out.println("判断一个数据是否为小数，如果是小数则将其变为double类型");
String str2 = "100.02.11";
String reg2 = "\\d+(\\.\\d+)?";
System.out.println(str2.matches(reg2));
System.out.println("判断一个字符串是否由日期所组成，如果是由日期所组成则将其转为Date类型");
String str3 = "2022-04-05";
String reg3 = "\\d{4}-\\d{2}-\\d{2}";
if(str3.matches(reg3)){
System.out.println(new SimpleDateFormat("yyyy-MM-dd").parse(str3));
}
//要判断的数据 51283346;01051283346;(010)-51283346。
String str4 = "(010)-51283346" ;
String reg4 = "((\\d{3,4})|(\\(\\d{3,4}\\)-))?\\d{7,8}";
System.out.println(str4.matches(reg4));
System.out.println("验证 email 格式");
String str5 = "m1395568255@163.com" ;
String reg5 = "[a-zA-Z0-9]\\w+@\\w+\\.(cn|com|com.cnInet gov)";
System.out.println(str5.matches(reg5));
}
}
regex包
Pattern正则表达式编译、Matcher匹配
pattern类
正则表达式的编译处理支持: public static Pattern compile(String regex);
字符串的拆分操作: public String[ split(CharSequence inpu);
Matcher类
Matcher 类，实现了正则匹配的处理类，这个类的对象实例化依靠 Pttern 类 完成:
Paterm 类提供的方法: public Matcher matcher(CharSequence input);
当获取了 Matcher 类的对象之后就可以利用该类中的方法进行如下操作:
正则匹配: public boolean matches);
字符串替换: public String replace AIl(String replacement)。
mather 类里面提供有一种String 不具备的分组功能
public class RegexUtil {
public static void main(String[] args) {
String str ="231";
String reg = "\\d+";
Pattern p = Pattern.compile(reg);
Matcher matcher = p.matcher(str);
System.out.println(matcher.matches());
//要求取出“#{内容}”标记中的所有内容
String str1 = "INSERT INTO dept(deptno,dname,loc)VALUES (#{deptno},#{dname}),#{loc})";
String reg1 = "#\\{\\w+\\}";
p = Pattern.compile(reg1);
matcher = p.matcher(str1);
while (matcher.find()){
System.out.println(matcher.group(0).replaceAll("#|\\{|\\}",""));
}
}
}
国际化
Locale类
在 java.util.里面提供有一个专门描述区域和语言编码的类:Locale
构造方法:
public Locale(String language);构造方法:
public Locale( String language, String country);读取本地默认环境getDefault()
public class LocaleDemo {
public static void main(String[] args) {
Locale locale = Locale.getDefault();
System.out.println(locale);
Locale locale1 = new Locale("zh", "cn");
System.out.println(locale1);
locale1 = Locale.CANADA;
System.out.println(locale1);
}
}
ResourceBundle 读取资源文件
获取 ResourceBundle 类对象:
public static final ResourceBundle getBundle( String baseName);
- baseName:描述的是资源文件的名称，但是没有后缀。
根据key读取资源内容:
public final String getString(String key);如果资源没有放在包里面，则直接编写资源名称即可。 在进行资源读取的时候数据 的 key 一定要存在，如果不存在则会出现异常信息读取指定区域的资源文件>默认的本地资源>公共的资源(没有区域)
public class ResourceBundleDemo {
public static void main(String[] args) {
// Locale locale = new Locale("en", "US");
Locale locale = Locale.GERMAN;
ResourceBundle bundle = ResourceBundle.getBundle("plugin", locale);
System.out.println(bundle.getString("key"));
// 修改当前的 Locale 坏境
}
}
格式化文本显示
MessageFormat 类中提供有一个格式化文本的方法:
public static String format(String pattern, Object... arguments)
public class MessageFormatDemo {
public static void main(String[] args) {
Locale locale = new Locale("en", "US");
ResourceBundle bundle = ResourceBundle.getBundle("plugin", locale);
String val = bundle.getString("key");
System.out.println(MessageFormat.format(val, "属性文件", new SimpleDateFormat("yy-MM-dd hh-mm-ss").format(new Date())));
}
}
开发支持类库
UUID类
根据时间戳实现一个自动的无重复的字符串定义 获取 UUID 对象:
public static UUID randomUUID();根据字符串获取 UUID 内容:public static UUID fromString(String name);在对一些文件进行自动命名处理的情况下，UUID 类型非常好用
Optional 类
进行 null 的相关处理，以前为了防止程序出现空指向异常，往往可以追加null 的验证
• 返回空数据: public staticT> Optional empty();
• 获取数据:public T get();
• 保存数据，但是不允许出现 null: public static Optional of(T value).
• 如果在保存数据的时候存在有 null，则会抛出 NullPointerException 异常；
• 空的时候返回其他数据：public T orElse(T other)
public class OptionalDemo {
public static void main(String[] args) {
// IResource resource = MessageUtil.getResource().get();//获取数据
// IResource resource = MessageUtil.getResource().orElse(null);//空的时候返回其他数据
IResource resource = MessageUtil.getResource().orElse(new ResourceImpl());//空的时候返回其他数据
MessageUtil.useResource(resource);
}
}
class MessageUtil {
private MessageUtil (){}
public static Optional<IResource> getResource() {
// return Optional.of(null) ; // 保存数据，但是不允许出现 null
return Optional.ofNullable(null) ; // 保存数据，但是允许出现 null
// return Optional.of(new ResourceImpl()) ;
}
public static void useResource( IResource resource) {
// 传统方式判断空指针
// if (resource != null) {
System.out.println(resource.getContent());
//有可能因为出现null，而导致空指向
// }
}
}
interface IResource {
public String getContent() ;
}
class ResourceImpl implements IResource{
@Override
public String getContent() {
return "connect";
}
}
ThreadLocal类
• 构造方法:
public ThreadLocal();• 设置数据:
public void set(T value)；• 取出数据
:public T get();• 删除数据:
public void remove();
线程不独立的情况可能会出现下面的情况
在保持 程序核心结构不改变的情况下，需要考虑到每个线程的独立操作问题
public class ThreadLocalDemo {
public static void main(String[] args) throws Exception{
// 多线程状态下数据可能被覆盖，不会同步
new Thread(()->{
Message1 message1 = new Message1();
message1.setInfo("info1");
Channel.setMessage(message1);
Channel.send();
}, "name1").start();
new Thread(()->{
Message1 message1 = new Message1();
message1.setInfo("info2");
Channel.setMessage(message1);
Channel.send();
}, "name2").start();
new Thread(()->{
Message1 message1 = new Message1();
message1.setInfo("info3");
Channel.setMessage(message1);
Channel.send();
}, "name3").start();
}
}
class Channel{
private static final ThreadLocal<Message1> THREADLOCAL = new ThreadLocal<Message1>();
private Channel (){}
public static void setMessage(Message1 msg){
THREADLOCAL.set(msg);// 向ThreadLocal存放数据
}
public static void send(){
System.out.println(Thread.currentThread().getName()+"【消息发送】"+ THREADLOCAL.get().getInfo());
}
}
class Message1{
private String info;
public void setInfo(String info){
this.info = info;
}
public String getInfo(){
return info;
}
}
定时调度
只能实现了一种间隔触发的操作
Timer ：可以指定线程在指定时间执行，只能控制TimerTask线程 TimerTask ： 被Timer指定的线程 schedule(TimerTask task,Date time) ： 控制指定的TimerTask对象(本质是线程)在指定的时间启动执行指定的任务 schedule(TimerTask task,Date firstTime,long period) ： 在指定时间启动task,当task执行完之后，每隔 period 又重复启动task
public class TimerTaskDemo {
public static void main(String[] args) {
// Timer timer = new Timer();// 定时任务
// timer.scheduleAtFixedRate(new MyTask(), 100, 2000);// 间隔触发
// timer.schedule(new MyTask(), 0);
TimerTask timerTask = new TimerTask() {
@Override
public void run() {
System.out.println("执行语句...");
}
};
Timer timer1 =new Timer();
Calendar instance = Calendar.getInstance();
instance.add(Calendar.MINUTE, 1);//下一分钟开始 执行语句...
instance.set(Calendar.SECOND, 0);
Date time = instance.getTime();
timer1.schedule(timerTask, time, 1000);//每隔一秒重复执行
}
}
class MyTask extends TimerTask{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"定时任务启动， 当前时间"+System.currentTimeMillis());
}
}
Base64加密与解密
Base64 类里面有两个内部类:
• Base64.Encoder:进行加密才能处理;
– 加密处理:public byte[] encode(byte[] src);
• Base64.Decoder:进行解密处理；
– 解密处理: public byte[] decode(String src);
public class Base64Demo {
public static void main(String[] args) {
String content = "nangong";
String encodeContent = Base64Util.encode(content);
System.out.println("加密后"+encodeContent);
String decodeContent = Base64Util.decode(encodeContent);
System.out.println("解密"+ decodeContent);
}
}
class Base64Util{
// 多次加密
private static final int REPEAT = 5 ; //加密次数
// 使用盐值加密
private static final String SALT = "yyds";
public static String encode(String str){
String temp = str + SALT;
byte data[] = temp.getBytes();
for (int i = 0; i < REPEAT; i++) {
data = Base64.getEncoder().encode(data);
}
return new String(data);
}
public static String decode(String str){
byte data[] = str.getBytes();
for (int i = 0; i < REPEAT; i++) {
data = Base64.getDecoder().decode(data);
}
return new String(data).replaceAll(SALT,"");
}
}
比较器
对象数组的排序支持: public static void sort(Object[] a);
任意的一个类默认情况下是无法使用系统内部的类实现数组排序或比较需求的，是因为没有明确的指定出到底该如何比较的定义（没有比较规则）， Java 为了统一比较规则的定义，提供有比较器的接口：Comparable
-
java.lang.Comparable是在类定义的时候实现的父接口，主要用于定义排序规则，里面只有 compareTo方法。 -
java.util.Comparator是挽救的比较器操作，需要设罝单独的比较器规则类实现排序，里面有compare方法
public class SortDemo {
public static void main(String[] args) {
Integer data[ ] = new Integer[ ] { 10,9,5,2,20 }; // 对象数组
Arrays.sort(data); //进行对象数组的排序
System. out. println(Arrays.toString(data) );
String data1 [ ] = new String[ ] {"X", "B", "A", "E", "G" };
Arrays.sort(data1); //进行对象数组的排序
System. out. println(Arrays.toString(data1) );
Person data2 [] = new Person []{
new Person("小强-A", 80),
new Person("小强-B", 50),
new Person("小强-C", 100)};
Arrays.sort(data2); //进行对象数组的排序
System. out. println(Arrays.toString(data) );
}
}
class Person {
private String name ;
private int age ;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 无参构造、setter、getter略
@Override
public String toString( ) {
return "【Person类对象】姓名:" + this.name + "、年龄:" + this.age + "\\";
}
}
Comparable 比较器
实现implements Comparable，重写compareTo方法
/**
* 实现对象的比较处理操作
*
* @param要比较的对象
* @return当前数据比传入的对象小返回负数，如果大于返回整数，如果等于返回0
*/
@Override
public int compareTo(Person o) {
return this.age - o.age;
}
public class SortDemo {
public static void main(String[] args) {
Integer data[ ] = new Integer[ ] { 10,9,5,2,20 }; // 对象数组
Arrays.sort(data); //进行对象数组的排序
System. out. println(Arrays.toString(data) );
String data1 [ ] = new String[ ] {"X", "B", "A", "E", "G" };
Arrays.sort(data1); //进行对象数组的排序
System. out. println(Arrays.toString(data1) );
Person data2 [] = new Person []{
new Person("小强-A", 80),
new Person("小强-B", 50),
new Person("小强-C", 100)};
Arrays.sort(data2); //进行对象数组的排序
System. out. println(Arrays.toString(data2));
}
}
class Person implements Comparable<Person>{
private String name ;
private int age ;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 无参构造、setter、getter略
@Override
public String toString( ) {
return "【Person类对象】姓名:" + this.name + "、年龄:" + this.age + "\\";
}
/**
* 实现对象的比较处理操作
*
* @param要比较的对象
* @return当前数据比传入的对象小返回负数，如果大于返回整数，如果等于返回0
*/
@Override
public int compareTo(Person o) {
return this.age - o.age;
}
}
Comparator 比较器
Comparator 属于一种挽救的比较器支持，其主要的目的是解决一些没有使用 Comparable 排序的类的对象数组排序
需要对 Person 类进行排序处理，但是又不能够去修改 Person 类（无法实现 Compparable 接口），需要采用一种挽救的形式来实现比较，在 Arrays 类里面排序有另外一种实现:Comparator 的排序
设罝单独的比较器规则类实现排序,implements Comparator函数接口，重写compare(Person1 o1, Person1 o2)方法
public class ComparatorDemo {
public static void main(String[] args) {
Integer data[ ] = new Integer[ ] { 10,9,5,2,20 }; // 对象数组
Arrays.sort(data); //进行对象数组的排序
System. out. println(Arrays.toString(data) );
String data1 [ ] = new String[ ] {"X", "B", "A", "E", "G" };
Arrays.sort(data1); //进行对象数组的排序
System. out. println(Arrays.toString(data1) );
Person data2 [] = new Person []{
new Person("小茗-A", 80),
new Person("小茗-B", 50),
new Person("小茗-C", 100)};
Arrays.sort(data2); //进行对象数组的排序
System. out. println(Arrays.toString(data2));
}
}
//设罝单独的比较器规则类实现排序
class PersonComparator implements Comparator<Person1> {
@Override
public int compare(Person1 o1, Person1 o2) {
return o1.getAge()- o2.getAge();
}
}
class Person1{
private String name ;
private int age ;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person1(String name, int age) {
this.name = name;
this.age = age;
}
// 无参构造、setter、getter略
@Override
public String toString( ) {
return "【Person类对象】姓名:" + this.name + "、年龄:" + this.age + "\\";
}
}
