（易忘篇）java基础编程高级阶段3
本博客随笔主要记录本人学习过程中的知识，欢迎大家一同学习，有不对的地方很高兴读者能详细指出，感激不尽！
Java集合
Collection接口
- Collection集合与数组间的转换
- 集合 --->数组：toArray()
Object[] arr = coll.toArray();
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
- 数组 --->集合:调用Arrays类的静态方法asList(T ... t)
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);
List arr1 = Arrays.asList(new int[]{123, 456});
System.out.println(arr1.size());//1
List arr2 = Arrays.asList(new Integer[]{123, 456});
System.out.println(arr2.size());//2
Collections接口常用方法
- reverse(List)：反转 List 中元素的顺序
- shuffle(List)：对 List 集合元素进行随机排序
- sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
- sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
- swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
- Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
- Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
- Object min(Collection)：通过自然排序返回指定集合中最小的元素
- Object min(Collection，Comparator)：通过自定义排序返回指定集合中最小的元素
- int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
- void copy(List dest,List src)：将src中的内容复制到dest中
- boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
说明：
ArrayList和HashMap都是线程不安全的，如果程序要求线程安全，我们可以将ArrayList、HashMap转换为线程的。使用synchronizedList(List list） 和 synchronizedMap(Map map）。
Collection子接口：List接口
- 常用实现类
|----Collection接口：单列集合，用来存储一个一个的对象
* |----List接口：存储有序的、可重复的数据。 -->“动态”数组,替换原的数组
* |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
* |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
* |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储
- 常用方法
增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator迭代器方式
② 增强for循环
③ 普通的循环
- 源码分析（难点）
3.1 ArrayList的源码分析：
- jdk7情况下：
初始化时底层创建了长度是10的Object[]数组elementData；如果某次添加导致底层elementData数组容量不够，则扩容；默认情况下，扩容为原来的容量的1.5，同时需要将原有数组中的数据复制到新的数组中。
结论：建议开发中使用带参数（指定容量）的构造器：ArrayList list = new ArrayList(int capacity)。 - jdk8中ArrayList的变化：
底层Object[] elementData初始化为{}，并没有创建长度为10的数组；第一次调用add()添加元素时，底层才创建了长度为10的数组，并将数据添加到elementData[0]中；后续的添加和扩容操作与jdk7无异。 - 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
3.2 LinkedList的源码分析：
-
LinkedList list = new LinkedList();内部声明了Node类型的first和last属性，默认值为null。
添加元素时，将元素分装到Node中，创建了Node对象。其中，Node定义：体现了LinkedList的双向链表的说法：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; } }
3.3 Vector的源码分析：
- jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。在扩容方面，默认扩容为原来的数组长度的2倍。
Map接口
- 常用实现类
|----Map:双列数据，存储key-value对的数据 ---类似于高中的函数：y = f(x)
* |----HashMap:作为Map的主要实现类；线程不安全的，效率高；可以存储null的key和value
* |----LinkedHashMap:保证在遍历map元素时，可以照添加的顺序实现遍历。
* 原因：在原的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
* 对于频繁的遍历操作，此类执行效率高于HashMap。
* |----TreeMap:保证照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
* 底层使用红黑树
* |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
* |----Properties:常用来处理配置文件。key和value都是String类型
*
*
* HashMap的底层：数组+链表 （jdk7及之前)
* 数组+链表+红黑树 （jdk 8)
- 常用方法
- 添加：put(Object key,Object value)
- 删除：remove(Object key)
- 修改：put(Object key,Object value)
- 查询：get(Object key)
- 长度：size()
- 遍历：keySet() / values() / entrySet()
- 存储结构的理解
- Map中的key：无序的、不可重复的，使用Set存储所有的key。（以HashMap为例）key所在的类要重写equals()和hashCode()。
- Map中的value：无序的、可重复的，使用Collection存储所有的value。value所在的类要重写equals()。
- key-value：一个键值对构成了一个Entry对象，Entry对象是无序的、不可重复的，使用Set存储所有的entry。
图示：
- 源码分析（难点）
4.1 HashMap在jdk7中实现原理：
HashMap map = new HashMap();在实例化以后，底层创建了长度是16的一维数组Entry[] table。map.put(key1,value1):
① 首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
② 如果此位置上的数据为空，此时的key1-value1添加成功。 ----情况1
③ 如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：
④ 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2
⑤ 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：如果equals()返回false:此时key1-value1添加成功。----情况3；如果equals()返回true:使用value1替换value2。- 补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
- 在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。默认的扩容方式：扩容为原来容量的2倍，并将原的数据复制过来。
4.2 HashMap在jdk8中相较于jdk7在底层实现方面的不同：
1. new HashMap():底层没创建一个长度为16的数组。
2. jdk 8底层的数组是：Node[],而非Entry[]。
3. 首次调用put()方法时，底层创建长度为16的数组。
4. jdk7底层结构只：数组+链表。jdk8中底层结构：数组+链表+红黑树。
4.1 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）。
4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。
4.3 HashMap底层典型属性的说明：
DEFAULT_INITIAL_CAPACITY：HashMap的默认容量，16
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
threshold：扩容的临界值=容量*填充因子：16 * 0.75 => 12
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8（前提：数组如果长度小于MIN_TREEIFY_CAPACITY（64）就选择扩容，而不是转化为红黑树）
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64
泛型
自定义泛型类
public class Order<T> {
String orderName;
int orderId;
//类的内部结构就可以使用类的泛型
T orderT;
public Order(){
//编译不通过
// T[] arr = new T[10];
//编译通过
T[] arr = (T[]) new Object[10];
}
public Order(String orderName,int orderId,T orderT){
this.orderName = orderName;
this.orderId = orderId;
this.orderT = orderT;
}
//如下的个方法都不是泛型方法
public T getOrderT(){
return orderT;
}
public void setOrderT(T orderT){
this.orderT = orderT;
}
@Override
public String toString() {
return "Order{" +
"orderName='" + orderName + '\'' +
", orderId=" + orderId +
", orderT=" + orderT +
'}';
}
//静态方法中不能使用类的泛型。
// public static void show(T orderT){
// System.out.println(orderT);
// }
public void show(){
//编译不通过
// try{
//
//
// }catch(T t){
//
// }
}
//泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没任何关系。
//换句话说，泛型方法所属的类是不是泛型类都没关系。
//泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
public static <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
}
通配符
- 通配符的使用
/*
通配符的使用
通配符：?
类A是类B的父类，G<A>和G<B>是没关系的，二者不具备子父类关系，二者是并列关系，二者共同的父类是：G<?>
补充：类A是类B的父类，A<G> 是 B<G> 的父类
*/
@Test
public void test3(){
List<Object> list1 = null;
List<String> list2 = null;
List<?> list = null;
list = list1;
list = list2;
//编译通过
// print(list1);
// print(list2);
//
List<String> list3 = new ArrayList<>();
list3.add("AA");
list3.add("BB");
list3.add("CC");
list = list3;
//添加(写入)：对于List<?>就不能向其内部添加数据。
//除了添加null之外。
// list.add("DD");
// list.add('?');
list.add(null);
//获取(读取)：允许读取数据，读取的数据类型为Object。
Object o = list.get(0);
System.out.println(o);
}
- 有限制条件的通配符的使用
/*
限制条件的通配符的使用。
? extends A:
G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类
? super A:
G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类
*/
@Test
public void test4(){
List<? extends Person> list1 = null;
List<? super Person> list2 = null;
List<Student> list3 = new ArrayList<Student>();
List<Person> list4 = new ArrayList<Person>();
List<Object> list5 = new ArrayList<Object>();
list1 = list3;
list1 = list4;
// list1 = list5;
// list2 = list3;
list2 = list4;
list2 = list5;
//读取数据：
list1 = list3;
Person p = list1.get(0);
//编译不通过
//Student s = list1.get(0);
list2 = list4;
Object obj = list2.get(0);
////编译不通过
// Person obj = list2.get(0);
//写入数据：
//编译不通过
// list1.add(new Student());
//编译通过
list2.add(new Person());
list2.add(new Student());
}
