文章目录
一、集合框架概述
集合、数组都是对多个数据进行存储操作的结构，简称Java容器。这里的存储，主要指的是内存层面的存储，不涉及到持久化的存储。
数组的特点及缺点
1 数组在存储多个数据方面的特点：
- 一旦初始化以后，其长度就确定了
- 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。比如：String[]arr；int[]arr1；Object[]arr2；
2 数组在存储多个数据方面的缺点：
- 一旦初始化以后，其长度就不可修改。
- 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
- 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
- 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
Java 集合可分为Collection和Map两种体系
Collection接口：单列数据，定义了存取一组对象的方法的集合
-
List：元素有序、可重复的集合
-
Set：元素无序、不可重复的集合
Map接口：双列数据，保存具有映射关系“key-value对”的集合接口：双列数据，保存具有映射关系“key-value对”的集合
二、Collection接口
|----CoLlection接口：单列集合，用来存储一个一个的对象
|----List接口：存储有序的、可重复的数据。--> “动态”数组，替换原有的数组
|----ArralList：作List接口的主要实现类；线程不安全的，效率高；底层使用Object[]存储。适合改、查
|----LinkedList：底层使用双向链表存储；适合增、删
|----Vector：作为为ist接口的古老(JDK1.0)实现类；线程安全的，效率低；底层使用Object[]存储
|----Set接口：存储无序（元素存储顺序与添加顺序不同，而由元素哈希值决定）的、不可重复的数据
|----HashSet：作为set接口的主要实现类；线程不安全的；可以存储null值
|----LinkedHashSet：作为HashSet的子类；遍历其内部教据时，可以按照添加的顺序遍历
|----TreeSet：可以按照添加对象的指定属性，进行排序。
关于迭代器Iterator
| Modifier and Type | Method and Description |
|---|---|
default void | forEachRemaining(Consumer<? super E> action)Performs the given action for each remaining element until all elements have been processed or the action throws an exception. |
boolean | hasNext()Returns true if the iteration has more elements. |
E | next()Returns the next element in the iteration. |
default void | remove()Removes from the underlying collection the last element returned by this iterator (optional operation). |
lterator对象称为迭代器（设计模式的一种），主要用于遍历Collection集合中的元素。
GOF给迭代器模式的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
Collection接口继承了java.lang.lterable接口，该接口有一个iterator（）方法，那么所o有实现了Collection接口的集合类都有一个iterator（）方法，用以返回一个实现了Iterator接口的对象。
lterator仅用于遍历集合，lterator本身并不提供承装对象的能力。如果需要创建Iterator对象，则必须有一个被迭代的集合。
集合对象每次调用iterator（）方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorTest {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
collection.add("jack");
collection.add("lisa");
collection.add("tom");
collection.add("lucy");
Iterator iterator = collection.iterator();
//hasNext（）：判断是否还有下一个元素
while (iterator.hasNext()) {
//next（）：①指针下移②将下移以后集合位置上的元素返回
String name = (String) iterator.next();
if ("tom".equals(name)) {
// 1 Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
// 2 如果还未调用next()或在上一次调用next()方法之后已经调用了remove方法，再调用remove都会报IllegalStateException。
iterator.remove();
}
System.out.println(name);
}
System.out.println("******************");
Iterator iterator1 = collection.iterator();
while (iterator1.hasNext()) {
System.out.println(iterator1.next());
}
}
}
List 接口
- 鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
- List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素
- JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。
1 ArrayList
ArrayList是List接口的典型实现类、主要实现类。本质上，ArrayList是对象引用的一个”变长”数组。
以下是jdk8的api中ArrayList的构造函数描述：
| Constructor and Description |
|---|
ArrayList()Constructs an empty list with an initial capacity of ten. |
ArrayList(Collection<? extends E> c)Constructs a list containing the elements of the specified collection, in the order they are returned by the collection’s iterator. |
ArrayList(int initialCapacity)Constructs an empty list with the specified initial capacity. |
jdk7情况下：当调用无参构造函数时，Arraylist list = new Arraylist()，底层创建了初始长度是10的Object[]数组elementData，当向数组中添加元素超过数组最大容量时，则elementData数组扩容。默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。实际使用时建议用带参的构造器：Arraylist list=new Arraylist(int capacity)，避免扩容操作影响效率。
jdk8情况下：当调用无参构造函数时，Arraylist list = new Arraylist()，底层并不会创建数组，数组为空，当第一次向数组中添加元素时，才会为数组分配内存，且数组初始容量为10（jdk8中注释没改，但是代码逻辑改了），当数组容量不足时，也是扩容为原来容量的1.5倍：newCapacity = oldCapacity + (oldCapacity >> 1)。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
private int size;
private static final int DEFAULT_CAPACITY = 10;
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 第一步： size 为int，初始为0，ensureCapacityInternal(1)
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
// 第二步：调用无参构造器时，this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA，又此方法实参为 1
// 因此calculateCapacity(DEFAULTCAPACITY_EMPTY_ELEMENTDATA, 1)
// 第四步：执行 ensureExplicitCapacity(10)
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 第三步：if条件为真，return 10（DEFAULT_CAPACITY = 10）
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 第五步：10 - 0 > 0，条件成立，执行grow(10)
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) { // 方法实参为10，minCapacity == 10
int oldCapacity = elementData.length; // elementData.length == 0 --> oldCapacity = 0
int newCapacity = oldCapacity + (oldCapacity >> 1);// newCapacity = 0 + 0 (>>：算术右移运算符，也称带符号右移，右移一次相当于除2)
if (newCapacity - minCapacity < 0) // 0 - 10 < 0，if条件为真，newCapacity = 10
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);// 创建一个初始容量为10的数组
}
总结：jdk7 中ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
2 LinkedList
LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。Node除了保存数据，还定义了两个变量：
- prev变量记录前一个元素的位置
- next变量记录下一个元素的位置
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;
}
}
| Constructor and Description |
|---|
LinkedList()Constructs an empty list. |
LinkedList(Collection<? extends E> c)Constructs a list containing the elements of the specified collection, in the order they are returned by the collection’s iterator. |
当调用无参构造函数时，什么也不做，向链表中添加元素时，才会创建链表。
transient int size = 0;
/**
* Pointer to first node.
*/
transient Node<E> first;
/**
* Pointer to last node.
*/
transient Node<E> last;
/**
* Constructs an empty list.
*/
public LinkedList() { // 第一步：创建一个LinkedList
}
public boolean add(E e) { // 第二步：添加第一个元素 E e，执行 linkLast(e)
linkLast(e);
return true;
}
/**
* Links e as last element.
*/
void linkLast(E e) { // 第三步：将元素 E e 添加到链表末尾
final Node<E> l = last; // 初始last == null --> l = null
final Node<E> newNode = new Node<>(l, e, null);// newNode = new Node<>(null, e, null)
last = newNode; // last = newNode
if (l == null)
first = newNode; // first = newNode
else
l.next = newNode;
size++; // size == 1
modCount++;
} // 方法执行结束，此时 头节点first、尾节点last 为同一节点，first == last；链表长度 size == 1
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 Vector
现在已经不经常使用了，略过。
4 List接口常用方法
| 用处 | 具体方法 |
|---|---|
| 增 | void add（Object ele）：末尾添加一个元素 |
| 删 | object remove（int index）：移除指定index位置的元素，并返回此元素 |
| 改 | object set（int index，Object ele）：设置指定index位置的元素为ele |
| 查 | object get（int index）：获取指定index位置的元素 |
| int indexOf（Object obj）：返回obj在集合中首次出现的位置 | |
| int LastIndexOf（Object obj）：返园obj在当前集合中最后一次出现的位置 | |
| List sublist（int fromIndex，int toIndex）：返回从fromIndex 到toIndex位置的子集合 | |
| 插入 | void add（int index，Object ele）：在index位置插入ele元素 |
| boolean addAll（int index，Collection eles）：从index位置开始将eles 中的所有元素添加进来 | |
| 遍历 | Iterator迭代器 |
| 增强for循环（其底部也是用Iterator实现） | |
| 普通循环：for、while | |
| 获取长度 | int size（）：返回集合长度 |
Set接口
- Set接口是Collection的子接口，set接口没有提供额外的方法
- Set集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set集合中，则添加操作失败
- Set判断两个对象是否相同不是使用==运算符，而是根据 equals（）方法
Set中添加元素的过程—以HashSet为例：
向HashSet 中添加元素a，首先得用元素a所在类的的HashCode（）方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素：
- 如果此位置上没有其他元素，则元a添加成功
- 如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素和与元素和的hash值：
- 如果hash值不相同，则元a添加成功。
- 如果hash值相同，进而需要调用元素a所在类的equals（）方法：
- equals（）返回true，元a添加失败
- equals（）返false，则元素a添加成功
1 HashSet
HashSet是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。HashSet按Hash算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。HashSet具有以下特点：
- 不能保证元素的排列顺序
- HashSet不是线程安全的
- 集合元素可以是null
HashSet 集合判断两个元素相等的标准：两个对象通过hashCode（）方法比较相等，并且两个对象的equals（）方法返回值也相等。
对于存放在Set容器中的对象，对应的类一定要重写equals（）和hashCode（Object obj）方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。
2 LinkedHashSet
LinkedHashSet是HashSet的子类。LinkedHashSet 根据元素的hashCode值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。LinkedHashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能。LinkedHashSet不允许集合元素重复。
3 TreeSet
TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。默认情况下，TreeSet采用自然排序。TreeSet底层使用红黑树结构存储数据，其新增的方法如下：（了解）
Comparator comparator（）
Object first（）
Object last（）
Object lower（Objecte）
Object higher（Objecte）
SortedSet subSet（fromElement，toElement）
SortedSet headSet（toElement）
SortedSet tailSet（fromElement）
TreeSet 两种排序方法：自然排序和定制排序。自然排序中，比较两个对象是否相同的标准为：compareTo（）返回0。不再是equals（）
import java.util.Arrays;
import java.util.Comparator;
import java.util.TreeSet;
class Person implements Comparable<Person> {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 省略Getter、Setter、toString
@Override
public int compareTo(Person o) {
// 先按姓名升序排序，再按年龄升序排序
if (this.getName().equals(o.getName())) {
return Integer.compare(this.getAge(), o.getAge());
} else {
return this.getName().compareTo(o.getName());
}
}
}
class Good {
private String name;
private int price;
public Good(String name, int price) {
this.name = name;
this.price = price;
}
// 省略Getter、Setter、toString
}
public class TreeSetTest {
public static void main(String[] args) {
// 1 自然排序
Person[] peoples = new Person[4];
peoples[1] = new Person("jack", 12);
peoples[2] = new Person("jim", 8);
peoples[3] = new Person("lisa", 66);
peoples[0] = new Person("jack", 25);
TreeSet<Person> peopleTreeSet = new TreeSet<>();
peopleTreeSet.addAll(Arrays.asList(peoples));
System.out.println(peopleTreeSet);
// 2 定制排序
Comparator<Good> comparator = new Comparator<Good>() {
@Override
public int compare(Good o1, Good o2) {
// 先按价格降序排序，再按商品名升序排序
if (o1.getPrice() == o2.getPrice()) {
return o1.getName().compareTo(o2.getName());
} else {
return Integer.compare(o2.getPrice(), o1.getPrice());
}
}
};
Good[] goods = new Good[4];
goods[0] = new Good("apple", 15);
goods[1] = new Good("orange", 88);
goods[2] = new Good("banana", 15);
goods[3] = new Good("watermelon", 77);
TreeSet<Good> goodsTreeSet = new TreeSet<>(comparator);
goodsTreeSet.addAll(Arrays.asList(goods));
System.out.println(goodsTreeSet);
}
}
三、Map接口
Map<key, value> ：其中key–无序的、不可重复的，使用Set 存储所有的key ；其中value–无序的、可重复的，使用Collection存储所有的value。一个键值对：key-value构成了一个Entry对象。Map 中的entry：无序的、不可重复的，使用Set 存储所有的entry
|----Map：双列数据，存储key-value对的数据
|----HashMap：作为Map的主要实现类；线程不安全的，效率高；能存储null的key和value。
|----LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。原因：在原有lashMap底层结构基础上，添加了一对 指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。
|----TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序底层使用红黑树
|----Hashtable：作为古老（jdk1.0）的实现类；线程安全的，效率低；不能存储null的key 和和alue
|----Properties：常用来处理配置文件。key 和value 都是String类到
1 HashMap
- HashMap是Map接口使用频率最高的实现类
- 允许使用null键和null值，与HashSet一样，不保证映射的顺序
- 所有的key构成的集合是Set：无序的、不可重复的。所以，key所在的类要重写：equals（）和hashCode（）
- 所有的value构成的集合是Collection：无序的、可以重复的。所以，value所在的类要重写：equals（）
- 一个key-value构成一个entry
- 所有的entry构成的集合是Set：无序的、不可重复的
- HashMap 判断两个key相等的标准是：两个key通过equals（）方法返回true，hashCode值也相等。
- HashMap 判断两个value相等的标准是：两个value通过equals（）方法返回true。
HashMap的底层实现原理–以jdk7为例说明
HashMap map = new HashMap（）：在实例化以后，底层创建了长度是16的一维数组Entry[] table。当执行map.put(key1, value1)方法时：
- 首先调用key1所在类的hashcode（）计算key1哈希值，此哈希值经过某种算法计拿以后，得到在Entry数组中的存放位置。如果此位置上的数据为空，此时的key1-value1添加成功。
- 如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值：
- 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。
- 如果key1的哈希值和已经存在的某一个数据（key2-value2）的哈希值相同，继续比较：调用key1所在类的equals（key2）
- 如果equals（）返回false：此时key1-value1添加成功。
- 如果equals（）返回true：使用value1替换value2。
在不断的添加过程中，会涉及到扩容问题，默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。
jdk8 相较于jdk7在底层实现方面的不同：
- new HashMap（）：底层没有创建一个长度为16的数组
- jdk8底层的数组是：Node[]，而非Entry[]
- 首次调用put（）方法时，底层创建长度为16的数组
- jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树。当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64 时，此时此索引位置上的所有数据改为使用红黑树存储。
2 LinkedHashMap
保证在遍历map元素时，可以按照添加的顺序实现遍历。原因：在原有lashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。
3 TreeMap
保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序底层使用红黑树
4 Properties
Properties类是Hashtable的子类，该对象用于处理属性文件。由于属性文件里的key、value都是字符串类型，所以Properties里的key和value都是字符串类型。存取数据时，建议使用setProperty（String key，String value）方法和getProperty（String key）方法
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/dbname?serverTimezone=UTC
jdbc.user=root
jdbc.password=*****
import java.io.FileInputStream;
import java.util.Properties;
public class PropertiesTest {
public static void main(String[] args) throws Exception {
Properties props = new Properties();
FileInputStream fis = new FileInputStream("jdbcConfig.properties");
props.load(fis);
String driver = props.getProperty("jdbc.driver");
String url = props.getProperty("jdbc.url");
String user = props.getProperty("jdbc.user");
String password = props.getProperty("jdbc.password");
System.out.println(driver);
System.out.println(url);
System.out.println(user);
System.out.println(password);
fis.close();
}
}
5 Map接口常用方法
添加、删除、修改操作
Object put（Object key，Object value）：将指定key-value添加到（或修改）当前map对象中
void putAll（Map m）：将m中的所有key-value对存放到当前map中
Object remove（Object key）：移除指定key的key-value对，并返回value
void clear（）：清空当前map中的所有数据
元素查询的操作
Object get（Object key）：获取指定key对应的value
boolean containsKey（Object key）：是否包含指定的key
boolean containsValue（Object value）：是否包含指定的value
int size（）：返回map中key-value对的个数
boolean isEmpty（）：判断当前map是否为空
boolean equals（Object obj）：判断当前map和参数对象obj是否相等
元视图操作的方法
Set keySet（）：返回所有key构成的Set集合
Collection values（）：返回所有value构成的Collection集合
Set entrySet（）：返回所有key-value对构成的Set集合
四、Collections工具类
Collections 是一个操作Set、List和Map等集合的工具类。Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。
排序操作：（均为static方法）
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对象的所有旧值
Collections类中提供了多个synchronizedXxx（）方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问
集合时的线程安全问题
static <T> Collection<T> | synchronizedCollection(Collection<T> c) 返回由指定集合支持的同步（线程安全）集合。 |
|---|---|
static <T> List<T> | synchronizedList(List<T> list) 返回由指定列表支持的同步（线程安全）列表。 |
static <K,V> Map<K,V> | synchronizedMap(Map<K,V> m) 返回由指定的Map支持的同步（线程安全）Map。 |
static <K,V> NavigableMap<K,V> | synchronizedNavigableMap(NavigableMap<K,V> m) 返回指定的导航Map支持的同步（线程安全）导航Map。 |
static <T> NavigableSet<T> | synchronizedNavigableSet(NavigableSet<T> s) 返回由指定的导航集支持的同步（线程安全）导航集。 |
static <T> Set<T> | synchronizedSet(Set<T> s) 返回一个由指定集合支持的同步（线程安全）集。 |
static <K,V> SortedMap<K,V> | synchronizedSortedMap(SortedMap<K,V> m) 返回一个由指定的排序映射支持的同步（线程安全）排序的Map。 |
static <T> SortedSet<T> | synchronizedSortedSet(SortedSet<T> s) 返回一个由指定的排序集支持的同步（线程安全）排序集。 |
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
