Java集合框架之ArrayList。本站提示廣大學習愛好者：（Java集合框架之ArrayList）文章只能為提供參考，不一定能成為您想要的結果。以下是Java集合框架之ArrayList正文
從Java集合框架之Collection接口中我們知道List接口有3個完成子類，辨別為ArrayList、LinedList與Vector類，而我們編程中最常用到的集合為ArrayList，這篇次要引見ArrayList類。
1、集合的呈現我們知道數組可以用來寄存根底數據類型與援用類型，在定義的時分，寄存在數組中的類型是曾經確定的了，如上面給定的數組只能用來寄存String類型的值，並且這時數組的長度曾經固定
String[] array = new String[5];
假如想給數組添加新的值，比方說像這樣
array[6] = "s";
則會報java.lang.IndexOutOfBoundsException的錯誤，即數組越界，假如想在原來數組的元素兩頭添加新的元素，那數組也是能干為力的，為了補償數組這種不可變的行為，Java中設計了一系列操作元素的集合類，比方這篇文章要講的ArrayList類。
2、承繼關系
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.ArrayList<E>
一切已完成的接口：
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
直接已知子類：
AttributeList, RoleList, RoleUnresolvedList
ArrayList承繼了AbstractList，完成了List接口，是一個數組隊列，提供了添加、刪除、修正、遍歷等功用，相當於是一個靜態數組，與數組的固定容量相比擬，ArrayList集合的容量可以依據一定的規則靜態的增長，關於事前不知道元素的類型以及數量時，思索用ArrayList比擬合適。
ArrayList完成了RandmoAccess接口，即提供了隨機訪問功用。在ArrayList中，我們可以經過元素的序號疾速獲取元素對象，這就是疾速隨機訪問。
ArrayList完成了Cloneable接口，即掩蓋了函數clone()，能被克隆。
ArrayList完成java.io.Serializable接口，這意味著ArrayList支持序列化，能經過序列化去傳輸。
ArrayList()
結構一個初始容量為 10 的空列表。
ArrayList(Collection<? extends E> c)
結構一個包括指定 collection 的元素的列表，這些元素是依照該 collection 的迭代器前往它們的順序陳列的。
ArrayList(int initialCapacity)
結構一個具有指定初始容量的空列表。
3.2、結構辦法
完成自Collection接口中的辦法
boolean add(E e)
確保此 collection 包括指定的元素（可選操作）。
boolean addAll(Collection<? extends E> c)
將指定 collection 中的一切元素都添加到此 collection 中（可選操作）。
void clear()
移除此 collection 中的一切元素（可選操作）。
boolean contains(Object o)
假如此 collection 包括指定的元素，則前往 true。
boolean containsAll(Collection<?> c)
假如此 collection 包括指定 collection 中的一切元素，則前往 true。
boolean equals(Object o)
比擬此 collection 與指定對象能否相等。
int hashCode()
前往此 collection 的哈希碼值。
boolean isEmpty()
假如此 collection 不包括元素，則前往 true。
Iterator<E> iterator()
前往在此 collection 的元素上停止迭代的迭代器。
boolean remove(Object o)
從此 collection 中移除指定元素的單個實例，假如存在的話（可選操作）。
boolean removeAll(Collection<?> c)
移除此 collection 中那些也包括在指定 collection 中的一切元素（可選操作）。
boolean retainAll(Collection<?> c)
僅保存此 collection 中那些也包括在指定 collection 的元素（可選操作）。
int size()
前往此 collection 中的元素數。
Object[] toArray()
前往包括此 collection 中一切元素的數組。
<T> T[] toArray(T[] a)
前往包括此 collection 中一切元素的數組；前往數組的運轉時類型與指定數組的運轉時類型相反。
完成自List接口中的辦法，簡直都是與地位有關的辦法
void add(int index, E element)
在列表的指定地位拔出指定元素（可選操作）。
boolean addAll(int index, Collection<? extends E> c)
將指定 collection 中的一切元素都拔出到列表中的指定地位（可選操作）。
E get(int index)
前往列表中指定地位的元素。
int hashCode()
前往列表的哈希碼值。
int indexOf(Object o)
前往此列表中第一次呈現的指定元素的索引；假如此列表不包括該元素，則前往 -1。
int lastIndexOf(Object o)
前往此列表中最後呈現的指定元素的索引；假如列表不包括此元素，則前往 -1。
ListIterator<E> listIterator()
前往此列表元素的列表迭代器（按適當順序）。
ListIterator<E> listIterator(int index)
前往列表中元素的列表迭代器（按適當順序），從列表的指定地位開端。
E remove(int index)
移除列表中指定地位的元素（可選操作）。
E set(int index, E element)
用指定元素交換列表中指定地位的元素（可選操作）。
List<E> subList(int fromIndex, int toIndex)
前往列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的局部視圖。
ArrayList自己特有的辦法
Object clone()
前往此 ArrayList 實例的淺表正本。
void ensureCapacity(int minCapacity)
如有必要，添加此 ArrayList 實例的容量，以確保它至多可以包容最小容量參數所指定的元素數。
protected void removeRange(int fromIndex, int toIndex)
移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之間的一切元素。
void trimToSize()
將此 ArrayList 實例的容量調整為列表的以後大小。
4、源碼
後續
5、遍歷方式 5.1、迭代器 1 package list;
2
3 import java.util.ArrayList;
4 import java.util.Iterator;
5 import java.util.List;
6
7 public class ListDemo1 {
8 public static void main(String[] args) {
9 List list = new ArrayList();
10 list.add("紅樓夢");
11 list.add("三國演義");
12 list.add("西游記");
13 list.add("水浒傳");
14
15 Object object = null;
16 Iterator it = list.iterator();
17
18 while (it.hasNext()) {
19 object = it.next();
20 System.out.println(object);
21 }
22 }
23 }
輸入後果
紅樓夢 三國演義 西游記 水浒傳
除了用Iterator接口中的iterator辦法遍歷外，還可以運用ArrayList集合特有的接口ListIterator來遍歷
ListIterator<E> listIterator()
前往列表中元素的列表迭代器（以正確的順序）。
ListIterator承繼自Iterator接口，除了擁有Iterator接口中的辦法之外，還擁有自己特有的遍歷辦法
boolean hasPrevious()
假如以反向遍歷列表，列表迭代器有多個元素，則前往 true。
E previous()
前往列表中的前一個元素。
雖然ListIterator可以完成集合的逆向迭代，但是從Java集合框架之Collection接口中我們知道，迭代器初始形態下後面並沒有任何元素，必需先正向遍歷，才干逆向遍歷，所以普通不運用逆向迭代。
1 package list;
2
3 import java.util.ArrayList;
4 import java.util.List;
5 import java.util.ListIterator;
6
7 public class ListDemo2 {
8 public static void main(String[] args) {
9 List list = new ArrayList();
10 list.add("紅樓夢");
11 list.add("三國演義");
12 list.add("西游記");
13 list.add("水浒傳");
14
15 Object object = null;
16 ListIterator it = list.listIterator();
17
18 System.out.println("----------逆向迭代----------");
19 while (it.hasPrevious()) {
20 object = it.previous();
21 System.out.println(object);
22 }
23
24 System.out.println("----------正向迭代----------");
25 while (it.hasNext()) {
26 object = it.next();
27 System.out.println(object);
28 }
29
30 System.out.println("----------逆向迭代----------");
31 while (it.hasPrevious()) {
32 object = it.previous();
33 System.out.println(object);
34 }
35 }
36 }
輸入後果
----------逆向迭代---------- ----------正向迭代---------- 紅樓夢 三國演義 西游記 水浒傳 ----------逆向迭代---------- 水浒傳 西游記 三國演義 紅樓夢
從下面後果可以看出，當第一次逆向迭代的時分並沒有任何輸入，當正向迭代後，迭代器到了集合的末尾之後，再次逆向迭代，這時才有輸入。
下面的while循環，我們可以改成for循環
1 package list;
2
3 import java.util.ArrayList;
4 import java.util.Iterator;
5 import java.util.List;
6
7 public class ListDemo3 {
8 public static void main(String[] args) {
9 List list = new ArrayList();
10 list.add("紅樓夢");
11 list.add("三國演義");
12 list.add("西游記");
13 list.add("水浒傳");
14
15 Object object = null;
16
17 for (Iterator iterator = list.iterator(); iterator.hasNext();) {
18 object = iterator.next();
19 System.out.println(object);
20 }
21 }
22 }
5.2、經過索引值
1 package list;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 public class ListDemo4 {
7 public static void main(String[] args) {
8 List list = new ArrayList();
9 list.add("紅樓夢");
10 list.add("三國演義");
11 list.add("西游記");
12 list.add("水浒傳");
13
14 Object object = null;
15
16 for (int i = 0; i < list.size(); i++) {
17 object = list.get(i);
18 System.out.println(object);
19 }
20 }
21 }
5.3、加強For循環
1 package list;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 public class ListDemo5 {
7 public static void main(String[] args) {
8 List list = new ArrayList();
9 list.add("紅樓夢");
10 list.add("三國演義");
11 list.add("西游記");
12 list.add("水浒傳");
13
14 for (Object object : list) {
15 System.out.println(object);
16 }
17 }
18 }
6、常用辦法示例
1 package list;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 public class ListDemo6 {
7 public static void main(String[] args) {
8 List list = new ArrayList();
9
10 // 添加元素
11 list.add("紅樓夢");
12 list.add("三國演義");
13 list.add("西游記");
14 list.add("水浒傳");
15
16 // 獲取集合大小
17 System.out.println("初始形態：" + list);
18 System.out.println("數組大小：" + list.size());
19
20 // 判別集合能否包括某元素
21 boolean contain = list.contains("水浒傳");
22 System.out.println("集合能否包括水浒傳: " + contain);
23
24 // 判別集合能否為空
25 boolean isEmpty = list.isEmpty();
26 System.out.println("集合能否為空：" + isEmpty);
27
28 // 獲取第一個元素
29 Object object = list.get(0);
30 System.out.println("第一個元素是: " + object);
31
32 // 獲取第一次呈現給定元素的地位
33 int index = list.indexOf("水浒傳");
34 System.out.println("第一次呈現水浒傳的地位是：" + index);
35
36 // 在1地位拔出元素，拔出的地位不能超越集合的最大長度，否則報java.lang.IndexOutOfBoundsException異常
37 list.add(2, "偉大的世界");
38 System.out.println("在地位2處拔出元素後的集合: " + list);
39
40 // 刪除方才拔出的元素
41 object = list.remove(2);
42 System.out.println("被刪除的元素: " + object);
43 System.out.println("刪除元素後的集合: " + list);
44
45 // 交換指定地位的元素
46 object = list.set(0, "儒林外史");
47 System.out.println("被交換的元素是：" + object);
48
49 System.out.println("如今集合中的元素是：" + list);
50
51 // 集合轉數組
52 Object[] objects = list.toArray();
53 for (int i = 0; i < objects.length; i++) {
54 System.out.println("第" + i + "個元素：" + objects[i]);
55 }
56
57 // 清空集合
58 list.clear();
59 System.out.println("清空集合後：" + list);
60 System.out.println("清空集合能否為空：" + list.isEmpty());
61 }
62 }
輸入後果
初始形態：[紅樓夢, 三國演義, 西游記, 水浒傳] 數組大小：4 集合能否包括水浒傳: true 集合能否為空：false 第一個元素是: 紅樓夢 第一次呈現水浒傳的地位是：3 在地位2處拔出元素後的集合: [紅樓夢, 三國演義, 偉大的世界, 西游記, 水浒傳] 被刪除的元素: 偉大的世界 刪除元素後的集合: [紅樓夢, 三國演義, 西游記, 水浒傳] 被交換的元素是：紅樓夢 如今集合中的元素是：[儒林外史, 三國演義, 西游記, 水浒傳] 第0個元素：儒林外史 第1個元素：三國演義 第2個元素：西游記 第3個元素：水浒傳 清空集合後：[] 清空集合能否為空：true
