集合（一）List

- IDEA部分快捷键
- 集合框架体系
- collection
- - collection接口实现类的特点
  - 方法
  - - 示例
  - 遍历元素方式1 - 使用Iterator（迭代器）
  - - 基本特点
    - 调用模板
  - 遍历元素方式2 - 使用for 循环增强
  - - 基本语法
    - 示例
- List
- - 基本说明
  - List的主要方法
  - - 示例
  - List的三种遍历方式
- Arraylist
- - 注意事项
  - add
  - 底层操作机制源码分析
  - 源码
  - - 构造
    - add()
- Vector
- - 基本说明
  - 底层解读
  - vector与ArrayList对比
- linkedList
- - 说明
  - 底层操作机制
  - 与ArrayList的比较
  - 如何选择ArrayList和linkedList

IDEA部分快捷键

空格键搜查类的信息

ctrl+h 可以看到接口类的详细信息

ctrl+shift+alt+u 可以看到继承视图

alt + 7 显示类的框架

集合框架体系

集合主要是两组（单列集合，双列集合）

单列：collection接口有两个重要的子接口List Set，他们的实现子类都是单列集合

双列：Map接口的实现子类是双列集合，存放的K-V

collection collection接口实现类的特点

collection的实现类，可以存放重复的元素，有些不可以
有些collection的实现类，可以存放重复的元素，有些不可以
有些collection的实现类，有些是有序的（list），有些不是有序（set）
collection接口没有直接的实现子类，是通过它的子接口set和List来实现的

方法

add()
remove()
contains()
size()
isEmpty()
clear()
addAll()
containsAll()
removeAll()

示例

// add:添加单个元素
list.add("jack");
list.add(10);//list.add(new Integer(10))
list.add(true);
System.out.println("list=" + list);

// remove:删除指定元素
//list.remove(0);//删除第一个元素
list.remove(true);//指定删除某个元素
System.out.println("list=" + list);

// contains:查找元素是否存在
System.out.println(list.contains("jack"));//T

// size:获取元素个数
System.out.println(list.size());//2

// isEmpty:判断是否为空
System.out.println(list.isEmpty());//F

// clear:清空
list.clear();
System.out.println("list=" + list);

// addAll:添加多个元素
ArrayList list2 = new ArrayList();
list2.add("红楼梦");
list2.add("三国演义");
list.addAll(list2);
System.out.println("list=" + list);

// containsAll:查找多个元素是否都存在
System.out.println(list.containsAll(list2));//T

// removeAll：删除多个元素
list.add("聊斋");
list.removeAll(list2);
System.out.println("list=" + list);//[

遍历元素方式1 - 使用Iterator（迭代器）基本特点

iterator对象称为迭代器，主要用于遍历Collection集合中的元素
所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器
Iterator的结构
Iterator仅用于遍历集合，Iterator本身并不存放对象

调用模板

//得到一个集合的迭代器
Iterator iterator = coll.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next()作用:1.下移 2.将下移以后集合位置上的元素返回
	System.out.println(iterator.next());
}

//退出while循环后，这时的iterator迭代器，指向最后的元素，不能往下运行了，会抛出异常
//如果希望再次遍历，需要重置迭代器
iterator = col.iterator();
System.out.println("===第二次遍历===");
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}

next()作用

下移
将下移以后集合位置上的元素返回

提醒：再调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常

快捷键用法快速生成while循环
itit
## 也可通过ctrl+j 来显示所有的快捷键的快捷键

遍历元素方式2 - 使用for 循环增强

增强for循环，可以代替iterator迭代器

特点：增强for就是简化版的iterator，本质一样。只能用于遍历集合或数组

基本语法

for(元素类型 元素名: 集合名或数组名){
	访问元素
}

示例

Collection col = new ArrayList();

col.add(new Book("三国演义","罗贯中",10.1));
col.add(new Book("小李飞刀","古龙",5.1));

for(Object book : col){
System.out.println("book="+book);
}

理解

增强for，底层仍然是迭代器

增强for可以理解成就是简化版本的迭代器遍历

快捷键 I

List 基本说明

List集合类中元素有序（即添加顺序和取出顺序一致）、且可重复
List集合中的每个元素都有其对应的顺序索引、即支持索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素
JDKAPI中List的实现类有

List的主要方法

// void add(int index, Object ele):在 index 位置插入 ele 元素

// boolean addAll(int index, Collection eles):从 index 位置开始将 eles 中的所有元素添加进来

// Object get(int index):获取指定 index 位置的元素

// int lastIndexOf(Object obj):返回 obj 在当前集合中末次出现的位置

// Object remove(int index):移除指定 index 位置的元素，并返回此元素

// Object set(int index, Object ele):设置指定 index 位置的元素为 ele , 相当于是替换

// List subList(int fromIndex, int toIndex):返回从 fromIndex 到 toIndex 位置的子集合
// 注意返回的子集合 fromIndex <= subList < toIndex

示例

List list = new ArrayList();
list.add("张三丰");
list.add("贾宝玉");
// void add(int index, Object ele):在 index 位置插入 ele 元素
//在 index = 1 的位置插入一个对象
list.add(1, "韩顺平");
System.out.println("list=" + list);
// boolean addAll(int index, Collection eles):从 index 位置开始将 eles 中的所有元素添加进来
List list2 = new ArrayList();
list2.add("jack");
list2.add("tom");
list.addAll(1, list2);
System.out.println("list=" + list);
// Object get(int index):获取指定 index 位置的元素
//说过
// int indexOf(Object obj):返回 obj 在集合中首次出现的位置
System.out.println(list.indexOf("tom"));//2
// int lastIndexOf(Object obj):返回 obj 在当前集合中末次出现的位置
list.add("韩顺平");
System.out.println("list=" + list);
System.out.println(list.lastIndexOf("韩顺平"));
// Object remove(int index):移除指定 index 位置的元素，并返回此元素
list.remove(0);
System.out.println("list=" + list);
// Object set(int index, Object ele):设置指定 index 位置的元素为 ele , 相当于是替换. list.set(1, "玛丽");
System.out.println("list=" + list);
// List subList(int fromIndex, int toIndex):返回从 fromIndex 到 toIndex 位置的子集合
// 注意返回的子集合 fromIndex <= subList < toIndex韩顺平循序渐进学 Java 零基础

List returnlist = list.subList(0, 2);
System.out.println("returnlist=" + returnlist);

List的三种遍历方式

//遍历
//1. 迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
    Object obj = iterator.next();
    System.out.println(obj);
}
System.out.println("=====增强 for=====");
//2. 增强 for
for (Object o : list) {
    System.out.println("o=" + o);
}
System.out.println("=====普通 for====");
//3. 使用普通 for
for (int i = 0; i < list.size(); i++) {
    System.out.println("对象=" + list.get(i));
}

Arraylist 注意事项

peimits all elements,including null , ArrayList 可以加入null，并且多个
ArrayList是由数组实现数据存储的
ArrayList基本等同于Vector，除了ArrayList是线程不安全的。在多线程情况下，不建议使用ArrayList

add

//线程不安全，没有 synchronized
public boolean add(E e) {
ensureCapacityInternal(size + 1);  // Increments modCount!!
elementData[size++] = e;
return true;
}

底层操作机制源码分析

ArrayList中维护了一个Object类型的数组elementData

transient Object[] elementData；//transient 表示瞬间，短暂的，表示该属性不会被序列化
当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，如需再次扩容，则扩容elementData为1.5倍。
如果使用的是指定大小的构造器，则初始elementData容器为指定大小，如果需要扩容，则直接扩容elementData为1.5倍

源码构造

使用无参构造器，创建和使用

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

add()

先确定是否要扩容
然后再执行赋值

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}


****************无参构造

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

//该方法确定miniCapacity
1. 第一次扩容为10

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

//modCount++ 记录集合被修改的次数
//如果elementData的大小不够，就调用grow去扩容
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

//真的扩容
//使用扩容机制来确定要扩容到多大
//第一次newCapacity=0
//第二次及其以后按照1.5倍扩容
//扩容使用的是Arrays.copyof()
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

**************** 到此返回到add()  



***************** 使用有参构造器，创建和使用 ArrayList的源码
//创建了一个指定大小elementData数组
//this.elementData = new Object[initialCapacity];  
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

Vector 基本说明

vector底层也是一个对象数组，protected Object[] elementData;

Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized

public synchronized E get(int index){
	if(index >= elementCount)
		throw new ArrayIndexOutOfBoundsExceptions(index);
	return elementData(index);
}

在开发中，需要线程同步安全时，考虑使用Vector

底层解读

//无参构造 new Vector() 底层
public Vector() {
    this(10);
}

public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}
//如果是有参构造，那么方法是
// 1.
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}
//2.
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}


//add()
//1.
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}
//2.确定是否需要扩容 条件：minCapacity - elementData.length > 0
private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
//3.如果 需要的数组大小不够用，就扩容
//扩容函数
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

vector与ArrayList对比

	底层结构	版本	线程安全（同步）效率	扩容倍数
ArrayList	可变数组	jdk1.2	不安全，效率高	如果有参构造1.5倍如果是无参 1.第一次10 2.从第二次开始按1.5倍扩容
Vector	可变数字	jdk1.0	安全，效率不高	如果是无参，默认10，满后，就按2倍扩容如果指定大小，则每次直接按2倍扩容

linkedList

说明

linkedList底层实现了双向链表和双端队列特点
可以添加任意元素（元素可以重复），包括null
线程不安全，没有实现同步

底层操作机制

linkedList底层维护了一个双向链表
linkedList中维护了两个属性first和last分别指向首节点和尾结点
每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点，最终实现双向链表
所以linkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高

//


//删除结点
linkedList.remove();//默认删除第一个结点


//修改某个结点对象
linkedList.set(1,999);

//得到某个结点对象
linkedList.get(1); //获取第二个对象

//因为linkedList是实现了List接口，遍历方式

//1.iterator
Iterator iterator = linkedList.iterator();
//2.增强for循环
for(Object o1 : linkedList){
    
}
//3.普通for循环 通过get函数遍历
for(int i  = 0 ; i < linkList.size();i++){
    
}

与ArrayList的比较

	底层结构	增删的效率	改查的效率
ArrayList	可变数组	较低数组扩容	较高
linkedList	双向链表	较高，通过链表追加	较低

如何选择ArrayList和linkedList

如果我们改查的操作多，选择ArrayList
如果我们增删的操作多，选择linkedList
一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选择ArrayList
在一个项目中，根据业务灵活选择，也可能这样，一个模块使用的是ArrayList，另另外一个模块是linkedList，也就是说，要更具业务来进行选择

集合（一）List

Java相关栏目本月热门文章