List接口
- List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
- List集合中的每元素都有其对应的顺序索引，即支持索引。
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
- List中的方法有很多，见手册
List接口的常用方法
import java.util.ArrayList;
import java.util.List;
public class ListMethod {
@SuppressWarnings({"all"})
public static void main(String[] args) {
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
List returnlist = list.subList(0, 2);
System.out.println("returnlist=" + returnlist);
}
}
List的三种遍历方式[ArrayList、LinkedList、Vector]
方式1：使用iterator
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
}
方式2：使用增强for
for(Object o:col){
}
方式3：使用普通for
for (int i = 0; i <list.size(); i++) {
Object object = list.get(i);
System.out.println(object);
}
ArrayList、LinkedList、Vector上面的三种方式都可以使用
使用LinkedList完成 使用方式和ArrayList一样
ArrayList使用细节
- ArrayList 可以加入null，并且可以多个
- ArrayList 是由数组来实现数据存储的
- ArrayList 基本等同于Vector，除了ArrayList是线程不安全看源码(没有synchronized线程互斥)。在多线程情况下，不建议使用ArrayList
ArrayList底层结构和源码分析
- ArrayList中维护了一个Object类型的数组elementDate
transient Object[] elementDate;//transient表示瞬间，短暂的，表示该属性不会被序列化
- 当创建ArrayList对象时，如果使用的是无参构造器，则初始化elementDate容量为0，第一次添加，则扩容elementDate位10，如需要再次扩容，则扩容elementDate为1.5倍
ArrayList()
- 如果使用的指定大小的构造器，则初始化elementDate容量为指定大小，如果需要扩容，则直接扩容elementDate位1.5倍
ArrayList(int)
Vector底层结构和源码分析
- Vector类的定义说明
- Vector底层也是一个对象数组，protected Object[] elementDate;
- Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized
public synchronized E get(int index){
if (index >= elementCount){
throw new ArrayIndexOutOfBoundsException(index);
return elementDate(index);
}
}
- 在开发中，需要线程同步安全时，考虑用Vector
底层源码分析
public class Vector_ {
public static void main(String[] args) {
//无参构造器
//有参数的构造
Vector vector = new Vector(8);
for (int i = 0; i < 10; i++) {
vector.add(i);
}
vector.add(100);
System.out.println("vector=" + vector);
//老韩解读源码
//1. new Vector() 底层
/*
public Vector() {
this(10);
}
补充：如果是 Vector vector = new Vector(8);
走的方法:
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
2. vector.add(i)
2.1 //下面这个方法就添加数据到vector集合
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
2.2 //确定是否需要扩容 条件 ： minCapacity - elementData.length>0
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
2.3 //如果 需要的数组大小 不够用，就扩容 , 扩容的算法
//newCapacity = oldCapacity + ((capacityIncrement > 0) ?
// capacityIncrement : oldCapacity);
//就是扩容两倍.
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);
}
*/
}
}
1.Vector底层结构和2.ArrayList的比较
底层结构：
1.可变数组
2.可变数组
线程安全：
1.安全，效率不高
2.不安全，效率高
扩容倍数：
1.如果是无参，默认10，满后，就按2倍扩容；如果指定大小，则每次直接2倍扩
2.如果有参构造器1.5倍，如果是无参构造器，第一次10，第二次开始按1.5扩
LinkedList底层结构
- LinkedList底层实现了双向链表和双端队列特点
- 可以添加任意元素(元素可以重复)，包括null
- 线程不安全，没有实现同步
LinkedList底层操作机制
- LinkdList底层维护了一个双向链表
- LinkedList中维护了两个属性first和last分别指向 首节点和尾节点
- LinkedList中维护了两个属性prev、next、itme三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表
- 所以LinkedList的元素添加和删除，不是通过数组完成的，相对来说效率较高
import java.util.Iterator;
import java.util.LinkedList;
@SuppressWarnings({"all"})
public class LinkedListCRUD {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
System.out.println("linkedList=" + linkedList);
//演示一个删除结点的
linkedList.remove(); // 这里默认删除的是第一个结点
//linkedList.remove(2);
System.out.println("linkedList=" + linkedList);
//修改某个结点对象
linkedList.set(1, 999);
System.out.println("linkedList=" + linkedList);
//得到某个结点对象
//get(1) 是得到双向链表的第二个对象
Object o = linkedList.get(1);
System.out.println(o);//999
//因为LinkedList 是 实现了List接口, 遍历方式
System.out.println("===LinkeList遍历迭代器====");
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println("next=" + next);
}
System.out.println("===LinkeList遍历增强for====");
for (Object o1 : linkedList) {
System.out.println("o1=" + o1);
}
System.out.println("===LinkeList遍历普通for====");
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
//源码阅读.
/* 1. LinkedList linkedList = new LinkedList();
public LinkedList() {}
2. 这时 linkeList 的属性 first = null last = null
3. 执行 添加
public boolean add(E e) {
linkLast(e);
return true;
}
4.将新的结点，加入到双向链表的最后
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
*/
/*
源码阅读 linkedList.remove(); // 这里默认删除的是第一个结点
1. 执行 removeFirst
public E remove() {
return removeFirst();
}
2. 执行
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
*/
}
}
ArrayList和LinkedList比较
| 底层结构 | 增删的效率 | 查改的效率 | |
|---|---|---|---|
| ArrayList | 可变数组 | 较低数组扩容 | 较高 |
| LinkedList | 双向链表 | 较高，通过链表追加 | 较低 |
| 如何选择 |
- 如果我们改查的操作多，选择ArrayList
- 如果我们增删的操作多，选择LinkedList
- 一般来说，在程序中，80%-90%都是查询，因此大部分情况下会选ArrayList
- 在一个项目中，更具业务灵活选择，也可能这样，一个模块使用的是Arraylist,另一个模块使用的是LinkedList，要根据业务来进行选择
163
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
