Java集合使用接口和类
- 一、Collection接口
- 二、Map接口
- 补充泛型的相关知识
- 补充二叉树的比较器compareTo方法的与原理及使用
- 问题1：Iterator迭代器与ListIterator迭代器的区别
- 问题2：iterator()，Iterator，Iterable的关系
- HashMap中的装填因子是0.75的原因
集合就是许多数据（啥类型的都有）存储在同一个“容器”中，那个“容器”好像就叫做集合，哈哈哈。
从数据库中提取出来数据，在后端存入一个集合，然后前端调用这个集合，然后一股脑的将该集合中的数据加载到页面上，让用户能看到数据。应该是这么回事。
一、Collection接口
Collection接口是List接口和Set接口的父接口，所以该接口中封装的方法，子接口可以照常使用。
以下方法都是基础的方法，详细的请查看API
public static void main(String[] args) {
/*
Collection接口的常用方法：
增加：add(E e) addAll(Collection<? extends E> c)
删除：clear() remove(Object o)
查看：iterator() size()
判断：contains(Object o) equals(Object o) isEmpty()
*/
//创建对象：接口不能创建对象，利用实现类创建对象：该创建方法为多态的一种使用方法
Collection col = new ArrayList();
//调用方法：
//集合有一个特点：只能存放引用数据类型的数据，不能是基本数据类型
//基本数据类型自动装箱，对应包装类。int--->Integer
col.add(18); //向集合中添加数据
//将这些数据转换成包装类，然后调用Arrays类中的asList方法转换为List集合
List list = Arrays.asList(new Integer[]{11, 15, 3, 7, 1});
col.addAll(list);//将另一个集合添加入col中
//col.clear();清空集合
System.out.println("集合中元素的数量为："+col.size());
System.out.println("集合是否为空："+col.isEmpty()); //返回值为布尔类型，true或false
boolean isRemove = col.remove(15); //删除值为15的元素
System.out.println("集合中数据是否被删除："+isRemove); //返回值为布尔类型，true或false
Collection col2 = new ArrayList();
col2.add(18);
col2.add(12);
Collection col3 = new ArrayList();
col3.add(18);
col3.add(12);
System.out.println(col2.equals(col3)); //调用equals方法比较两个集合中的元素是否相等，返回true或false
System.out.println(col2==col3);//地址一定不相等 false
System.out.println("是否包含元素："+col3.contains(117)); //contain是否包含此元素，返回true或false
}
1.List接口（继承于Collection接口）（特点：不唯一，有序的）
因为List接口为有序的集合，所以在该集合中增加的方法都是一些与索引相关的方法。
增加：add(int index, E element)
删除：remove(int index) remove(Object o)
修改：set(int index, E element)
查看：get(int index)
List集合的遍历：
//方式1：普通for循环：
System.out.println("---------------------");
for(int i = 0;i<list.size();i++){
System.out.println(list.get(i));
}
//方式2：增强for循环：
System.out.println("---------------------");
for(Object obj:list){
System.out.println(obj);
}
//方式3：迭代器：
System.out.println("---------------------");
//Iterator为迭代器，后续会介绍
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
（1）、ArrayList类（底层为数组存储）
因为JDK1.7跟JDK1.8版本的ArrayList是不一样的，所以我会分别列举：
1.7版本：当在调用构造器时，数组初始化的长度为10，然后当数据超出初始化时，会自动扩容为原来的1,5倍，然后再将老数组指向新数组，在返回新数组。
1.8版本：当在调用构造器时，底层数组为null，只有在调用add方法以后底层的数组才重新复制新的数组，长度为10，也是扩容1.5倍。优点：节省内存
ArrayList的线程不安全，但是效率高
数组的优点：查询速度快，但是可以重复。
数组的缺点：删除，增加元素效率低
（2）、Vector类（已淘汰，底层为数组存储）
该类底层也是数组，但是该类扩容2倍，线程安全，效率低。
（3）、LinkeList类（底层为双向链表存储）
LinkedList的源码：
public class LinkedList<E>{//E是一个泛型，具体的类型要在实例化的时候才会最终确定
transient int size = 0;//集合中元素的数量
//Node的内部类
private static class Node<E> {
E item;//当前元素
Node<E> next;//指向下一个元素地址
Node<E> prev;//上一个元素地址
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
transient Node<E> first;//链表的首节点
transient Node<E> last;//链表的尾节点
//空构造器：
public LinkedList() {
}
//添加元素操作：
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {//添加的元素e
final Node<E> l = last;//将链表中的last节点给l 如果是第一个元素的话 l为null
//将元素封装为一个Node具体的对象：
final Node<E> newNode = new Node<>(l, e, null);
//将链表的last节点指向新的创建的对象：
last = newNode;
if (l == null)//如果添加的是第一个节点
first = newNode;//将链表的first节点指向为新节点
else//如果添加的不是第一个节点
l.next = newNode;//将l的下一个指向为新的节点
size++;//集合中元素数量加1操作
modCount++;
}
//获取集合中元素数量
public int size() {
return size;
}
//通过索引得到元素：
public E get(int index) {
checkElementIndex(index);//健壮性考虑
return node(index).item;
}
Node<E> node(int index) {
//如果index在链表的前半段，那么从前往后找
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {//如果index在链表的后半段，那么从后往前找
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
}
2.Set接口（继承于Collection接口）（特点：唯一，无序的）
该接口因为是无序的（而非随机，而是根据底层的算法来进行排序），所以没有与索引相关方法。
遍历的方法：使用Iterator迭代器迭代；增强for循环遍历。
（1）、HashSet类（底层为哈希表（数组+链表）存储）
该类下还有一个实现类为：LinkedHashSet实现类。
该类的特点为：唯一，而且有序的（按照输入的顺序输出）。
该类底层是HashMap类。
（2）、TreeSet类（底层为二叉树存储）
该类的特点：唯一，有序的（是按照升序的排序进行输出），无序（没有按照输入的方式进行输出）。
底层原理：实现内部比较器（compareTo）或者外部比较器（compare）
当调用TreeSet的空构造器时，底层创建了一个TreeMap。
二、Map接口
Map接口的常用方法：
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
增加：put(K key, V value)
删除：clear() remove(Object key)
修改：
查看：entrySet() get(Object key) keySet() size() values()
判断：containsKey(Object key) containsValue(Object value)
equals(Object o) isEmpty()
*/
//创建一个Map集合：无序，唯一
Map<String,Integer> map = new HashMap<>();
System.out.println(map.put("lili", 10101010));
map.put("nana",12345234);
map.put("feifei",34563465);
System.out.println(map.put("lili", 34565677));
map.put("mingming",12323);
/*map.clear();清空*/
/*map.remove("feifei");移除*/
System.out.println(map.size());
System.out.println(map);
System.out.println(map.containsKey("lili"));
System.out.println(map.containsValue(12323));
Map<String,Integer> map2 = new HashMap<>();
System.out.println(map2.put("lili", 10101010));
map2.put("nana",12345234);
map2.put("feifei",34563465);
System.out.println(map2.put("lili", 34565677));
map2.put("mingming2",12323);
System.out.println(map==map2);
System.out.println(map.equals(map2));//equals进行了重写，比较的是集合中的值是否一致
System.out.println("判断是否为空："+map.isEmpty());
System.out.println(map.get("nana"));
System.out.println("-----------------------------------");
//keySet()对集合中的key进行遍历查看：
Set<String> set = map.keySet();
for(String s:set){
System.out.println(s);
}
System.out.println("-----------------------------------");
//values()对集合中的value进行遍历查看：
Collection<Integer> values = map.values();
for(Integer i:values){
System.out.println(i);
}
System.out.println("-----------------------------------");
//get(Object key) keySet()
Set<String> set2 = map.keySet();
for(String s:set2){
System.out.println(map.get(s));
}
System.out.println("-----------------------------------");
//entrySet()
Set<Map.Entry<String, Integer>> entries = map.entrySet();
for(Map.Entry<String, Integer> e:entries){
System.out.println(e.getKey()+"----"+e.getValue());
}
}
}
1、HashMap类（底层为哈希表（数组+链表）存储）
HashMap实现类的特点为：无序，但唯一。
该实现类按照key值进行排序总结，因底层key是按照哈希表的结构进行排序。
所以当放入这个集合的数据对应的类时，必须重写HashCode方法（将key进行哈希运算）和equals方法（判断维不唯一）。
HashMap源码详解：
public class HashMap<K,V>
extends AbstractMap<K,V> //【1】继承的AbstractMap中，已经实现了Map接口,这个地方属于重复使用
implements Map<K,V>, Cloneable, Serializable{
static final int DEFAULT_INITIAL_CAPACITY = 16;//哈希表主数组的默认长度
//定义了一个float类型的变量，以后作为：默认的装填因子，加载因子是表示Hsah表中元素的填满的程度
//太大容易引起哈西冲突，太小容易浪费 0.75是经过大量运算后得到的最好值
static final float DEFAULT_LOAD_FACTOR = 0.75f;
transient Entry<K,V>[] table;//主数组,每个元素为Entry类型
transient int size;
int threshold;//数组扩容的界限值,门槛值 16*0.75=12
final float loadFactor;//用来接收装填因子的变量
//【4】查看构造器：内部相当于：this(16,0.75f);调用了当前类中的带参构造器
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
//【5】本类中带参数构造器：--》作用给一些数值进行初始化的！
public HashMap(int initialCapacity, float loadFactor) {
//【6】给capacity赋值，capacity的值一定是 大于你传进来的initialCapacity 的 最小的 2的倍数
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
//【7】给loadFactor赋值，将装填因子0.75赋值给loadFactor
this.loadFactor = loadFactor;
//【8】数组扩容的界限值,门槛值
threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//【9】给table数组赋值，初始化数组长度为16
table = new Entry[capacity];
}
//【10】调用put方法：
public V put(K key, V value) {
//【11】对空值的判断
if (key == null)
return putForNullKey(value);
//【12】调用hash方法，获取哈希码
int hash = hash(key);
//【14】得到key对应在数组中的位置
int i = indexFor(hash, table.length);
//【16】如果你放入的元素，在主数组那个位置上没有值，e==null 那么下面这个循环不走
//当在同一个位置上放入元素的时候
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//哈希值一样 并且 equals相比一样
//(k = e.key) == key 如果是一个对象就不用比较equals了
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//【17】走addEntry添加这个节点的方法：
addEntry(hash, key, value, i);
return null;
}
//【13】hash方法返回这个key对应的哈希值，内部进行二次散列，为了尽量保证不同的key得到不同的哈希码！
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
//k.hashCode()函数调用的是key键值类型自带的哈希函数，
//由于不同的对象其hashCode()有可能相同，所以需对hashCode()再次哈希，以降低相同率。
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
/*
接下来的一串与运算和异或运算，称之为“扰动函数”，
扰动的核心思想在于使计算出来的值在保留原有相关特性的基础上，
增加其值的不确定性，从而降低冲突的概率。
不同的版本实现的方式不一样，但其根本思想是一致的。
往右移动的目的，就是为了将h的高位利用起来，减少哈西冲突
*/
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
//【15】返回int类型数组的坐标
static int indexFor(int h, int length) {
//其实这个算法就是取模运算：h%length，取模效率不如位运算
return h & (length-1);
}
//【18】调用addEntry
void addEntry(int hash, K key, V value, int bucketIndex) {
//【25】size的大小 大于 16*0.75=12的时候，比如你放入的是第13个，这第13个你打算放在没有元素的位置上的时候
if ((size >= threshold) && (null != table[bucketIndex])) {
//【26】主数组扩容为2倍
resize(2 * table.length);
//【30】重新调整当前元素的hash码
hash = (null != key) ? hash(key) : 0;
//【31】重新计算元素位置
bucketIndex = indexFor(hash, table.length);
}
//【19】将hash,key,value,bucketIndex位置 封装为一个Entry对象：
createEntry(hash, key, value, bucketIndex);
}
//【20】
void createEntry(int hash, K key, V value, int bucketIndex) {
//【21】获取bucketIndex位置上的元素给e
Entry<K,V> e = table[bucketIndex];
//【22】然后将hash, key, value封装为一个对象，然后将下一个元素的指向为e （链表的头插法）
//【23】将新的Entry放在table[bucketIndex]的位置上
table[bucketIndex] = new Entry<>(hash, key, value, e);
//【24】集合中加入一个元素 size+1
size++;
}
//【27】
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//【28】创建长度为newCapacity的数组
Entry[] newTable = new Entry[newCapacity];
boolean oldAltHashing = useAltHashing;
useAltHashing |= sun.misc.VM.isBooted() &&
(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean rehash = oldAltHashing ^ useAltHashing;
//【28.5】转让方法：将老数组中的东西都重新放入新数组中
transfer(newTable, rehash);
//【29】老数组替换为新数组
table = newTable;
//【29.5】重新计算
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
//【28.6】
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//【28.7】将哈希值，和新的数组容量传进去，重新计算key在新数组中的位置
int i = indexFor(e.hash, newCapacity);
//【28.8】头插法
e.next = newTable[i];//获取链表上元素给e.next
newTable[i] = e;//然后将e放在i位置
e = next;//e再指向下一个节点继续遍历
}
}
}
}
HashMap效率高，但线程不安全。key可以存入null值，并且key的null值也遵循唯一的特点。
在JDK1.2之前有个Hashtable实现类，但是它的效率低，线程安全，并且key不可以存入null值。
2、TreeMap类（底层为二叉树存储）
TreeMAp底层为二叉树，所以遵照二叉树的特点，放入集合的key的数据对应的类型内部一定要实现比较器（内部或外部比较器）。
补充泛型的相关知识
泛型就相当于标签
形式：<>
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，
JDK1.5之 后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。
Collection,List,ArrayList中的就是类型参数，就是泛型。
示例代码：
import java.util.ArrayList;
public class Test01 {
//这是main方法，程序的入口
public static void main(String[] args) {
//创建一个ArrayList集合，向这个集合中存入学生的成绩：
//加入泛型的优点：在编译时期就会对类型进行检查，不是泛型对应的类型就不可以添加入这个集合。
ArrayList<Integer> al = new ArrayList<Integer>();
al.add(98);
al.add(18);
al.add(39);
al.add(60);
al.add(83);
/*al.add("丽丽");
al.add(9.8);*/
//对集合遍历查看：
/*for(Object obj:al){
System.out.println(obj);
}*/
for(Integer i:al){
System.out.println(i);
}
}
}
· 泛型引用的必须都是引用数据类型，不能是基本数据类型。
·ArrayList<Integer> al = new ArrayList<Integer>();在JDK1.7之后可以写钻石运算符：ArrayList<Integer> al = new ArrayList<>();
`泛型继承关系：当父类指定了泛型，子类可以直接使用；当父类没指定泛型时，那么子类可以在创建子类对象的时候指定泛型。
·泛型类可以定义多个参数。例如：
public class TestGeneric<A,B,C>{
A age ; B name ; C sex ;
public void a(A m , B n , C x ){
}
}
·静态方法不能使用类的泛型;也就是有static关键词修饰的方法
·泛型如果没被指定，那么系统就会把他擦除。
泛型方法的含义：没带泛型的方法为泛型方法。
泛型方法对应的参数类型与当前所在的这个类是否为泛型类，是否为泛型无关。
· 泛型方法的定义前边要加上< T >，< T >在调用方法的时候确认。泛型方法可以是静态方法。
示例：
public static <T> void b(T t){
}
泛型的通配符<?>的作用：当G< A >和G< B >不存在父子关系时，加入G<?>就会变成他俩的父类。
List<? extends Person>:
就相当于：
List<? extends Person>是List的父类，是List<Person的子类>的父类
List<? super Person>就相当于：List<? super Person>是List的父类，是List<Person的父类>的父类
补充二叉树的比较器compareTo方法的与原理及使用
比较器分为内部比较器compareTo（）跟外部比较器compareTo（）
String类实现了Comparable接口，这个接口中有一个抽象方法compareTo，String类中重写这个方法即可。
内部比较器的使用逻辑代码里重写compareTo（）方法。
外部比较器是创建单独的类来重写compare（）方法。
问题1：Iterator迭代器与ListIterator迭代器的区别
Iterator只是单纯的迭代数据。
当程序需要对集合进行迭代加修改双重操作时，就会使用ListIterator。
问题2：iterator()，Iterator，Iterable的关系
HashMap中的装填因子是0.75的原因
这时我们得考虑时间跟空间的问题
如果装填因子为1，那么就证明需要等到数组满了时候才能进行数组2倍扩容，这样可以做到最大的空间利用率，但是现实中元素不可能完全的均匀分布，那就很可能发生哈希碰撞，就会产生链表，产生链表就会使查询速度变慢。
所以说当装填因子为1时，能做到最大的空间利用率，但是时间会变慢。
如果装填因子变小，变到0.5时，也就说当元素数量增加到数组容量的一半时就会进行2倍的数组扩容，这样做可以减少哈希碰撞，若不产生链表，那么查询的效率很高，但是会浪费空间。
所以当装填因子为0.5时，查询时间会很快，但是空间会浪费。
所以我们会在空间和时间中取中间值0.75来平衡这个因素。
