0、Java集合框架概述
- 集合可以将多个对象的引用动态放入容器中，方便对对象进行一些操作。现有的用来存放多个对象的结构为Array数组，但数组存在一些弊端：
①数组初始化之后，长度不可以进行改变，不便于扩展
②数组中提供的方法和属性少，不便于进行添加、删除、插入等操作，且效率不高，同时无法直接获取存储元素的个数
③数组存储的数据是有序的可以重复的
而java集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组 -
Java集合体系
Collection接口：单列数据，定义了存取一组对象的方法的集合
-------------|List接口：元素有序、可重复的集合 类似一个“动态”数组
------------------------|ArryaList类：是List接口的主要实现类；线程不安全，效率高；底层使用Object[ ]数组
------------------------|LinkedList类：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表
------------------------|Vector类：作为List接口的古老实现类；线程安全，效率低；底层使用Object[ ]数组
-------------|Set接口：元素无序、不可重复的集合 更接近于高中所讲的“集合”概念
------------------------|HashSet类：作为Set接口的主要实现类；线程不安全的；可以存储null值
------------------------------------|LinkedHashSet类：作为HashSet的子类，遍历器内部数据时，可以按照添加时的顺序遍历
------------------------|TreeSet类：可以按照添加对象的指定属性进行排序
Map接口：双列数据，保存具有映射关系“key-value”对的集合 类似于数学上的y=f(x)
-------------|Hashtable类：作为古老的实现类，线程安全，效率低，不能存储null的key和value
------------------------|Properties类：常用来处理文件，key和value都是String类型的
-------------|HashMap类：是Map的主要实现类，线程不安全的，效率高；可以存储null的key和value
------------------------|LinkedHashMap类：保证在遍历map元素时，可以按照添加的顺序进行遍历（在原有结构的基础上，按照添加顺序使用了双链表）
-------------|TreeMap类：按照添加的key-value对进行排序，实现排序遍历（key的自然排序和定制排序）
Collection接口继承树
Map接口继承树
1.Collection接口
1.1 Collection接口中的常用方法
- 使用Iterator接口遍历集合元素
Collections接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前
@Test
public void test1(){
Collection col=new ArrayList();
col.add("aaaa");
col.add("bbbb");
col.add("vv");
col.add("wweeeee");
Iterator iterator = col.iterator();
while(iterator.hasNext()){ //判断是否还有下一个元素
//next():指针下移，将下移后集合位置上的元素返回
System.out.println(iterator.next());
}
}
- 使用foreach遍历数组元素
底层仍然是调用Iterator完成操作，但注意用来修改数组元素是无用的
@Test
public void test1(){
Collection col=new ArrayList();
col.add("aaaa");
col.add("bbbb");
col.add("vv");
col.add("wweeeee");
Iterator iterator = col.iterator();
while(iterator.hasNext()){ //判断是否还有下一个元素
//next():指针下移，将下移后集合位置上的元素返回
System.out.println(iterator.next());
}
//注意此处一定要重新获取
iterator=col.iterator();
while(iterator.hasNext()){ //判断是否还有下一个元素
//next():指针下移，将下移后集合位置上的元素返回
Object str=iterator.next();
if (str.equals("vv"))
iterator.remove(); //使用iterator删除集合中的元素
}
//使用foreach循环遍历集合元素
for(Object str:col){
System.out.println(str);
}
}
-
add(Object e)添加元素 -
size()集合中的元素个数 -
addAll(Collection col)将集合中的元素全部添加到当前集合中 isEmpty()-
boolean remove(Object obj)通过元素的equals方法判断是否是要删除的那个元素，只会删除找到的第一个元素 -
boolean removeAll(Collection col)取当前集合的差集 -
boolean retainAll(Collection col)把交集的结果存在当前集合中，不影响c -
boolean equals(Object o)判断集合是否相等 -
Object[] toArray()转换成对象数组 -
hashCode()获取当前集合对象 的哈希值 - 扩展：数组变成集合 Arrays.asList(array)
1.2 List接口中的方法
- java中使用数组存储数据具有局限性（如上所述），所以通常使用List代替数组。List集合类中元素有序、可重复，集合中的每个元素都有其对应的顺序索引，可以根据元素的存储位置序号存取容器中的元素。List中的常用实现类有：ArrayList、LinkedList、Vector
- List接口：元素有序、可重复的集合 类似一个“动态”数组
-------|ArryaList类：是List接口的主要实现类；线程不安全，效率高；底层使用Object[ ]数组
-------|LinkedList类：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表 - 由于List接口的特性是元素可以通过其位置序号进行访问，所以List接口比Collection接口多出了一些有关下标index的方法，这些是Set接口中没有的，所以Collection中也没有
- void add(int index, Object ele) 在index位置插入ele元素
- boolean addAll(int index, Collection c) 在index位置插入集合c中的所有元素
- Object get(int index) 获取指定位置的元素
- int indexOf(Object o) 返回第一次出现o的位置
- int lastIndexOf(Object o) 返回最后一次出现o的位置
- Object remove(int index) 移除index位置的元素
此处一定要注意，Collection接口有一个remove(Object o)方法,如果输入是int，此时会有限考虑此int值为index，而不是数组中的元素,因为数组中存到是包装类 - Object set(int index, Object element) 设置index处的元素为element，并返回原来该位置的元素
- List subList(int fromIndex, int toIndex) 返回从fromIndex到toIndex-1的子集合（左闭右开）
@Test
public void test3(){
List list = new ArrayList(); //多态
list.add(0);
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
//1 void add(int index, Object ele) 在index位置插入ele元素
list.add(3,'A');
System.out.println(list); //[0, 1, 2, A, 3, 4, 5]
//2 boolean addAll(int index, Collection c) 在index位置插入集合c中的所有元素
List list1 = new ArrayList();
list1.add('B');
list1.add('C');
list1.add('D');
list.addAll(4,list1);
System.out.println(list); //[0, 1, 2, A, B, C, D, 3, 4, 5]
//3 Object get(int index) 获取指定位置的元素
System.out.println(list.get(1)); //1
//4 int indexOf(Object o) 返回第一次出现o的位置
System.out.println(list.indexOf(3)); //7
//5 int lastIndexOf(Object o) 返回最后一次出现o的位置
System.out.println(list.lastIndexOf(4)); //8
//6 Object remove(int index) 移除index位置的元素
// 此处一定要注意，Collection接口有一个remove(Object o)方法
// 如果输入是int，此时会有限考虑此int值为index，而不是数组中的元素
// 因为数组中存到是包装类
System.out.println(list.remove(4)); //B
System.out.println(list); //[0, 1, 2, A, C, D, 3, 4, 5]
//7 Object set(int index, Object element) 设置index处的元素为element，并返回原来该位置的元素
System.out.println(list.set(0,"hhhhhhh")); //0
System.out.println(list); //[hhhhhhh, 1, 2, A, C, D, 3, 4, 5]
//8 List subList(int fromIndex, int toIndex) 返回从fromIndex到toIndex-1的子集合（左闭右开）
List list2 =list.subList(0,3);
System.out.println(list2); //[hhhhhhh, 1, 2]
}
- 由于List接口是有顺序的，所以不仅可以通过之前的两种方法进行遍历（迭代器和for each），还可以使用最普通的通过位置来遍历，下面使用LinkedList来举例
@Test
public void test4(){
List list = new LinkedList();
list.add(0);
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
for(int i=0;i- 一道面试题
@Test
public void test5(){
List list = new ArrayList(); //多态
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
updateList(list);
System.out.println(list);
}
private void updateList(List list){
list.remove(2);
}
答案： [1, 2, 4, 5] 原因上面提到过（1.2的remove方法中）
1.3List的三个实现类
1.3.1 ArrayList
ArrayList在jdk7和jdk8中的实现有所不同（建议查看源码，顺着add函数一直看下去）
- jdk7️⃣中：创建ArrayList的同时就在内存中开辟空间，当内存不够时，扩容为原来的1.5倍。扩容是一个耗时的操作，所以建议在开发中使用带参的构造器：
ArrayList list = new ArrayList(int capacity)
ArrayList list = new ArrayList();//底层创建长度为10的object[ ]数组elementData
list.add(123);//elementData[0]=new Integer(123);
//.......
list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容
//默认情况下扩容为原来的1.5倍，同时需要将原有数组中的数据复制到新的数组中
- jdk8️⃣中：创建ArrayList时并没有在内存中开辟空间，而是在首次调用add()函数添加元素时才创建长度为10的数组，并将元素添加进去，其他的与jdk7无异
ArrayList list = new ArrayList();//底层object[ ] elementData初始化为{ }，实际长度为0
list.add(123);//第一次调用add，底层创建长度为10的数组，并将123添加到数组中
//.......
list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容
//默认情况下扩容为原来的1.5倍，同时需要将原有数组中的数据复制到新的数组中
- 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存
1.3.2 LinkedList
- 创建list的时候实际上创建了一个空的list，源码：
ransient int size = 0;
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node last;
/**
* Constructs an empty list.
*/
public LinkedList() {
}
- 内部声明了Node类型的first和last属性，默认值为null，从源码可以看出，LinkedList是以双向链表的形式进行存储，添加的元素都被封装到Node中，每次添加元素时，都会与last元素链接起来（下面的代码是从源码中抽出来的，配合食用效果更佳）
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* Links e as last element.
*/
void linkLast(E e) {
final Node l = last;
final Node newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
//内部使用Node进行存储，Node中的属性声明以及构造器
private static class Node {
E item;
Node next;
Node prev;
Node(Node prev, E element, Node next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
1.3.3 Vector
- 通过Vector()构造器创建对象时，底层都创建了长度为10的数组，在扩容方面，默认扩容为原来的数组长度的2倍
1.4Set接口
- Set接口是Collection的子接口，它没有提供额外的方法。Set集合中不允许包含相同的元素，Set判断两个对象是否相同使用的不是==运算符，而是根据equals()方法
- Set接口：元素无序、不可重复的集合 更接近于高中所讲的“集合”概念
----------|HashSet类：作为Set接口的主要实现类；线程不安全的；可以存储null值
------------------|LinkedHashSet类：作为HashSet的子类，遍历器内部数据时，可以按照添加时的顺序遍历
----------|TreeSet类：可以按照添加对象的指定属性进行排序 - 无序性不等于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加，而是按照数据的哈希值进行存储
- 不可重复性：保证添加的元素按照equals进行判断是，不能返回true，即相同的元素只能添加一个
- 以HashSet为例描述添加元素的过程
① 调用该元素所在类的hashCode()方法，计算其哈希值，利用此哈希值通过某种算法计算出在HashSet底层数组的存放位置（索引位置）
② 判断该位置上是否有元素
③ 如果没有元素，则添加成功；
如果有其他元素（链表形式连接），则挨个进行比较：如果hash值不同，则添加成功，；如果hash值相同但equals()返回false，则添加成功；如果hash相同，equals()返回true，则添加失败
在链表处采用七上八下的做法：jdk7中，添加的元素放在数组位置，指向原链表列；jdk8中，添加的元素放在链表中，原数组中的元素仍在原地 - hash值不多讲，直接使用重写时idea提供的即可
1.5Set的三个实现类
1.5.1 HashSet
- HashSet的底层实际上是HashMap
- HashSet是Set接口的典型实现，大多时候使用Set集合时都使用这个实现类。HashSet使用Hash算法来存储集合中的元素，因此具有很好的存取、查找、删除性能
- HashSet中判断两个元素相等的标准：hashCode() 和equals()都相等
- 重写hashCode()的基本原则：在程序运行时，同一个对象多次调用hashCode()方法应该返回相同的值；当两个对象的equals方法返回true时，这两个对象的hashCode方法的返回值也应该相等；equals方法用来比较的field都应该用来计算hashCode值
1.5.2 LinkedHashSet
- LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个数据和后一个数据（双向链表），所以能够实现按照添加顺序进行遍历，对于频繁的遍历操作，LinkedHashSet的效率高于HashSet
1.5.3 TreeSet
- TreeSet和后面要讲的TreeMap底层采用的是红黑树的方式进行存储，查找元素的速度比List要快，可以实现按照指定属性进行排序输出
- 由于TreeSet需要对元素进行比较，所以要写该元素对应类的比较器（自然排序、定制排序），此时比较两个对象是否相同的标准不是equals而是compare或者compareTo方法
- 向TreeSet中添加的数据必选是相同类的对象
public class StudentTestDemo{
@Test
public void test1(){
TreeSet set = new TreeSet();
set.add(new StudentTest(12,"ddddd"));
set.add(new StudentTest(13,"gggg"));
set.add(new StudentTest(9,"rrrr"));
set.add(new StudentTest(4,"ppppp"));
for(Object student : set){
System.out.println(student);
}
}
}
class StudentTest implements Comparable{
int age;
String name;
public StudentTest(int age, String name) {
this.age = age;
this.name = name;
}
@Override
public int compareTo(Object o) {
Integer ageInteger= age;
return ageInteger.compareTo(((StudentTest)o).age);
}
@Override
public String toString() {
return "StudentTest{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
- 面试题一道
注意重写了Person的equals()和hashCode()
public class PersonTest{
@Test
public void test(){
HashSet set = new HashSet();
Person person1=new Person(1001,"AA");
Person person2=new Person(1002,"BB");
set.add(person1);
set.add(person2);
person1.name="CC";
set.remove(person1);
System.out.println(set); //[Person{age=1002, name='BB'}, Person{age=1001, name='CC'}]
set.add(new Person(1001,"CC"));
System.out.println(set); //[Person{age=1002, name='BB'}, Person{age=1001, name='CC'}, Person{age=1001, name='CC'}]
set.add(new Person(1001,"AA"));
System.out.println(set);
//[Person{age=1002, name='BB'}, Person{age=1001, name='CC'}, Person{age=1001, name='CC'}, Person{age=1001, name='AA'}]
}
}
class Person{
int age;
String name;
public Person(int age, String name) {
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(age, name);
}
}
2.Map接口
2.1 Map接口的基础知识
- Map接口：双列数据，保存具有映射关系“key-value”对的集合 类似于数学上的y=f(x)
-------------|Hashtable类：作为古老的实现类，线程安全，效率低，不能存储null的key和value
------------------------|Properties类：常用来处理文件，key和value都是String类型的
-------------|HashMap类：是Map的主要实现类，线程不安全的，效率高；可以存储null的key和value
------------------------|LinkedHashMap类：保证在遍历map元素时，可以按照添加的顺序进行遍历（在原有结构的基础上，按照添加顺序使用了双链表）
-------------|TreeMap类：按照添加的key-value对进行排序，实现排序遍历（key的自然排序和定制排序） - 对Map的进一步理解
Map中的key是无序的、不可重复的，如果将所有的key抽取出来，应该使用Set来存储，因此key所在的类要重写equals()和hashCode()方法（参考HashSet）
Map中的value是无序的、可重复的，如果将所有的value抽取出来，应该使用Collection来存储 - 一个键值对：key-value构成了一个Entry对象
Map中的Entry是无序的、不可重复的，使用Set存储所有的entry - 增、改：
Object put(Object key, Object value)将键值对添加到或者修改当前的map对象
void putAll(Map m)将m中所有的键值对存储到当前map中 - 删：
Object remove(Object key)删除指定key值的键值对，返回其value值
void clear()：清楚map中的所有数据，但是此时的map并不是null，只是没有存数据 - 查：
Object get(Object key)获取指定key对应的value
boolean containsKey(Object key)是否包含指定的key
boolean containsValue(Object value)是否包含指定的value
int size()
boolean isEmpty()判断当前map是否为空
boolean equals(Object obj)判断当前map和参数对象obj是否相等(类型不相同的话一定不相等) - 元视图操作的方法
Set keySet()返回所有key构成的set集合
Collection values()返回所有values构成的Collection集合
Set entrySet()返回所有key-value对构成的set集合
//遍历所有的set
public void test(){
//遍历所有的key 遍历key-value对的方法之一
HashMap map = new HashMap();
map.put("AA",123);
map.put("BB",456);
map.put("CC",789);
Set keys=map.keySet();
//迭代器 foreach keys.size() 都可以
Iterator iterator1=keys.iterator();
while(iterator1.hasNext()){
Object o=iterator1.next();
System.out.println("key:"+o+";value:"+map.get(o));
}
//遍历所有的values
Collection values = map.values();
for(Object o:values){
System.out.println(obj);
}
//遍历key-value对的方法之二
Set entrySet = map.entrySet();
Iterator iterator2 = entrySet.iterator();
while(iterator2.hasNext()){
Object o=iterator1.next();
Map.Entry entry = (Map.Entry)o;
System.out.println("key:"+entry.getKey()+";value:"+entry.getValue());
}
}
2.2 Map的相关实现类
2.2.1 HashMap
- HashMap的底层：
jdk7.0及之前：数组+链表
jdk8.0及之后：数组+链表+红黑树 - 此处以HashMap（jdk7.0）为例用来理解添加键值对的基本过程：
HashMap map = new HashMap()； //实例化之后，底层创建了长度为16的一维数组Entry[] table
map.put(key1, value1)；
① 调用key1所在类的hashCode()计算其hash值，此hash值经过计算后得到Entry数组中的存放位置
② 如果此位置为空，则key1-value1添加成功
③如果跟不为空，证明此位置上存在着一个或多个通过链表结构链接的entry，比较key1与他们的哈希值（过程与HashSet的添加过程相同）
④如果hash不相同，则添加成功；如果hash相同，equals不同，则添加成功；如果都相同，则使用value1替换原位置上的value，更新成功。（添加成功的情况均以链表的形式存在，并且添加的过程中会涉及到扩容的问题，建议查看源码，扩容为原来容量的二倍，将原有的数据复制过来） - JDK8.0相较于JDK7.0在底层实现方面的不同：
① new HashMap() 底层并不会创建一个长度为16的数组
② jdk 8底层的数组是 Node[ ]
③ 首次使用put方法添加数据时，底层创建长度为16的数组
④ jdk7.0及之前的底层结构为数组+链表；jdk8.0及之后的底层结构为数组+链表+红黑树。具体来说，当数组某一个索引位置上的元素以链表形式存在的数组个数>8且当前数组的长度>64时，此时会将此索引上的所有数据改为红黑树进行存储 - 强烈建议查看源码
- 几个比较重要的常量
1️⃣DEFAULT_INITIAL_CAPACITY：HashMap的默认容量，16（初始化的容量）
2️⃣DEFAULT_LOAD_FACTOR：加载因子，默认加载因子为0.75
3️⃣thread：扩容的临界值=容量加载因子 160.75=12
4️⃣TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值（8）时，转化为红黑树
5️⃣MIN_TREEIFY_CAPACITY：Bucket中的Node被树化时最小的hash表容量 64
2.2.2 LinkedHashMap
是HashMap的子类，在其基础上使用双向链表将元素按照添加顺序连接起来，频繁执行遍历操作时建议使用LinkedHashMap（同一个位置上的元素使用单向链表连接）
2.2.3 Properties
- 该对象用于处理属性文件。由于属性文件里的key和value都是字符串类型，所以Properties里的key和value也都是字符串类型
- 存取数据时，建议使用setProperty(String key, String value)方法和getProperty(String key)
- 示例（idea创建属性文件的后缀为.properties，看看就好了，涉及到文件读写的exception没有处理）
public void test(){
Properties pro = new Properties();
FileInputStream fis = new FileInputStream("jdbc.properties");
pro.load(fis);
String name = pro.getproperty("name");
pro.setproperty("password","123456789");
fis.close();
}
3.Collections工具类
- Collections是一个操作List、Set和Map等集合的工具类
- Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
- 排序操作：
reverse(List)反转
shuffle(List)对List中元素进行随机排序
sort(List)根据元素所在类的自然排序都元素按照升序进行排序
sort(List, Comparator)定制排序
swap(List, int ,int)交换指定位置上的两个元素 - 查找、替换
Object max(Collection)按照元素的自然排序，返回集合中的最大元素
Object max(Collection, 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对象的所有旧值 - 需要注意的void copy(List dest,List src)` 将src的内容复制到dest中
在源码中，会首先比较dest和src的长度，如果dest.size()
List dest = Arrays.asList(new Object[list.size]);//list为需要被复制的src
System.out.println(dest.size());
Collections.copy(dest,list);
System.out.println(dest);
- Collections类中提供了多个synchronizedXxx()方法，该方法可以将指定的集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题，例如synchronizedCollection()、synchronizedList()、synchronizedMap()、synchronizedSet()
其实看它的源码，使用的还是类自己的原始方法，只是包装的时候，用synchronized同步代码块的方式把它包裹起来了