新增日期类&正则表达式&泛型&迭代器&比较器& 基于Pinyin4J实现中文排序

目录：LocalDateTime & DateTimeFormatter & Pattern & Matcher & 泛型 & Collection接口 & List & 迭代器(Iterator) & Comparator(比较器) & 基于Pinyin4J实现中文排序 & Map

LocalDate

//获取当前系统时间所表示的日期对象
LocalDate date = LocalDate.now();
//获取月份值（年周日同理）
Date.getMonthValue();
//根据指定的日期构建一个LocalDate对象
LocalDate date2 = LocalDate.of(2020,7,8);

LocalTime

//获取当前系统时间所表示的日期对象
LocalTime time = LocalTime.now();
//获取时(分秒)
time.getHour();
//根据指定的日期构建一个LocalTime对象
LocalTime time = LocalDate.of(12,11,18);

LocalDateTime

//获取当前系统时间所表示的日期对象
LocalDateTime time = LocalDateTime.now();
//根据指定的日期构建一个LocalDateTime对象
LocalDateTime time = LocalDateTime.of(2020,8,9,19,22,12);
//将LocalDateTime转换为LocalDate跟LocalTime
LocalDate localDate = time.toLocalDate();
LocalTime localTime = time.toLocalTime();

DateTimeFormatter

//创建一个格式化解析对象
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒");
//获取系统时间
LocalDateTime datetime = LocalDateTime.now();

//将datetime格式转成2020年07月……的形式
String time = fmt.format(datetime);
time = datetime.format(fmt);

//将2020年07月……的String类型转成DateTime
String t = "2020年07月08日 09时33分21秒"; 
dateTime = LocalDateTime.parse(t, fmt);

注意事项:

与DateFormat和SimpleDateFormat的区别在于，DateTimeFormatter是线程安全的实现，在多线程并发的时候可以让多个线程使用同一当前实例，能保证数据的一致性；但是DateFormat是线程非安全实现，因此在多线程并发时，需要为每个线程单独创建该实例。

Pattern & Matcher

• Pattern ：提供针对正则表达式的编译功能
• Matcher：提供对已经编译过的正则表达式匹配字符串的功能

//Pattern & Matcher 用法：
String s = "234798273489176123123123";
Pattern p = Pattern.compile("1\\d{10}");
Matcher m = p.matcher(s);
//如果成功查找 m.find() 返回值为true
while(m.find()){
    System.out.println(m.group());
}

泛型（Generic）

在类声明时在后面通过<>符号指定类型参数，然后在类中可以使用这些类型参数设置动态类型

public class MyCalc<I,D,F> {
    public I add(I i1,I i2) {
		return null;
	}
    ...
}

public interface BaseManager<T> {

	boolean add(T obj);
	
	boolean delete(T obj);
	
	boolean update(T obj);
	
	T findById(int id);
	
	ArrayList<T> findAll();
}
//接口后接<T>，在实现类中要加具体类<Emp>
public class EmpManager implements BaseManager<Emp>{
    ...
}

Collection接口

是java集合框架中的顶层接口，用于表示一些相同类型的数据集合，内部提供了一系列用于对集合中元素进行存储的方法。

Collection接口的常见方法;

• add(E e) 添加元素
• addAll(Collection<? extends E> c) 添加一个集合到当前集合中
• clear() 从集合中删除所有的元素
• contains(Object obj) 判断集合中是否包含指定的元素
• isEmpty() 判断集合是否为空
• remove(Object o) 删除指定的元素
• removeAll(Collection<?> c) 删除指定的集合
• size() 获取集合中元素的个数
• toArray() 将集合中的所有元素转换为数组
• iterator() 返回集合中的元素的迭代器

List

List是从Collection继承过来，也是一个接口；List扩展自Collection，在Collection基础上新增了一些方法：

• get(int index) 根据索引获取元素
• set(int index,E e) 向指定的位置插入元素
• remove(int index) 删除指定索引处的元素
• listIterator() 获取一个列表迭代器(有序)

由于List是一个接口，所以没法直接实例化，因此JDK中提供了一些对于List接口实现的实现类：

• ArrayList：线程不安全(不同步)
• LinkedList：基于链表的List实现

迭代器(Iterator)

迭代器即游标，将集合处理为类似栈结构的数据结构，通过栈顶指针依次向下搜索元素，直到达到栈底为止

//获取当前集合对象的迭代器（游标）
List<String> list = new ArrayList<>();
Iterator<String> it = list.iterator();
while(it.hasNext()) {			
    String s = it.next();
    if(s.equals("30")) {
        it.remove();
    }
    System.out.println(s);
}

Comparator

定义比较器（MyComparator）

//创建一个MyComparator类
public class MyComparator implements Comparator<String>{
	@Override
	public int compare(String s1, String s2) {
		return s1.compareTo(s2);
	}
}
//对数组进行排序
list.sort(new MyComparator());

//匿名内部类使用方法
list.sort(new Comparator<Student>() {
    @Override
    public int compare(Student s1, Student s2) {
        return s1.getAge() - s2.getAge();
});

如果被添加到TreeSet中的元素没有实现Comparable接口也可以，此时只需要在创建TreeSet时通过以下构造器，传入排序比较器对象即可：

//User无需实现Comparable接口
//构造TreeSet时传入排序比较器
Set<User> set = new TreeSet<>(
(u1,u2)->u1.getId()-u2.getId());

基于Pinyin4J实现中文排序

对中文内容排序需要使用到一个开源插件(jar包)-Pinyin4j

• pinyin4j-2.5.0.jar

中文排序示例:

List<String> names = new ArrayList<>();
names.add("柴老师");
names.add("王老师");
names.add("苍老师");
names.add("老王");
names.add("老李");
names.add("小泽老师");

Collections.sort(names,(s1,s2)->{

    String p1 = "";
    String p2 = "";
    for(int i = 0;i<s1.length();i++) {
        p1 += PinyinHelper.toHanyuPinyinStringArray(s1.charAt(i))[0];
    }
    for(int i = 0;i<s2.length();i++) {
        p2 += PinyinHelper.toHanyuPinyinStringArray(s2.charAt(i))[0];
    }
    return p1.compareTo(p2);
});

System.out.println(names);

Set

Set集合也是从Collection扩展而来的子集合，相比List集合来说，Set集合内部存储的数据不是按照添加顺序存储，内部不允许出现重复的元素(不允许出现e1.equals(e2))，对null也只允许出现一个，对于set集合常用的实现主要有以下:

• HashSet（哈希表-散列表）
• TreeSet（二叉树-红黑树）
• LinkedHashSet

HashSet

//创建
Set<String> set = new HashSet<String>();
//获取set集合的迭代器
Iterator<String> it = set.iterator();
while(it.hasNext()) {
    String s = it.next();
    System.out.println(s);
    if(s.equals("lily")) {

TreeSet

当多个用户的id一致时，TreeSet会根据compareTo方法判定元素为重复，此时会去除重复

注意事项：

1. 由于Set集合存储元素的”无序“（不按照添加顺序存储），因此元素没有索引的概念，在获取元素的时候只能通过迭代器迭代。
2. HashSet和TreeSet区别
   1. HashSet是基于哈希表的实现，元素的存储顺序也是按照哈希地址排序，因此是否重复由哈希值确定
   2. TreeSet是基于二叉树-红黑树实现，元素的存储顺序根据元素实现的Comparable接口中的comparaTo方法的实现排序，是否重复也是根据排序值判定
3. TreeSet使用要求:
   1. 集合中元素必须是同一种数据类型
   2. 要么让内部元素实现Comparable接口，要么创建TreeSet时提供排序比较器（Comparator）

Map(映射)

//获取value值
map.get("id")；
//foreach遍历
Set<Long> keys = map.keySet();
for (Long l : keys) {
System.out.println(map.get("id").toString());
}

TreeMap

//创建存储数据
Map<Stuent, String> map = new TreeMap<>();
map.put(new Student(), "vaen");
//创建并附加比较器
Map<Stu, Object> map2 = new TreeMap<Stuent, String>(new Comparator<Stu>{
	public int compara(Stu s1,Stu s2){
	return s1.getAge() - s2.getAge();
	}
});

HashMap、Hashtable、TreeMap的区别

1. HashMap是基于hash算法的实现，内不通过数组结合链表实现，允许空键值存在，是线程不同步的实现
2. TreeMap是基于红黑树的实现，内部元素的存储顺序是由自然顺序对键进行排序之后存储，是线程不同步的实现
3. Hashtable是从老式的Dictionary类继承而来，内部的实现原理跟HashMap一样，不允许空键值存在，实现线程同步的实现，运行效率较低