集合与数组的区别
- 数组:
- 长度开始时必须指定,而且一旦指定,不能修改。
- 保存的必须为同一类型的元素。
- 使用数组进行增加/删除元素比较麻烦。
- 集合:
- 可以动态保存任意多个对象,使用比较方便。
- 提供了一系列方便操作对象的方法: add、remove、set、get。
- 使用集合添加,删除新元素的代码简洁明了。
Collection体系框架图
单列集合
双列集合
Collection接口和常用方法
特点:
-
collection实现子类可以存放多个元素,每个元素可以是Object。
-
有些Collection的实现类,可以存放重复的元素,有些不可以。
-
有些Collection的实现类,是有序的(List),有些不是有序的(Set)。
有序:指存取顺序一致
-
Collection接口没有直接的实现子类,是通过它的子接口Set和List来实现的。
操作元素方法
- add:添加单个元素。
- remove:删除指定元素。
- contains:查找元素是否存在。
- size:获取元素个数。
- isEmpty:判断是否为空。
- clear:清空。
- addAll:添加多个元素。
- containsAll:查找多个元素是否都存在。
- removeAll:删除多个元素。
代码:
import java.util.ArrayList;
//集合操作元素方法
public class Demo {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
//1.add:添加单个元素
arrayList.add("jack");
arrayList.add(10); //arrayList.add(new Integer(10)); 自动装箱
arrayList.add(true);
System.out.println("List:" + arrayList); //List:[jack, 10, true]
//2.remove:删除指定元素
Object first = arrayList.remove(0); //删除第一个元素
System.out.println("删除的第一个元素为:" + first); //删除的第一个元素为:jack
arrayList.remove("jack");
arrayList.remove(new Integer(10)); //这里就没有默认装箱了,输入10会删除第十一个元素
System.out.println("List:" + arrayList); //List:[true]
//3.contains:查找元素是否存在
System.out.println(arrayList.contains("jack")); //false
//4.size:获取元素个数
System.out.println(arrayList.size()); //1
//5.isEmpty:判断是否为空
System.out.println(arrayList.isEmpty()); //false
//6.clear:清空
arrayList.clear();
System.out.println("List:" + arrayList); //List:[]
//7.addAll:添加多个元素
ArrayList<Object> arrayList1 = new ArrayList<>();
arrayList1.add("红楼梦");
arrayList1.add("西游记");
arrayList1.add("水浒传");
arrayList1.add("三国演义");
arrayList.addAll(arrayList1);
System.out.println("List:" + arrayList); //List:[红楼梦, 西游记, 水浒传, 三国演义]
//8.containsAll:查找多个元素是否都存在
System.out.println(arrayList.containsAll(arrayList1)); //true
//9.removeAll:删除多个元素
ArrayList<Object> arrayList2 = new ArrayList<>();
arrayList2.add("红楼梦");
arrayList2.add("西游记");
arrayList.removeAll(arrayList2);
System.out.println("List:" + arrayList); //List:[水浒传, 三国演义]
}
}
使用迭代器遍历
基本介绍
- Iterator对象称为迭代器,主要用于遍历Collection集合中的元素。
- 所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器。
- Iterator的结构
- Iterator仅用于遍历集合,Iterator本身并不存放对象。
迭代器执行原理
//得到一个集合的迭代器
Iterator iterator = collection.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next()作用: 1.下移 2.将下移以后集合位置上的元素返回
System.out.printIn(iterator.next());
}
iterator接口方法
返回类型 | 方法 | 描述 |
---|---|---|
boolean | hasNext() | 如果迭代具有更多元素,则返回true |
E | next() | 返回迭代中的下一个元素 |
default void | remove() | 从底层集合中删除此迭代器返回的最后一个元素(可选操作)。 |
default void | forEachRemaining(Consumer action) | 对每个剩余元素执行给定的操作,直到所有元素都被处理或动作引发异常。 |
代码:
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
//迭代器遍历集合
public class CollectionIterator {
@SuppressWarnings({"all"}) //警告抑制
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("红楼梦");
collection.add("三国演义");
collection.add("西游记");
collection.add("水浒传");
System.out.println(collection);
//迭代器遍历集合
//1.得到集合对应的迭代器
Iterator iterator = collection.iterator();
//2.使用while循环遍历
while (iterator.hasNext()) { //判断是否还有元素
//返回下一个元素,类型是Object
Object object = iterator.next(); //编译类型是Object,运行类型取决于对象实际类型
System.out.println("object:" + object);
}
//快捷键快速生成该while循环 ==> itit
//CTRL+J 显示所有快捷键选项
//while (iterator.hasNext()) {
// Object next = iterator.next();
//}
//3.当退出while循环后,这时iterator迭代器指向最后一个元素
//iterator.next(); //报错:NoSuchElementException
//4.重新遍历
iterator = collection.iterator();
while (iterator.hasNext()) { //判断是否还有元素
//返回下一个元素,类型是Object
Object object = iterator.next(); //编译类型是Object,运行类型取决于对象实际类型
System.out.println("new object:" + object);
}
}
}
增强for循环遍历
增强for循环,可以替代iterator迭代器,特点:增强for就是简化版的iterator,本质一样。只能用于遍历集合或数组。
基本语法
for(元素类型 元素名 : 集合名或数组名){
访问元素
}
代码:
import java.util.ArrayList;
import java.util.Collection;
//增强for循环遍历集合
public class CollectionFor {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("红楼梦");
collection.add("三国演义");
collection.add("西游记");
collection.add(new book("三国演义","罗贯中",20.2));
collection.add(new book("红楼梦","曹雪芹",150.3));
collection.add(new book("西游记","吴承恩",25.3));
System.out.println(collection);
//增强for循环的底层实现依旧是迭代器
//增强for循环可以理解为简化版的迭代器
//快捷键 ==> I
//CTRL+J 显示所有快捷键选项
//for (Object object :) {
//
//}
//增强for循环遍历集合
for (Object object : collection) {
System.out.println(object);
}
}
}
class book{
public String name;
public String author;
public double price;
public book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
List接口方法
List接口基本介绍
List接口是Collection接口的子接口。
- List集合类中元素有序(即添加顺序和取出顺序一致)且可重复。
- List集合中的每个元素都有其对应的顺序索引,即支持索引。
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
- List接口常用的实现类有很多,常用的有:ArrayList、LinkedList 和 Vector。
常用方法
方法 | 描述 |
---|---|
void add ( int index , Object ele) | 在index位置插入ele元素 |
boolean addAll ( int index , Collection eles) | 从index位置开始将eles中的所有元素添加进来 |
Object get ( int index ) | 获取指定index位置的元素 |
int indexOf ( Object obj) | 返回obj在集合中首次出现的位置 |
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 位置的子集合 |
代码:
import java.util.ArrayList;
import java.util.List;
//List常用方法
public class ListDemo {
public static void main(String[] args) {
List list = new ArrayList();
list.add("Tom");
list.add("Jerry");
list.add("Jack");
//1.void add ( int index , Object ele )
//在index位置插入ele元素
list.add(1, "Jack"); //在index=1的位置插入一个对象"jack"
System.out.println(list); //[Tom, Jack, Jerry, Jack]
//2.boolean addAll ( int index , Collection eles )
//从index位置开始将eles中的所有元素添加进来
List list1 = new ArrayList();
list1.add("林黛玉");
list1.add("孙悟空");
list.addAll(1, list1);
System.out.println(list); //[Tom, 林黛玉, 孙悟空, Jack, Jerry, Jack]
//3.Object get ( int index )
//获取指定index位置的元素
System.out.println(list.get(1)); //林黛玉
//4.int indexOf ( Object obj )
//返回obj在集合中首次出现的位置
System.out.println(list.indexOf("Jack")); //3
System.out.println(list.indexOf("林黛玉")); //1
System.out.println(list.indexOf("贾宝玉")); //-1
//5.int lastIndexOf ( Object obj )
//返回obj在当前集合中末次出现的位置
System.out.println(list.lastIndexOf("Jack")); //5
System.out.println(list.lastIndexOf("林黛玉")); //1
System.out.println(list.lastIndexOf("贾宝玉")); //-1
//6.Object remove ( int index )
//移除指定index位置的元素,并返回此元素
list.remove(0);
System.out.println(list); //[林黛玉, 孙悟空, Jack, Jerry, Jack]
//7.Object set ( int index , Object ele )
//设置指定index位置的元素为ele,相当于是替换
list.set(1, "贾宝玉");
System.out.println(list); //[林黛玉, 贾宝玉, Jack, Jerry, Jack]
//list.set(5, "王熙凤");//IndexOutOfBoundsException
//下标必须存在,不能在最后的后一个使用set添加元素,可以用add
//8.List subList ( int fromIndex , int toIndex )
//返回从fromIndex 到 toIndex 位置的子集合
//返回的子集合区间左闭右开 [fromIndex,toIndex)
System.out.println(list.subList(1,3)); //[贾宝玉, Jack]
}
}
List遍历
三种遍历方式:List下所有的实现类都可以用这三种方式遍历元素。
- 使用iterator
- 使用增强for
- 使用普通for
代码:
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
//List遍历
public class ListTraversal {
public static void main(String[] args) {
//List下所有的实现类都可以用这三种方式遍历元素
//List list = new ArrayList();
//List list = new Vector();
List list = new LinkedList();
list.add("Tom");
list.add("Jerry");
list.add("Jack");
//遍历
//1.迭代器
System.out.println("=====迭代器=====");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
//2.增强for循环
System.out.println("=====增强for=====");
//list.forEach(System.out::println);
for (Object object : list) {
System.out.println(object);
}
//3.普通for
System.out.println("=====普通for=====");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
List实现类-ArrayList
ArrayList注意事项
- ArrayList 可以加入null,并且多个。
- ArrayList是由数组来实现的。
- ArrayList基本等同于Vector,除了 ArrayList是线程不安全(执行效率高),在多线程情况下,不建议使用ArrrayList。
源码:
// ArrayList是线程不安全,源码没有synchronized
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
ArrayList的底层操作机制源码分析(重点、难点)
-
ArrayList 中维护了一个 Object类型的数组 elementData。
transient Object[] elementData; // transient 标识瞬间,短暂的,表示该属性不会被序列化,即仅存于调用者的内存中而不会保存在硬盘上持久化
-
当创建ArrayList对象时,如果使用的是无参构造器,则初始elementData 容量为0,第一次添加,则扩容elementData为10,如需再次扩容,则扩容elementData容量为1.5倍。
-
如果使用的是指定大小的构造器,则初始elementData容量为指定大小,如果需要扩容,则直接扩容elementData为1.5倍。
测试程序:
import java.util.ArrayList;
//ArrayList的底层操作机制源码分析
public class ArrayListDemo {
public static void main(String[] args) {
//源码分析
//使用无参构造器创建ArrayList对象
ArrayList list = new ArrayList();
//使用for循环给list集合添加 1-10 数据
for (int i = 1; i <= 10; i++) {
list.add(i);
}
//使用for循环给list集合添加 11-15 数据
for (int i = 11; i <= 15; i++) {
list.add(i);
}
list.add(100);
list.add(200);
list.add(null);
for (Object object : list) {
System.out.println(object);
}
}
}
无参构造器源码分析
有参构造器源码分析
List实现类-Vector
基本介绍
-
定义说明
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable
-
Vector 底层也是一个对象数组,
protected Object[] elementData;
-
Vector 是线程同步的,即线程安全,Vector 类的操作方法带有
synchronized
-
在开发中,需要线程同步安全时,考虑使用Vector。
Vector和ArrayList的比较
List实现类 | 底层结构 | 版本 | 线程安全(同步)&&效率 | 扩容倍数 |
---|---|---|---|---|
ArrayList | 可变数组 | jdk1.2 | 不安全,效率高 | 如果有参构造1.5倍,如果是无参构造: 1.第一次10; 2.从第二次开始按1.5倍扩容。 |
Vector | 可变数组 | jdk1.0 | 安全,效率不高 | 如果是无参,默认10,满后,就按2倍扩容。 如果指定大小,则每次直接按2倍扩容。 |
源码分析:
import java.util.Vector;
//List实现类–Vector的底层操作机制源码分析
public class VectorDemo {
public static void main(String[] args) {
//无参构造器
Vector vector = new Vector();
//有参构造器
Vector vector1 = new Vector(10);
//1. new Vector()底层
/*
无参构造:
public Vector() {
this(10);
}
有参构造:
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
*/
for (int i = 0; i < 10; i++) {
vector.add(i);
}
//2. vector.add()
/*
2.1 add方法添加数据到vector集合
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
2.2 确定是否需要扩容,判断条件: if (minCapacity - elementData.length > 0)
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
*/
vector.add(100);
//3.需要扩容的vector 两倍扩容
// capacityIncrement:指定扩容大小,默认为0
//扩容算法:int 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);
}
*/
}
}
List实现类-LinkedList
基本介绍
- LinkedList底层实现了双向链表和双端队列特点。
- 可以添加任意元素(元素可以重复),包括null。
- 线程不安全,没有实现同步。
LinkedList底层结构
- LinkedList底层维护了一个双向链表。
- LinkedList中维护了两个属性first和last分别指向首节点和尾节点。
- 每个节点(Node对象),里面又维护了prev、next、item、三个属性,其中通过prev指向前一个,通过next指向后一个节点。最终实现双向链表。
- LinkedList的元素的添加和删除,不是通过数组完成的,相对来说效率较高。
源码分析:
import java.util.Iterator;
import java.util.LinkedList;
//List实现类-LinkedList的底层操作机制源码分析
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
/*源码1:
public LinkedList() {
}
这时的LinkedList属性 first = null , last =null
*/
linkedList.add(1);
/*源码2 执行 添加
2.1:
public boolean add(E e) {
linkLast(e);
return true;
}
2.2: 将新的节点加入到双向链表中,尾插法
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
*/
linkedList.add(2);
linkedList.add(3);
System.out.println("linkedList:"+linkedList);
//删除节点,默认删除首节点
linkedList.remove();
/* 3.源码 :删除
3.1 默认删除第一个 队列特征,先进先出
public E remove() {
return removeFirst();
}
3.2 当first对象为空时,抛出异常
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
3.3 将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;
}
*/
System.out.println("linkedList:"+linkedList);
//修改某个节点对象
Object set = linkedList.set(0, 666);
System.out.println(set);
System.out.println("linklist:"+linkedList);
/* 4. 修改源码
4.1 判断 获取 修改 返回旧值
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
4.2 判断index是否合法
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException
}
4.3 获取索引对应的对象
如果索引值小于size的一半,从头开始查找,否则从尾开始查找
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;
}
}
*/
//得到某个节点对象
//get(1)为第二个对象
Object o = linkedList.get(1);
System.out.println(o);
//LinkedList 实现 List 接口 遍历方式与List一致
System.out.println("=====linkedList迭代器遍历=====");
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
System.out.println("=====增强for循环遍历=====");
for (Object o1 : linkedList) {
System.out.println(o1);
}
System.out.println("=====传统for循环=====");
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
}
}
ArrayList和LinkedList比较
List实现类 | 底层结构 | 增删效率 | 改查效率 |
---|---|---|---|
ArrayList | 可变数组 | 较低,数组扩容 | 较高 |
LinkedList | 双向链表 | 较高,通过链表追加 | 较低 |
如何选择ArrayList和LinkedList:
- 如果改查的操作较多,选择ArrayList。
- 如果增删的操作较多,选择LinkedList。
- 一般来说,程序中,80%-90%都是查询,因此大部分情况下选择ArrayList。
- 在一个项目中,根据业务灵活选择,也可以这样,一个模块使用的是ArrayList,另外一个模块是LinkedList。根据业务合理选择。