集合
数组
- 长度开始时必须指定,而且一旦指定,不能更改
- 保存的必须为同一类型的元素
- 使用数组进行增加元素的示意代码-比较麻烦
集合体系图
Collection
Map
集合主要分为两组:(单列集合,双列集合)
单列集合:List、Set
双列集合:Map
Collection接口和方法
- Collection接口实现类的特点
public interface Collection<E> extends Iterable<E>
迭代器
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
集合增强for
import java.util.ArrayList;
public class T2 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add(new Book("张三",13,"北京"));
arrayList.add(new Book("李四",12,"上海"));
arrayList.add(new Book("王五",14,"深圳"));
//1、使用增强for
//2、增强for,底层仍然是迭代器
//3、增强for可以理解成简化版的迭代器遍历
for (Object item : arrayList){
System.out.println(item);
}
}
}
List接口方法
ArrayList的注意事项
ArrayList是线程不安全的
//ArrayList 是线程不安全的,看源码,没有synchronized修饰
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
ArrayList自动扩容机制(底层为数组)
public static void main(String[] args) {
//使用无参构造器创建ArrayList对象
ArrayList arrayList = new ArrayList();
for (int i = 1; i <= 10; i++) {
arrayList.add(i);
}
for (int i = 11; i <= 15; i++) {
arrayList.add(i);
}
arrayList.add(100);
arrayList.add(200);
arrayList.add(null);
}
Debug
1、创建了一个空的elementData数组
2、先确定是否要扩容,然后再执行,赋值
3、比较
4、
5、真正的扩容,第一次newCapacity=10,第二次按照1.5倍扩容
Transient注解
表示瞬间,短暂的,表示该属性不会被序列化
Vector(底层为数组)
LinkedList(底层为双向链表)
底层代码是双向链表的实现
添加
删除
ArrayList和LinkedList的比较
Set
HashSet(底层为HashMap)
源码分析
package com.qw.collectionTest;
import java.util.HashSet;
public class T4 {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add("java");
hashSet.add("php");
hashSet.add("python");
hashSet.add("js");
System.out.println(hashSet);
}
/*
* 1.它的底层是HashMap
* public HashSet() { map = new HashMap<>(); }
* 2、执行add()
* public boolean add(E e) {
return map.put(e, PRESENT)==null;
// PRESENT 指的是 private static final Object PRESENT = new Object();
}
* 3、执行put()
*public V put(K key, V value) { // key:java, value:PRESENT
return putVal(hash(key), key, value, false, true);
}
* 4、进入hash(key),通过hashCode()算法会得到一个hash值,然后通过计算(h = key.hashCode()) ^ (h >>> 16)得到一个索引值即为存放在哈希表中的位置号。
* static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
* 5、进入核心代码putVal()
* final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i; // 定义了辅助变量
* // table就是HashMap的一个数组,类型是Node<k,v>[]
if ((tab = table) == null || (n = tab.length) == 0) //如果table为null
n = (tab = resize()).length; // resize()要扩容,第一次扩容16个空间
* // 根据key,得到hash,去计算该key应该存放到table表的哪个索引位置,并把这个位置的对象赋给p
* // 然后判断p是否为null,如果p为null,表示还没有存放元素,就创建一个Node,放(hash,key = "java",value = PRESENT,null)
* // 就放在该位置tab[i] = newNode(hash, key, value, null);
* if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else { // 数组中的p不为null,要在数组中tab[i]后边添加新元素,形成链表
Node<K,V> e; K k;
* // 如果p指向位置中的hash和将要添加进来的值的hash相同并且比较这俩的key是否相同 注意:前者比较的字符串或其他,后者比较的对象或者其他
// 就不能加入
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 再判断p是不是一颗红黑树
* // 如果是一颗红黑树,就调用putTreeVal来进行比较添加
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else { // 单链表情况,使用for循环和每个元素比较添加,若有相同不添加,负责添加到链表尾部
for (int binCount = 0; ; ++binCount) { // 死循环
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//注意:把元素添加到链表后,立即判断该链表是否已经达到8个结点,若达到了
8个结点就调用treeifyBin() 对当前这个链表进行树化(转成红黑树),但是在
转之前还要判断tab数组的大小,若为null或者小于64,就要先扩充数组,若等于
64,就要把链表树化。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// size的大小指的是数组里面值的数量+单链表上元素的数量,只要增加了,si
if (++size > threshold) // 第一次判断++size是否大于12,如果大于就再扩容
resize();
afterNodeInsertion(evict);
return null;
}
*6、resize() 用来扩容
* final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY; //DEFAULT_INITIAL_CAPACITY = 16;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 0.75 * 16
* // DEFAULT_LOAD_FACTOR = 0.75; 初始 newThr = 12; 意思是 容量到12的时候就要扩容了,而不是满了才扩容
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr; // 12
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // newCap = 16;
table = newTab; // table = 16; 初始扩容16
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
*
*
* */
}
HashMap(底层为数组+链表+红黑树)
注意
- 当添加有相同的key,后面key将覆盖掉前面的key
package com.qw.collectionTest;
import java.util.HashMap;
import java.util.Map;
public class T5 {
public static void main(String[] args) {
Map map = new HashMap();
map.put("name","zhangsan");
map.put("age","18");
/*
* 1、k-v 最终放到了 HashMap$Node node = newNode(hash,key,value,null)里面
* 2、k-v 为了方便程序员的遍历,还会创建EntrySet集合,该集合存放的元素的类型是 Entry,而一个Entry
* 对象就有k,v。即EntrySet<Entry<k,v>>,注意:这里面的k,v指的是newNode(hash,key,value,null)里面
* 的k,v的引用而不是数据。
* 3、entrySet中,定义的类型是Map.Entry,但是实际上存放的还是 HashMap$Node
* 这是因为 HashMap$Node implements Map.Entry
* 4、当把HashMap$Node对象存放到entrySet就方便我们的遍历,因为Map.Entry
* 提供了 K getKey(); V getValue();
*
* */
}
}
Map接口常用方法
package com.qw.collectionTest;
import java.util.HashMap;
import java.util.Map;
public class T5 {
public static void main(String[] args) {
Map map = new HashMap();
map.put("name","zhangsan");
map.put("age","18");
//map.remove("name");//根据键删除映射关系
//Object name = map.get("name");//根据键获取值
//int size = map.size();//获取元素个数
//boolean empty = map.isEmpty();//判断个数是否为0
//map.clear();//清空map中的元素
boolean name = map.containsKey("name");//查找键是否存在
System.out.println(name);
}
}
Map接口遍历方法
package com.qw.collectionTest;
import com.sun.deploy.config.WinPlatform;
import java.util.*;
public class T5 {
public static void main(String[] args) {
Map map = new HashMap();
map.put("name","zhangsan");
map.put("age","18");
map.put("address","北京");
map.put("sex","1");
//遍历
//取出所有key,然后遍历key再去除value
Set set = map.keySet();
//(1)增强for
for (Object key :set) {
System.out.println(key + "---" + map.get(key));
}
//(2)迭代器
System.out.println("======================================");
Iterator iterator = set.iterator();
while (iterator.hasNext()){
Object key = iterator.next();
System.out.println(key + "---" + map.get(key));
}
//把所有的values取出
//(1)增强for
Collection values = map.values();
System.out.println("======================================");
for (Object value :values) {
System.out.println(value);
}
//(2)迭代器
System.out.println("======================================");
Iterator iterator1 = values.iterator();
while (iterator1.hasNext()){
Object value = iterator1.next();
System.out.println(value);
}
//通过EntrySet来获取k-v
Set entrySet = map.entrySet();//这里的类型指的是EntrySet<Entry<K,V>>
//(1)增强for
for (Object entry :entrySet) { //这里是取出每个Entry<K,V>
// 将entry转成Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey()+"---"+m.getValue());
}
//(2)迭代器
Iterator iterator2 = entrySet.iterator();
while (iterator2.hasNext()){
Object entry = iterator2.next();
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey()+"---"+m.getValue());
}
}
}
小结
底层分析总结