Collection
集合与数组存储数据概述：
集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中)数组存储的特点：
一旦初始化以后，其长度就确定了。
数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
比如：String[] arr;int[] arr1;Object[] arr2;
- 数组存储的弊端：
一旦初始化以后，其长度就不可修改。
数组中提供的方法非常限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
- 集合存储的优点：
解决数组存储数据方面的弊端。
集合中有Collection和Map
Collection
1.List 接口：存储有序的，可重复的数据
----》ArrayList ： List的主要实现类，线程不安全，效率高，底层使用Object[]存储
----》LindedList ：底层使用双向链表，对于插入删除效率比ArrayList高
----》vector：古老实现类，线程安全的，效率低
ArrayList 的底层实现原理：
ArrayList arr = new ArrayList（）；//底层创建了长度是10 的obj数组如果此次添加导致底层elementData数组容量不足，则扩容，一般情况下扩容为1.5倍
同时需要将原有的数组复制到新的数组中
建议开发中使用带参的构造器：ArrayList list = new ArrayList（int capacity）
向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().
Collection接口常用方法：
add(Object obj)
addAll(Collection coll)
size()
isEmpty()
clear();
contains(Object obj)
containsAll(Collection coll)
remove(Object obj)
removeAll(Collection coll)
retainsAll(Collection coll)
equals(Object obj);
hasCode()
toArray()
iterator();
@Override
public boolean equals(Object o) {
System.out.println("person equals....");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
if (age != person.age) return false;
return name != null ? name.equals(person.name) : person.name == null;
}
增：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循环
③ 普通的循环
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
1 ArrayList的源码分析：
* 2.1 jdk 7情况下
* ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
* list.add(123);//elementData[0] = new Integer(123);
* ...
* list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
* 默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
*
* 结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
*
* 2.2 jdk 8中ArrayList的变化：
* ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没创建长度为10的数组
*
* list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
* ...
* 后续的添加和扩容操作与jdk 7 无异。
* 2.3 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象
* 的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
*
4.2 LinkedList的源码分析：
* LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null
* list.add(123);//将123封装到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;
}
}
4.3 Vector的源码分析：
jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
在扩容方面，默认扩容为原来的数组长度的2倍。
面试题：ArrayList，LinkList，Vector三者的异同？
- 同：三个类都实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
- 不同：见上方
2.Set接口：存储无序的，不可重复的数据
----》 HashSet：作为Set接口的主要实现类：线程不安全，可以存储null值
----》 LinkHashSet：作为 HashSet的子类，遍历其内部数据时，可以按照添加的顺序去遍历
---------------------------优点：对于频繁的遍历操作，效果高于HashSet，因为其添加了两个引用
----》 TreeSet：可以按照添加对象的指定属性进行排序
要求：向set中添加的数据，其所在类一定要重写equals和hashCode方法。
Set接口中没额外定义新的方法，使用的都是Collection中声明过的方法。
一。Set：存储无序的，不可重复的数据
以HashSet为例说明：
1.无序性：不等于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的
2.不可重复性：保证添加的元素，安装equals()判断时，不能返回true，相同的元素只能添加一个
二。添加元素的过程：以HashSet为例：
我们向HashSet中添加元素，首先调用元素a所在的类的hashCode()方法，计算a的哈希值
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放元素，即为索引位置
判断数组此位置上是否有元素：
如果位置上没有元素，则元素a添加成功
如果此位置上有其他元素B（或以链表形式存在的多个元素，）则比较a与b的哈希值：
如果哈希值不同，则a添加成功
如果哈希值相同，则需要调用元素a所在类的equals方法
HashSet 底层存储形式：数组加链表
TreeSet:
1.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
2.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().
6. TreeSet的使用
6.1 使用说明:
1.向TreeSet中添加的数据，要求是相同类的对象。
2.两种排序方式：自然排序（实现Comparable接口 和 定制排序（Comparator）
6.2 常用的排序方式:
//方式一：自然排序
@Test
public void test1(){
TreeSet set = new TreeSet();
//失败：不能添加不同类的对象
// set.add(123);
// set.add(456);
// set.add("AA");
// set.add(new User("Tom",12));
//举例一：
// set.add(34);
// set.add(-34);
// set.add(43);
// set.add(11);
// set.add(8);
//举例二：
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
set.add(new User("Jim",2));
set.add(new User("Mike",65));
set.add(new User("Jack",33));
set.add(new User("Jack",56));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
//方式二：定制排序
@Test
public void test2(){
Comparator com = new Comparator() {
//照年龄从小到大排列
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
return Integer.compare(u1.getAge(),u2.getAge());
}else{
throw new RuntimeException("输入的数据类型不匹配");
}
}
};
TreeSet set = new TreeSet(com);
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
set.add(new User("Jim",2));
set.add(new User("Mike",65));
set.add(new User("Mary",33));
set.add(new User("Jack",33));
set.add(new User("Jack",56));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
