Java4-开发支持类库（UUID、Optional、ThreadLocal、定时调度、Base64）

1、UUID类

产生随机数：默认为32位，提供以下两个方法；

• andomUUID()是随机(适用于唯一订单号)的。
• nameUUIDFromBytes(byte[] n)会根据n产生唯一的uuid。只要有用户的唯一性信息。就能保证此用户的uuid的唯一性。例如（身份证号等）。

 //UUID
       UUID uuid = UUID.randomUUID();
       System.out.println(uuid.toString()); //621b8c2a-612b-4e3a-b018-88fb91d57136

2、Optional类

进行null（NullPointerException））的相关处理。Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

import java.util.Optional;
 
public class Java8Tester {
   public static void main(String args[]){
   
      Java8Tester java8Tester = new Java8Tester();
      Integer value1 = null;
      Integer value2 = new Integer(10);
        
      // Optional.ofNullable - 允许传递为 null 参数
      Optional<Integer> a = Optional.ofNullable(value1);
        
      // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
      Optional<Integer> b = Optional.of(value2);
      System.out.println(java8Tester.sum(a,b));
   }
    
   public Integer sum(Optional<Integer> a, Optional<Integer> b){
    
      // Optional.isPresent - 判断值是否存在
        
      System.out.println("第一个参数值存在: " + a.isPresent());
      System.out.println("第二个参数值存在: " + b.isPresent());
        
      // Optional.orElse - 如果值存在，返回它，否则返回默认值
      Integer value1 = a.orElse(new Integer(0));
        
      //Optional.get - 获取值，值需要存在
      Integer value2 = b.get();
      return value1 + value2;
   }
}

执行结果

$ javac Java8Tester.java 
$ java Java8Tester
第一个参数值存在: false
第二个参数值存在: true
10

3、ThreadLocal类

ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法。

  public class ThreadLocalTest {

        static ThreadLocal<String> localVar = new ThreadLocal<>();

        static void print(String str) {
            //打印当前线程中本地内存中本地变量的值
            System.out.println(str + " :" + localVar.get());
            //清除本地内存中的本地变量
            localVar.remove();
        }

        public static void main(String[] args) {
            Thread t1  = new Thread(new Runnable() {
                @Override
                public void run() {
                    //设置线程1中本地变量的值
                    localVar.set("localVar1");
                    //调用打印方法
                    print("thread1");
                    //打印本地变量
                    System.out.println("after remove : " + localVar.get());
                }
            });

            Thread t2  = new Thread(new Runnable() {
                @Override
                public void run() {
                    //设置线程1中本地变量的值
                    localVar.set("localVar2");
                    //调用打印方法
                    print("thread2");
                    //打印本地变量
                    System.out.println("after remove : " + localVar.get());
                }
            });

            t1.start();
            t2.start();
        }
    }

执行结果：

thread2 :localVar2
thread1 :localVar1
after remove : null
after remove : null

ThreadLocal与synchronized有本质的区别：

1、Synchronized用于线程间数据共享，而ThreadLocal则用于线程间数据隔离。

2、Synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。

4、定时调度

指定时间后执行任务

class MyTask extends TimerTask {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":"+System.currentTimeMillis());
    }
}

调用

    Timer timer = new Timer();
    timer.schedule(new MyTask() ,0);

5、Base64加密与解密

package com.alan;

import java.util.Base64;

public class Base64Test {

    //定义要加密的字符串
    private static String src = "imooc security base64";

    public static void main(String[] args) {
        bouncyCastleBase64(src);

    }

    //jdk方式加密
    public static void jdkBase64(String src){

        Base64.Encoder encoder = Base64.getEncoder();
        String s = encoder.encodeToString(src.getBytes());
        System.out.println("加密："+s);
        Base64.Decoder decoder = Base64.getDecoder();
        System.out.println("解密："+ new String(decoder.decode(s)));
    }

    //commons codec
    public static void commonsCodesBase64(String src){
        byte[] bytes = org.apache.commons.codec.binary.Base64.encodeBase64(src.getBytes());
        System.out.println("加密："+new String(bytes));
        byte[] bytes1 = org.apache.commons.codec.binary.Base64.decodeBase64(bytes);
        System.out.println("解密:"+ new String(bytes1));

    }

    //bouncyCastleBase64
    public static void bouncyCastleBase64(String src){
        byte[] encode = org.bouncycastle.util.encoders.Base64.encode(src.getBytes());
        System.out.println("加密1："+new String(encode));
        byte[] decode = org.bouncycastle.util.encoders.Base64.decode(encode);
        System.out.println("解密1:"+ new String(decode));

    }

}

执行结果

加密：aW1vb2Mgc2VjdXJpdHkgYmFzZTY0
解密：imooc security base64

为了增加安全性；可以插入盐值，多次加密；
如加密：123456 ，可增加盐值变为：123{456}，再次加密。