1. Java集合框架概述
1.集合、数组都是对多个数据进行存储操作的结构,简称Java容器。
2. 数组在存储多个数据方面的特点:
1)一旦初始化之后,其长度就确定了。
2) 定义数组是必须要定义化其存储元素的类型。
缺点:
1)一旦初始化之后,器长度就不可修改。
2)数组中提供的方法非常有限,对于添加、删除、插入数据等操作,非常不变,同时效率不高。
3)获取数组中实际元素的个数需求,数组没有现成的属性和方法可用。
4)数组存储数据的特点:有序、可重复、对于无序、不可重复的需求,不能满足。
上图中iterator应为iterable!!!
2. Collection接口方法
/**
* 返回集合中元素的个数,当元素个数超过Integer.MAX_VALUE,返回Integer.MAX_VALUE。
*/
int size();
/**
* 当集合中没有元素时返回true,否则返回false.
*/
boolean isEmpty();
/**
* 判断集合中是否有元素e,满足o.equals(e).
*/
boolean contains(Object o);
/**
* 判断某一集合是否包含集合c中的所有元素。
*/
boolean containsAll(Collection<?> c);
/**
* 向集合中添加该元素。添加成功返回true。
* 如果此集合不允许重复,并且已经包含指定元素,返回false。
*/
boolean add(E e);
/**
* 向集合中添加集合c中的所有元素,如果集合因此操作而改变(添加了c中的元素),则返回true.
*/
boolean addAll(Collection<? extends E> c);
/**
* 从集合中移除一个元素e满足o.equals(e),如果集合中存在多个相同的e,只移除一个(先找到的那个【待定】)。
*/
boolean remove(Object o);
/**
* 从该集合中移除所有集合c中存在的元素。
*/
boolean removeAll(Collection<?> c);
/**
* 只保留该集合与集合c中元素相同的元素(交集)。
*/
boolean retainAll(Collection<?> c);
/**
* 清除该集合中的所有元素。
*/
void clear();
/**
* 返回该集合的迭代器
*/
Iterator<E> iterator();
/**
* 集合转数组
*/
Object[] toArray();
/**
* 集合转数组
*/
<T> T[] toArray(T[] a);
/**
* 判断该集合和o是否相等
*/
boolean equals(Object o);
/**
* 返回此集合的hashcode
*/
int hashcode();
3. Iterator迭代器接口
/**
* 集合的遍历操作,使用迭代器Iterator接口
* <p>
* 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,
* 默认游标都在集合的第一个元素之前。
*/
public interface Iterator<E> {
/**
* 判断是否有下一个元素
*/
boolean hasNext();
/**
* 返回迭代器指向的下一个元素。
*/
E next();
/**
* 移除当前指向的元素
*/
default void remove();
}
foreach循环内部其实就是调用了迭代器。
4. Collection子接口一:List
/**
* 1.List接口:
* 1)ArrayList:作为List接口的主要实现类,线程不安全,效率高。底层使用Object[]存储。
* 2)LinkedList:对于频繁的插入和删除操作,使用此类效率比ArrayList高;底层使用双向链表存储。
* 3)Vector:作为List接口的古老实现类,线程安全,效率低。底层使用Object[]存储。
*
* 2. ArrayList源码分析:
* 2.1 jdk7情况下:
* ArrayList list = new Arraylist();//底层创建了长度为10的Object[]数组elementData.
* list.add(1);//elementData[0] = new Integer(1);
* ...
* list.add(11);//如果此次的添加导致底层的elementData数组容量不够,则扩容。
* 默认情况下,扩容为原来的容量的1.5倍,同时需要将原有的数组中的数据复制到新数组中。
* 建议开发中使用带参的构造器 ArrayList list = new ArrayList(int capacity);
* 2.2 jdk8中ArrayList的变化:
* ArrayList list = new ArrayList();//底层Object[] elementData初始化为{},并没有创建长度为
* 10的数组。
* list.add(123);//第一次调用add()时,底层才创建了长度为10的数组,并将数据123添加到elementData.
* 2.3 小结:jdk7中ArrayList的对象的创建类似与单例的饿汉式,而jdk8中的ArrayList的对象的创建类似与
* 单例的懒汉式,延迟了数组的创建,节省了内存。
*
* 3. LinkedList源码分析:
* LinkedList list = new LinkedList();
* list.add(1);//将1封装到Node中,创建了Node对象。
*
* 其中,Node定义为:(体现了LinkedList的双向链表的说法)
* private static class Node<E> {
* E item;
* Node<E> next;
* Node<E> prev;
* }
*
* 4. Vector源码分析:jdk7和jdk8中通过Vector()构造器创建对象时,底层到创建了长度为10的数组。
* 在扩容方面,默认扩容为原来的数组长度的2倍。
*
*
*
* 面试题:ArrayList、LinkedList、Vector三者有何异同?
* 同:三个类都实现了List接口。
* 不同:如上
*/
List接口中remove有两种方法,一个继承Collection接口的remove方法,一个是重载的remove方法。注意区分!!!
subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开的子集合。
总结:List常用方法
增:add(Object obj)
删:remove(int index)/ remove(Object obj)
改:set(int index, Object o)
查:get(int index)
插入:add(int index, object o);
长度:size()
遍历:1)Iterator迭代器。2)for 。3) for each
5. Collection子接口二:Set
/**
* 1. Set接口的框架结构:无序的,不可重复的数据。
* 1)HashSet:作为Set接口的主要实现类:线程不安全;可以存储null值。底层是数组加链表的形式存储的。
* 2) LinkedHashSet: HashSet子类;遍历其内部数据时,可以按照添加的顺序进行遍历。
* 3)TreeSet:可以按照添加对象的指定属性进行排序。
* <p>
* 1. set接口中没有额外定义新的方法
* 2. 要求:向Set中添加的数据,其所在的类一定要重写hashCode()和equals()
* 重写的hashCode()和equals()尽可能保持一致性:相等的对象不许具有相同的散列码。
* 重写两个方法的小技巧:对象中用作equals()方法比较的Field,都应该用来计算hashCode。
* 尽量通过IDE来生成。
* <p>
* 一、Set:存储无序的,不可重复的数据。
* 以HashSet为例说明
* 1. 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值决定存储位置。
* <p>
* 2. 不可重复性:保证添加的元素按照equals()判断时,不能返回true。即:相同的元素只能添加一个。
* <p>
* 二、添加元素的过程:以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
* <p>
* 对于添加成功的情况2和情况3而言:元素a已经存在指定索引位置上数据以链表的方式存储。
* jdk7:元素a放在数组中,指向原来的元素。
* jdk8:原来的元素在数组中,指向元素a.
* 总结:七上八下
* <p>
* <p>
* 三、LinkedHashSet的使用
* LinkedHashSet作为HashSet的子类,在添加数据的同时,每个数据还维护了两个引用,记录此数据的前一个数据和后一个数据。
* 优点:对于频繁的遍历操作,LinkedHashSet效率高于HashSet
* <p>
* 四、TreeSet的使用
* 1. 向TreeSet中添加的数据,要求是相同类的对象。
* 2. 两种排序方式:自然排序(Comparable)、定制排序(Comparator)
* 3. 自然排序中,比较两个对象是否相同的标准为:compareTo()返回0,不再是equals().
* 4. 定制排序中,比较两个对象是否相同的标准为:compare() 返回0,不再是equals().
*
*/
TreeSet两种排序方式的实现
- 自然排序:需要TreeSet中存储的对象的对应类实现Comparable接口
class User implements Comparable {
String name;
int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public int compareTo(Object o) {
if (o instanceof User) {
User user = (User) o;
return this.name.compareTo(user.name);
} else {
throw new RuntimeException("输入类型不匹配");
}
}
}
@Test
public void test3() {
TreeSet set = new TreeSet();
set.add(new User("Tom", 20));
set.add(new User("Jim", 21));
set.add(new User("Jack", 26));
set.add(new User("Mike", 23));
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
- 定制排序:需要在新建TreeSet对象时传入实现Comparator接口的对象。
@Test
public void test4(){
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);
}
6. Map接口
/**
* Map双列数据,存储key-value对的数据。
* ->HashMap:作为Map的主要实现类;线程不安全;效率高;存储null的key和value
* -->HashLinkedMap:保证在遍历Map元素时,可以按照添加的顺序实现遍历。
* ----------------原因:在原有的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素。
* ----------------对于频繁的遍历操作,此类执行效率高于HashMap.
* <p>
* ->TreeMap:保证按照添加的key-value对进行排序,是排序遍历。排序考虑key的自然排序或定制排序。
* -----------底层使用红黑树。
* ->Hashtable:作为古老的实现类;线程安全;效率低;不能存储null的key和value
* -->Properties:常用来处理配置文件。key和value都是String类型。
* <p>
* HashMap的底层:数组+链表 (jdk7之前)。 数组+链表+红黑树 (jdk8)
* <p>
* 面试题:
* 1. HashMap的底层实现原理?
* <p>
* 2. HashMap和Hashtable的异同?
* <p>
* 3. CurrentHashMap和Hashtable的异同?(暂时不讲)
* <p>
* 二、Map结构的理解:
* Map中的key:无序的、不可重复的,使用Set存储所有的key -->key所在的类要重写equals()和hashcode()。以hashMap为例)
* Map中的value:无序的、可重复的,使用Collection存储所有的value.-->value所在类要重写equals().
* 一个键值对:key-value构成一个Entry对象。
* Map中的entry:无序的、不可重复的,使用Set存储所有的entry.
* <p>
* 三、HashMap的底层实现原理?(以jdk7为例说明)
* HashMap map = new HashMap();
* 在实例化以后,底层创建了长度为16的一维数组Entry[] table.
* ....已经执行多次put...
* map.put(key1,value1);
* 首先,调用key1所在类的hashcode()计算key1的哈希值,此哈希值经过某种算法计算以后,得到在entry数组的
* 存放位置,如果此位置上的数据为空,此时的key1-value1添加成功。
* 如果此位置上的数据不为空,(意味着此位置上存放一个或多个数据(以链表的形式存在),比较key1和已经存在的一个或多个
* 数据的哈希值:
* ---------如果key1的哈希值与已经存在的数据的哈希值都不同,此时key1-value1添加成功。---情况2
* ---------如果相同,继续比较:调用key1所在类的equals()方法,比较:
* ----------------如果equals()方法返回false:此时key1-value1添加成功。---情况3
* ----------------如果返回true,使用value1替换以前的value2.(相当于修改key1对应的value)
* <p>
* 补充:关于情况2和情况3:此时key1-value1和原来的数据以链表的方式存储。
* <p>
* 在不断的添加过程中,会涉及到扩容问题,当超出临界值(且要存放的位置非空时)默认扩容方式:扩容为原来容量的2倍。并将原有的数据复制过来。
* <p>
* jdk8相较于jdk7在底层实现方式的不同:
* 1.new HashMap():底层没有创建一个长度为16的数组。
* 2.jdk8底层数组是:Node[]而非Entry[]。
* 3.首次调用put()方法时,底层创建长度为16的数组。
* 4.jdk7底层结构只有数组+链表。jdk8底层结构:数组+链表+红黑树。
* 当数组的某一个索引位置上的元素以链表的方式存储的数据个数>8且当前数组的长度>64时,
* 此时此索引位置上的所有数据改为使用红黑树存储。(红黑树提高查找效率)
* <p>
* 四、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);
* }
* }
* <p>
*五、Map常用方法
*
* 六、TreeMap的使用
* 向TreeMap中添加key-value,要求key必须是由同一个类创建的对象
* 因为要按照key进行排序:自然排序,定制排序
*
* @author AmorFati
* 2020/10/5 10:50
*/
properties 的使用
package org.example.map;
import java.io.FileInputStream;
import java.util.Properties;
/**
* Properties:常用来处理配置文件。key和value都是String类型。
* @author AmorFati
* 2020/10/5 16:24
*/
public class PropertiesTest {
public static void main(String[] args) throws Exception {
Properties properties = new Properties();
FileInputStream fis = new FileInputStream("jdbc.properties");
properties.load(fis);
String name = properties.getProperty("name");
String password = properties.getProperty("password");
fis.close();
}
}
7. Collections工具集
//Collections.copy()
List dest = Arrays.asList(new Object[list.size()]);
Collections.copy(dest, list);