Java集合（三）、继承⾃Collection接⼝的List接⼝
⼀、Collection接⼝
⾸先，让我们来看⼀下Collection接⼝的继承体系
（⼀）Collection的常⽤功能
1. 添加功能
boolean add(E e)
添加⼀个元素
boolean addAll(Collection c)
添加⼀批元素
2. 删除功能
boolean remove(Object o)
删除⼀个元素
3. 判断功能
boolean contains(Object o)
判断集合是否包含指定的元素
boolean isEmpty()
判断集合是否为空(集合中没有元素)
4. 获取功能
java arraylist用法int size()
获取集合的长度
5. 转换功能
Object[] toArray()
把集合转换为数组
（⼆）遍历集合的⽅式
１．普通的for循环【必须要有索引，可以修改元素】
import java.util.*;
public class test{
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("Hello");
list.add("Java");
list.add("World");
for (int i = 0; i < list.size(); i++){
String s = (String) (i);
System.out.println(s);
}
}
}
２．迭代器遍历【任何集合都可以遍历，只能获取元素】
import java.util.*;
public class test{
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("Hello");
c.add("Java");
c.add("World");
//获取迭代器对象
Iterator<String> it = c.iterator();
//hasNext()判断是否有下⼀个元素，如果有就⽤next()获取
while(it.hasNext()){
//获取下⼀个元素
String s = it.next();
System.out.println(s);
}
}
}
３．⾼级for循环【就是迭代器的简化⽅式】
import java.util.*;
public class test{
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("Hello");
c.add("Java");
c.add("World");
//⾼级for遍历集合
for (String s : c){
System.out.println(s);
}
int[] arr = {1, 2, 3, 4, 5};
//⾼级for遍历数组
for (int a : arr){
System.out.println(a);
}
}
}
（三）常见的数据结构
数据结构指的是数据的组存储⽅式，不同的数据结构有不同的特点。
1. 数组结构（ArrayList底层结构）
  查询快，增删慢
2. 链表结构（LinkedList底层结构）
  查询慢，增删快
3. 栈和队列
  栈：先进后出(⼦弹夹，杯⼦)
  队列：先进先出(排队，管⼦)
⼆、List接⼝
List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应⼀个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
JDK API中List接⼝的实现类常⽤的有：ArrayList、LinkList和Vector。
List集合⾥添加了⼀些根据索引来操作集合元素的⽅法
1.add(int index, Object ele)
2.boolean addAll(int index, Collection eles)
3.Object get(int index)
4.int indexOf(Object obj)
5.int lastIndexOf(Object obj)
6.Object remove(int index)
7.Object set(int index, Object ele)
8.List subList(int fromIndex, int toIndex)
（⼀）ArrayList
ArrayList是List接⼝的典型实现类，本质上，ArrayList是对象引⽤的⼀个变长数组。
ArrayList是List接⼝的可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。除了实现List接⼝外，此类还提供了⼀些⽅法来操作内部⽤来存储列表的数组的⼤⼩。
每个ArrayList实例都有⼀个初始容量，该容量⽤来储存列表元素的数组⼤⼩。默认初始容量为10。
ArrayList底层采⽤数组实现。数组都有⼀个重⼤的缺陷，这就是从数组的中间位置删除⼀个元素要付出很⼤的代价，其原因是数组中处于被删除元素之后的所有元素都要向数组的前端移动。在数组中间位置插⼊⼀个元素也是如此（数据的copy）。
注：Arrays.asList(…) ⽅法返回的 List 集合既不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…)返回值是⼀个固定长度的 List 集合。
1.ArrayList的存取实现
存储：
ArrayList提供了⼀下添加元素的⽅法
  set(int index, E element)、
  add(E e)、
  add(int index, E element)、
  addAll(Collection<? extends E> c)、
  addAll(inr index, Collection<? extends E> c)
add(E element)⽅法，将指定的元素添加到列表的尾部
import java.util.*;
public class test{
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
System.out.println(list);
list.add("Java");
System.out.println(list);
}
}
add(int index, E element)⽅法，将指定的元素插⼊此列表的指定位置，如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后续元素（将其索引值加1）
import java.util.*;
public class test{
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("leslie");
System.out.println(list);
list.add(1,"Java");
System.out.println(list);
}
}
set(int index, E element)⽅法，替换数组中已经存在的元素内容。
import java.util.*;
public class test{
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("leslie");
System.out.println(list);
list.set(1,"Java");
System.out.println(list);
}
}
addAll(Collection<? extends E> c)⽅法，按照指定Collection的迭代器所返回的元素顺序，将该Collection中的所有元素添加到此列表的尾部。
import java.util.*;
public class test{
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("leslie");
System.out.println(list);
List<String> list_ad = new ArrayList<String>();
list_ad.add("are you ok ?");
//将list中的全部元素添加到list_ad中
System.out.println("添加是否成功：" + list_ad.addAll(list));
//通过循环输出列表中的内容
for (int i = 0; i < list_ad.size(); i++){
System.out.println(i + ":" + (i));
}
}
}
addAll(int index, Collection<? extends E> c)⽅法，从指定的位置开始，将指定collection中的所有元素插⼊到此列表中
import java.util.*;
public class test{
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("leslie");
System.out.println(list);
List<String> list_ad = new ArrayList<String>();
list_ad.add("are you ready ?");
list_ad.add("are you ok ?");
//将list中的全部元素添加到list_ad中
System.out.println("添加是否成功：" + list_ad.addAll(1,list));
//通过循环输出列表中的内容
for (int i = 0; i < list_ad.size(); i++){
System.out.println(i + ":" + (i));
}
}
}
读取
get(int index)⽅法，获取指定位置上的元素
import java.util.*;
public class test{
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("leslie");
System.out.println(list);
System.out.(1));
}
}
总结：
ArrayLlist内部是由数组来实现的。在存放数据的数组长度不够时，会进⾏扩容，即增加数组长度。扩展为原来的1.5倍。
由于是数组来实现，所以，优点是查元素很快。可以通过下标查元素，查效率⾼。缺点是每次添加和删除元素都会进⾏⼤量的数组元素移动。长度不够会扩容。效率底下。
ArrayList每次的增、删、改操作都伴随着数组的复制和元素的移动。这意味着新的内存空间的开辟。
（⼆）LinkedList
LinkedList其实也就是我们在数据结构中的链表，这种数据结构有这样的特性：
分配内存空间不是必须是连续的；
插⼊、删除操作很快，只要修改前后指针就OK了，时间复杂度为O(1)；
访问⽐较慢，必须得从第⼀个元素开始遍历，时间复杂度为O(n)；
在Java中，LinkedList提供了丰富的⽅法，可以模拟链式队列，链式堆栈等数据结构，为⽤户带来了极⼤的⽅便，下⾯看看这些⽅法的⽤法：
add
boolean add(E e)：在链表后添加⼀个元素，如果成功，返回true，否则返回false；
void addFirst(E e)：在链表头部插⼊⼀个元素；
addLast(E e)：在链表尾部添加⼀个元素；
void add(int index, E element)：在指定位置插⼊⼀个元素。
⽰例代码
import java.util.*;
public class test{
public static void main(String[] args) {
LinkedList<String> linkList = new LinkedList<>();
linkList.add("first");
linkList.add("second");
linkList.add("third");
System.out.println(linkList);
linkList.addFirst("addFirst");
System.out.println(linkList);
linkList.addLast("addLast");
System.out.println(linkList);
linkList.add(2, "addByIndex");
System.out.println(linkList);
}
}
输出：
remove
E remove()；移除链表中第⼀个元素；
boolean remove(Object o)：移除链表中指定的元素；
E remove(int index)：移除链表中指定位置的元素；
E removeFirst()：移除链表中第⼀个元素，与remove类似；
E removeLast()：移除链表中最后⼀个元素；
boolean removeFirstOccurrence(Object o)：移除链表中第⼀次出现所在位置的元素；
boolean removeLastOccurrence(Object o)：移除链表中最后⼀次出现所在位置的元素；
⽰例代码：
import java.util.*;
public class test{
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("first");
linkedList.add("second");
linkedList.add("second");
linkedList.add("third");
linkedList.add("four");
linkedList.add("five");
System.out.println(linkedList);
System.out.println("remove: " + linkedList);
System.out.println("remove(Object): " + linkedList);
System.out.println("remove(Object) not exist: " + linkedList);
System.out.println("remove(index): " + linkedList);

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。