在使用集合类之间我们总是使用数组存储数据，但是数组存有一些缺点，比如数组一创建就将数组的长度限定了，没有方法适时的扩容，而且数组提供的方法很有限，很难满足对数组内数据操作的需求。所以java 提供了集合。JAVA集合类中涉及到的知识点包括如下：
1）集合类的体系架构
2）Collection的常用方法
3）迭代器
4）集合类各个类的使用的底层原理
5）比较器
6）Collections工具类
一。集合类的体系架构
java中集合主要分为两个体系，粉别是Collection和Map两个，我们常用他们的具体实现类去做不同的操作。
Collection中有两个实现类，粉别是List和Set，他俩的区别是，
List可以存放重复有序的数据，List可以存放多个null。
Set存放的是无序不可重复的数据**，set中可以存放一个null。**
List
ArrayList底层是一个数组，可以通过get数组的索引快速获取某个值，但是当需要插入/删除一个数据的时候，需要将整个数组的数据全部都移动，效率较低
LinkedList内部实现是一个双向链表，当他想要查询某个值的时候，需要一个一个的去遍历，效率比较差，但是当需要插入/删除一个数据的时候，可以直接使用其内部的前后指针，直接指向插入，效率较高。当需要的频繁插入或者删除数据的时候，使用LinkedList效率比较高。
Vector 和ArrayList几乎一样的，但是区别就是Vertor是线程安全的，他内部的方法是Synchronized的，因此开销比较大，再有ArrayList每次扩容是1.5倍，Vertor每次是2倍。
Set
HashSet： 存放无序不重复的数据。
LinkedHashSet：HashSet的子类，存放的数据是无序的但是可以按照存入的顺序取出，因为linkedHashSet存的数据有前后指针指向上/下一个数据。
TreeSet：（底层是红黑树）通过重写自然排序方法/自定义排序方法，使得存入的数据按照一定的比较逻辑实现存入的数据时候顺序的。
equals()方法和hashcode方法()，以及HashSet底层逻辑
我们看下面的代码
public class Person {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public static void main(String[] args) {
Set set=new HashSet();
set.add(new Person("张三",12));
set.add(new Person("张三",12));
set.add("nihao");
set.add("nihao");
System.out.println(set);
}
为什么会这样的？set存放的不是无序不重复的代码吗，为什么对象存进去的数据可以存放重复的数据，字符串就不行呢（实际数字型也不行）？原因就是，在Person类中没有重写equals()方法，而String和数字型重写了equals方法（）。那我们就在Person类中加上equals（）方法。运行以下
public class Person {
private String name;
private Integer age;
-------------------get/set方法-------------
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
if (name != null ? !name.equals(person.name) : person.name != null) return false;
return age != null ? age.equals(person.age) : person.age == null;
}
不对啊，怎么加上equals方法以后，还是把重复的数据存进去了呢？先别急让我们在加上hashCode（）方法看下运行结果。
public class Person {
private String name;
private Integer age;
-------------------get/set方法-------------
@Override
/**重写的equals方法，就是分别给对象的每个字段调用equals方法，如果有一个字段不相等，
*就不相等，直到最后一个字段全部equals都相等，最后就相等了。
*/
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
if (name != null ? !name.equals(person.name) : person.name != null) return false;
return age != null ? age.equals(person.age) : person.age == null;
}
@Override
/**
*这是系统自动生成的hashCode方法，他是先获取其中一个字段的hashCode方法，然后
乘以31（通过位运算可以得到数，并且是质数），在加上另一个字段的哈希值。
这样可能会造成一个问题，就是hash值相等的对象不一定是同一个对象，但是同一个对象的
hash值一定是hashCode相同。
举个例子 44+22=66/35+31=66,通过计算得到的hashCode相同，当时可能不是同一个对象
*/
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + (age != null ? age.hashCode() : 0);
return result;
}
}
加上Hashcode就可以了，为什么？？？？？？是不是有很多问好，我们就需要从HashSet的底层逻辑说起。
HashSet底层逻辑
HashSet的底层采用的是数组加链表的结构，通过重写hashCode方法，当获取到当前对象的hashCode值以后，通过某种散列函数得到存到数字的位置（散列函数可以通过最简单的取模来理解），但是有一定的概率，当要存入的位置已经有值了（通过散列函数得到的值相等了），这个时候就存入当前位置的链表里，这个时候调用equals()方法，不相等就存入，相等就不存了。
1）通过hashCode()方法获取hashCode（），有的时候需要重写hashCode方法。
2）通过散列函数，获取存入数组的位置。
2.1）当前位置没有值，直接存入（这个时候就不需要equals方法比较了）
2.2）当前位置已经有值了，通过equals()方法去比较，相等就不存，不等就村上。
HashSst在JDK1.7和JDK1.8中的区别就是：七上八下，jdk1.7中，新增的数据插到上面，老数据下移到链表里，Jdk1.8中，新增的数据插到下面。
TreeSet
TreeSet不使用equals比较数据，使用compareTo方法
1.自然排序的compareTo方法（实现Comparable接口）
/**
* @author yongchaoliu
* @create 2021-01-26 18:57
*/
public class Person implements Comparable{
private String name;
private Integer age;
----------------getter/settter-----------------
public int compareTo(Object o) {
if(o instanceof Person){
Person person=(Person)o;
int compare=name.compareTo(person.name);
if(compare==0){
return Integer.compare(this.age,person.age);
}else {
return compare;
}
}else{
throw new RuntimeException("输入类型不匹配");
}
}
}
2.定制排序
import java.util.*;
/**
* @author yongchaoliu
* @create 2021-01-26 18:17
*/
public class Hello {
public static void main(String[] args) {
Comparator com = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Person && o2 instanceof Person) {
Person p1 = (Person) o1;
Person p2 = (Person) o2;
return p1.getName().compareTo(p2.getName());
} else {
throw new RuntimeException();
}
}
};
TreeSet set=new TreeSet(com);
set.add(new Person("张三",-12));
set.add(new Person("李四",5));
set.add(new Person("王五",78));
set.add(new Person("六六",125));
set.add(new Person("六六",124));
Iterator i =set.iterator();
while(i.hasNext()){
System.out.println(i.next());
}
}
}
Map体系
Map存储的是键值对形式的值，键不能重复，可以理解为一个是一个set,存储的数据无序不可重复，value可以理解是一个collection,无序可重复。
1）**HashMap:**使用的最多的,允许key值为null,线程不安全。
2)**HashTable:**不允许key为null 线程安全的。
3）LinkedHashMap: HashMap的子类，可以将数据按照存入的顺序读出来。
4）**TreeMap:**可以有顺序的存储数据，内部实现是红黑树
5)**properties:**主要用于做配置i文件。
HashMap
HashMap中的key值可以为null,当要往map存数据的时候，map中已经存在这个key，以及对应的key值的时候，这个时候会将原来的数据覆盖，不会像hashSet中一样存不进去。
HashMap的低等原理
hashMap在jdk1.7和jdk1.8中的底层结构是不同的。在jdk1.7中 HashMap=数组+链表，在jdk1.8中HashMap=数组+链表+红黑树。
jdk7中HashMap的等层结构
1）当HashMap被创建的时候，会创建一个长度为16的数组，如果在new HashMap（15）指定一个长度话，也不知按照指定的长度去创建的，而是当创建大于传入数据的最小的2的n次方的数，如果传入的是15,就创建16长度的数组，如果传入7就创建8长度的数组。如果不传就创建默认长度16的数组。
2）当往Map中put数据的时候,首先获取key中对象的hash值，然后通过某种计算，确定该对象要存到数组的位置，
２.１）如果当前位置没有值,直接存入
2.2.1)如果当前位置有值,通过equals方法比较,值是否相等,如果不等,将数组插入到链表的顶端.
2.2.2)如果当前位置有值,通过equals方法比较,值相等,将新数据存入.老数据返回.
3)当put数据到一定程度时候,数组就会扩容,这里HashMap默认的加载因子是0.75,数组长度*加载因子就是临界值,当数组的中已有数据的个数大于等于临界时,再往Map中put数据是,就需要扩容了,这里也有区别
3.1）当已有数据的当都大于等于临界值的时候,如果通过hashCode和散列函数计算得到的存放的数组的位置,为空时,不需要扩容.
3.2)当以后数据大于等于临界值时,通过hashCode和散列函数获取的存放位置有值时就需要扩容,扩容为原来的2倍.
/**
*initialCapacity :new HashMap的时候,可以传入的想创建内部数组的长度,不传的话默认值是16
*DEFAULT_LOAD_FACTOR:默认的加载因子 值为0.75
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
------------------------------------------------------------------------------
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//MAXIMUM_CAPACITY默认可创建的组数长度的最大值,如果传入的值大于该值,创建默认最大长度的数组
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// Find a power of 2 >= initialCapacity
int capacity = 1;
//这里就是说的,不是传入多大值就创建多大的数组,而是创建大于传入值的最小2的N次方的数,通过位运算获取2的n次方的值.
while (capacity < initialCapacity)
capacity <<= 1;
this.loadFactor = loadFactor;
//临界值,阈值,给阈值赋值
threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//创建定长的数组
table = new Entry[capacity];
useAltHashing = sun.misc.VM.isBooted() &&
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
init();
}
--------------------------------------------------------------------------------------
public V put(K key, V value) {
//put null
if (key == null)
return putForNullKey(value);
//获取hash值再经过计算得到一个hash值.
int hash = hash(key);
//获取插入数组的位置,通过&运算获取
int i = indexFor(hash, table.length);
//数组i位置有数据,且hash值相同,循环每个值,知道相等的值,链表顶端你插入新值,旧的值返回.
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//1.数组i没有值
//2.经过计算的到hash不相等,说明不是同一个对象,直接插入(hash值不同,绝对不是通一个对象)
//3.hash值相同,也有可能不是同一个对象,equals比较对象是否相等,不等的才会插入
addEntry(hash, key, value, i);
return null;
}
-------------------------------------------------------------------------------
void addEntry(int hash, K key, V value, int bucketIndex) {
//以后数据长度大于阈值,如果当前要插的数组的位置没有值,不扩容,如果有值才扩容
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
JDK1.8中HashMap的等层结构
在jdk1.8中 HashMap=数组+链表+红黑树,之所以会加红黑树,是因为当聊表中的数据太长的时候,会影响查询效率,因为链表的插叙是要变遍历真个链表,时间复杂度O(n),所以加入了链表.刚才是往Map中插入数据的时候,还是采用数组+链表的结构,当链表的数据长度大于等于8的时候,并且数组的长度大于64的时候,才会将链表转换为树结构,当链表数据长度大于8,但是数组的长度小于64的时候,采用的方式是扩容以后重新分配数据的存储.,还有一点就是,在创建HashMap中的数组的时候,不是在一开始new 的时候就创建数据,而是在put的数据的时候才,创建数据.而且jdk8中是用的Node.
//没有创建默认长度得数组
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
-------------------------------------------------------------------------------
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
------------------------------------------------------------------------------------------
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//当首次put数据得时候,通过扩容的方式创建数组
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//不是首次put数据,通过hash计算到数组中下标i的数据赋值给p,如果为空,直接插入数组中,
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//得到的P不为空,先比较Hash值,hash值相同,并且equals也相同,将P赋值给e
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//转换树结构
else if (p instanceof TreeNode)
//当是树节点的时候,添加树节点
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//hash不同,比较链表的下一个元素,如果没有下一个元素,直接插入.
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//满足条件,转换为树结构,插入第8个元素的时候(TREEIFY_THRESHOLD默认为8),切数组长度大于64
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//下一个元素(从第二个元素开始)不为空,在比较hashcode和equals,当相等时候,直接跳出循环直接执行后面的覆盖返回操作,如果不相等,将当元素的下一个元素给p继续比较.知道为空,执行上面的创建信node,跳出循环,这时候e为null,不会走覆盖返回操作.
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//当是第一个元素hash值和equals都相等时,直接覆盖原来元素,原来元素返回
//当是第二个及以后的元素hash值和equals都相等时,直接覆盖原来元素,原来元素返回
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
-------------------------------------------------------------------------------------------------------------------
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//刚进来的时候,数组长度(oldCap )和阈值(oldThr )都是0,直接给newCap(数组长度)和newThr(阈值) 赋值,并且创建newCap长度的数组.
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;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
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;
}
---------------------------------------------------------------------------------------------------------------------------
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//当tab为null 是首次进入,扩容创建数组,当数组的长度小于MIN_TREEIFY_CAPACITY(64)时,也是扩容.
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
//当数组数组长度大于64时,转换为树结构
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
LinkHashedMap
LinkedHashMap可以按存入key的顺序,取出数据.是因为当它put数据的时候,重写了HashMap的new Node()方法
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
LinkedHashMap.Entry<K,V> p =
new LinkedHashMap.Entry<K,V>(hash, key, value, e);
linkNodeLast(p);
return p;
}
----------------------------------------------------------------------------------------
static class Entry<K,V> extends HashMap.Node<K,V> {
//它在HashMap中的node的基础上,又加了两个指针.
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
1773
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
