Java基础——集合体系结构
Posted 我永远信仰
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java基础——集合体系结构相关的知识，希望对你有一定的参考价值。
文章目录
1.Collection
1.1 集合知识
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变
1.2 集合的体系结构
1.3 Collection集合概述和使用
Collection集合概述
-
是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
-
JDK不提供此接口的任何直接实现，它提供更具体的子接口(如Set和List)实现
创建Collection集合的对象
- 多态的方式
- 具体的实现类ArrayList
1.4 Collection集合的遍历
lterator:迭代器，集合的专用遍历方式
- lterator iterator():返回此集合中元素的迭代器，通过集合的iterator(方法得到
- 迭代器是通过集合的iterator)方法得到的，所以我们说它是依赖于集合而存在的
lterator中的常用方法
-
E next():返回迭代中的下一个元素。用一个对应的E类来接收，可以处理数据
-
boolean hasNext():如果迭代具有更多元素，则返回true。用来循环获取集合里的元素
实例
public class TestIterator {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
collection.add("java");
collection.add("hello");
collection.add("world");
//获得迭代器
Iterator<String> it = collection.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
2. List
2.1List集合概述和使用
List集合概述
- 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，
并搜索列表中的元素 - 与Set集合不同，列表通常允许重复的元素
List集合特点
- 有序:存储和取出的元素顺序一蚁
- 可重复:存储的元素可以重复
迭代器和Collection一样
2.2List集合特有方法
（因为它有序，所以可以使用索引）
| 方法名 | 说明 |
|---|---|
| void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |
| E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| E set(int index,Eelement) | 修改指定索引处的元素，返回被修改的元素 |
| E get(int index) | 返回指定索引处的元素 |
注意：操作的时候索引不要越界
List可以通过get方法（获得索引对应的元素）和size方法（循环结束条件）对其进行遍历
2.3并发修改异常
看这个例子，我们使用正确的思路写下了正确的代码，却抛出了异常：ConcurrentModificationException
public class ListDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("java");
list.add("hello");
list.add("world");
//遍历方法一
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String s = it.next();
if ("world".equals(s)) {//如果两个字符串相等
list.add("abc"); //抛出异常：ConcurrentModificationException
}
}
/*
遍历方法二
for (int i = 0; i < len; i++) {
String s = list.get(i);
if ("world".equals(s)) {//如果两个字符串相等
list.add("abc"); //这里会抛出异常吗
}
}
*/
//输出集合对象
System.out.println(list);
}
}
ConcurrentModificationException异常是如何产生的？
查看源码：
//什么情况下会抛出这个异常
final void checkForComodification() {
if (modCount != expectedModCount) //当这两个不相等的时候
throw new ConcurrentModificationException();
}
//这两个又是什么,继续翻源码
private class Itr implements Iterator<E> { //这是实现迭代器接口的类里。我们使用的是迭代器方式遍历
int expectedModCount = modCount; //一个值在这里被定义
/*
modCount：实际修改集合的次数
expectedModCount：预期修改集合的次数
*/
一开始他们是相等的，但是我们上面在上面使用迭代器遍历过程中让它进行了一次add操作，导致这两个值不等，所以抛出了异常。
...
思考：
-
如果if条件不成立，程序仍然会抛出异常吗。
答案是不会，因为if条件不成立，那么if (modCount != expectedModCount) 也成立，就不会抛出异常
-
如果遍历方式改为使用第二种会抛出异常吗
答案是不会，因为get方法只有检测索引的范围是否越界，并没有做checkForComodification()方法。只有索引越界了才会抛出异常：IndexOutOfBoundsException。
总结：
产生原因
- 迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致
- 增强for循环内部也使用了迭代器实现，他也可能抛出并发修改异常
解决方案
- 用for循环遍历，然后用集合对象做对应的操作即可
2.4 ListIterator:列表迭代器
-
通过List集合的listlterator)方法得到，所以说它是List集合特有的迭代器
-
用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
Listlterator中的常用方法
- E next():返回迭代中的下一个元素
- boolean hasNext():如果迭代具有更多元素，则返回true
- E previous):返回列表中的上一个元素
- boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
- void add(Ee):将指定的元素插入列表
实例
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class TestListItr {
//列表迭代器，含有add方法，不会抛出并发修改异常
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("java");
list.add("hello");
list.add("world");
ListIterator<String> listIt = list.listIterator();
//正序输出
while (listIt.hasNext()) {
String s = listIt.next();
//主要是想说明，可以使用add
if ("world".equals(s)) {
listIt.add("llllll");
}
System.out.println(s);
}
System.out.println("-----------");
//反序，基本不用
while (listIt.hasPrevious()) {
String previous = listIt.previous();
System.out.println(previous);
}
/*运行结果
java
hello
world
-----------
llllll
world
hello
java
*/
}
}
思考：为什么ListIterator使用add方法，不会抛出并发修改异常？
查看源码
//在调用 list.listIterator()方法的时候，返回的是一个ListItr。
public ListIterator<E> listIterator() {
return new ListItr(0);
}
//找到ListItr，查看ListItr的add方法，
private class ListItr extends Itr implements ListIterator<E> {
...
...
public void add(E e) {
checkForComodification();
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount; //发现在执行add方法，他也会将这两个值保持一致。所以在检测的时候不会出现异常。
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
总结：
ListIterator使用add方法，不会抛出并发修改异常，因为它会在add方法中执行 expectedModCount = modCount;所以不会抛出并发修改异常
2.5 数据结构
-
栈（先进后出）
-
队列先进先出
- 数组
- 链表
2.6 List集合子类
-
ArrayList
底层数据结构是用大小可变的数组实现的，特点是查询快，增删慢
- LinkedList
底层数据结构是链表，特点是查询慢，增删快。
3种遍历方式
- 迭代器
- 普通for(用索引)
- 增强for
LinkedList 相比ArrayList 多了几种常用的特有的方法
- addFirst
- addLast
- getFirst
- getLast
- peek
- poll
- …
3. Set
3.1 Set
概述：
- 继承了Collection接口
- 一个不包含重复元素的 collection
- 底层结构是哈希表
特点：
- 不包含重复元素的集合，可以当成数学里的集合来理解。
- 没有带索引的方法，所以不能使用普通for循环遍历
实现类：
HashSet
-
对元素的迭代顺序不做保证
-
此实现不是同步的。
应该使用
Collections.synchronizedSet方法来“包装” set。最好在创建时完成这一操作，以防止对该 set 进行意外的不同步访问：Set s = Collections.synchronizedSet(new HashSet(...));
3.2 哈希值
哈希值:是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值
- public int hashCode):返回对象的哈希码值
class HashDemo {
public static void main(String[] args) {
//创建学生对象
Student s1 = new Student("林青霞", 30);
//同一个对象多次调用hashCode()方法返回的哈希值是相同的
System.out.println(s1.hashCode()); //460141958
System.out.println(s1.hashCode()); //460141958
System.out.println("--------");
Student s2 = new Student("林青霞", 30);
//默认情况下，不同对象的哈希值是不相同的
//但是我们可以重写hashCode方法，达到自己想要的结果。比如这里可以在Student类种重写
System.out.println(s2.hashCode()); //1163157884
}
}
class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//重写哈希值方法
@Override
public int hashCode() {
return 0;
}
}
在运行，发现三次都是返回0
对象的哈希值特点
-
同一个对象多次调用hashCode(方法返回的哈希值是相同的
-
默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同
3.3 HashSet
HashSet集合特点
- 底层数据结构是哈希表
- 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
- 没有带索引的方法，所以不能使用普通for循环遍历
- 由于是Set集合，所以是不包含重复元素的集合
HashSet集合保证元素唯一性的源码分析
HashSet<String> hashSet = new HashSet<>();
//添加元素
hashSet.add("java");
hashSet.add("hello");
hashSet.add("world");
hashSet.add("world");
//---------------------------
//源码部分：
//跟进add方法，参数就是我们传进来的参数，比如E是String类型，e=hello
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
//hash(),该方法返回的是一个hash值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//跟进put，hash值与元素的hashCode相关
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//跟进putVal，这里我们只需要观察前面这两个参数，
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//元素为结点的数组，hash的一种实现
Node<K,V>[] tab; Node<K,V> p; int n, i;
//为空，长度为0。意思是如果哈希表未初始化，就对其进行初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//根据对象的哈希值计算对象的存储位置，如果该位置没有元素，就存储元素，
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {//如果该位置由元素
Node<K,V> e; K k;
/*
存入的元素和之前的元素比较哈希值
如果哈希值不同，会继续向下执行，把元素添加到集合
如果哈希值相同，会调用对象的equals方法比较
如果返回false，会继续向下执行，把元素添加到集合
如果返回true，说明元素重复
*/
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))//equals方法比较
e = p;//说明元素重复，并没有将它添加到集合。
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {//哈希值不同
for (int binCount = 0; ; ++binCount) {
//把元素添加到集合
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
流程图：
总结：
- 它是根据hashCode方法和equals方法来确认元素是否重复
- HashSet集合存储元素，要保证元素的唯一性，需要重写hashCode方法和equals方法
3.4 哈希表
-
JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
-
JDK8以后，在长度比较长的时候，底层实现了优化
哈希表是如何保证元素的唯一性呢？
原理和上面差不多，举个例子说明：
将元素存储到哈希表中。
1.首先计算出每个元素的哈希值，
默认构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16。
把元素对应的哈希值存储到里面，将其对16取余，计算出自己存储的位置。
存储过程：
hello：其对应的哈希值计算后的需要存储的位置为2，2没有元素，直接存储
world: 2里有一个元素，有元素就需要和里面的元素进行比较，比较哈希值，哈希值不相同，world加入该位置。
java:2的位置有多个元素，首先与第一个比较，哈希值不同，与第二个比较哈希值也不同。要与这多个元素进行比较，哈希值都不相同，才加入该位置
world：与第一个比，哈希值相同，比较内容，内容也相同。所以这个不加入
通话：直接加入
重地：3的位置有元素，比较哈希值，哈希值相同，比较内容，内容不同，加入。
最后结构如图，使用的是存储结构是数组+链表的形式。
了解更多关于哈希表，一定要了解这些
3.5 LinkedHashSet
LinkedHashSet集合特点
- 哈希表和链表实现的Set接口，具有可预测的迭代次序
- 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
- 由哈希表保证元素唯一，也就是说没有重复的元素
3.6 TreeSet
TreeSet集合特点
-
元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
-
TreeSet():根据其元素的自然排序进行排序
-
TreeSet(Comparator comparator):根据指定的比较器进行排序没有带索引的方法，所以不能使用普通for循环遍历
-
由于是Set集合，所以不包含重复元素的集合
自然排序 Comparable的使用
题目要求：
存储学生对象并遍历，创建TreeSet集合使用无参构造方法
按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
//学生类
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int 以上是关于Java基础——集合体系结构的主要内容，如果未能解决你的问题，请参考以下文章