1、Object 的to String()方法
Object是所有类的父类，String to String(),返回该对象的字符串表示。
Object中的 to String()方法打印的是对象的地址值
String s = p.to String()，打印s就是直接打印p这个对象。
如果一个类重写了to String方法，就直接打印，如Scanner, Arraylist<>集合
如果没有，而需要打印的是对象属性，此时需要重写to String()方法，在这里面写什么，调用就会打印什么。如Random类，需要重写。
重写直接快捷键Alt+Inset选择to String().
2、Object 的equals方法
equals没有重写的时候与“==”类似，
对于8种基本数据类型比较的是值
其他引用类型比较的地址值。
equals返回的就是一个布尔值，
对于要比较类中的属性时，需要进行重写，一般重写的时候需要进行判断。
可以进行null判断，还有是不是对象类型的判断等（减少不必要的程序）
重写快捷键Alt+Inset选择equals
对于字符串的比较的时候，一般都用equals，
因为它自己重写了equals方法，而且注意null不能调用方法
3、Object 的Date方法
主要用来表示日期和时间的方法，而且以毫秒来计时，一刹那，一瞬间。
计算时通过时间原点来看，
时间原点（0毫秒）：1970年1月1日00：00：00
中国时间要加8小时1970年1月1日08：00：00
主要方法：
1）sout(System.currentTimeMIllis());// 表示从时间原点到此时此刻经历了多少的毫秒
输出结果14135453445346；
2）Date date=new Date(); 导包的时是util包；
Sout(date);
// 空参直接打印获取的是当前的系统时间，
打印输出格式 如：Sun Aug 08 15:35:12 CST 2018

3）Date date=new Date(134235426436L);
Sout(date);
当有参打印的时候，传递参数毫秒数long类型时，是指时间点，即从时间原点过了这么多毫秒之后的时间点。
打印输出格式 如：Sun Aug 08 15:35:12 CST 2018
4）Date date=new Date();
long time=date.getTime();
Sout(time);
// 该方法时把日期转换为毫秒数相当于1）；
输出结果14135453445346；
4、DateFormat类（抽象类）的用法
用它的子类，主要用来把输出的日期格式转换为常用（顺眼）的格式
1）SimpleDateFormat sdf=new SimpleDateFormat (“yyyy年MM月dd日 HH时mm分ss秒”);
Date date=new Date();
String s=sdf.Format(date);
Sout(s);// 输出的就是括号里面的格式，其中字母不可改，其他都可以改动
2）SimpleDateFormat sdf=new SimpleDateFormat (“yyyy年MM月dd日 HH时mm分ss秒”);
Date date=sdf.parse(“2108年02月03日 12时23分22秒”);(自动修改)
Sout(date);// 输出的就是原来格式的日期
5、Calender类的用法
主要用来日历输出，是抽象类不能直接new，可以静态格式直接建立对象
Calendar c=Calendar.getTime();
1）直接获取指定的日历字段值
  例如 Int a=c.get(Calendar.YEAR);// 获取年份
2）给日历段设定值
c.set(Calendar.YEAR,2017);
3)add把指定字段增加或减少多少
c.add(Calendar.YEAR,-2);// 减少年份2.
4）返回一个此日历的值，转为日期
Date date=c.getTime();//返回的就是日期值。
6、System类的用法
1）System.currentTimeMills();// 这返回的就是一个到现在的毫秒值，可以用long接收
2）System.arraycopy(数组1名称,起始索引值,数组2名称,粘贴索引值,复制长度);
7、StringBuilder的用法
1）StringBuilder bu1=new StringBuilder();
bu1.append(数据类型（可以是String也可以是int）);可以连续.append()
增加字符串
2）StringBuilder与String的相互转换
String s=bu1.toString();//  builder转为String,
StringBuilder bu=new StringBuilder(Str);// String转为builder
8、装箱与拆箱
8种数据类型的转换，特殊的Integer,Character,其他的都是首字母大写就可以
在Integer参与运算，比较的时候，会自动拆箱为int类型
通常下-128到127之间的int值的地址值一样的，超过之后就改变了。
1、集合分为2大类，分别是单列集合java.util.Collection和双列集合java.util.Map，
Collection定义的是所有单列集合中共性的方法，（不包含带索引的方法）是单列集合的根接口，其下有2个接口，List接口和Set接口。
LIst接口下面主要有3个实现子类，Vetor集合，Arraylist集合，Linkedlist集合。
Set接口下面主要有2个子类，一个是HashSet集合（无序的集合）和LinkedHashSet集合（有序的集合）。
List接口特点：1）有序的集合（存储与取出元素的顺序是一致的）
2）允许存储重复的元素
3）有索引，包含一些带索引的方法
Set接口特点：1）不允许存储重复的元素
2）没有索引不包含带索引的方法
2、Collection有几个共性的常用方法：
Collection<String> c = new Collection<>();
1）添加元素的方法，c.add(“soul”);// 返回布尔值
2）把给定对象在当前集合中删除，c.remove(“soul”);// Collection不可以索引，返回布尔值
3）判断集合是否存在某元素，c.contains(“soul”);// 返回布尔值
4）判断集合是否为空，c.isEmpty();// 返回布尔值
5）获取集合元素个数，c.size();// 返回的是int类型
6）把集合转换为数组，Object[] arr = c.toArray();// 返回的是Object[]数组
7）清空集合，c.clear();// 没有返回值，结果[]；
3、Iterator 迭代器接口的用法
主要是用来遍历集合，通常用while循环
2个常用方法：
首先要Iterator<String> it = c.iterator();建立迭代器对象
1）It.hasNext()；判断是否索引达到集合的末尾，否返回true，是返回false。
2）It.next();取出元素，返回的是一个元素。
格式
Iterator<String> it = c.iterator();
While(it.hasNaxt()){ // 判断后面还有没有元素，没有就停止循环
String s = it.next(); // 取出指针位置的元素，并且让指针向下移一位
Sout(s);// 打印输出元素
}
这就是用迭代器遍历一个集合的元素。
/*  取出元素并不影响集合长度，不相当于remove
     用Collection建立对象的时候，不可在迭代器创建对象后，改变集合长度，否则报“迭代器并发修改异常”，例如增加add，移除remove一个元素。
     删除最后一个（或倒数第二个）不报异常，因为循环会结束,hasNext会返回false。
     主要是创建迭代器（new）的时候，会复制一份集合的修改值，
     修改值默认0，改变一次长度就+1
每一次执行next（）都会将他和集合的修改值对比一下，如果不一样就会抛出异常 */

如果是用List接口的话，可以进行长度变化，因为内部重新校对了修改值，不会报错

3）增强for循环遍历数组或者集合格式（底层就是迭代器）
for(String s : c){
Sout(s);
}
4、泛型的用法
定义是<E e>表示一种未知的数据类型，当不知道使用什么数据类型的时候可以用泛型，可以看成一个变量来接收数据类型。
创建集合对象的时候，就会确定泛型的数据类型。可以是任意类型。
集合不使用泛型，默认为Object类型，不安全，会引发异常，杂乱。
5、自己定义一个泛型的类,也可以是方法，是接口
public class 类名<E>{
Private E name;
Public E getname(){
Return name;
}
Public <E> void setname(E name){
This.name=name;
}
}
用了泛型，类中所有数据类型都会变为与泛型一致。
6、泛型的通配符？
不能在创建对象的时候使用，只能作为方法的参数使用。
Public static void Array(ArrayList<?> list){
// 遍历集合的时候iterator<?> it=list.iterator();也是？；
}
泛型没有继承概念
泛型的受限用法：
上限限定：? extends E ，代表使用的泛型只能是E类型的子类/本身
下限限定：? super E ，代表使用的泛型只能是E类型的父类/本身
Public static void 方法名(Collection<? extends E> coll){}
调用时传入数据只能依照上面的限定传递。
1、数据结构类型；
1）栈，出入口都是顶端，先进的元素后出，
2）队列，先进先出，
3）数组：查询快，有索引，所以查的快，地址是连续的，
增删慢，长度不变，add/remove，都会重新创建新数组，把地址赋值给对象
4）链表：查询慢，地址不是连续的，每次查询要从头开始
增删快，add/remove一个元素，对链表的整体结构无影响，所以快
单项链表，无序的，添加随便添，只能从开头开始查
双向链表，有序的，查询效率比单项快，可以从末尾开始查，
5）红黑树，趋近于平衡树，查询非常快，查询叶子节点最大次数和最小次数不能超过        2倍。
节点可以是红色/黑色；
根节点是黑色的；
叶子节点是黑色的；
每个红色的节点的子节点都是黑色的；
任何一个节点到其每一个叶子的所有路径上黑色节点数相同
二叉树，分支不能超过2个。二叉树的元素有大小顺序，左小右大，查询速度非常快。
平衡树，左右孩子相等
2、List集合的常用特有方法
List<E> list= new ArrayList<>();// 以List为父类
1）List.add(index,E e);把元素插入到指定索引位置处，后面的元素自动后移一位
2）List.remove(index);移除该索引位置的元素，返回的是元素
3）List.get(index);返回的是元素，获取索引位置的元素
4）List.set(index,E e);返回的是元素，用一个新元素来代替索引位置的元素
3、LinkedList集合的特点
1）底层是一个链表结构（双向，有序），保存了上一个元素的地址，查询慢，增删快
2）里面包含了大量操作首位元素的方法，
3）使用LinkedList特有的方法的时候，不能使用多态
常用方法（常用于增删改）
LinkedList<E> linked = new LinkedList<>();
1）Linked.addFirst(E e);// 在列表首位插入一个指定元素，等效于Linked.Push(E e);
2）Linked.addLast(E e);// 在列表末尾插入一个指定元素，等效于add方法
3）Linked.getFirst();// 获取首位元素
4）Linked.getLast();// 获取末尾元素，没有元素的时候会报错，可以用isEmpty判断
5）Linked.removeFirst();// 移除第一个元素，返回的是第一个元素，同Linked.pop();
6）Linked.removeLast();// 移除末尾的元素，并返回这个元素，
4、Vector集合无用，被ArrayList取代了，单线程的，

5、HashSet集合特点
1）无序集合，存储与取出元素的顺序可能不一致，不能存储重复元素（会自己去重复）。
2）不能用普通for循环遍历，可以用迭代器，增强for。不能用带索引的方法
3）底层是一个哈希表（查询速度非常快）数组+链表，数组+红黑树
“String”.hashCode();获取元素的哈希值。
如果其他元素哈希值相同，则再次使用equals方法判断内容是否相同，不同则添加
HashSet存储自定义类型元素
必须要重写hashCode()和equals()方法（Alt+enter），例如，存储对象（person）的时候
6、LinkedHashset集合
底层是哈希表，多了一条链表记录存储顺序，保证元素有序，但是不允许重复
7、可变参数
使用前提：当方法的参数列表的数据类型已确定，但是参数个数不确定时，就可以使用
格式：
修饰符 返回值类型 方法名（数据类型...变量名）{}
原理：底层是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储参数
传递的参数个数可以时0（不传递），1，2...多个
注意：一个方法的参数列表，只能有一个可变参数；
如果方法的参数有多个，那么可变参数必须写在参数列表的末尾
可变参数的终极写法，public static void method (Object...a){}
8、Collections集合工具类常用方法
ArrayList<String> list=new ArrayList<>();
1）Collections.addAll(list,”s”,”w”,”e”,...);// 多个元素添加，将元素添加到集合list中
2）Collections.shuffle(list);// 将集合list里的元素顺序打乱。
3）Collections.sort(list);// 将集合list的元素按系统安排的（升序）顺序排好，
4）Collections.sout(list);// 当集合中的元素是对象时（person），要对对象的属性排序时，        那么需要在person中先实现接口Comparable再对compareTo()方法重写，
格式1
Public int compareTo(person o){
Return this.getAge()-o.getAge(); // 按年龄升序排列，反转就是降序
}
可以直接在main方法中直接输出时调用sort()方法，在传递参数的时候直接new
格式2
Collections.sort(list,new Comparator<person>(){ // 匿名内部类
@Override
Public int compare(person o1, person o2){// 自动生成2个参数
Int num= o1.getAge()-o2.getAge();// 看年龄的大小，
If(num=0){ //年龄相等的时候启动，以名字首字母大小排序
num=01.getName().charAt(0)-02.getName().charAt(0);
}
Return num;// 升序排列
}
});
1、Map集合是一个双列集合，一个元素包含2个值（类型可同可不同）
Key是不能重复的，value可以重复，
key-value一一对应。
2、HashMap集合
(1)底层是哈希表，查询很快，数组+单项链表/红黑树
(2)无序的集合，存储与取出顺序可能不一致
3、LinkedHashMap集合
(1)底层是哈希表+链表
(2)有序的

4、Map的常用方法

Map<String,Integer> map=new HashMap<>();

(1)Integer num=map.put(k,v);// 将指定键和值添加到map集合中，返回的是v，
如果k在集合中不存在，则返回null，若存在则把v替换之前存在的v0，并返回v0
(2)Integer num=map.remove(k);// 移除k所在的元素，返回的是移除的v
如果k不存在返回null，如果k存在，则返回对应的v
(3)Integer num=map.get(k);// 获取k对应的值
如果k不存在，返回null，如果k存在，则返回k对应的v
(4)Boolean b=map.containsKey(k);// 查看集合中是否含有键k，有返回true，无返回false
(5)Set<String> keys=map.keySet();// 获取集合中的key，并且放到Set集合中去，主要用来遍历（键找值的方法）
for(String s : keys){
Sout( s+map.get(s) );// 遍历map集合
}
(6)Set<Map.Entry<String ,Integer>> entries = map.entrySet(); // 键值对存储

for(Entry entry: entries){
Sout(entry.getKey()+entry.getValue());
} // 用entrySet方法（更加面向对象）直接打印键值对来遍历map
5、Map集合为保证key的唯一，在添加key元素的时候，都会重写equals()方法和hashCode()方法（Alt+Insert）

6、Hashtable集合
底层就是一个哈希表，线程安全的集合，但是是单线程的，速度慢
Hastable集合不能存储null值/键。
而HashMap集合可以存null,如map.put(null,”are”);多线程的，不安全的，速度快。
其子类properties集合是一个唯一和IO流相结合的集合。
1、错误：处理不了只能修改源代码
2、异常：编译期异常；运行期异常RunTimeException；
处理：1）往上抛，抛给虚拟机，JVM处理（中断程序，后续代码不执行）
2）try{}catch{}处理异常，处理后，程序继续执行。      
3、异常过程解析
(1)运行期异常，先看调用方法处有无处理异常的逻辑-->若无，JVM把异常抛给main方法，看main方法有无处理异常的逻辑-->若无，则抛给JVM处理。
(2)编译期异常，可以直接抛，处理。
4、throw抛出异常
(1)在指定方法中抛出指定的异常
(2)格式：throw new xxxException(“异常产生的原因”);
(3)Throw关键子必须写在方法的内部
(4)关键字后面的new对象必须是Exception或其子类对象
(5)Throw关键字抛出的指定异常对象，我们就必须处理它，
(6)如果是runtimeexception或其子类对象我们可以不处理，默认交给JVM处理
(7)如果是编译异常（写代码的时候）,我们必须处理这个异常，用throw/try...catch
5、Objcets非空判断，格式Objects.requireNonNull(obj,message:...);（了解）
源代码：
Public static <T> T requireNonNull(T obj){
If(obj==null){
Throw new NullPointerException();
}
Return obj;
}
6、Try{可能产生异常的代码...}catch(定义一个异常变量，接收try中抛出的异常){异常处理逻辑...}异常捕获，自己处理异常，catch(){}可以跟有多个
(1)可以抛出多个异常对象
(2)如果try产生了异常，就会执行catch中的异常处理逻辑，执行完毕，继续执行后续代码，如果try没有产生异常，执行完try中的方法，就执行后续，catch跳过
7、finally{}代码块
格式是添加到catch(){}后面的，必须和try一起，不能单独写
程序里面的代码一定会执行，就算是有异常或者return。
一般用于资源回放/释放
8、多个异常的处理，可以一个try多个catch，但是catch里面的异常变量，如果已有子父类关系，子类的异常变量必须写在上一个catch，否则报错         
9、自定义异常的定义，格式：
Public class xxxExcepition extends Exception / RunTimeException{
// 添加一个空参数的构造方法
Public 参数名{}
// 添加一个带异常信息的构造方法
Public 参数名(String message){
Super(message);// 父类的方法
}
}         
10、并发、指2个或以上的程序交替执行（高速切换）（同时间段）
11、并行、指2个或以上的程序同时进行（同时刻）     
12、进程、应用程序都进入到内存中执行，临时储存RAM，
(1)内存空间不稳定，断电就没有了，但是运行很快
(2)硬盘存的都是二进制的数据（灯亮就是1，灯熄就是0，高速运转），永久存储，   ，运行慢，需要把数据加载到内存中形成进程运行
13、线程、进程中的执行单元，负责执行程序   
14、Thread多线程类的创建的第一种方式
(1)格式：                     
Public class Xiancz exends Thread(){
// 重写run()方法，在里面写代码
}
在main方法中开辟新线程，
New Xiancz;
Xc.start(); // 开辟新线程执行run方法
// 方法体
Tread.sleep(num毫秒);暂停num毫秒  
1、String S =get.name()；直接获取当前线程的名称，子线程里面才能用
Thread.currentTread();获取当前正在执行的线程，后面接.getNmae();获取名称
2、1）方法1  Xc.setName(“wew”);给线程（改变）设置一个名称
2）方法2  
Pulic Thread (String name){
Super(name);
}// 以有参构造来设置
run()[
Sout(Thread.currentThread().getNmae());// 获取线程名称
}
3、Thread.sleep(long 毫秒数);静态方法直接调用，暂停该（方法）线程多少毫秒
4、创建线程的第二种方式，避免了单继承的局限性，增强了扩展性，格式：
Public class (实现类名称)sximpl implements Runnable{
// 重写run(){设置线程任务}方法
}
Public class xxx{
Psvm(){
// 创建实现类对象
// Tread t=new Thread(实现类对象);
// t.start();
}}
5、用匿名内部类创建// 多态写法
new Thread(new Runnable(){
//重写 run()方法
}).start();// 直接链式编程执行新线程
6、处理线程安全的方法
都是把可能会产生安全问题的代码放进去
(1)同步代码块 ,在成员变量处，定义Object obj=new Object();
synchronized(obj){// 有安全隐患，需要一个一个执行的代码，}
(2)同步方法（含静态）Public (static) synchronized void method(){}
(3)Lock锁
①实现类中成员变量位置，new对象，Lock l =new ReentrantLock();
②在可能有安全代码前调用 l.lock();
③在结束之后调用 l.unlock();可以使用finally来帮助释放，避免异常影响

为保证等待与唤醒一致，需要先锁对象Object obj=new Object();
7、obj.wait();// 等待，知道被唤醒，(long 毫秒数)，到点自己醒了
8、Obj.notify();// 随机唤醒一个子线程；obj.notifyAll();//唤醒所有子线程  

1、Object 的to String()方法
Object是所有类的父类，String to String(),返回该对象的字符串表示。
Object中的 to String()方法打印的是对象的地址值
String s = p.to String()，打印s就是直接打印p这个对象。
如果一个类重写了to String方法，就直接打印，如Scanner, Arraylist<>集合
如果没有，而需要打印的是对象属性，此时需要重写to String()方法，在这里面写什么，调用就会打印什么。如Random类，需要重写。
重写直接快捷键Alt+Inset选择to String().
2、Object 的equals方法
equals没有重写的时候与“==”类似，
对于8种基本数据类型比较的是值
其他引用类型比较的地址值。
equals返回的就是一个布尔值，
对于要比较类中的属性时，需要进行重写，一般重写的时候需要进行判断。
可以进行null判断，还有是不是对象类型的判断等（减少不必要的程序）
重写快捷键Alt+Inset选择equals
对于字符串的比较的时候，一般都用equals，
因为它自己重写了equals方法，而且注意null不能调用方法
3、Object 的Date方法
主要用来表示日期和时间的方法，而且以毫秒来计时，一刹那，一瞬间。
计算时通过时间原点来看，
时间原点（0毫秒）：1970年1月1日00：00：00
中国时间要加8小时1970年1月1日08：00：00
主要方法：
1）sout(System.currentTimeMIllis());// 表示从时间原点到此时此刻经历了多少的毫秒
输出结果14135453445346；
2）Date date=new Date(); 导包的时是util包；
Sout(date);
// 空参直接打印获取的是当前的系统时间，
打印输出格式 如：Sun Aug 08 15:35:12 CST 2018

3）Date date=new Date(134235426436L);
Sout(date);
当有参打印的时候，传递参数毫秒数long类型时，是指时间点，即从时间原点过了这么多毫秒之后的时间点。
打印输出格式 如：Sun Aug 08 15:35:12 CST 2018
4）Date date=new Date();
long time=date.getTime();
Sout(time);
// 该方法时把日期转换为毫秒数相当于1）；
输出结果14135453445346；
4、DateFormat类（抽象类）的用法
用它的子类，主要用来把输出的日期格式转换为常用（顺眼）的格式
1）SimpleDateFormat sdf=new SimpleDateFormat (“yyyy年MM月dd日 HH时mm分ss秒”);
Date date=new Date();
String s=sdf.Format(date);
Sout(s);// 输出的就是括号里面的格式，其中字母不可改，其他都可以改动
2）SimpleDateFormat sdf=new SimpleDateFormat (“yyyy年MM月dd日 HH时mm分ss秒”);
Date date=sdf.parse(“2108年02月03日 12时23分22秒”);(自动修改)
Sout(date);// 输出的就是原来格式的日期
5、Calender类的用法
主要用来日历输出，是抽象类不能直接new，可以静态格式直接建立对象
Calendar c=Calendar.getTime();
1）直接获取指定的日历字段值
  例如 Int a=c.get(Calendar.YEAR);// 获取年份
2）给日历段设定值
c.set(Calendar.YEAR,2017);
3)add把指定字段增加或减少多少
c.add(Calendar.YEAR,-2);// 减少年份2.
4）返回一个此日历的值，转为日期
Date date=c.getTime();//返回的就是日期值。
6、System类的用法
1）System.currentTimeMills();// 这返回的就是一个到现在的毫秒值，可以用long接收
2）System.arraycopy(数组1名称,起始索引值,数组2名称,粘贴索引值,复制长度);
7、StringBuilder的用法
1）StringBuilder bu1=new StringBuilder();
bu1.append(数据类型（可以是String也可以是int）);可以连续.append()
增加字符串
2）StringBuilder与String的相互转换
String s=bu1.toString();//  builder转为String,
StringBuilder bu=new StringBuilder(Str);// String转为builder
8、装箱与拆箱
8种数据类型的转换，特殊的Integer,Character,其他的都是首字母大写就可以
在Integer参与运算，比较的时候，会自动拆箱为int类型
通常下-128到127之间的int值的地址值一样的，超过之后就改变了。
1、集合分为2大类，分别是单列集合java.util.Collection和双列集合java.util.Map，
Collection定义的是所有单列集合中共性的方法，（不包含带索引的方法）是单列集合的根接口，其下有2个接口，List接口和Set接口。
LIst接口下面主要有3个实现子类，Vetor集合，Arraylist集合，Linkedlist集合。
Set接口下面主要有2个子类，一个是HashSet集合（无序的集合）和LinkedHashSet集合（有序的集合）。
List接口特点：1）有序的集合（存储与取出元素的顺序是一致的）
2）允许存储重复的元素
3）有索引，包含一些带索引的方法
Set接口特点：1）不允许存储重复的元素
2）没有索引不包含带索引的方法
2、Collection有几个共性的常用方法：
Collection<String> c = new Collection<>();
1）添加元素的方法，c.add(“soul”);// 返回布尔值
2）把给定对象在当前集合中删除，c.remove(“soul”);// Collection不可以索引，返回布尔值
3）判断集合是否存在某元素，c.contains(“soul”);// 返回布尔值
4）判断集合是否为空，c.isEmpty();// 返回布尔值
5）获取集合元素个数，c.size();// 返回的是int类型
6）把集合转换为数组，Object[] arr = c.toArray();// 返回的是Object[]数组
7）清空集合，c.clear();// 没有返回值，结果[]；
3、Iterator 迭代器接口的用法
主要是用来遍历集合，通常用while循环
2个常用方法：
首先要Iterator<String> it = c.iterator();建立迭代器对象
1）It.hasNext()；判断是否索引达到集合的末尾，否返回true，是返回false。
2）It.next();取出元素，返回的是一个元素。
格式
Iterator<String> it = c.iterator();
While(it.hasNaxt()){ // 判断后面还有没有元素，没有就停止循环
String s = it.next(); // 取出指针位置的元素，并且让指针向下移一位
Sout(s);// 打印输出元素
}
这就是用迭代器遍历一个集合的元素。
/*  取出元素并不影响集合长度，不相当于remove
     用Collection建立对象的时候，不可在迭代器创建对象后，改变集合长度，否则报“迭代器并发修改异常”，例如增加add，移除remove一个元素。
     删除最后一个（或倒数第二个）不报异常，因为循环会结束,hasNext会返回false。
     主要是创建迭代器（new）的时候，会复制一份集合的修改值，
     修改值默认0，改变一次长度就+1
每一次执行next（）都会将他和集合的修改值对比一下，如果不一样就会抛出异常 */

如果是用List接口的话，可以进行长度变化，因为内部重新校对了修改值，不会报错

3）增强for循环遍历数组或者集合格式（底层就是迭代器）
for(String s : c){
Sout(s);
}
4、泛型的用法
定义是<E e>表示一种未知的数据类型，当不知道使用什么数据类型的时候可以用泛型，可以看成一个变量来接收数据类型。
创建集合对象的时候，就会确定泛型的数据类型。可以是任意类型。
集合不使用泛型，默认为Object类型，不安全，会引发异常，杂乱。
5、自己定义一个泛型的类,也可以是方法，是接口
public class 类名<E>{
Private E name;
Public E getname(){
Return name;
}
Public <E> void setname(E name){
This.name=name;
}
}
用了泛型，类中所有数据类型都会变为与泛型一致。
6、泛型的通配符？
不能在创建对象的时候使用，只能作为方法的参数使用。
Public static void Array(ArrayList<?> list){
// 遍历集合的时候iterator<?> it=list.iterator();也是？；
}
泛型没有继承概念
泛型的受限用法：
上限限定：? extends E ，代表使用的泛型只能是E类型的子类/本身
下限限定：? super E ，代表使用的泛型只能是E类型的父类/本身
Public static void 方法名(Collection<? extends E> coll){}
调用时传入数据只能依照上面的限定传递。
1、数据结构类型；
1）栈，出入口都是顶端，先进的元素后出，
2）队列，先进先出，
3）数组：查询快，有索引，所以查的快，地址是连续的，
增删慢，长度不变，add/remove，都会重新创建新数组，把地址赋值给对象
4）链表：查询慢，地址不是连续的，每次查询要从头开始
增删快，add/remove一个元素，对链表的整体结构无影响，所以快
单项链表，无序的，添加随便添，只能从开头开始查
双向链表，有序的，查询效率比单项快，可以从末尾开始查，
5）红黑树，趋近于平衡树，查询非常快，查询叶子节点最大次数和最小次数不能超过        2倍。
节点可以是红色/黑色；
根节点是黑色的；
叶子节点是黑色的；
每个红色的节点的子节点都是黑色的；
任何一个节点到其每一个叶子的所有路径上黑色节点数相同
二叉树，分支不能超过2个。二叉树的元素有大小顺序，左小右大，查询速度非常快。
平衡树，左右孩子相等
2、List集合的常用特有方法
List<E> list= new ArrayList<>();// 以List为父类
1）List.add(index,E e);把元素插入到指定索引位置处，后面的元素自动后移一位
2）List.remove(index);移除该索引位置的元素，返回的是元素
3）List.get(index);返回的是元素，获取索引位置的元素
4）List.set(index,E e);返回的是元素，用一个新元素来代替索引位置的元素
3、LinkedList集合的特点
1）底层是一个链表结构（双向，有序），保存了上一个元素的地址，查询慢，增删快
2）里面包含了大量操作首位元素的方法，
3）使用LinkedList特有的方法的时候，不能使用多态
常用方法（常用于增删改）
LinkedList<E> linked = new LinkedList<>();
1）Linked.addFirst(E e);// 在列表首位插入一个指定元素，等效于Linked.Push(E e);
2）Linked.addLast(E e);// 在列表末尾插入一个指定元素，等效于add方法
3）Linked.getFirst();// 获取首位元素
4）Linked.getLast();// 获取末尾元素，没有元素的时候会报错，可以用isEmpty判断
5）Linked.removeFirst();// 移除第一个元素，返回的是第一个元素，同Linked.pop();
6）Linked.removeLast();// 移除末尾的元素，并返回这个元素，
4、Vector集合无用，被ArrayList取代了，单线程的，

5、HashSet集合特点
1）无序集合，存储与取出元素的顺序可能不一致，不能存储重复元素（会自己去重复）。
2）不能用普通for循环遍历，可以用迭代器，增强for。不能用带索引的方法
3）底层是一个哈希表（查询速度非常快）数组+链表，数组+红黑树
“String”.hashCode();获取元素的哈希值。
如果其他元素哈希值相同，则再次使用equals方法判断内容是否相同，不同则添加
HashSet存储自定义类型元素
必须要重写hashCode()和equals()方法（Alt+enter），例如，存储对象（person）的时候
6、LinkedHashset集合
底层是哈希表，多了一条链表记录存储顺序，保证元素有序，但是不允许重复
7、可变参数
使用前提：当方法的参数列表的数据类型已确定，但是参数个数不确定时，就可以使用
格式：
修饰符 返回值类型 方法名（数据类型...变量名）{}
原理：底层是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储参数
传递的参数个数可以时0（不传递），1，2...多个
注意：一个方法的参数列表，只能有一个可变参数；
如果方法的参数有多个，那么可变参数必须写在参数列表的末尾
可变参数的终极写法，public static void method (Object...a){}
8、Collections集合工具类常用方法
ArrayList<String> list=new ArrayList<>();
1）Collections.addAll(list,”s”,”w”,”e”,...);// 多个元素添加，将元素添加到集合list中
2）Collections.shuffle(list);// 将集合list里的元素顺序打乱。
3）Collections.sort(list);// 将集合list的元素按系统安排的（升序）顺序排好，
4）Collections.sout(list);// 当集合中的元素是对象时（person），要对对象的属性排序时，        那么需要在person中先实现接口Comparable再对compareTo()方法重写，
格式1
Public int compareTo(person o){
Return this.getAge()-o.getAge(); // 按年龄升序排列，反转就是降序
}
可以直接在main方法中直接输出时调用sort()方法，在传递参数的时候直接new
格式2
Collections.sort(list,new Comparator<person>(){ // 匿名内部类
@Override
Public int compare(person o1, person o2){// 自动生成2个参数
Int num= o1.getAge()-o2.getAge();// 看年龄的大小，
If(num=0){ //年龄相等的时候启动，以名字首字母大小排序
num=01.getName().charAt(0)-02.getName().charAt(0);
}
Return num;// 升序排列
}
});
1、Map集合是一个双列集合，一个元素包含2个值（类型可同可不同）
Key是不能重复的，value可以重复，
key-value一一对应。
2、HashMap集合
(1)底层是哈希表，查询很快，数组+单项链表/红黑树
(2)无序的集合，存储与取出顺序可能不一致
3、LinkedHashMap集合
(1)底层是哈希表+链表
(2)有序的

4、Map的常用方法

Map<String,Integer> map=new HashMap<>();

(1)Integer num=map.put(k,v);// 将指定键和值添加到map集合中，返回的是v，
如果k在集合中不存在，则返回null，若存在则把v替换之前存在的v0，并返回v0
(2)Integer num=map.remove(k);// 移除k所在的元素，返回的是移除的v
如果k不存在返回null，如果k存在，则返回对应的v
(3)Integer num=map.get(k);// 获取k对应的值
如果k不存在，返回null，如果k存在，则返回k对应的v
(4)Boolean b=map.containsKey(k);// 查看集合中是否含有键k，有返回true，无返回false
(5)Set<String> keys=map.keySet();// 获取集合中的key，并且放到Set集合中去，主要用来遍历（键找值的方法）
for(String s : keys){
Sout( s+map.get(s) );// 遍历map集合
}
(6)Set<Map.Entry<String ,Integer>> entries = map.entrySet(); // 键值对存储

for(Entry entry: entries){
Sout(entry.getKey()+entry.getValue());
} // 用entrySet方法（更加面向对象）直接打印键值对来遍历map
5、Map集合为保证key的唯一，在添加key元素的时候，都会重写equals()方法和hashCode()方法（Alt+Insert）

6、Hashtable集合
底层就是一个哈希表，线程安全的集合，但是是单线程的，速度慢
Hastable集合不能存储null值/键。
而HashMap集合可以存null,如map.put(null,”are”);多线程的，不安全的，速度快。
其子类properties集合是一个唯一和IO流相结合的集合。
1、错误：处理不了只能修改源代码
2、异常：编译期异常；运行期异常RunTimeException；
处理：1）往上抛，抛给虚拟机，JVM处理（中断程序，后续代码不执行）
2）try{}catch{}处理异常，处理后，程序继续执行。      
3、异常过程解析
(1)运行期异常，先看调用方法处有无处理异常的逻辑-->若无，JVM把异常抛给main方法，看main方法有无处理异常的逻辑-->若无，则抛给JVM处理。
(2)编译期异常，可以直接抛，处理。
4、throw抛出异常
(1)在指定方法中抛出指定的异常
(2)格式：throw new xxxException(“异常产生的原因”);
(3)Throw关键子必须写在方法的内部
(4)关键字后面的new对象必须是Exception或其子类对象
(5)Throw关键字抛出的指定异常对象，我们就必须处理它，
(6)如果是runtimeexception或其子类对象我们可以不处理，默认交给JVM处理
(7)如果是编译异常（写代码的时候）,我们必须处理这个异常，用throw/try...catch
5、Objcets非空判断，格式Objects.requireNonNull(obj,message:...);（了解）
源代码：
Public static <T> T requireNonNull(T obj){
If(obj==null){
Throw new NullPointerException();
}
Return obj;
}
6、Try{可能产生异常的代码...}catch(定义一个异常变量，接收try中抛出的异常){异常处理逻辑...}异常捕获，自己处理异常，catch(){}可以跟有多个
(1)可以抛出多个异常对象
(2)如果try产生了异常，就会执行catch中的异常处理逻辑，执行完毕，继续执行后续代码，如果try没有产生异常，执行完try中的方法，就执行后续，catch跳过
7、finally{}代码块
格式是添加到catch(){}后面的，必须和try一起，不能单独写
程序里面的代码一定会执行，就算是有异常或者return。
一般用于资源回放/释放
8、多个异常的处理，可以一个try多个catch，但是catch里面的异常变量，如果已有子父类关系，子类的异常变量必须写在上一个catch，否则报错         
9、自定义异常的定义，格式：
Public class xxxExcepition extends Exception / RunTimeException{
// 添加一个空参数的构造方法
Public 参数名{}
// 添加一个带异常信息的构造方法
Public 参数名(String message){
Super(message);// 父类的方法
}
}         
10、并发、指2个或以上的程序交替执行（高速切换）（同时间段）
11、并行、指2个或以上的程序同时进行（同时刻）     
12、进程、应用程序都进入到内存中执行，临时储存RAM，
(1)内存空间不稳定，断电就没有了，但是运行很快
(2)硬盘存的都是二进制的数据（灯亮就是1，灯熄就是0，高速运转），永久存储，   ，运行慢，需要把数据加载到内存中形成进程运行
13、线程、进程中的执行单元，负责执行程序   
14、Thread多线程类的创建的第一种方式
(1)格式：                     
Public class Xiancz exends Thread(){
// 重写run()方法，在里面写代码
}
在main方法中开辟新线程，
New Xiancz;
Xc.start(); // 开辟新线程执行run方法
// 方法体
Tread.sleep(num毫秒);暂停num毫秒  
1、String S =get.name()；直接获取当前线程的名称，子线程里面才能用
Thread.currentTread();获取当前正在执行的线程，后面接.getNmae();获取名称
2、1）方法1  Xc.setName(“wew”);给线程（改变）设置一个名称
2）方法2  
Pulic Thread (String name){
Super(name);
}// 以有参构造来设置
run()[
Sout(Thread.currentThread().getNmae());// 获取线程名称
}
3、Thread.sleep(long 毫秒数);静态方法直接调用，暂停该（方法）线程多少毫秒
4、创建线程的第二种方式，避免了单继承的局限性，增强了扩展性，格式：
Public class (实现类名称)sximpl implements Runnable{
// 重写run(){设置线程任务}方法
}
Public class xxx{
Psvm(){
// 创建实现类对象
// Tread t=new Thread(实现类对象);
// t.start();
}}
5、用匿名内部类创建// 多态写法
new Thread(new Runnable(){
//重写 run()方法
}).start();// 直接链式编程执行新线程
6、处理线程安全的方法
都是把可能会产生安全问题的代码放进去
(1)同步代码块 ,在成员变量处，定义Object obj=new Object();
synchronized(obj){// 有安全隐患，需要一个一个执行的代码，}
(2)同步方法（含静态）Public (static) synchronized void method(){}
(3)Lock锁
①实现类中成员变量位置，new对象，Lock l =new ReentrantLock();
②在可能有安全代码前调用 l.lock();
③在结束之后调用 l.unlock();可以使用finally来帮助释放，避免异常影响

为保证等待与唤醒一致，需要先锁对象Object obj=new Object();
7、obj.wait();// 等待，知道被唤醒，(long 毫秒数)，到点自己醒了
8、Obj.notify();// 随机唤醒一个子线程；obj.notifyAll();//唤醒所有子线程