day03


数据结构
数据的存储方式
不同的数据结构代表了不同的存储方式
不同的数据结构中, 会有不同的存入, 取出, 查找的方式和效率, 数据的存放方式也不同

栈
先进后出 (FILO, First In Last Out)
入口和出口在同一侧

入栈(压栈): 将元素存入栈
出栈(弹栈): 从栈中取出元素

栈的适用场景:
        栈内存
        反转内容

队列
先进先出 (FIFO, First In First Out)
入口和出口在两端
   
队列的适用场景:
        秒杀, 抢购
        在线售票
        处理高并发场景

数组
查询快: 通过 (第一个元素地址值 + 索引) 可以快速计算出该索引元素的地址值
增删慢: 增加一个元素, 要创建长度+1的新数组, 然后将原数组元素复制到新数组, 然后存入新元素; 删除类似

数组的适用场景:
  查询多, 增删少的数据存储场景

链表
由多个 节点(Node / Entry) 组成
单向链表: 每个节点存储 数据 和 下一个节点的地址值
双向链表: 每个节点存储 数据, 上一个节点地址值 和 下一个节点地址值

链表的特点:
  查询慢: 要找到其中某个节点, 只能从第一个节点一个一个向后寻找
  增删快: 只需要修改保存的下一个节点的地址值, 就可以快速完成增删

链表的适用场景:
  查询少, 增删多的场景
  链表可以实现栈和队列的结构, 因为栈和队列增删频繁

红黑树
特点:
        元素存储过程中就完成了大小排序
        查询比链表快, 增删比数组快 (数组和链表的折中)


List集合

List集合体系的特点:
1. 元素存取有序 (存入和取出元素的顺序一致)
2. 元素可以重复
3. 有索引

java.util.List接口:
// 常用特有成员方法 (都是按照索引来操作的)   
void add(int index, E element): 将指定的元素, 添加到该集合中的指定位置上
E get(int index): 返回集合中指定位置的元素
E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素
E set(int index, E element): 用指定元素替换集合中指定位置的元素, 返回值的更新前的元素

ArrayList
底层的数据结构:
        数组
        
ArrayList的特点:
        查询快
        增删慢
        线程不安全, 效率高
        
ArrayList适用场景:
        存储的数据"查询多, 增删少"的场景.

LinkedList
底层的数据结构:
  链表
        
LinkedList的特点:
  查询慢
  增删快
  线程不安全, 效率高
        
LinkedList适用场景:
  存储的数据"查询少, 增删多"的场景. 如用LinkedList实现栈或队列
        
java.util.LinkedList<E>类: 链表结构, 查询慢, 增删快
  // 特有成员方法(主要操作开头和末尾元素)
  void addFirst(E e): 将指定元素插入此列表的开头
  void addLast(E e): 将指定元素添加到此列表的结尾
  E getFirst(): 返回此列表的第一个元素
  E getLast(): 返回此列表的最后一个元素
  E removeFirst(): 移除并返回此列表的第一个元素
  E removeLast(): 移除并返回此列表的最后一个元素
  E pop(): (其实就是removeFirst())从此列表所表示的栈中弹出一个元素
  void push(E e): (其实就是addFirst())将元素添加到此列表所表示的栈中



Set集合
Set集合体系特点:
        1. 元素不可重复
        2. 没有索引

HashSet
HashSet特点:
        1. 元素不可重复
        2. 没有索引
        3. 元素存取无序 (存入和取出顺序有可能不一致)
        4. 底层采用 哈希表 结构. (查询快)
                哈希表 = 数组 + 链表或红黑树

java.util.HashSet类:
        // 常用方法
        boolean add(E e): 添加元素, 根据元素的 hashCode() 和 equals() 方法判断是否重复. 重复则不添加并返回false, 不重复则添加并返回true

哈希值
一个十进制数值, 一般是通过将该对象的内部地址转换成一个整数来实现的
public native int hashCode();
可以调用系统本地代码(C/C++)计算出一个对象地址的哈希值
        
hashCode()方法的作用
方法内部的算法用于将对象计算为一个哈希值, 便于根据哈希值比较对象是否"相等"
哈希值主要是为了提高对象存储在 哈希表 中的效率

哈希表结构
JDK 8以前   : 哈希表 = 数组 + 链表
JDK 8及之后 : 哈希表 = 数组 + 链表或红黑树
数组中存储的每个元素, 是哈希值相同的一组节点的链表或红黑树

LinkedHashSet
特点:
        1. 元素存取有序 (存入和取出顺序一致)
        2. 元素不可重复
        3. 没有索引
        
LinkedHashSet底层数据结构:
        哈希表 + 链表   (也就是: 数组 + 链表或红黑树 + 链表)
        其中, 哈希表用于存储数据, 额外的链表用于记录元素添加时的先后顺序, 以便在获取元素时保持顺序一致


总结：

要存储的元素可以重复的, 用List集合:
                增删少, 用ArrayList
                增删多, 用LinkedList
        要存储的数据要求不重复, 或者相对一个集合去重, 用Set集合:
                不要求存取顺序一致, 用HashSet
                要求存取顺序一致, 用LinkedHashSet


可变参数

JDK 5 出现. 指同一个类型的参数, "个数可变"
        可变参数的本质就是一个"数组"
        
        格式: 用在方法的参数中
            修饰符 返回值类型 方法名(int... 变量名) {
                    // 可以直接将 变量名 当作 数组名 使用
            }
            方法名();

注意事项:
        1. 可变参数可以传递的参数个数, 可以是 0个, 1个, 多个
        2. 一个方法的参数列表中, 只能有一个可变参数
        3. 如果方法的参数有多个, 可变参数必须写在参数列表的最后


Collections集合工具类

java.util.Collections类: 操作集合的工具类
        // 静态方法
        static <T> boolean addAll(Collection<? super T> c, T... elements):往集合中添加一些元素
        static void shuffle(List<?> list): 打乱集合顺序
        static <T> void sort(List<T> list): 将集合中元素按照默认规则排序
        static <T> void sort(List<T> list，Comparator<? super T> c):将集合中元素按照指定规则排序

sort(List<T> list)
默认按照"升序"将元素排序
        数字, 字母, 都可以按照升序排序
        
自定义JavaBean对象默认不能排序, 因为不知道如何比较哪个对象大, 哪个对象小
自定义JavaBean对象要想排序, 需要实现 Comparable<E> 接口, 重写 int compareTo(E e) 方法
        规则:
                this-参数: 升序(从小到大)
                参数-this: 降序(从大到小)

sort(List<T> list，Comparator<? super T> )
Comparable接口和Comparator接口区别
        Comparable: 让JavaBean自身具有可比较性 (自己和其他人比)
        Comparator: 定义一个比较器类, 用比较器对象比 (让第三个人来帮两个人比较)

Comparator使用方式:
        1. 定义类实现Comparator<E>接口, 重写 int compare(E o1, E o2) 方法, 泛型为比较元素的类型
                规则:
            o1-o2: 升序(从小到大)
            o2-o1: 降序(从大到小)
        2. 在Collections.sort(List<T> list，Comparator<? super T> c)方法中传入自定义比较器对象


day04


Map集合
java.util.Map<K, V>接口
特点:
        1. 是双列集合, 一个元素包含两个值 (键key, 值value) 键值对
        2. key和value的类型可以相同, 也可以不同
        3. key不允许重复, value可以重复
        4. key和value是一一对应的, 一个键只能对应一个值


// 成员方法
V put(K key, V value): 添加/修改 键值对.
如果键存在, 则用新值替换已有值, 返回被替换的值; 如果键不存在, 添加键值对, 返回null
V remove(Object key): 根据键删除键值对, 返回被删除元素的值
        如果键不存在, 返回null
V get(Object key): 根据键获取值.
            如果键不存在, 则返回null
boolean containsKey(Object key): 判断是否包含指定的键
        
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的Entry对象的集合(Set集合)

Map遍历方式

keySet()方法实现通过键找值：

keySet()遍历步骤:
        1. Map对象调用 keySet() 方法, 获取包含所有key的Set集合
        2. 遍历Set集合, 获取每个key
        3. 通过Map对象调用 get(Object key) 方法根据key获取到value

Entry键值对对象查找

        1.Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)
        2.遍历Set集合, 获取每个Entry对象
        3.调用Entry对象的 getKey() 和 getValue() 方法获取键和值

HashMap存储自定义数据类型作为键

HashMap存储自定义JavaBean对象作为key保证key唯一不重复, 需要让JavaBean重写 hashCode() 和 equals() 方法

LinkedHashMap

LinkedHashMap底层: 哈希表 + 链表
        key不允许重复, 但key存取有序

JDK9对集合添加的优化

使用集合添加大量元素时, 反复add(...)比较麻烦. JDK 9 为集合提供了一些静态方法, 可以方便的对集合进行初始化

java.util.List接口:
        // 静态方法
        static List<E> of(E... e): 返回包含指定元素的 不可变List 集合
        
java.util.Set接口:
        // 静态方法
        static Set<E> of(E... e): 返回包含指定元素的 不可变Set 集合
        
java.util.Map接口:
        // 静态方法
        static Map<K, V> of(K k1, V v1, ...): 返回包含指定键值对的 不可变Map 集合
        
注意事项:
        1. of() 方法只适用于List接口, Set接口, Map接口, 不适用于接口的实现类
        2. of() 方法的返回值是一个不可变的集合, 集合不能再使用 add(), put() 方法添加元素, 会抛出异常
        3. Set接口和Map接口在调用 of() 方法的时候, 不能有重复的元素, 否则会抛出异常



day05


异常

指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常体系

异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception

Throwable体系：

• Error:严重错误Error，无法通过处理的错误，只能事先避免。
• Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。
  

Throwable中的常用方法：

• public void printStackTrace():打印异常的详细信息。
  

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

• public String getMessage():获取发生异常的原因。
  

提示给用户的时候,就提示错误原因。

• public String toString():获取异常的类型和异常描述信息(不用)。
  

异常分类

平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。
异常(Exception)的分类:根据在编译时期还是运行时期去检查异常

• 编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
  

• 运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)
  

异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

抛出异常throw

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：throw new 异常类名(参数);


声明异常throws

将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }        


捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

• 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
• 在方法中使用try-catch的语句块来处理异常。
  

try-catch的方式就是捕获异常。

• 捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
  

捕获异常语法：

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}


finally 代码块

有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
一般用来关闭try...catch...中调用的资源

异常注意事项

多个异常使用捕获处理方式：

• 多个异常分别处理。
• 多个异常一次捕获，多次处理。
• 多个异常一次捕获一次处理。
  

• 运行时异常被抛出可以不处理。即不捕获也不声明抛出。
• 如果finally有return语句,永远返回finally中的结果,避免该情况.
• 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
• 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
  

自定义异常

实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题，需要在开发中根据自己业务的异常情况来定义异常类.

格式：

• 自定义一个编译期异常: 自定义类 并继承于java.lang.Exception。
• 自定义一个运行时期的异常类:自定义类 并继承于java.lang.RuntimeException。
  

多线程

并发与并行

• 并发：指两个或多个事件在同一个时间段内发生。
• 并行：指两个或多个事件在同一时刻发生（同时发生）。
  

线程与进程

• 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
  

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

线程调度:

• 分时调度
  

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

• 抢占式调度
  

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

day06
线程

多线程原理

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用线程对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。
当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

Thread类

java.lang.Thread:

构造方法：

• public Thread():分配一个新的线程对象。
• public Thread(String name):分配一个指定名字的新的线程对象。
• public Thread(Runnable target):分配一个带有指定目标新的线程对象。
• public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
  

常用方法：

• public String getName():获取当前线程名称。
• public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
• public void run():此线程要执行的任务在此处定义代码。
• public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
• public static Thread currentThread():返回对当前正在执行的线程对象的引用。
  

Runnable接口

java.lang.Runnable：

步骤如下：

• 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
• 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
• 调用线程对象的start()方法来启动线程。
  

Thread和Runnable的区别

• 适合多个相同的程序代码的线程去共享同一个资源。
• 可以避免java中的单继承的局限性。
• 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
• 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
  

线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题Java中提供了同步机制(synchronized)来解决。

同步代码块

synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式：
synchronized(同步锁){
     需要同步操作的代码
}
同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

• 锁对象可以是任意类型。
• 多个线程对象要使用同一把锁。
  

同步方法

使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式：
public synchronized void method(){
           可能会产生线程安全问题的代码
}

对于非static方法,同步锁就是this。  
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

获取一个类的字节码对象的3种方式:
        1. 对象名.getClass()          new RunnableImpl().getClass()
        2. 类名.class                 RunnableImpl.class
        3. Class.forName("类的全名");         
                        Class.forName("com.itheima.test05.RunnableImpl");

Lock锁

java.util.concurrent.locks.Lock接口
java.util.concurrent.locks.ReentrantLock类: Lock的实现类

jdk1.5提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：

• public void lock():加同步锁。
• public void unlock():释放同步锁。
  

使用方式:
@Override
    public void run() {
        // 加锁
        lock.lock();
        try {
                    // 操作共享变量的代码...
        } finally {
                    // 在finally中保证释放锁
                    lock.unlock();  
        }
    }


线程状态

java.lang.Thread.State这个枚举中给出了六种线程状态

线程状态	导致状态发生条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

Timed Waiting（计时等待

wait() 和 sleep() 的区别:
        1. wait会释放锁, 恢复时需要重新获取锁; sleep不会释放锁
        2. wait可以被notify/notifyAll唤醒; sleep不会
        3. wait要用锁对象调用; sleep要用Thread类名调用

BLOCKED（锁阻塞）

线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

day03


数据结构
数据的存储方式
不同的数据结构代表了不同的存储方式
不同的数据结构中, 会有不同的存入, 取出, 查找的方式和效率, 数据的存放方式也不同

栈
先进后出 (FILO, First In Last Out)
入口和出口在同一侧

入栈(压栈): 将元素存入栈
出栈(弹栈): 从栈中取出元素

栈的适用场景:
        栈内存
        反转内容

队列
先进先出 (FIFO, First In First Out)
入口和出口在两端
   
队列的适用场景:
        秒杀, 抢购
        在线售票
        处理高并发场景

数组
查询快: 通过 (第一个元素地址值 + 索引) 可以快速计算出该索引元素的地址值
增删慢: 增加一个元素, 要创建长度+1的新数组, 然后将原数组元素复制到新数组, 然后存入新元素; 删除类似

数组的适用场景:
  查询多, 增删少的数据存储场景

链表
由多个 节点(Node / Entry) 组成
单向链表: 每个节点存储 数据 和 下一个节点的地址值
双向链表: 每个节点存储 数据, 上一个节点地址值 和 下一个节点地址值

链表的特点:
  查询慢: 要找到其中某个节点, 只能从第一个节点一个一个向后寻找
  增删快: 只需要修改保存的下一个节点的地址值, 就可以快速完成增删

链表的适用场景:
  查询少, 增删多的场景
  链表可以实现栈和队列的结构, 因为栈和队列增删频繁

红黑树
特点:
        元素存储过程中就完成了大小排序
        查询比链表快, 增删比数组快 (数组和链表的折中)


List集合

List集合体系的特点:
1. 元素存取有序 (存入和取出元素的顺序一致)
2. 元素可以重复
3. 有索引

java.util.List接口:
// 常用特有成员方法 (都是按照索引来操作的)   
void add(int index, E element): 将指定的元素, 添加到该集合中的指定位置上
E get(int index): 返回集合中指定位置的元素
E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素
E set(int index, E element): 用指定元素替换集合中指定位置的元素, 返回值的更新前的元素

ArrayList
底层的数据结构:
        数组
        
ArrayList的特点:
        查询快
        增删慢
        线程不安全, 效率高
        
ArrayList适用场景:
        存储的数据"查询多, 增删少"的场景.

LinkedList
底层的数据结构:
  链表
        
LinkedList的特点:
  查询慢
  增删快
  线程不安全, 效率高
        
LinkedList适用场景:
  存储的数据"查询少, 增删多"的场景. 如用LinkedList实现栈或队列
        
java.util.LinkedList<E>类: 链表结构, 查询慢, 增删快
  // 特有成员方法(主要操作开头和末尾元素)
  void addFirst(E e): 将指定元素插入此列表的开头
  void addLast(E e): 将指定元素添加到此列表的结尾
  E getFirst(): 返回此列表的第一个元素
  E getLast(): 返回此列表的最后一个元素
  E removeFirst(): 移除并返回此列表的第一个元素
  E removeLast(): 移除并返回此列表的最后一个元素
  E pop(): (其实就是removeFirst())从此列表所表示的栈中弹出一个元素
  void push(E e): (其实就是addFirst())将元素添加到此列表所表示的栈中



Set集合
Set集合体系特点:
        1. 元素不可重复
        2. 没有索引

HashSet
HashSet特点:
        1. 元素不可重复
        2. 没有索引
        3. 元素存取无序 (存入和取出顺序有可能不一致)
        4. 底层采用 哈希表 结构. (查询快)
                哈希表 = 数组 + 链表或红黑树

java.util.HashSet类:
        // 常用方法
        boolean add(E e): 添加元素, 根据元素的 hashCode() 和 equals() 方法判断是否重复. 重复则不添加并返回false, 不重复则添加并返回true

哈希值
一个十进制数值, 一般是通过将该对象的内部地址转换成一个整数来实现的
public native int hashCode();
可以调用系统本地代码(C/C++)计算出一个对象地址的哈希值
        
hashCode()方法的作用
方法内部的算法用于将对象计算为一个哈希值, 便于根据哈希值比较对象是否"相等"
哈希值主要是为了提高对象存储在 哈希表 中的效率

哈希表结构
JDK 8以前   : 哈希表 = 数组 + 链表
JDK 8及之后 : 哈希表 = 数组 + 链表或红黑树
数组中存储的每个元素, 是哈希值相同的一组节点的链表或红黑树

LinkedHashSet
特点:
        1. 元素存取有序 (存入和取出顺序一致)
        2. 元素不可重复
        3. 没有索引
        
LinkedHashSet底层数据结构:
        哈希表 + 链表   (也就是: 数组 + 链表或红黑树 + 链表)
        其中, 哈希表用于存储数据, 额外的链表用于记录元素添加时的先后顺序, 以便在获取元素时保持顺序一致


总结：

要存储的元素可以重复的, 用List集合:
                增删少, 用ArrayList
                增删多, 用LinkedList
        要存储的数据要求不重复, 或者相对一个集合去重, 用Set集合:
                不要求存取顺序一致, 用HashSet
                要求存取顺序一致, 用LinkedHashSet


可变参数

JDK 5 出现. 指同一个类型的参数, "个数可变"
        可变参数的本质就是一个"数组"
        
        格式: 用在方法的参数中
            修饰符 返回值类型 方法名(int... 变量名) {
                    // 可以直接将 变量名 当作 数组名 使用
            }
            方法名();

注意事项:
        1. 可变参数可以传递的参数个数, 可以是 0个, 1个, 多个
        2. 一个方法的参数列表中, 只能有一个可变参数
        3. 如果方法的参数有多个, 可变参数必须写在参数列表的最后


Collections集合工具类

java.util.Collections类: 操作集合的工具类
        // 静态方法
        static <T> boolean addAll(Collection<? super T> c, T... elements):往集合中添加一些元素
        static void shuffle(List<?> list): 打乱集合顺序
        static <T> void sort(List<T> list): 将集合中元素按照默认规则排序
        static <T> void sort(List<T> list，Comparator<? super T> c):将集合中元素按照指定规则排序

sort(List<T> list)
默认按照"升序"将元素排序
        数字, 字母, 都可以按照升序排序
        
自定义JavaBean对象默认不能排序, 因为不知道如何比较哪个对象大, 哪个对象小
自定义JavaBean对象要想排序, 需要实现 Comparable<E> 接口, 重写 int compareTo(E e) 方法
        规则:
                this-参数: 升序(从小到大)
                参数-this: 降序(从大到小)

sort(List<T> list，Comparator<? super T> )
Comparable接口和Comparator接口区别
        Comparable: 让JavaBean自身具有可比较性 (自己和其他人比)
        Comparator: 定义一个比较器类, 用比较器对象比 (让第三个人来帮两个人比较)

Comparator使用方式:
        1. 定义类实现Comparator<E>接口, 重写 int compare(E o1, E o2) 方法, 泛型为比较元素的类型
                规则:
            o1-o2: 升序(从小到大)
            o2-o1: 降序(从大到小)
        2. 在Collections.sort(List<T> list，Comparator<? super T> c)方法中传入自定义比较器对象


day04


Map集合
java.util.Map<K, V>接口
特点:
        1. 是双列集合, 一个元素包含两个值 (键key, 值value) 键值对
        2. key和value的类型可以相同, 也可以不同
        3. key不允许重复, value可以重复
        4. key和value是一一对应的, 一个键只能对应一个值


// 成员方法
V put(K key, V value): 添加/修改 键值对.
如果键存在, 则用新值替换已有值, 返回被替换的值; 如果键不存在, 添加键值对, 返回null
V remove(Object key): 根据键删除键值对, 返回被删除元素的值
        如果键不存在, 返回null
V get(Object key): 根据键获取值.
            如果键不存在, 则返回null
boolean containsKey(Object key): 判断是否包含指定的键
        
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的Entry对象的集合(Set集合)

Map遍历方式

keySet()方法实现通过键找值：

keySet()遍历步骤:
        1. Map对象调用 keySet() 方法, 获取包含所有key的Set集合
        2. 遍历Set集合, 获取每个key
        3. 通过Map对象调用 get(Object key) 方法根据key获取到value

Entry键值对对象查找

        1.Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)
        2.遍历Set集合, 获取每个Entry对象
        3.调用Entry对象的 getKey() 和 getValue() 方法获取键和值

HashMap存储自定义数据类型作为键

HashMap存储自定义JavaBean对象作为key保证key唯一不重复, 需要让JavaBean重写 hashCode() 和 equals() 方法

LinkedHashMap

LinkedHashMap底层: 哈希表 + 链表
        key不允许重复, 但key存取有序

JDK9对集合添加的优化

使用集合添加大量元素时, 反复add(...)比较麻烦. JDK 9 为集合提供了一些静态方法, 可以方便的对集合进行初始化

java.util.List接口:
        // 静态方法
        static List<E> of(E... e): 返回包含指定元素的 不可变List 集合
        
java.util.Set接口:
        // 静态方法
        static Set<E> of(E... e): 返回包含指定元素的 不可变Set 集合
        
java.util.Map接口:
        // 静态方法
        static Map<K, V> of(K k1, V v1, ...): 返回包含指定键值对的 不可变Map 集合
        
注意事项:
        1. of() 方法只适用于List接口, Set接口, Map接口, 不适用于接口的实现类
        2. of() 方法的返回值是一个不可变的集合, 集合不能再使用 add(), put() 方法添加元素, 会抛出异常
        3. Set接口和Map接口在调用 of() 方法的时候, 不能有重复的元素, 否则会抛出异常



day05


异常

指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。
在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常体系

异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception

Throwable体系：

• Error:严重错误Error，无法通过处理的错误，只能事先避免。
• Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。
  

Throwable中的常用方法：

• public void printStackTrace():打印异常的详细信息。
  

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

• public String getMessage():获取发生异常的原因。
  

提示给用户的时候,就提示错误原因。

• public String toString():获取异常的类型和异常描述信息(不用)。
  

异常分类

平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。
异常(Exception)的分类:根据在编译时期还是运行时期去检查异常

• 编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
  

• 运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)
  

异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

抛出异常throw

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：throw new 异常类名(参数);


声明异常throws

将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理。
关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }        


捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

• 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
• 在方法中使用try-catch的语句块来处理异常。
  

try-catch的方式就是捕获异常。

• 捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
  

捕获异常语法：

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}


finally 代码块

有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
一般用来关闭try...catch...中调用的资源

异常注意事项

多个异常使用捕获处理方式：

• 多个异常分别处理。
• 多个异常一次捕获，多次处理。
• 多个异常一次捕获一次处理。
  

• 运行时异常被抛出可以不处理。即不捕获也不声明抛出。
• 如果finally有return语句,永远返回finally中的结果,避免该情况.
• 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
• 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
  

自定义异常

实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题，需要在开发中根据自己业务的异常情况来定义异常类.

格式：

• 自定义一个编译期异常: 自定义类 并继承于java.lang.Exception。
• 自定义一个运行时期的异常类:自定义类 并继承于java.lang.RuntimeException。
  

多线程

并发与并行

• 并发：指两个或多个事件在同一个时间段内发生。
• 并行：指两个或多个事件在同一时刻发生（同时发生）。
  

线程与进程

• 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
  

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

线程调度:

• 分时调度
  

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

• 抢占式调度
  

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

day06
线程

多线程原理

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用线程对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。
当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

Thread类

java.lang.Thread:

构造方法：

• public Thread():分配一个新的线程对象。
• public Thread(String name):分配一个指定名字的新的线程对象。
• public Thread(Runnable target):分配一个带有指定目标新的线程对象。
• public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
  

常用方法：

• public String getName():获取当前线程名称。
• public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
• public void run():此线程要执行的任务在此处定义代码。
• public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
• public static Thread currentThread():返回对当前正在执行的线程对象的引用。
  

Runnable接口

java.lang.Runnable：

步骤如下：

• 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
• 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
• 调用线程对象的start()方法来启动线程。
  

Thread和Runnable的区别

• 适合多个相同的程序代码的线程去共享同一个资源。
• 可以避免java中的单继承的局限性。
• 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
• 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
  

线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题Java中提供了同步机制(synchronized)来解决。

同步代码块

synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式：
synchronized(同步锁){
     需要同步操作的代码
}
同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

• 锁对象可以是任意类型。
• 多个线程对象要使用同一把锁。
  

同步方法

使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式：
public synchronized void method(){
           可能会产生线程安全问题的代码
}

对于非static方法,同步锁就是this。  
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

获取一个类的字节码对象的3种方式:
        1. 对象名.getClass()          new RunnableImpl().getClass()
        2. 类名.class                 RunnableImpl.class
        3. Class.forName("类的全名");         
                        Class.forName("com.itheima.test05.RunnableImpl");

Lock锁

java.util.concurrent.locks.Lock接口
java.util.concurrent.locks.ReentrantLock类: Lock的实现类

jdk1.5提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：

• public void lock():加同步锁。
• public void unlock():释放同步锁。
  

使用方式:
@Override
    public void run() {
        // 加锁
        lock.lock();
        try {
                    // 操作共享变量的代码...
        } finally {
                    // 在finally中保证释放锁
                    lock.unlock();  
        }
    }


线程状态

java.lang.Thread.State这个枚举中给出了六种线程状态

线程状态	导致状态发生条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

Timed Waiting（计时等待

wait() 和 sleep() 的区别:
        1. wait会释放锁, 恢复时需要重新获取锁; sleep不会释放锁
        2. wait可以被notify/notifyAll唤醒; sleep不会
        3. wait要用锁对象调用; sleep要用Thread类名调用

BLOCKED（锁阻塞）

线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。