diff --git a/pom.xml b/pom.xml
index a91c75e..6be9297 100644
--- a/pom.xml
+++ b/pom.xml
@@ -69,6 +69,17 @@
+
+ junit
+ junit
+ 4.13.2
+ compile
+
+
+ org.projectlombok
+ lombok
+ provided
+
diff --git a/src/main/java/Test.java b/src/main/java/Test.java
index 269694c..fe0ac04 100644
--- a/src/main/java/Test.java
+++ b/src/main/java/Test.java
@@ -1,22 +1,12 @@
-import org.springframework.beans.factory.annotation.Lookup;
import org.springframework.stereotype.Service;
-/**
- * @author hpl
- * @date 2023/4/15 14:40
- */
+import javax.script.*;
+import java.io.FileReader;
+import java.util.LinkedList;
+import java.util.Scanner;
+
@Service
public class Test {
-
-
-
-
- public static void main(String[] args) {
-
- }
-
-
- public void test(){
-
+ public static void main(String[] args) throws Exception {
}
}
diff --git a/src/main/java/WorkTimeCalculator.java b/src/main/java/WorkTimeCalculator.java
new file mode 100644
index 0000000..09cec9c
--- /dev/null
+++ b/src/main/java/WorkTimeCalculator.java
@@ -0,0 +1,78 @@
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class WorkTimeCalculator {
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+
+// System.out.println("请输入开始工作的年份");
+// int startYear = sc.nextInt();
+// System.out.println("请输入开始工作的月份");
+// int startMonth = sc.nextInt();
+// System.out.println("请输入开始工作的日");
+// int startDay = sc.nextInt();
+// System.out.println("请输入开始工作当天的起始时间（24小时制，如0830表示8点30分）");
+// int startTimeInput = sc.nextInt();
+// int startTimeHour = startTimeInput / 100;
+// int startTimeMinute = startTimeInput % 100;
+// LocalTime startTime = LocalTime.of(startTimeHour, startTimeMinute);
+
+// System.out.println("请输入每次工作的时长（分钟）");
+// int workTime = sc.nextInt();
+// System.out.println("请输入工作的休息间隔（分钟）");
+// int intervalTime = sc.nextInt();
+
+
+ int startYear = 2025;
+ int startMonth = 1;
+ int startDay = 1;
+ LocalTime startTime = LocalTime.of(4, 0);
+ int workTime = 120;
+ int intervalTime = 480;
+
+ System.out.println("请输入月份和日期");
+ int selectYear = 2025;
+ int selectMonth = sc.nextInt();
+ int selectDay = sc.nextInt();
+ sc.close();
+
+ LocalDate startDate = LocalDate.of(startYear, startMonth, startDay);
+ LocalDateTime startDateTime = LocalDateTime.of(startDate, startTime);
+ LocalDate selectDate = LocalDate.of(selectYear, selectMonth, selectDay);
+ LocalDateTime selectDateTime = LocalDateTime.of(selectDate, LocalTime.MIDNIGHT);
+
+ List workPeriods = calculateWorkPeriods(startDateTime, workTime, intervalTime, selectDateTime);
+
+ for (String period : workPeriods) {
+ System.out.println(period);
+ }
+ }
+
+ public static List calculateWorkPeriods(LocalDateTime startDateTime, int workTimeMinutes, int intervalTimeMinutes, LocalDateTime selectDateTime) {
+ List periods = new ArrayList<>();
+ LocalDateTime currentTime = startDateTime;
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
+
+ while (!currentTime.isAfter(selectDateTime.withHour(23).withMinute(59).withSecond(59).withNano(999999999))) {
+ LocalDateTime endTime = currentTime.plusMinutes(workTimeMinutes);
+ if (endTime.isAfter(selectDateTime.withHour(23).withMinute(59).withSecond(59).withNano(999999999))) {
+ // 工作时间跨天，只计算到当天的23:59:59
+ endTime = selectDateTime.withHour(23).withMinute(59).withSecond(59).withNano(999999999);
+ }
+
+ String period = currentTime.format(formatter) + " 到 " + endTime.format(formatter);
+ if (!endTime.isBefore(selectDateTime)) {
+ periods.add(period);
+ }
+
+ currentTime = endTime.plusMinutes(intervalTimeMinutes);
+ }
+
+ return periods;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/javaStudy/basic/callBack/CallBack.java b/src/main/java/javaStudy/basic/callBack/CallBack.java
new file mode 100644
index 0000000..81ac77e
--- /dev/null
+++ b/src/main/java/javaStudy/basic/callBack/CallBack.java
@@ -0,0 +1,50 @@
+package javaStudy.basic.callBack;
+
+import org.junit.Test;
+
+import java.util.Random;
+import java.util.concurrent.*;
+
+public class CallBack {
+ //这里简单地使用future和callable实现了线程执行完后
+ public static void main(String[] args) throws ExecutionException, InterruptedException {
+ // 创建一个可缓存的线程池，用于执行异步任务
+ ExecutorService executor = Executors.newCachedThreadPool();
+ Future future = executor.submit(new Callable() {
+ @Override
+ public String call() throws Exception {
+ System.out.println("call");
+ TimeUnit.SECONDS.sleep(1);
+ return "str";
+ }
+ });
+ //手动阻塞调用get通过call方法获得返回值。
+ System.out.println(future.get());
+ //需要手动关闭，不然线程池的线程会继续执行。
+ executor.shutdown();
+
+ //使用futuretask同时作为线程执行单元和数据请求单元。
+ FutureTask futureTask = new FutureTask(new Callable() {
+ @Override
+ public Integer call() throws Exception {
+ System.out.println("dasds");
+ return new Random().nextInt();
+ }
+ });
+ new Thread(futureTask).start();
+ //阻塞获取返回值
+ System.out.println(futureTask.get());
+ }
+
+ @Test
+ public void test() {
+ Callable callable = new Callable() {
+ @Override
+ public Object call() throws Exception {
+ return null;
+ }
+ };
+ FutureTask futureTask = new FutureTask(callable);
+
+ }
+}
diff --git a/src/main/java/javaStudy/basic/callBack/demo/BottomService.java b/src/main/java/javaStudy/basic/callBack/demo/BottomService.java
new file mode 100644
index 0000000..03c3a0e
--- /dev/null
+++ b/src/main/java/javaStudy/basic/callBack/demo/BottomService.java
@@ -0,0 +1,21 @@
+package javaStudy.basic.callBack.demo;
+
+public class BottomService {
+
+ public String bottom(String param) {
+
+ try { // 模拟底层处理耗时，上层服务需要等待
+
+ Thread.sleep(3000);
+
+ } catch (InterruptedException e) {
+
+ e.printStackTrace();
+
+ }
+
+ return param +" BottomService.bottom() execute -->";
+
+ }
+
+}
diff --git a/src/main/java/javaStudy/basic/callBack/demo/Test.java b/src/main/java/javaStudy/basic/callBack/demo/Test.java
new file mode 100644
index 0000000..48f3ec2
--- /dev/null
+++ b/src/main/java/javaStudy/basic/callBack/demo/Test.java
@@ -0,0 +1,25 @@
+package javaStudy.basic.callBack.demo;
+
+import java.util.Date;
+
+public class Test {
+
+ public static void main(String[] args) {
+
+ BottomService bottomService = new BottomService();
+
+ UpperService upperService = new UpperServiceImpl(bottomService);
+
+ System.out.println("=============== callBottomService start ==================:" + new Date());
+
+ String result = upperService.callBottomService("callBottomService start --> ");
+
+ //upperTaskAfterCallBottomService执行必须等待callBottomService()调用BottomService.bottom()方法返回后才能够执行
+
+ upperService.upperTaskAfterCallBottomService(result);
+
+ System.out.println("=============== callBottomService end ====================:" + new Date());
+
+ }
+
+}
diff --git a/src/main/java/javaStudy/basic/callBack/demo/UpperService.java b/src/main/java/javaStudy/basic/callBack/demo/UpperService.java
new file mode 100644
index 0000000..647a3d8
--- /dev/null
+++ b/src/main/java/javaStudy/basic/callBack/demo/UpperService.java
@@ -0,0 +1,9 @@
+package javaStudy.basic.callBack.demo;
+
+public interface UpperService {
+
+ public void upperTaskAfterCallBottomService(String upperParam);
+
+ public String callBottomService(final String param);
+
+}
\ No newline at end of file
diff --git a/src/main/java/javaStudy/basic/callBack/demo/UpperServiceImpl.java b/src/main/java/javaStudy/basic/callBack/demo/UpperServiceImpl.java
new file mode 100644
index 0000000..c9932d6
--- /dev/null
+++ b/src/main/java/javaStudy/basic/callBack/demo/UpperServiceImpl.java
@@ -0,0 +1,29 @@
+package javaStudy.basic.callBack.demo;
+
+public class UpperServiceImpl implements UpperService {
+
+ private BottomService bottomService;
+
+ @Override
+
+ public void upperTaskAfterCallBottomService(String upperParam) {
+
+ System.out.println(upperParam + " upperTaskAfterCallBottomService() execute.");
+
+ }
+
+ public UpperServiceImpl(BottomService bottomService) {
+
+ this.bottomService = bottomService;
+
+ }
+
+ @Override
+
+ public String callBottomService(final String param) {
+
+ return bottomService.bottom(param + " callBottomService.bottom() execute --> ");
+
+ }
+
+}
\ No newline at end of file
diff --git a/src/main/java/javaStudy/basic/callBack/pratice/CallBack.java b/src/main/java/javaStudy/basic/callBack/pratice/CallBack.java
new file mode 100644
index 0000000..016dfc6
--- /dev/null
+++ b/src/main/java/javaStudy/basic/callBack/pratice/CallBack.java
@@ -0,0 +1,5 @@
+package javaStudy.basic.callBack.pratice;
+
+public interface CallBack {
+ void tellAnswer(int res);
+}
diff --git a/src/main/java/javaStudy/basic/callBack/pratice/Student.java b/src/main/java/javaStudy/basic/callBack/pratice/Student.java
new file mode 100644
index 0000000..94791eb
--- /dev/null
+++ b/src/main/java/javaStudy/basic/callBack/pratice/Student.java
@@ -0,0 +1,5 @@
+package javaStudy.basic.callBack.pratice;
+
+public interface Student {
+ void resolveProblem (Teacher teacher);
+}
diff --git a/src/main/java/javaStudy/basic/callBack/pratice/Teacher.java b/src/main/java/javaStudy/basic/callBack/pratice/Teacher.java
new file mode 100644
index 0000000..ff102b7
--- /dev/null
+++ b/src/main/java/javaStudy/basic/callBack/pratice/Teacher.java
@@ -0,0 +1,32 @@
+package javaStudy.basic.callBack.pratice;
+
+public class Teacher implements CallBack{
+ private Student student;
+
+ Teacher(Student student) {
+ this.student = student;
+ }
+
+ void askProblem (Student student, Teacher teacher) {
+ //main方法是主线程运行，为了实现异步回调，这里开启一个线程来操作
+ new Thread(new Runnable() {
+ @Override
+ public void run() {
+ student.resolveProblem(teacher);
+ }
+ }).start();
+ //老师让学生做题以后，等待学生回答的这段时间，可以做别的事，比如玩手机.\
+ //而不需要同步等待，这就是回调的好处。
+ //当然你可以说开启一个线程让学生做题就行了，但是这样无法让学生通知老师。
+ //需要另外的机制去实现通知过程。
+ // 当然，多线程中的future和callable也可以实现数据获取的功能。
+ for (int i = 1;i < 4;i ++) {
+ System.out.println("等学生回答问题的时候老师玩了 " + i + "秒的手机");
+ }
+ }
+
+ @Override
+ public void tellAnswer(int res) {
+ System.out.println("the answer is " + res);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/javaStudy/basic/callBack/pratice/Test.java b/src/main/java/javaStudy/basic/callBack/pratice/Test.java
new file mode 100644
index 0000000..b021814
--- /dev/null
+++ b/src/main/java/javaStudy/basic/callBack/pratice/Test.java
@@ -0,0 +1,16 @@
+package javaStudy.basic.callBack.pratice;
+
+public class Test {
+ public static void main(String[] args) {
+ //测试
+ Student tom = new Tom();
+ Teacher lee = new Teacher(tom);
+ lee.askProblem(tom, lee);
+ //结果
+ // 等学生回答问题的时候老师玩了 1秒的手机
+ // 等学生回答问题的时候老师玩了 2秒的手机
+ // 等学生回答问题的时候老师玩了 3秒的手机
+ // work out
+ // the answer is 111
+ }
+}
diff --git a/src/main/java/javaStudy/basic/callBack/pratice/Tom.java b/src/main/java/javaStudy/basic/callBack/pratice/Tom.java
new file mode 100644
index 0000000..d9a264c
--- /dev/null
+++ b/src/main/java/javaStudy/basic/callBack/pratice/Tom.java
@@ -0,0 +1,16 @@
+package javaStudy.basic.callBack.pratice;
+
+public class Tom implements Student {
+
+ @Override
+ public void resolveProblem(Teacher teacher) {
+ try {
+ //学生思考了3秒后得到了答案，通过老师提供的回调方法告诉老师。
+ Thread.sleep(3000);
+ System.out.println("work out");
+ teacher.tellAnswer(111);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/src/main/java/javaStudy/basic/reflect/BasicClass.java b/src/main/java/javaStudy/basic/reflect/BasicClass.java
new file mode 100644
index 0000000..3370d99
--- /dev/null
+++ b/src/main/java/javaStudy/basic/reflect/BasicClass.java
@@ -0,0 +1,79 @@
+package javaStudy.basic.reflect;
+
+import java.lang.reflect.*;
+import java.util.Vector;
+
+/**
+ * @author: li
+ * @description: 反射的基本运用
+ * @date: 2024/12/23 21:56
+ */
+public class BasicClass {
+ public static void main(String[] args) throws Exception {
+ // 获取Class对象的三种方法
+ //1.通过Class.forName(全类名)
+ Class classA = Class.forName("javaStudy.basic.reflect.People");
+ //2.直接获取某一个对象的class
+ Class classB = People.class;
+ Class classInt = Integer.TYPE;
+ //3.调用某个对象的getClass()方法
+ People people = new People();
+ Class classC = people.getClass();
+
+ // 判断是否为某个类的实例 a instanceof b 判断a是否为b的实例
+ People tom = new People();
+ if (tom instanceof People) {
+ System.out.println("tom是一个People对象");
+ } else {
+ System.out.println("tom不是一个People对象");
+ }
+
+ // 通过反射创建实例
+ // 1.使用Class对象的newInstance()方法来创建Class对象对应类的实例 (已过时)
+
+ // 2.使用Class对象获取构造器,再调用构造器对象的newInstance()方法创建实例
+ Constructor constructor = classB.getConstructor();
+ Object o = constructor.newInstance();
+ System.out.println(o);
+ // 输出:People(name=null, age=0)
+
+ // 获取方法
+ // 1.getDeclaredMethods() 获取方法返回类或接口声明的所有方法,包含公共、保护、默认访问和私有方法,但不包含继承的方法
+ Method[] declaredMethods = classA.getDeclaredMethods();
+ // 2.getMethods() 返回某个类的所有公用(public)方法，包括其继承类的公用方法
+ Method[] methods = classA.getMethods();
+ // 3.getMethod(String name) 返回一个指定的方法 第一个参数为方法名称
+ Method method1 = classA.getMethod("setName", String.class);
+
+ /*
+ * getMethods和getDeclaredMethods的区别
+ * getDeclaredMethods是获取该类所有的方法及接口声明的方法
+ * getMethods是获取该类及继承类的所有公共方法
+ */
+
+ // 获取构造器
+ // 获取所有构造器 getConstructors
+ Constructor[] constructors = classA.getConstructors();
+
+ // 获取类的成员变量
+ // getFiled:访问公有的成员变量
+ // getDeclaredField:所有已声明的成员变量(但得不到父类的成员变量)
+ Field[] fields = classA.getDeclaredFields();
+ for (Field field : fields) {
+ // 设置访问权限 private属性即使不使用下面这个语句也可以访问
+ field.setAccessible(true);
+ String fieldString = "";
+ // 获取字段修饰符
+ fieldString += Modifier.toString(field.getModifiers()) + " "; //private
+ // 获取字段类型
+ fieldString += field.getType().getSimpleName() + " ";
+ // 获取字段名
+ fieldString += field.getName();
+ fieldString += ";";
+ System.out.println(fieldString);
+ }
+
+ //调用方法,获取方法之后,使用invoke()调用该方法
+
+ }
+}
diff --git a/src/main/java/javaStudy/basic/reflect/People.java b/src/main/java/javaStudy/basic/reflect/People.java
new file mode 100644
index 0000000..8f126a3
--- /dev/null
+++ b/src/main/java/javaStudy/basic/reflect/People.java
@@ -0,0 +1,23 @@
+package javaStudy.basic.reflect;
+
+import lombok.Data;
+
+/**
+ * @author: licheng
+ * @Description:
+ * @create: 2018-10-24 14:06
+ **/
+@Data
+public class People {
+
+ private String name;
+
+ private int age;
+
+ public People() {
+ }
+
+ private static void eat() {
+ System.out.println("eat");
+ }
+}
diff --git a/src/main/java/javaStudy/collectors/ArrayList,Vector,Stack.txt b/src/main/java/javaStudy/collectors/ArrayList,Vector,Stack.txt
new file mode 100644
index 0000000..1ea2b21
--- /dev/null
+++ b/src/main/java/javaStudy/collectors/ArrayList,Vector,Stack.txt
@@ -0,0 +1,135 @@
+1.ArrayList
+ (1)概述
+ I:实现List接口的动态数组(大小可变),默认初始容量为10,随着ArrayList中元素的增加,容量也会不断自动增长。
+ II:每次添加新的元素时,ArrayList会检查是否需要扩容,所以在知道场景数据的时候,构造时指定一个初始容量会减少资源消耗。
+ III:ArrayList实现不是同步的,若多个线程同时访问一个ArrayList实例,要保持同步,在创建ArrayList时可以通过
+ List list = Collections.synchronizedList(new ArrayList(...));来保持同步
+
+ (2)ArrayList的继承关系
+ public class ArrayList extends AbstractList
+ implements List, RandomAccess, Cloneable, java.io.Serializable
+ ArrayList继承AbstractList抽象父类，实现了List接口（规定了List的操作规范）、RandomAccess（可随机访问）、Cloneable（可拷贝）、Serializable（可序列化）。
+
+ (3)底层数据结构
+ 底层是一个object数组,由transient修饰 transient Object[] elementData;
+ ArrayList底层数组不会参与序列化,而是使用另外的序列化方式.
+ 使用writeObject方式序列化:只复制数组中有值的位置,其他未赋值的位置不进行序列化,可以节省空间
+ // private void writeObject(java.io.ObjectOutputStream s)
+ // throws java.io.IOException{
+ // // Write out element count, and any hidden stuff
+ // int expectedModCount = modCount;
+ // s.defaultWriteObject();
+ //
+ // // Write out size as capacity for behavioural compatibility with clone()
+ // s.writeInt(size);
+ //
+ // // Write out all elements in the proper order.
+ // for (int i=0; i= size) {
+ throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
+ }
+ }
+
+ V:modCount:在一个迭代器初始的时候会赋予它调用这个迭代器对象的modCount,一旦发现该对象的modCount和迭代器中存储的modCount不一样就抛出异常
+ 这被叫做Fail-Fast机制,ArrayList不是线程安全的,所以使用modCount来判断:
+ 判断 modCount 跟 expectedModCount 是否相等，如果不相等就表示已经有其他线程修改了 ArrayList,不相等就抛出异常
+ 建议:遍历非安全的数据结构的时候,最好使用迭代器.
+
+
+ VI:初始容量和扩容方式
+ ArrayList初始容量为10
+ 扩容方法:每次扩容处理是1.5倍,因为一次性扩容太大浪费更多内存,扩容太小,需要多次对数组重新分配内存,所以1.5是比较好的扩容倍数;
+
+ VII:线程安全
+ ArrayList是线程不安全的,在迭代器中,如果多线程操作导致modCount改变,会执行fastFail,抛出异常
+ final void checkForComodification() {
+ if (modCount != expectedModCount) {
+ throw new ConcurrentModificationException();
+ }
+ }
+
+2.Vector
+ (1)概述:Vector可以实现可增长的对象数组,可以使用整数索引进行访问的组件.但是Vector大小是可以增加或者减少的,便于后续的添加或删除操作
+ public class Vector
+ extends AbstractList
+ implements List, RandomAccess, Cloneable, java.io.Serializable
+ 实现List<>,继承AbstractList类:可以将其看做队列,支持相关的添加、删除、修改、遍历等功能
+ 实现RandomAccess接口:提供了随机访问功能,能够直接访问元素
+ 实现了Cloneable接口:支持clone()方法,可以被克隆
+ vector底层数组不加transient,序列化的时候会全部复制
+
+ (2)增删改查:
+ I:查:vector.elementAt(int index)
+ II:改:vector.setElementAt(E obj,int index)
+ III:删:removeElementAt(int index)
+ IV:增:insertElementAt(E obj, int index)
+ addElement(E obj)
+
+ (3)初始容量和扩容:
+ I:扩容方式和ArrayList一样,通过扩容增量来决定扩容的大小(初始容量和扩容大小:capacityIncrement)
+
+ (4)线程安全:
+ vector大部分方法都使用了synchronized修饰符,属于线程安全的集合类
+
+3.Stack
+ (1)概述:最常用的结构,继承了Vector类,是一个后进先出(LIFO)的对象堆栈
+
+ (2)通过5个操作扩展Vector
+ I:empty():测试堆栈是否为空
+ II:peek():查看堆栈顶部的对象,不移除,仅查看
+ III:pop():移除堆栈顶部的对象,并作为返回值返回
+ IV:push(E item):将项压入堆栈顶部
+ V:search(Object o):返回对象在堆栈中的位置,以1为基数
+
+
+
+4.三个集合类的区别
+ (1)ArrayList的优缺点:
+ - 优点:I:底层以数组实现,可以随机访问,实现了RandomAccess接口,get效率高
+ II:ArrayList在顺序添加一个元素的时候非常方便
+ - 缺点:I:删除元素的时候，涉及到元素的复制,如果需要复制的元素很多,消耗性能
+ II:插入元素的时候(非顺序),涉及到元素的复制,如果要复制很多元素,消耗性能
+ - 总结:ArrayList适合顺序添加,随机访问的场景
+
+ (2)ArrayList和Vector的区别
+ - Vector:线程安全;ArrayList:线程非安全
+ - Vector:可以指定增长因子,扩容的时候会根据增长因子来扩容
+
+
+
+
+
+
+
diff --git a/src/main/java/javaStudy/collectors/Queue&LinkedList.txt b/src/main/java/javaStudy/collectors/Queue&LinkedList.txt
new file mode 100644
index 0000000..c09d6e2
--- /dev/null
+++ b/src/main/java/javaStudy/collectors/Queue&LinkedList.txt
@@ -0,0 +1,10 @@
+1.LinkedList
+ (1)概述:LinkedList与ArrayList一样实现List接口,只是ArrayList是List接口的大小可变数组的实现,
+ LinkedList是List接口链表的实现。基于链表实现的方式使得LinkedList在插入和删除时更优于ArrayList，而随机访问则比ArrayList逊色些。
+ 除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。
+ (2)源码分析:
+ I:定义
+ public class LinkedList
+ extends AbstractSequentialList
+ implements List, Deque, Cloneable, java.io.Serializable
+ AbstractSequentialList:提供List接口的骨干实现,最大限度减少
\ No newline at end of file
diff --git a/src/main/java/javaStudy/collectors/note.txt b/src/main/java/javaStudy/collectors/note.txt
new file mode 100644
index 0000000..040db68
--- /dev/null
+++ b/src/main/java/javaStudy/collectors/note.txt
@@ -0,0 +1,18 @@
+1.对于已知得场景,要指定集合的初始容量。(可以减少资源的消耗)
+
+2.asList的缺陷(入参为泛型类型):
+ (1)asList的参数为泛型的变长参数,若入参类型不为泛型,则会出错
+ 例如:int[] ins = {1,2,3,4,5};
+ System.out.println(Arrays.asList(ins).size()) -> 1
+ 原因:因为ins类型为int,无法泛型化,不能作为asList的参数,
+ 但是int类型的数组可以泛型化,可以就相当于入参为一个数组,即结果为1
+
+ (2)asList返回的列表只是披着list的外衣,但是没有list的基本特性(变长),所以在使用asList之后
+ 不要试图去改变asList返回的列表,否则会出现问题
+
+3.subList(用于对List进行分割)的缺陷:
+ subList()分割的其实是原表的一个视图,但是子列表的操作都会反应在原列表上。
+
+4.保持compareTo和equals同步
+ 对于compareTo和equals两个方法我们可以总结为：compareTo是判断元素在排序中的位置是否相等，
+ equals是判断元素是否相等，既然一个决定排序位置，一个决定相等，所以我们非常有必要确保当排序位置相同时，其equals也应该相等。
\ No newline at end of file