Java集合类思想（一）
一、集合与数组
数组（可以存储基本数据类型）是用来存现对象的一种容器，但是数组的长度固定，不适合在对象数量未知的情况下使用。
集合（只能存储对象，对象类型可以不一样）的长度可变，可在多数情况下使用。
二、层级关系
（自己画一张）
（网上找一张）
如图所示：图中，实线边框的是实现类，折线边框的是抽象类，而点线边框的是接口
Collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。但是却让其被继承产生了两个接口，就是Set和List。Set中不能包含重复的元素。List是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式。
Map是Java.util包中的另一个接口，它和Collection接口没有关系，是相互独立的，但是都属于集合类的一部分。Map包含了key-value对。Map不能包含重复的key，但是可以包含相同的value。
Iterator，所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含以下三种方法：
1.hasNext()是否还有下一个元素。
2.next()返回下一个元素。
3.remove()删除当前元素。
三、几种重要的接口和类简介
1、List（有序、可重复）
List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据的移动，所有插入删除数据速度慢。
2、Set（无序、不能重复）
Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。
3、Map（键值对、键唯一、值不唯一）
Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。
（插一个表）
四、遍历
在类集中提供了以下四种的常见输出方式：
1）Iterator：迭代输出，是使用最多的输出方式。
2）ListIterator：是Iterator的子接口，专门用于输出List中的内容。
3）foreach输出：JDK1.5之后提供的新功能，可以输出数组或集合。
4）for循环
（四种常见方式）
代码实现：
// for的形式
for（int i=0;i<arr.size();i++）{...}
// foreach的形式
for（int i：arr）{...}
// iterator的形式
Iterator it = arr.iterator();
while(it.hasNext()){ object o =it.next(); ...}
五、描述特点注意事项
描述特点时按照结构从浅到深描述
>```java
>// 1, 父子关系
>// 2, 数据结构结构表现
>// 3, 底层结构: 数组 or 链表
>// 4, (数组): 初始长度, 扩容机制
>// 5, 有序 / 允许重复 / 允许null
>// 6, 线程安全与否
# 1, Collection
## 1.1 Collection的特点
>1, Collection是Collection集合体系的顶级接口
>
>2, Collection描述了一个存储数据的容器
>
>3, Collection有些子实现存储数据有序, 有些子实现存储数据无序
>
>4, Collection有些子实现允许存储重复数据, 有些子实现不允许存储重复数据
>
>5, Collection有些子实现允许存储null, 有些子实现不允许存储null
## 2.1 List的特点
>1, List接口是Collection接口的子接口
>
>2, List数据结构表现为: 线性表
>
>3, List的子实现存储数据有序
>
>4, List的子实现存储数据允许重复
>
>5, List的子实现允许存储null
## 3.1 ArrayList的特点
>1, ArrayList是List的接口的子实现
>
>2, ArrayList的数据结构为: 线性表
>
>3, ArrayList的底层结构: 数组
>
>4, 数组的默认的初始长度, 数组的默认扩容机制
>
>5, 存储元素有序
>
>6, 允许存储重复数据
>
>7, 允许存储null
>
>8, 线程不安全
(API具体调用这边就不列举了, 可以自己查阅jdk1.6 CHM)
(配图两张)
六、几枚横炮（补充知识点）
JavaSE相关 抽象类与接口
总结几句话来说：
1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2、抽象类要被子类继承，接口要被类实现。
3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
6、抽象方法只能申明，不能实现。abstract void abc();不能写成abstract void abc(){}。
7、抽象类里可以没有抽象方法
8、如果一个类里有抽象方法，那么这个类只能是抽象类
9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
10、接口可继承接口，并可多继承接口，但类只能单根继承。
淘宝万亿数据如何存储
基于X-Engine引擎的历史库方案
-
在线库依然沿用之前的MySQL InnoDB集群，但是只保存90天的数据量，90天之前的订单会被删除，数据量少，可以保证较高的缓存命中率，确保读写延时。
-
通过数据同步将在线库中超过90天的订单迁移到历史库中，迁移之后该部分订单从在线库删除。
-
历史库切换为X-Engine，保存全量的交易订单数据，90之前的订单读写，直接操作历史库, 同时历史库承接在线库的所有迁移写入负载。
数据库架构参考
在淘宝交易历史库的方案中，考虑到业务层面历史代码架构的延续性，采用了InnoDB引擎在线库和X-Engine历史库分离的方案。在这套架构中，X-Engine历史库其实同时承担了在线库迁移过来的写入以及90天以前记录的读写流量。
实际上，考虑到淘宝交易订单记录流水型的访问特征(最近写入的记录会被大量访问，随着时间推移，记录访问频次急剧衰减），X-Engine引擎内部的冷热分离机制就能很好的处理这种流水型业务，所以单一X-Engine数据库集群完全解决需求。
对于新开业务或者有大量流水型记录存储需求的现有业务且业务层面还未做冷热分离，我们建议直接使用一套X-Engine引擎，在存储成本降低的同时，DB层的访问代码会更简单。基于X-Engine引擎的PolarDB-X分布式数据库可以同时解决scale out问题和成本问题。
关于modCount是啥，为啥要用，底层发生了啥
在ArrayList中有个成员变量modCount，继承于AbstractList。
这个成员变量记录着集合的修改次数，也就每次add或者remove它的值都会加1。这到底有什么用呢？
先看下面一段测试代码：
package temp;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class demo {
public static void main(String[] args){
List<String> list = new ArrayList<String>();
//CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
list.add("a");
Iterator iterator = list.iterator();
while(iterator.hasNext()){
String str = (String) iterator.next();
list.remove(str);
}
}
}
在使用迭代器遍历集合的时候同时修改集合元素。因为ArrayList被设计成非同步的，所以理所当然会抛异常。但是该抛什么异常才能说明该问题呢？
首先得了解ArrayList的迭代器
public Iterator<E> iterator() {
return new Itr();
}
在调用list.iterator()的时候返回的是一个Itr对象，它是ArrayList中的一个内部类。
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
主要关注3个点：
1、expectedModCount的初值为modCount
2、hasNext的判断条件为cursor!=size，就是当前迭代的位置不是数组的最大容量值就返回true
3、next和remove操作之前都会先调用checkForComodification来检查expectedModCount和modCount是否相等
如果没checkForComodification去检查expectedModCount与modCount相等，这个程序肯定会报ArrayIndexOutOfBoundsException
这样的异常显然不是应该出现的(这些运行时错误都是使用者的逻辑错误导致的，我们的JDK那么高端，不会出现使用错误，我们只抛出使用者造成的错误，而这个错误是设计者应该考虑的)，为了避免出现这样的异常，定义了检查。所以抛出ConcurrentModificationException异常更能说明问题。
package temp;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class demo {
public static void main(String[] args){
List<String> list = new ArrayList<String>();
//CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
Iterator iterator = list.iterator();
while(iterator.hasNext()){
String str = (String) iterator.next();
if(str.equals("d")){
list.remove(str);
}else{
System.out.println(str);
}
}
}
}
输出却是 a b c。
因为在删除 d 的时候cursor为4,size也变成了4。所以hasNext就返回为true了，循环结束，从而后面的元素也不会输出了。
又想，为什么不把hasNext()的判断改为cursor <=size()呢？但是我们还有可能 add（）这样的话就会导致数据混乱，事实上线程安全本身就不允许读的时候被修改。
七、算法打卡
–
参考网址 ：xwdreamer lipper_ 活到老，学到老 Alan’s Blog skin778
–
--我是博客签名--
座右铭：保持热情
版权声明：自由转载-非商用-非衍生-保持署名。
本作品采用知识共享署名 4.0 国际许可协议进行许可。
--
标签：存储,Java,思想,list,ArrayList,List,接口,集合 From： https://www.cnblogs.com/yepq2025/p/16720899.html