数组在存储多个数据方面的缺点：
- 一旦初始化以后，其长度就不可修改。
- 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
- 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
- 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
集合框架继承关系图
image.png
Collection
向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()
对于remove 和contains 方法，内部会去调用ArrayList的equals方法，所以我们使用contains方法时，需要重写自定义类的equals方法
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(new Person("Jerry",20));
System.out.println(coll.contains(new Person("Jerry",20)));
}
使用 Arrays.asList方法时，注意 不要使用int[]类型，可以使用其包装类类型
@Test
public void test4(){
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
}
使用Iterator来操作Collection
//错误使用iterator的情况：集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
//默认游标都在集合的第一个元素之前。
while (coll.iterator().hasNext()){
System.out.println(coll.iterator().next());
}
List接口及其实现类ArrayLisyt,LinkedList,Vector
- ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
- LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
- Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储
-ArrayList的底层原理(jdk7)
ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData，添加时，先确认容量，如果容量够，那么直接将元素赋值，如果容量不够，那么进入扩容步骤，默认扩容1.5倍，如果1.5倍依然不够，那么就使用原数组的长度加元素的长度(1)之和，如果上一步得出来的结果大于(Integer.MAX_VALUE - 8), 那么就取Integer.MAX_VALUE做数组的容量，最后根据这个最新的容量去复制老数据老新数组中并且将其赋值到elementData引用。正是因为有扩容这个步骤，所以建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity) - (对于jdk8)第一次调用add()时，底层才创建了长度10的数组，并将数据添加到elementData[0]，创建数组的步骤延迟了，其他操作基本和7一样
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
LinkedList,其内部节点为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;
}
}
Set
Set：存储无序的、不可重复的数据
无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
-
不可重复性：底层使用equals()方法来判断元素是否重复，如果元素重复，那么、添加失败。
HashSet底层：数组+链表的结构。向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值， 此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断 数组此位置上是否已经有元素： 如果此位置上没有其他元素，则元素a添加成功。 --->情况1 如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值： 如果hash值不相同，则元素a添加成功。--->情况2 如果hash值相同，进而需要调用元素a所在类的equals()方法： equals()返回true,元素a添加失败 equals()返回false,则元素a添加成功。--->情况3 对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。 jdk7:头插，jdk8:尾插(七头八尾) 因此：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals()
根据以上hashset原理做这个题(已经重写equals()和hashcode())
@Test
public void test3(){
HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
System.out.println(set); // 输出 [Person{id=1002, name='BB'}, Person{id=1001, name='AA'}]
p1.name = "CC";
set.remove(p1);
System.out.println(set); // 输出 [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
set.add(new Person(1001,"CC"));
System.out.println(set); // [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
set.add(new Person(1001,"AA"));
System.out.println(set);// [Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]
}
LinkedHashSet：可以按照添加的顺序遍历
public static void main(String[] args) {
Set set = new LinkedHashSet();
set.add(456);
set.add(123);
set.add(123);
set.add("AA");
set.add("CC");
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
// 输出结果如下
// 456
// 123
// AA
// CC
// 129
}
TreeSet
可以按照添加对象的指定属性，进行排序。
- 两种排序方式：默认排序（实现Comparable接口） 和 定制排序（Comparator）
- 默认排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
- 定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().
Map
以HashMap为例子
- Map中的key:无序的、不可重复的，使用Set存储所有的key ---> key所在的类要重写equals()和hashCode() （以HashMap为例）
- Map中的value:无序的、可重复的，使用Collection存储所有的value --->value所在的类要重写equals()
- 一个键值对：key-value构成了一个Entry对象。
- Map中的entry:无序的、不可重复的，使用Set存储所有的entry
HashMap map = new HashMap(): * 在实例化以后，底层创建了长度是16的一维数组Entry[] table。 * ...可能已经执行过多次put... * 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倍，并将原有的数据复制过来。 * * jdk8 相较于jdk7在底层实现方面的不同： * 1. new HashMap()时:底层没有创建一个长度为16的数组 * 2. jdk 8底层的数组是：Node[],而非Entry[] * 3. 首次调用put()方法时，底层创建长度为16的数组 * 4. jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树。 * 4.1 形成链表时，七头八尾 * 4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。
LinkedHashMap数据节点
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;//能够记录添加的元素的先后顺序
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
TreeMap ： 按照key进行排序：默认排序 、定制排序
泛型
泛型类
public class Order<T> {
String orderName;
int orderId;
T orderT;
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;
}
}
使用泛型类
@Test
public void test1(){
//如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
Order order = new Order();
order.setOrderT(123);
order.setOrderT("ABC");
//建议：实例化时指明类的泛型
Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");
order1.setOrderT("AA:hello");
}
泛型方法
//泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
//换句话说，泛型方法所属的类是不是泛型类都没有关系。
//泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
public static <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e : arr){
list.add(e);
}
return list;
}
在泛型的继承中
//数组中是可以这么操作的
Object[] arr1 = null;
String[] arr2 = null;
arr1 = arr2;
但是泛型是不允许这样做的，虽然类A是类B的父类，但是G<A> 和G<B>二者不具备子父类关系，二者是并列关系。
List<Object> list1 = null;
List<String> list2 = new ArrayList<String>();
//此时的list1和list2的类型不具有子父类关系
//编译不通过
// list1 = list2;
但是：类A是类B的父类，A<G> 是 B<G> 的父类,这样是可以的
通配符?的使用
@Test
public void test3(){
//类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
List<Object> list1 = null;
List<String> list2 = null;
List<?> list = null;
list = list1;
list = list2;
//使用通配符之后 可以读但是不能写
List<String> list3 = new ArrayList<>();
list3.add("AA");
list3.add("BB");
list = list3;
//添加(写入)：对于List<?>就不能向其内部添加数据。
//除了添加null之外。
// list.add("DD");
list.add(null);
//获取(读取)：允许读取数据，读取的数据类型为Object。
Object o = list.get(0);
System.out.println(o);
}
extend和super
@Test
public void test4(){
//这里的 Student是extends Person的
List<? extends Person> list1 = null; //? extends Person 表示Person类或者Person类的子类
List<? super Person> list2 = null; //? super Person 表示Person类或者Person类的父类
List<Student> list3 = new ArrayList<Student>();
List<Person> list4 = new ArrayList<Person>();
List<Object> list5 = new ArrayList<Object>();
list1 = list3;
list1 = list4;
}
