List接口
1.概述:是Collection接口的子接口
2.常见的实现类:
ArrayList LinkedList Vector
List集合下的实现类
1.ArrayList集合
1.概述:ArrayList是List接口的实现类
2.特点:
a.元素有序-> 按照什么顺序存的,就按照什么顺序取
b.元素可重复
c.有索引-> 可以利用索引去操作元素
d.线程不安全
3.数据结构:数组
4.常用方法:
boolean add(E e) -> 将元素添加到集合中->尾部(add方法一定能添加成功的,所以我们不用boolean接收返回值)
void add(int index, E element) ->在指定索引位置上添加元素
boolean remove(Object o) ->删除指定的元素,删除成功为true,失败为false
E remove(int index) -> 删除指定索引位置上的元素,返回的是被删除的那个元素
E set(int index, E element) -> 将指定索引位置上的元素,修改成后面的element元素
E get(int index) -> 根据索引获取元素
int size() -> 获取集合元素个数
1.1.ArrayList集合使用
public class Demo01ArrayList {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//boolean add(E e) -> 将元素添加到集合中->尾部(add方法一定能添加成功的,所以我们不用boolean接收返回值)
list.add("铁胆火车侠");
list.add("喜洋洋");
list.add("火影忍者");
list.add("灌篮高手");
list.add("网球王子");
System.out.println(list);
//void add(int index, E element) ->在指定索引位置上添加元素
list.add(2,"涛哥");
System.out.println(list);
//boolean remove(Object o) ->删除指定的元素,删除成功为true,失败为false
list.remove("涛哥");
System.out.println(list);
//E remove(int index) -> 删除指定索引位置上的元素,返回的是被删除的那个元素
String element = list.remove(0);
System.out.println(element);
System.out.println(list);
//E set(int index, E element) -> 将指定索引位置上的元素,修改成后面的element元素
String element2 = list.set(0, "金莲");
System.out.println(element2);
System.out.println(list);
//E get(int index) -> 根据索引获取元素
System.out.println(list.get(0));
//int size() -> 获取集合元素个数
System.out.println(list.size());
}
}
public class Demo02ArrayList {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("铁胆火车侠");
list.add("喜洋洋");
list.add("火影忍者");
list.add("灌篮高手");
list.add("网球王子");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("=====================");
for (int i = 0;i<list.size();i++){
System.out.println(list.get(i));
}
System.out.println("=====================");
/*
遍历带有索引集合的快捷键
集合名.fori
*/
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
public class Demo03ArrayList { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<>(); list.add(2); System.out.println(list); /* 需求:删除2 remove(Object o) -> 直接删除指定元素 remove(int index) -> 删除指定索引位置上的元素 如果remove中直接传递整数,默认调用按照指定索引删除元素的remove 但是此时list中没有2索引,所以越界 解决:我们可以将2包装成包装类,变成包装类之后,其父类就是Object了, */ //list.remove(2); list.remove(Integer.valueOf(2)); System.out.println(list); } }
1.2.底层源码分析
1.ArrayList构造方法:
a.ArrayList() 构造一个初始容量为十的空列表
b.ArrayList(int initialCapacity) 构造具有指定初始容量的空列表
2.ArrayList源码总结:
a.不是一new底层就会创建初始容量为10的空列表,而是第一次add的时候才会创建初始化容量为10的空列表
b.ArrayList底层是数组,那么为啥还说集合长度可变呢?
ArrayList底层会自动扩容-> Arrays.copyOf
c.扩容多少倍?
1.5倍
ArrayList() 构造一个初始容量为十的空列表
=========================================
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
Object[] elementData; ->ArrayList底层的那个数组
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
=========================================
list.add("a");
public boolean add(E e) {
modCount++;
add(e, elementData, size);// e->要存的元素 elementData->集合数组,长度开始为0,size->0
return true;
}
private void add(E e->元素, Object[] elementData->集合数组, int s->0) {
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}
private Object[] grow() {
return grow(size + 1);
}
private Object[] grow(int minCapacity->1) {
int oldCapacity = elementData.length;//0
if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
int newCapacity = ArraysSupport.newLength(oldCapacity,
minCapacity - oldCapacity, /* minimum growth */
oldCapacity >> 1 /* preferred growth */);
return elementData = Arrays.copyOf(elementData, newCapacity);
} else {
return elementData = new Object[Math.max(DEFAULT_CAPACITY->10, minCapacity->1)];
}
}
==========================================
假设ArrayList中存了第11个元素,会自动扩容-> Arrays.copyOf
private Object[] grow(int minCapacity) {//11
int oldCapacity = elementData.length;//10
if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
int newCapacity(15) = ArraysSupport.newLength(oldCapacity->10,
minCapacity - oldCapacity->1, /* minimum growth */
oldCapacity >> 1 ->5 /* preferred growth */);
return elementData = Arrays.copyOf(elementData, newCapacity);
} else {
return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
}
}
public static int newLength(int oldLength->10, int minGrowth->1, int prefGrowth->5) {
// preconditions not checked because of inlining
// assert oldLength >= 0
// assert minGrowth > 0
int prefLength = oldLength + Math.max(minGrowth, prefGrowth); // 15
if (0 < prefLength && prefLength <= SOFT_MAX_ARRAY_LENGTH) {
return prefLength;
} else {
// put code cold in a separate method
return hugeLength(oldLength, minGrowth);
}
}
ArrayList(int initialCapacity) 构造具有指定初始容量的空列表
ArrayList<String> list = new ArrayList<>(5);
==============================================
public ArrayList(int initialCapacity->5) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];//直接创建长度为5的数组
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
ArrayList list = new ArrayList() -> 现在我们想用都是new
但是将来开发不会想使用就new集合,都是调用一个方法,查询出很多数据来,此方法返回一个集合,自动将查询出来的数据放到集合中,我们想在页面上展示数据,遍历集合
而且将来调用方法,返回的集合类型,一般都是接口类型
List<泛型> list = 对象.查询方法()
LinkedList集合
1.概述:LinkedList是List接口的实现类
2.特点:
a.元素有序
b.元素可重复
c.有索引 -> 这里说的有索引仅仅指的是有操作索引的方法,不代表本质上具有索引
d.线程不安全
3.数据结构:双向链表
4.方法:有大量直接操作首尾元素的方法
- public void addFirst(E e):将指定元素插入此列表的开头。
- public void addLast(E e):将指定元素添加到此列表的结尾。
- public E getFirst():返回此列表的第一个元素。
- public E getLast():返回此列表的最后一个元素。
- public E removeFirst():移除并返回此列表的第一个元素。
- public E removeLast():移除并返回此列表的最后一个元素。
- public E pop():从此列表所表示的堆栈处弹出一个元素。
- public void push(E e):将元素推入此列表所表示的堆栈。
- public boolean isEmpty():如果列表没有元素,则返回true。
public class Demo05LinkedList {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("吕布");
linkedList.add("刘备");
linkedList.add("关羽");
linkedList.add("张飞");
linkedList.add("貂蝉");
System.out.println(linkedList);
linkedList.addFirst("孙尚香");
System.out.println(linkedList);
linkedList.addLast("董卓");
System.out.println(linkedList);
System.out.println(linkedList.getFirst());
System.out.println(linkedList.getLast());
linkedList.removeFirst();
System.out.println(linkedList);
linkedList.removeLast();
System.out.println(linkedList);
System.out.println("======================");
Iterator<String> iterator = linkedList.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("=======================");
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
}
}
public E pop():从此列表所表示的堆栈处弹出一个元素。
public void push(E e):将元素推入此列表所表示的堆栈。
public class Demo06LinkedList {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("吕布");
linkedList.add("刘备");
linkedList.add("关羽");
linkedList.add("张飞");
linkedList.add("貂蝉");
//public E pop():从此列表所表示的堆栈处弹出一个元素。
linkedList.pop();
System.out.println(linkedList);
//public void push(E e):将元素推入此列表所表示的堆栈。
linkedList.push("涛哥");
System.out.println(linkedList);
}
}
1.1 LinkedList底层成员解释说明
1.LinkedList底层成员
transient int size = 0; 元素个数
transient Node<E> first; 第一个节点对象
transient Node<E> last; 最后一个节点对象
2.Node代表的是节点对象
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;
}
}
1.2 LinkedList中add方法源码分析
LinkedList<String> list = new LinkedList<>();
list.add("a");
list.add("b");
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++;
}
1.3.LinkedList中get方法源码分析
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
index < (size >> 1)采用二分思想,先将index与长度size的一半比较,如果index<size/2,就只从位置0往后遍历到位置index处,而如果index>size/2,就只从位置size往前遍历到位置index处。这样可以减少一部分不必要的遍历
增强for
1.基本使用
1.作用:
遍历集合或者数组
2.格式:
for(元素类型 变量名:要遍历的集合名或者数组名){
变量名就是代表的每一个元素
}
3.快捷键:集合名或者数组名.for
public class Demo01ForEach {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
for (String s : list) {
System.out.println(s);
}
System.out.println("=====================");
int[] arr = {1,2,3,4,5};
for (int i : arr) {
System.out.println(i);
}
}
}
2.注意
1.增强for遍历集合时,底层实现原理为迭代器
2.增强for遍历数组时,底层实现原理为普通for
所以不管是用迭代器还是使用增强for,在遍历集合的过程中都不要随意修改集合长度,否则会出现并发修改异常