day015

Collection接口
集合层次根接口

List接口(其特有方法都是与下标有关的)
List集合是有下标的
List集合是有顺序的
List集合可以存放重复的数据

Map接口

				<collection所有方法>
				以下collection即集合
					↓ 

boolean add(E e) //将指定元素添加到集合中
确保此 collection 包含指定的元素（可选操作）。

boolean addAll(Collection<? extends E> c) //<? extends E>–<>将c集合中所有的元素加到本集合中
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

void clear()
移除此 collection 中的所有元素（可选操作）。

boolean contains(Object o)
如果此 collection 包含指定的元素，则返回 true。

boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。

boolean equals(Object o) //比较集合对象与参数对象o是否相等,参数对象为集合才有意义
比较此 collection 与指定对象是否相等。

int hashCode()
返回此 collection 的哈希码值。

boolean isEmpty()
如果此 collection 不包含元素，则返回 true。

Iterator iterator()
返回在此 collection 的元素上进行迭代的迭代器。

boolean remove(Object o)
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。

boolean removeAll(Collection<?> c) //移除本集合中属于参数集合c的所有元素
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

boolean retainAll(Collection<?> c) //<>表示泛型,传啥都行.保留本集合与参数集合C的公共元素
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

int size()
返回此 collection 中的元素数。

Object[] toArray()
返回包含此 collection 中所有元素的数组。

T[]
toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

				<List特有方法>
			             ↓ 

void add(int index, E element)
在列表的指定位置插入指定元素（可选操作）。

boolean addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

E get(int index)
返回列表中指定位置的元素。

E set(int index, E element)
用指定元素替换列表中指定位置的元素（可选操作）。

Iterator iterator()
返回按适当顺序在列表的元素上进行迭代的迭代器。

E remove(int index)
移除列表中指定位置的元素（可选操作）。

List subList(int fromIndex, int toIndex) //截取子集合,含头不含尾
返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。

ListIterator listIterator(int index) //不常用,但可逆序迭代
返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。

			<Map特有方法>(Entry--键值对)

简单方法：

void clear() 清空集合

boolean equals(Object o) 判断集合对象与参数o是否相等

int hashCode() 返回本集合的哈希码值

boolean isEmpty() 判断集合是否为空

int size() 返回本集合中键值对的个数

map单个集合间的操作:

boolean containsKey(Object key) 判断map中是否包含指定的key

boolean containsValue(Object value) 判断map中是否包含指定的value

V get(Object key) 根据指定的key返回对应的value,如果不存在，返回null

V remove(Object key) 删除本集合中参数key对应的键值对

V put(K key, V value) 向集合中添加映射关系（键值对）

void putAll(Map<> m) 向本集合中添加m集合的所有映射关系（键值对）

map的迭代:

Collection values() 把本map中的Value值取出放入一个Collection中并返回这个Collection

Set keySet() 把本map中的Key值取出放入一个Set集合中并返回这个Set集合

Set<Map.Entry<K,V>> entrySet()

把本map中的每一对KV都看成是一个Entry,把所有的Entry取出放入一个Set集合中并返回这个Set集合

3.List接口的两个常用实现类

ArrayList的特点：
底层的数据结构是数组，内存空间是连续的
元素有下标，通常可以根据下标进行操作
增删操作比较慢，查询操作比较快【数据量大时】

LinkedList的特点：
底层的数据结构是链表，内存空间是不连续的
元素有下标，但是通常首尾节点操作比较多
增删操作比较快，查询操作比较慢【数据量大时】
注意：LinkedList查询慢也不是都慢，首尾操作还是比较快的

#################################################################

map中的value可以重复,所以 拿Entry的key去求哈希,结果对数组长度取余

数组的扩容 与 链表无关

链表长度>8时,链表会转成红黑树(左小右大,自平衡二叉查找树)

所以HashMap数组中 可能 会同时 存在 单个元素+链表+红黑树

加载因子:数组存到什么程度才自动扩容
HashMap源码中的加载因子static final float DEFAULT_LOAD_FACTOR = 0.75f;
0.75—存了3/4再扩容

加载因子是表示Hsah表中元素的填满的程度。

加载因子越大,填满的元素越多,空间利用率越高，但冲突的机会加大了。

反之,加载因子越小,填满的元素越少,冲突的机会减小,但空间浪费多了。

冲突的机会越大,则查找的成本越高。反之,查找的成本越小。

因此,必须在 "冲突的机会"与"空间利用率"之间寻找一种平衡与折衷。

#################################################################

set接口

Set是一个不包含重复数据的Collection
Set集合中的数据是无序的(因为Set集合没有下标)
Set集合中的元素不可以重复 – 常用来给数据去重

Set集合的特点
数据无序且数据不允许重复
HashSet : 底层是哈希表，包装了HashMap，相当于向HashSet中存入数据时，会把数据作为K，存入内部的HashMap中。当然K仍然不许重复。
TreeSet : 底层是TreeMap,也是红黑树的形式,便于查找数据

1.set集合没有重复浮点元素
2.无序
3.可以存一个null
4.我们自定义对象如果想去重,需要在自定义类中添加重写的equals()与hashcode()

集合学习的方法:
学习父级的公共方法,学习子类的创建方式,学习各种集合的特点
1.关于List大都是与下标有关的操作
2.关于Set通常都是去重的操作
3.关于map通过都是映射关系
4.API要常练习,方法互相之间没有任何关系,用哪个,查哪个.

#################################################################

IO流-序列化

集合

进程-线程

组合,互不干扰

#################################################################

					<进程>

每个进程都有自己独立的运行空间,互不影响

1.1 进程的概念

进程就是正在运行的程序,它代表了程序所占用的内存区域

1.2 进程的特点

独立性
进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间
动态性
进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的.
并发性
多个进程可以在单个处理器CPU上并发执行,多个进程之间不会互相影响.

±–+<–谷歌
|cpu|<–QQ
±–+<–百度

高并发:多个进程强占公共资源

±–+
|cpu|<–谷歌
±–+

±–+
|cpu|<–QQ
±–+

±–+
|cpu|<–百度
±–+
并行:多个cpu同时处理不同的进程

HA(High Availability)高可用:指在高并发的情景中,尽可能的保证程序的可用性,减少系统不能提供服务的时间

(当你在高并发的环境中,尽量保持不崩溃,即使奔溃了也能尽快恢复)

							<线程>

2.1 线程的概念
线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位
一个进程可以开启多个线程,其中有一个主线程来调用本进程中的其他线程
我们看到的进程的切换，切换的也是不同进程的主线程
多线程扩展了多进程的概念,使的同一个进程可以同时并发处理多个任务

(IDEA中打开多个界面)(QQ中打开多个聊天窗口)

2.2 进程与线程的关系
一个操作系统中可以有多个进程,一个进程中可以包含一个线程(单线程程序),也可以包含多个线程(多线程程序)

宏观层面上,所有的进程/线程看似同时运行,
但是微观层面上,同一时刻,一个CPU只能处理一件事.切换的速度甚至是纳秒级别的,非常快

CPU分时调度

时间片,即CPU分配给各个线程的一个时间段,称作它的时间片,即该线程被允许运行的时间.

如果在时间片用完时线程还在执行,那CPU将被剥夺并分配给另一个线程,将当前线程挂起.

如果线程在时间片用完之前阻塞或结束,则CPU当即进行切换,从而避免CPU资源浪费,当再次切换到之前挂起的线程,
恢复现场,继续执行。

OS执行线程的规则(OS自行选择):

FCFS(First Come First Service 先来先服务算法)

SJS(Short Job Service短服务算法)

*(哲学家/银行家算法)

3.3 线程的状态
线程状态比较复杂,由易到难,先学习线程的三种基础状态及其转换,简称”三态模型” :

就绪(可运行)状态：线程已经准备好运行，只要获得CPU，就可立即执行

执行(运行)状态：线程已经获得CPU，其程序正在运行的状态

阻塞状态：正在运行的线程由于某些事件（I/O请求等）暂时无法执行的状态，即线程执行阻塞

---

			    【就绪】
				      ↖时间片完
							
		   I/O完成↗          线程调度↘
			

	【阻塞】      <-    （I/O阻塞）    -     【执行】    -  (终止) ->

---

就绪 → 执行:为就绪线程分配CPU即可变为执行状态"

执行 → 就绪:正在执行的线程由于时间片用完被剥夺CPU暂停执行,就变为就绪状态

执行 → 阻塞:由于发生某事件,使正在执行的线程受阻,无法执行,则由执行变为阻塞

(例如线程正在访问临界资源,而资源正在被其他线程访问)
反之,如果获得了之前需要的资源,则由阻塞变为就绪状态,等待分配CPU再次执行

再添加两种状态:

创建状态:线程的创建比较复杂,需要先申请PCB（进程控制块）,然后为该线程运行分配必须的资源,
并将该线程转为就绪状态插入到就绪队列中

终止状态:等待OS进行善后处理,最后将PCB清零,并将PCB返回给系统

---

     【创建】         ->          【就绪】
				      	↖时间片完
							
		   I/O完成↗          线程调度↘
			

	【阻塞】      <-    （I/O阻塞）    -     【执行】    -  (终止) -> 【终止】

---

######################################################################

多线程实现的方案一:继承
1.自定义一个类extends Thread
2.重写run()里面写业务
3.创建线程对象
4.调用start()
注意:可以通过调用父类Tread的含参构造Thread(String name)
给自定义线程对象起名字,调用方式:super(name)

多线程实现的方案二:实现
1.自定义一个类implements Runnable
2.实现接口中未实现的run()
3.打印线程名称:Thread.currentThread().getName()
4.创建目标业务对象----接口实现类的对象–包含的是我们的业务
5.创建线程对象—Thread t1 = new Thread(targert);
目的:为了把实现类与Thread建立关系,原因是想用Thread的start()
6.通过线程对象调用start(),把线程对象加入就绪队列

Runnable比继承 难 在于总是要绕一步

方案二:
降低耦合性
任务发布效率高

#################################################################

HashMap HashSet

实现了Map接口 实现Set接口

存储键值对 仅存储对象

调用put（）向map中添加元素
调用add（）方法向Set中添加元素

HashMap使用键（Key）计算Hashcode
HashSet使用成员对象来计算hashcode值，

HashMap相对于HashSet较快，因为它是使用唯一的键获取对象
HashSet较HashMap来说比较慢

#################################################################

集合类对象.iterator()
返回在此集合的元素上进行迭代的迭代器。

class MyRunnable implements Runnable

MyRunnable:接口Runnable的实现类

Thread t1 = new Thread(target);

线程类的一个含参构造就是接收MyRunnable实现类对象的

因为接口不能创建对象
所以 传 接口 的实现子类

##############################################################################

		+----------------------------------------+

	       集合  结束		 

		+----------------------------------------+				

##############################################################################