20-工具类

工具类

Math

• static double max(double x,double y)：返回xy的最大值，有int、long、float、double数据类型的重载

• static double min(double x,double y)：返回xy的最小值，有int、long、float、double数据类型的重载

• static double abs(double num)：取绝对值，有int、long、float、double数据类型的重载

• static double ceil(double num)：向上取整

• static double floor(double num)：向下取整

• static long round(double num)：四舍五入

• static double random() ：无参，返回[0,1)的double数

  Math.random();//获取[0,1)的double数
  b*Math.random();	//获取[0.0,b.0)的double数
  (int)(b*Math.random())	//获取[0,b-1]的int数
  a+(int)((b+1-a)*Math.random());	//获取[a,b]的int数
  
  Random random = new Random();	//创建随机数对象
  int randomNumber = random.nextInt();	//返回int范围内的伪随机数
  int randomNumber = random.nextInt(b);	//返回[0,b-1]范围内的int形态伪随机数
  int randomNumber = random.nextInt(b+1)+a;	//返回[a,b]范围内的int形态伪随机数
  

时间工具类

定时器

• 由TimerTask类（定时任务）和Timer类（定时器）构成。
• TimerTask类是Runnable的实现类，需要重写run()方法，run方法就是定时任务。
• 而Timer类是调用TimerTask计划任务的定时器
• 这两个方法的区别在于，当有多个定时任务时，固定定时器是抢占式执行调用时机会跟加准确，简单定时器是礼让执行可能会稍有延迟

方法名	描述
void schedule(TimerTask task, long delay, long period)	简单定时器（单位毫秒）
void scheduleAtFixedRate(TimerTask task, long delay, long period)	固定时间定时器（单位毫秒）

Date时间对象

实现时间和long类型数字的互相转换

构造方法

方法名	描述
Date()	创建当前时间的时间对象
Date(long date)	创建指定时间的时间对象

成员方法

方法名	描述
long getTime()	获取该时间对象的时间戳
void setTime(long time)	修改时间对象的时间

Date date = new Date();	//无参构造时间对象，是当前系统时间
Date date = new Date(0L);	//参数是long类型的时间戳，是指定时间戳的时间
//Thu Jan 01 08:00:00 CST 1970
//由于中国位于东八区，所以时间原点是1970-1-1 08:00:00 0毫秒

long s = new Date().getTime();	//获取当前系统时间戳
s = System.currentTimeMillis();	//获取当前系统时间戳
String str = new Date().toLocaleString();	//将时间对象以返回本地格式化时间字符串，1970年1月1日 上午12:00:00

SimpleDateFormat（时间格式化）

实现时间和字符串之间的转换

构造方法

• yyyy-MM-dd HH:mm:ss:SSS：标准24小时制时间
• yyyy-MM-dd hh:mm:ss:SSS： 标准12小时制时间
• 默认格式是本地默认时间格式

方法名	描述
SimpleDateFormat()	获取默认格式的转换日期对象
SimpleDateFormat(String pattern)	获取指定转化的日期格式对象

成员方法

方法名	描述
String format(Date date)	将日期对象转化为指定格式字符串
Date parse(String source)	将指定格式字符串转换为日期对象，线程不安全

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = simpleDateFormat.format(new Date);
//将时间对象转换成构造方法中指定格式的字符串
Date date = simpleDateFormat.parse("1970-01-01 00:00:00");
//将构造方法中指定格式字符串转换成时间对象,需要手动抛出ParseException异常
date = simpleDateFormat.parse("1970-99-99 99:99:99");
//自动进位

Calendar（日历对象）

主要实现日期的运算处理，是个抽象类，可以使用该类中的静态方法getInstance()或GregorianCalendar子类实例化

静态方法和静态属性

方法名	描述
static Calendar getInstance()	获取当前时间的日历对象
YEAR	年
MONTH	月（从0开始的）
DAY_OF_MONTH	日
DAY_OF_WEEK	星期（1是周日，以此类推）
HOUR	时
MINUTE	分
SECOND	秒

成员方法

方法名	描述
int get(int field)	根据指定字段获取内容
void set(int field, int value)	修改指定字段的内容（其他重载的set方法可以直接设置年月日时分秒）
void add(int field, int amount)	对指定字段加减运算操作
Date getTime()	返回当前日历对象转换为的Date对象
void setTime(Date date)	将Date对象转换为日历对象

Calendar calendar = Calendar.getInstance();	//获取日历对象，是当前系统时间
Calendar calendar = new GregorianCalendar();	//当前系统时间
Calendar calendar = new GregorianCalendar(1970,1,1);	//指定年月日
Calendar calendar = new GregorianCalendar(1970,1,1,0,0,0);	//指定年月日时分秒

Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);	//获取日历对象的年
int month = calendar.get(Calendar.MONTH);	//获取日历对象的月，[0-11]月
int day = calendar.get(Calendar.DAY_OF_MONTH);	//获取日历对象的日
int week = calendar.get(Calendar.DAY_OF_WEEK);	//获取日历对象的星期，[1,7],1是周日,7是周1
calendar.set(Calendar.MONTH,10);	//设置日历对象的月为10月,超出范围会进位
calendar.add(Calendar.MONTH,-2);	//给日历对象的月份减少-2
Date date = calendar.getTime();	//将日历对象转换为Date对象
Calendar c = calendar.setTime(new Date());	//将Date对象转换为日历对象

time包

jdk1.8后新增的time包，解决了星期一是周日和月从零开始问题，更符合中国人的习惯，更加方便的对时间进行处理，其中LocalDate（日期）、LocalTime（时间）、LocalDateTime（日期时间）都相差不大

• 静态方法

  • LocalXXX now()：获取当前系统时间的LocalXXX对象
  • LocalXXX of(...)：获取指定时间的LocalXXX对象，LocalDateTime参数有年月日时分秒，LocalDate只有年月日，LocalTime只有时分秒毫秒
  • LocalXXX parse(CharSequence text, DateTimeFormatter formatter)：解析字符串格式方式获取LocalXXX对象，第二个参数一般接收DateTimeFormatter.ofPattern("格式")来指定解析模式，此方法线程安全

• 成员方法

  • int get(ChronoField Field)根据指定字段获取内容，ChronoField类是枚举类，有大量的常量
  • LocalXXX withXXX(int num)对指定字段修改，返回新的LocalXXX对象，原来的不会更改
  • LocalXXX plusXXX(long num)对指定字段加减运算操作，返回新的LocalXXX对象，原来的不会更改

• LocalDateTime转换Date

  LocalDateTime localDateTime = LocalDateTime.now();
  ZoneId zoneId = ZoneId.systemDefault();
  //获取系统时区
  ZonedDateTime zonedDateTime = localDateTime.atZone(zoneId);
  //根据系统时区获取时区时间日期对象
  Instant instant = zonedDateTime.toInstant();
  //时区时间日期对象转换为Instant对象
  Date date = Date.from(instant);
  //Date静态方法将Instant对象转换为Date对象
  System.out.println(date);
  

包装类

继承关系

所有包装类都无法被继承，String类和System类也无法被继承

对应关系表

基本类型	对应包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

装箱与拆箱

/*
* 手动装箱拆箱
*/
Integer integer = new Integer("1");	//不推荐
Integer integer = new Integer(1);	//不推荐
Integer integer = Integer.valueOf(1);
Integer integer = Integer.valueOf("1");
//可以是基本数据类型，也可以是字符串
//字符串若不能转换则会抛出NumberFormatException数字格式化异常
int i = integer.intValue();	//为某个对象拆箱，所以是成员方法
double i = doubleI.doubleValue();	//xxxValue方法
/*
* 1.5后自动装箱拆箱
*/
Integer integer = 1;	//编译器会自动调用Xxx.valueOf()方法
//Integer integer = "1";	//报错，若是字符串还是需要手动装箱或字符串转换后自动装箱的
int i = integer;	//编译器自动调用x.xxxValue()方法
//Integer integer = null;
//int i = integer;	//抛出空指针异常，因为编译器会自动调用i.intValue()方法

Integer a = 128;
Integer b = 128;
System.out.println(a==b);	//false
System.out.println(a.equals(b));	//true
Integer a = 127;
Integer b = 127;
Integer c = new Integer(127);
System.out.println(a==b);	//true
System.out.println(a==c);	//false,new关键字会创建新对象
System.out.println(a.equals(b));	//true
//自动缓存[-128,127]的包装类对象，所以再范围内使用的是缓存中的对象，不再才创建新对象

字符串转换基本数据类型

除了Character外，每个包装类都有对应static xxx parseXxx(String s)的静态方法，将字符串转换成对应基本数据类型，若有非数字字符出现则会抛出NumberFormatException异常。但是Boolean.parseBoolean()比较特殊，只有true才会返回true，其他一律返回false

包括Character，每个包装类都有对应static String toString(xxx x)的静态方法和String类中的static String valueOf(xxx x)静态方法，都将基本数据类型转换为字符串，虽然为基本数据类型加上空字符串更简单可以转换，但是由于会产生空字符串的垃圾空间，所以不推荐

排序接口

自定义对象想要排序，都要定义比较器，比较器泛型要使用要排序的对象类型

要么给排序方法传入一个实现Comparator接口的实现类对象，该实现类重写compare()方法的排序规则

要么自定义类实现Comparable接口重写compareTo()方法的排序规则

Comparable自然排序和Comparator比较器的区别

Comparator	Comparable
位于java.util包下	位于java.lang包下
独立于自定义类之外	在自定义类上实现
调用排序方法指定实现对类对象	直接调用排序方法

集合框架

集合框架的体系结构

Collection

子类可通过构造方法进行Collection集合之间的转换，和Map集合之间转换通过entrySet()和values()方法

Collection和set（集）

• 存储元素特点：无序无下标，不可重复
• 元素只能存储一个null

方法名	描述
Iterator<E> iterator();	获取集合迭代器对象（继承的）
boolean add(E e)	集合中追加元素
boolean remove(Object o)	根据对象equals方法，移除集合中元素
void clear()	清空集合元素
boolean contains(Object o)	根据对象equals方法，判断集合是否包含该元素
boolean isEmpty()	集合是否为空
int size()	集合大小
<T> T[] toArray(T[] a)	集合转换为数组
boolean addAll(Collection<? extends E> c)	将集合c中元素添加到当集合（并）
boolean removeAll(Collection<?> c)	将当前集合包含c集合的元素删除（差）
boolean retainAll(Collection<?> c)	将当前集合不包含c集合的元素删除（交）

HashSet

• 底层基于HashMap实现，因此查询效率和增删效率都比较高
• 存放到HashSet集合中的元素相当于放入HashMap集合的key部分
• 只能存一个null元素
• 默认容量是16

LinkedHashSet

• 底层基于哈希表+链表，有序，不可重复
• 只能存一个null元素

TreeSet

• 底层基于TreeMap实现，无序，不可重复，自动排序
• 存放到HashSet集合中的元素相当于放入HashMap集合的key部分
• 不允许存null

方法名	描述
TreeSet()	自然顺序排序，继承Comparable接口
TreeSet(Comparator<? super E> comparator)	传入比较器Comparator接口

List（链表）

• 存储元素特点：有序有下标，可重复
• 可存储多个元素为null

方法名	描述
ListIterator<E> listIterator(int index)	返回list迭代器对象
void add(int index, E element)	集合中指定索引后追加元素
E remove(int index)	根据索引移除集合中元素并返回
E get(int index)	获取指定索引元素
E set(int index, E element)	根据索引修改元素
int indexOf(Object o)	查找指定对象第一次出现的索引，找不到返回-1
int lastIndexOf(Object o)	倒着查找指定对象第一次出现的索引，找不到返回-1
List<E> subList(int fromIndex, int toIndex)	返回截取的子[fromIndex,toIndex)集合

ArrayList

• 底层是基于数组形式实现集合操作，所以查询效率高，增删效率低，且线程不安全
• 数组存满后，ArrayList底层就会新开辟一个更大（大50%）的数组，将原数组加入到新数组中，从而实现扩容操作，这样就会产生旧的数组成为垃圾空间，若明知道会超过默认容量（10）建议使用有参构造设置更大容量

方法名	描述
ArrayList()	使用默认容量10
ArrayList(int initialCapacity)	使用自定义容量

LinkedList

• 底层是基于双向链表的数据结构实现的集合操作，所以查询效率低，增删效率高，且线程不安全
• 存在一个Node的内部类，存放元素信息和指针信息

Vector

方法名	描述
Enumeration<E> elements()	获取Enumeration迭代对象

• 底层实现集合操作与ArrayList一样的，但是方法都使用了synchronized同步处理机制，所以线程安全，效率低

Stack（栈）

• 方法都使用了synchronized同步处理机制，所以线程安全

方法名	描述
E push(E item)	入栈
E pop()	出栈
boolean empty()	检查栈中是否为空
E peek()	返回栈顶元素
int search(Object o)	栈中利用对象equals方法查找数据，栈顶是1，找不到返回-1

Queue（单向队列）

操作	失败抛出异常	失败返回值
队尾增加元素	boolean add(E e)	boolean offer(E e)
队头删除元素	E remove()	E poll()
查看队头	E element()	E peek()

Deque(双向队列)

操作	失败抛出异常	失败返回值
队头增加元素	void addFirst(E e)	boolean offerFirst(E e)
队头删除元素	E removeFirst()	E pollFirst()
查看队头	E getFirst()	E peekFirst()
队尾增加元素	void addLast(E e)	boolean offerLast(E e)
队尾删除元素	E removeLast()	E pollLast()
查看队头尾	E getLast()	E peekLast()

迭代器

迭代器体系结构

Iterator

方法名	描述
boolean hasNext()	检查是否有下一个元素
E next()	获取当前内容，并且指针下移
default void remove()	删除当前元素

ListIterator

方法名	描述
boolean hasPrevious()	检查是否有上一个元素
E previous();	获取上一个元素
int previousIndex();	获取上一个的元素下标
int nextIndex()	获取下一个元素下标
void set(E e);	修改当前元素
void add(E e)	当前位置添加元素

Enumeration

方法名	描述
boolean hasMoreElements()	检查是否有下一个元素
E nextElement()	获取当前元素

foreach

原理

自定义类要想使用foreach输出，则必须实现<<Iterable>>接口返回迭代对象，迭代对象又依赖于内部类要实现<<Iterator>>接口重写hasNext()和next()方法

自定义单项链表实现foreach

public class MyList<T> implements Iterable<T>{
  private class Node<T>{
    private T date; //节点数据
    private Node<T> next; //下一个节点
    private Node(T date){
      this.date = date;
    }
  }
  private Node<T> rootNode; //根节点信息
  private Node<T> lastNode; //最后一个节点信息
  private Node<T> currentNode;  //当前节点指针
  public boolean add(T data){
    Node newNode = new Node(data);  //将数据进行节点包裹
    if (rootNode == null){
      rootNode = newNode; //保存第一个节点
    }else {
      this.lastNode.next = newNode; //向最后一个节点添加下一个的节点指针信息
    }
    this.lastNode = newNode;  //更新最后一个节点为传入的新节点
    return true;  //添加成功返回true
  }
  @Override
  public Iterator<T> iterator() { //重写Iterable接口获取迭代器
    return new Iterator<T>(){ //返回迭代器对象
      {
        MyList.this.currentNode = MyList.this.rootNode;
        //每次获取迭代器将当前节点指针置为第一个
      }
      @Override
      public boolean hasNext() {  // 匿名内部类重写hasNext
        return MyList.this.currentNode != null;
        //若当前指针是null则是最后一个节点，返回false，否则返回true
      }
      @Override
      public T next() {
        T date =  MyList.this.currentNode.date;
        //取出当前节点数据
        MyList.this.currentNode = MyList.this.currentNode.next;
        //更新当前节点指针为当前节点的存放的下一个节点指针
        return date;  //返回当前节点数据
      }
    };
  }
  public static void main(String[] args) {
    MyList<String> myList = new MyList<>();
    myList.add("1");
    myList.add("2");
    myList.add("3");
    for (String str: myList){
      System.out.println(str);
    }
  }
}

Map（映射）

• 通过键值对形式存储，改键值对是以Map.Entry类型的对象实例存在
• 存储元素特点：无序，键不可重复，值可重复
• 通过键可快速查找到value

方法名	描述
V put(K key, V value)	存放键值对，key存在返回旧元素并替换value，key不存在返回null
V get(Object key)	通过键对象equals方法，获取值
boolean containsKey(Object key)	通过键对象equals方法，检查是否包含该键
boolean containsValue(Object value)	通过值对象equals方法，检查是否包含该值
V remove(Object key)	通过键对象equals方法，删除键值对，并返回值
void clear()	清空集合元素
int size()	获取键值对数量
boolean isEmpty()	检查集合是否为空
void putAll(Map<? extends K, ? extends V> m)	将集合m中元素添加到当集合（并）
Collection<V> values()	获取值集合
Set<K> keySet()	获取键集合
Set<Map.Entry<K, V>> entrySet()	获取Map.Entry接口实例集合形式返回

HashMap

• 底层是哈希表数据结构，数组+链表，效率高，线程不安全
• 允许key或value为null，但是key为null只能有一个
• 默认初始化容量是16，二倍扩容，自定义容量建议是2的倍数

LinkedHashMap

• 底层基于哈希表+链表，有序，键不可重复
• 只能存一个null元素

Hashtable

• 底层是哈希表数据结构，效率低，线程安全
• 不允许key和value为null
• 默认初始容量（16）

TreeMap

• 底层是二叉树数据结构，TreeMap集合的key自动排序
• 不允许key为null，允许value为null

Properties

• 线程安全，key和value只能存储字符串

• 不允许key或value为null

方法名	描述
Object setProperty(String key, String value)	向Property对象加入键值对
String getProperty(String key)	通过键获取值，获取不到返回null
String getProperty(String key, String defaultValue)	通过键获取值，为获取到则是默认内容
Set<String> stringPropertyNames()	获取全部属性名的set集合
void store(Writer writer, String comments)	将Property中的信息输出到writer字符输出流中，comments是写入的注释信息
void load(Reader reader)	将reader字符输入流中的数据读入到Property
void store(OutputStream out, String comments)	将Property中的信息输出到out字节输出流中，comments是写入的注释信息
void load(InputStream inStream)	将inStream字节输入流中的数据读入到Property

Collections（集合工具类）

方法名	描述
void sort(List<T> list)	集合自然排序
void sort(List<T> list, Comparator<? super T> c)	集合比较器排序
void shuffle(List<?> list)	集合洗牌
void reverse(List<?> list)	集合逆序
boolean addAll(Collection<? super T> c, T... elements)	向集合c添加多个元素

jdk9 后新增方法

为List、Set、Map接口新增了静态工厂方法创建集合的方法集合<E> of(E... elements)

• 只适用于List、Set、Map接口，不适用与实现类
• 返回创建的集合是一个不可改变的集合
• Set、Map集合不能添加重复元素，List可以

函数式接口

用于这些接口作为参数的方法，传入的就是这些接口的Lambda表达式，而这些方法内部调用传入的Lambda表达式实现的接口对象方法，类似于回调函数

Supplier（生产形接口）

@FunctionalInterface
public interface Supplier<T> { T get(); }

Consumer（消费形接口）

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
    default Consumer<T> andThen(Consumer<? super T> after) {
      //连接多个Consumer接口实现类对象
      //此方法后调用accept方法才能实现多个Consumer的accept方法依次调用
      //c1.andThen(c2).andThen(c3).accept(s); //c1、c2和c3的accept依次执行
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Predicate（断言形接口）

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    default Predicate<T> and(Predicate<? super T> other) {
      //连接多个Predicate接口实现类对象，短路与操作
      //此方法调用后用test方法才能实现多个Predicate的test方法的结果短路与
      //p1.and(p2).test(b);//p1.test(b)&&p2/test(b)
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    default Predicate<T> or(Predicate<? super T> other) {
			//连接多个Predicate接口实现类对象，短路或操作
      //此方法调用后用test方法才能实现多个Predicate的test方法的结果短路或
      //p1.or(p2).test(b);//p1.test(b)||p2/test(b)
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
      default Predicate<T> negate() {
      //对测试结果取反
      //test方法之前调用可以使测试结果取反操作
      //p.negate().test();
        return (t) -> !test(t);
    }
  ...
}

Function（功能形接口）

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
			//连接多个Function接口实现类对象
      //此方法后调用apply方法才能实现多个Function的apply方法向外嵌套调用
      //f1.andThen(f2).apply(s); //f2.apply(f1.apply());
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
  ...
}

Stream流

生成流

要转化的容器	生成方式	描述
散开的元素	Stream<T> Stream.of(T ...Values)	Stream接口的静态方法
数组	Stream<T> stream(T[] array)	Arrays工具类的静态方法
Collection集合	Stream<E> stream()	Collection接口的默认方法
Collection集合	Stream<E> parallelStream()	并行计算流，多核CPU支持
Map集合	由entrySet、keySet、values方法先得到collection集合	转化Collection集合后间接得到

中间操作

方法名	描述
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)	合并a、b两个流
Stream<T> filter(Predicate<? super T> predicate)	过滤
Stream<T> limit(long maxSize)	截取从0到maxSize个
Stream<T> skip(long n)	跳过n个到最后
Stream<T> distinct()	去重（使用equals方法判断是否重复）
Stream<T> sorted()	自然排序
Stream<T> sorted(Comparator<? super T> comparator)	比较器排序

转化流操作

方法名	描述
<R> Stream<R> map(Function<? super T, ? extends R> mapper)	将T类型流转化为R类型的流
IntStream mapToInt(ToIntFunction<? super T> mapper)	将T类型流转化为IntStream流
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)	将T类型流转化为DoubleStream流
LongStream mapToLong(ToLongFunction<? super T> mapper)	将T类型流转化为LongStream流

原始流

方法名	描述
Xxx sum()	求和
XxxSummaryStatistics summaryStatistics()	获取汇总统计对象

Optional

此类主要用途是在方法声明处检测空指向异常

方法名	描述
static <T> Optional<T> of(T value)	获取Optional对象，不允许内容是null
static <T> Optional<T> ofNullable(T value)	获取Optional对象，允许内容是null，但是调用get方法会报找不到异常
public T get()	获取Optional对象中存储的内容
boolean isEmpty()	判断Optional对象存储内容是否为null，是返回true
boolean isPresent()	判断Optional对象存储内容是否为null，是返回false

终结操作

方法名	描述
void forEach(Consumer<? super T> action)	遍历
long count()	统计个数

收集操作

方法名	描述
<R, A> R collect(Collector<? super T, A, R> collector)	由收集器收集

收集器

由Collectors工具类生成Collector收集器

方法名	描述
static <T> Collector<T, ?, List<T>> toList()	获取List收集器
static <T> Collector<T, ?, Set<T>> toSet()	获取Set收集器
static <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function keyMapper, Function valueMapper)	获取Map收集器，前面是key的格式，后面的value的格式

国际化程序

Locale类

用来描述语言和地区的一个类

Locale locale = new Locale("en","US");	//en_US，手动创建
System.out.println(Locale.CHINA);	//zh_CN，使用Locale类的常量
Locale aDefault = Locale.getDefault();	//zh_CN，获取本地的语言城市

资源文件

• 文件命名规则文件名_语言_地区.properties，例如：info_zh_ch.properties

• 一组语言资源文件中必须包含有一个默认的资源文件文件名.properties即可，找不到指定的语言文字时使用默认资源文件

• 内容依然是key=value形式

资源读取

Locale locale = new Locale("en","US");
ResourceBundle bundle = ResourceBundle.getBundle("com.Info",locale);
//获取指定语言的读取资源文件类，info_en_US.properties
//资源文件的包名+资源文件名，不要加后缀
//若没有该语言则使用默认资源文件
System.out.println(bundle.getString("hollow")); //英文
//读取资源文件的key，获取value


ResourceBundle bundle = ResourceBundle.getBundle("com.Info");
//获取读取资源文件类
//未指定语言，使用系统默认语言
//若只有一个资源文件则使用默认资源文件Info.properties
System.out.println(bundle.getString("hollow")); //中文

文本占位符替换

String str = "你好{0}，{1}欢迎来到{1}";
//花括号包裹索引的形式作为占位符
String format = MessageFormat.format(str, "用户", "java世界");
//将要格式化的字符串按照后续参数索引进行替换
//占位符也可以复用
//未被替换的保持原样
System.out.println(format);
//你好用户，java世界欢迎来到java世界

Base64

静态方法

方法名	描述
static Encoder getEncoder()	获取加密对象
static Decoder getDecoder()	获取解密对象

静态内部类成员方法

Encoder

方法名	描述
byte[] encode(byte[] src)	对字符串对应字节数组加密，获取加密后的字节数组
String encodeToString(byte[] src)	对字符串对加密，获取加密后的字节数组

Decoder

方法名	描述
byte[] decode(byte[] src)	对加密后的字节数组解密
byte[] decode(String src)	对加密后的字符串解密

UUID uuid = UUID.randomUUID();	//获取UUID