[TOC]
## **第1部分 ArrayList简介**
ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长,类似于C语言中的动态申请内存,动态增长内存。
<br>
ArrayList不是线程安全的,只能在单线程环境下,多线程环境下可以考虑用collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类,也可以使用concurrent并发包下的CopyOnWriteArrayList类。
<br>
ArrayList实现了Serializable接口,因此它支持序列化,能够通过序列化传输,实现了RandomAccess接口,支持快速随机访问,实际上就是通过下标序号进行快速访问,实现了Cloneable接口,能被克隆。
<br>
<br>
### **ArrayList与Collection关系如下图**:
:-: ![](https://img.kancloud.cn/eb/ba/ebba2c7a28a5a40b645abd803e110c31_480x414.png)
<br>
### **ArrayList实现原理:**
:-: ![](https://img.kancloud.cn/87/23/872301706ef3a9b147ff947f5e8837c6_548x354.png)
<br>
<br>
### **ArrayList基本语法:**
`ArrayList 类位于 java.util 包中,使用前需要引入它,语法格式如下:`
```
import java.util.ArrayList; // 引入 ArrayList 类
```
```
ArrayList<E> objectName =new ArrayList<>(); // 初始化
```
* **E**: 泛型数据类型,用于设置 objectName 的数据类型,**只能为引用数据类型**。
* **objectName**: 对象名。
ArrayList 是一个数组队列,提供了相关的添加、删除、修改、遍历等功能。
<br>
<br>
## **第2部分 ArrayList添加元素**
ArrayList 类提供了很多有用的方法,添加元素到 ArrayList 可以使用 add() 方法:
```
import java.util.ArrayList;
public class day01Arraylist01{
public static void main(String []agrs){
ArrayList<String> sites = new ArrayList<String>();
sites.add("Python人生苦短");
sites.add("java一切皆对象");
sites.add("Golang你俩说的对");
System.out.println(sites);
}
}
```
**运行结果:**
`[Python人生苦短, java一切皆对象, Golang你俩说的对]`
<br>
<br>
## **第3部分 ArrayList访问元素**
访问 ArrayList 中的元素可以使用 get() 方法:
```
import java.util.ArrayList;
public class day01Arraylist01{
public static void main(String []agrs){
ArrayList<String> sites = new ArrayList<String>();
sites.add("Python人生苦短");
sites.add("java一切皆对象");
sites.add("Golang你俩说的对");
System.out.println(sites);
// 访问第二个元素
System.out.println(sites.get(2));
}
}
```
**运行结果:**
Golang你俩说的对
**注意**:数组的索引值从 0 开始。
<br>
<br>
## **第5部分 toArray()修改元素**
如果要修改 ArrayList 中的元素可以使用 set() 方法:
```
import java.util.ArrayList;
public class day01Arraylist01{
public static void main(String []agrs){
ArrayList<String> sites = new ArrayList<String>();
sites.add("Python人生苦短");
sites.add("java一切皆对象");
sites.add("Golang你俩说的对");
sites.set(1,"MYSQL");// 第一个参数为索引位置,第二个是要修改的值
System.out.println(sites);
}
}
```
**运行结果:**
`[Python人生苦短, MYSQL, Golang你俩说的对]`
<br>
<br>
## **第6部分 ArrayList删除元素**
如果要删除 ArrayList 中的元素可以使用 remove() 方法:
```
import java.util.ArrayList;
public class day01Arraylist01{
public static void main(String []agrs){
ArrayList<String> sites = new ArrayList<String>();
sites.add("Python人生苦短");
sites.add("java一切皆对象");
sites.add("Golang你俩说的对");
sites.remove(1); // 通过索引删除元素,这里删除的是第一个
System.out.println(sites);
}
}
```
**运行结果:**
`[Python人生苦短, Golang你俩说的对]`
<br>
<br>
## **第6部分 ArrayList示例**
### 计算大小
如果要计算 ArrayList 中的元素数量可以使用 size() 方法:
```
import java.util.ArrayList;
public class day01Arraylist01{
public static void main(String []agrs){
ArrayList<String> sites = new ArrayList<String>();
sites.add("Python人生苦短");
sites.add("java一切皆对象");
sites.add("Golang你俩说的对");
System.out.println(sites.size());
}
}
```
**运行结果:**
3
<br>
<br>
### 迭代数组列表
我们可以使用 for 来迭代数组列表中的元素:
```
import java.util.ArrayList;
public class day01Arraylist01{
public static void main(String []agrs){
ArrayList<String> sites = new ArrayList<String>();
sites.add("Python人生苦短");
sites.add("java一切皆对象");
sites.add("Golang你俩说的对");
for(int i = 0;i < sites.size();i++){
System.out.println(sites.get(i));
}
}
}
```
**运行结果:**
Python人生苦短
java一切皆对象
Golang你俩说的对
<br>
也可以使用 for-each 来迭代元素:
```
import java.util.ArrayList;
public class day01Arraylist01{
public static void main(String []agrs){
ArrayList<String> sites = new ArrayList<String>();
sites.add("Python人生苦短");
sites.add("java一切皆对象");
sites.add("Golang你俩说的对");
for (String i : sites){
System.out.println("我是each");
System.out.println(i);
}
}
}
```
**运行结果:**
我是each
Python人生苦短
我是each
java一切皆对象
我是each
Golang你俩说的对
<br>
<br>
### 其他的引用类型
ArrayList 中的元素实际上是对象,在以上实例中,数组列表元素都是字符串 String 类型。
<br>
如果我们要存储其他类型,而 只能为引用数据类型,这时我们就需要使用到基本类型的包装类。
<br>
### 基本类型对应的包装类表如下:
| 基本类型 | 引用类型 |
| --- | --- |
| boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
此外,BigInteger、BigDecimal 用于高精度的运算,BigInteger 支持任意精度的整数,也是引用类型,但它们没有相对应的基本类型。
```
ArrayList<Integer> li=new Arraylist<>(); // 存放整数元素
ArrayList<Character> li=new Arraylist<>(); // 存放字符元素
```
<br>
<br>
以下实例使用 ArrayList 存储数字(使用 Integer 类型):
```
import java.util.ArrayList;
public class day02ArrayList02{
public static void main(String [] args){
ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(10);
nums.add(9);
nums.add(8);
nums.add(7);
nums.add(6);
nums.add(6);
for(int i : nums){
System.out.println(i);
}
}
}
```
**运行结果:**
10
9
8
7
6
6
<br>
### ArrayList 排序
Collections 类也是一个非常有用的类,位于 java.util 包中,提供的 sort() 方法可以对字符或数字列表进行排序。
以下实例对数字进行排序:
```
import java.util.ArrayList;
import java.util.Collections; // 引入 Collections 类
public class day02ArrayList02{
public static void main(String [] args){
ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(10);
nums.add(9);
nums.add(12);
nums.add(7);
nums.add(6);
nums.add(6);
Collections.sort(nums);// 排序
for(int i : nums){
System.out.println(i);
}
}
}
```
**运行结果:**
6
6
7
9
10
12
<br>
以下实例对字母进行排序:
```
import java.util.ArrayList;
import java.util.Collections; // 引入 Collections 类
public class day02ArrayList02{
public static void main(String [] args){
ArrayList<String> nums = new ArrayList<String>();
nums.add("Golang");
nums.add("java");
nums.add("Python");
nums.add("C++");
nums.add("C");
nums.add("JS");
Collections.sort(nums);// 排序
for(String i : nums){
System.out.println(i);
}
}
}
```
**运行结果:**
C
C++
Golang
JS
Python
java
<br>
<br>
## **第7部分 ArrayList 方法集合**
Java ArrayList 常用方法列表如下:
| 方法 | 描述 |
| --- | --- |
| [add()]() | 将元素插入到指定位置的 arraylist 中 |
| [addAll()]() | 添加集合中的所有元素到 arraylist 中 |
| [clear()]() | 删除 arraylist 中的所有元素 |
| [clone()]() | 复制一份 arraylist |
| [contains()]() | 判断元素是否在 arraylist |
| [get()]() | 通过索引值获取 arraylist 中的元素 |
| [indexOf()]() | 返回 arraylist 中元素的索引值 |
| [removeAll()]() | 删除存在于指定集合中的 arraylist 里的所有元素 |
| [remove()]() | 删除 arraylist 里的单个元素 |
| [size()]() | 返回 arraylist 里元素数量 |
| [isEmpty()]() | 判断 arraylist 是否为空 |
| [subList()]() | 截取部分 arraylist 的元素 |
| [set()]() | 替换 arraylist 中指定索引的元素 |
| [sort()]() | 对 arraylist 元素进行排序 |
| [toArray()]() | 将 arraylist 转换为数组 |
| [toString()]() | 将 arraylist 转换为字符串 |
| [ensureCapacity]() | 设置指定容量大小的 arraylist |
| [lastIndexOf()]() | 返回指定元素在 arraylist 中最后一次出现的位置 |
| [retainAll()]() | 保留 arraylist 中在指定集合中也存在的那些元素 |
| [containsAll()]() | 查看 arraylist 是否包含指定集合中的所有元素 |
| [trimToSize()]() | 将 arraylist 中的容量调整为数组中的元素个数 |
| [removeRange()]() | 删除 arraylist 中指定索引之间存在的元素 |
| [replaceAll()]() | 将给定的操作内容替换掉数组中每一个元素 |
| [removeIf()]() | 删除所有满足特定条件的 arraylist 元素 |
| [forEach()]() | 遍历 arraylist 中每一个元素并执行特定操作 |
<br>
<br>
### 1:clear( )方法实例演示
clear() 方法用于删除动态数组中的所有元素。
clear() 方法的语法为:
```
arraylist.clear()
```
**注:** arraylist 是 ArrayList 类的一个对象。
**参数说明:**
* 无
```
import java.util.ArrayList;
public class day03ArrayList03{
public static void main(String []args){
// 创建一个数组
ArrayList<String> nums = new ArrayList<>();
nums.add("Python");
nums.add("Java");
nums.add("Golnag");
nums.add("C++");
System.out.println("It常用语言有:"+nums);
// 删除所有元素
nums.clear();
System.out.println("clear后的结果是:"+nums);
}
}
```
**运行结果:**
`It常用语言有:[Python, Java, Golnag, C++]`
`clear后的结果是:[ ]`
<br>
在上面的实例中,我们创建了一个名为 nums 的动态数组。该动态数组存储这编程语言的名称。
实例最后,我们使用 clear() 方法删除了动态数组 nums 的所有元素。
<br>
<br>
### 2:clear() 与 removeAll( ) 方法
接下来我们正好可引入另一个方法[isEmpty()]()判断是否为空,这次删除是使用 removeAll
在动态数组中还提供了 removeAll() 方法,它同样能删除数组中的所有元素,如下:
```
import java.util.ArrayList;
public class day04ArrayList04{
public static void main(String[]args){
// 创建一个动态数组
ArrayList <Integer> nums = new ArrayList<>();
// 添加元素
nums.add(12);
nums.add(43);
nums.add(21);
nums.add(54);
System.out.println("removeAll() 前:" + nums);
// 删除所有元素
nums.removeAll(nums);
System.out.println("removeAll() 后:" + nums);
if(nums.isEmpty()){//判断是否为空
System.out.println("你尽然把它全删了!呜呜呜");
}
}
}
```
**运行结果:**
removeAll() 前:[12, 43, 21, 54]
removeAll() 后:[]
你尽然把它全删了!呜呜呜
我们创建了一个名为 nums 的动态数组,然后使用 removeAll() 方法删除数组中所有的元素。
removeAll() 和 clear() 方法功能都是一样都。但是 clear() 方法的比 removeAll() 更常被用到,因为 clear() 比 removeAll() 更快,更高效。
<br>
<br>
### 3:remove()方法案例演示
remove() 方法用于删除动态数组里的单个元素。
remove() 方法的语法为:
// 删除指定元素
```
arraylist.remove(Object obj)
```
// 删除指定索引位置的元素
```
arraylist.remove(int index)
```
**注:** arraylist 是 ArrayList 类的一个对象。
**参数说明:**
* obj - 要删除的元素
* index - 要删除元素索引值
如果 obj 元素出现多次,则删除在动态数组中最第一次出现的元素。
<br>
#### 3.1:返回值
如果传入元素,删除成功,则返回 true。
如果传入索引值,则返回删除的元素。
注意:如果指定的索引超出范围,则该方法将抛出 IndexOutOfBoundsException 异常。
<br>
#### 3.2:实例——从数组中删除指定的元素:【数字】
```
import java.util.ArrayList;
public class day04ArrayList04{
public static void main(String[]args){
// 创建一个动态数组
ArrayList <Integer> nums = new ArrayList<>();
// 添加元素
nums.add(12);
nums.add(43);
nums.add(21);
nums.add(54);
System.out.println("remove() 前:" + nums);
// 删除单个元素,通过下标
nums.remove(1);
System.out.println("remove() 后:" + nums);
if(nums.isEmpty()){//判断是否为空
System.out.println("你尽然把它全删了!呜呜呜");
}
}
}
```
**运行结果:**
remove() 前:[12, 43, 21, 54]
remove() 后:[12, 21, 54]
<br>
#### 3.3:实例——从数组中删除指定的元素:【字母】
```
import java.util.ArrayList;
public class day04ArrayList04{
public static void main(String[]args){
// 创建一个动态数组
ArrayList <String> nums = new ArrayList<>();
// 添加元素
nums.add("一");
nums.add("二");
nums.add("三");
nums.add("四");
System.out.println("remove() 前:" + nums);
// 删除单个元素,通过下标
nums.remove("四");
System.out.println("remove() 后:" + nums);
}
}
```
**运行结果:**
remove() 前:[一, 二, 三, 四]
remove() 后:[一, 二, 三]
<br>
<br>
#### 3.4:实例——删除第一次出现的元素:
```
import java.util.ArrayList;
class day05ArrayList05{
public static void main(String[]args){
ArrayList <Integer> nums = new ArrayList<>();
nums.add(23);
nums.add(56);
nums.add(45);
nums.add(23);
nums.add(78);
nums.add(98);
nums.add(34);
System.out.println("init array :" + nums);
// 删除第一个次出现的23的元素
boolean result = nums.remove(Integer.valueOf(23));
System.out.println("23被删除了吗?" + result);
System.out.println("使用remove后:" + nums);
}
}
```
**运行结果:**
init array :[23, 56, 45, 23, 78, 98, 34]
23被删除了吗?true
使用remove后:[56, 45, 23, 78, 98, 34]
<br>
我们创建了一个名为 nums 的动态数组。在这个数组中,元素 23 出现了两次,注意这一行:
~~~
nums.remove(Integer.valueOf(23))
~~~
Integer.valueOf()将 23 从 int 类型转变成一个 Integer 对象。因为 remove() 方法仅将对象作为其参数。
remove()用于删除第一个出现在数组中的 23。
<br>
<br>
### 4:set() 方法
set() 方法用于替换动态数组中指定索引的元素。
set() 方法的语法为:
```
arraylist.set(int index, E element)
```
**注:** arraylist 是 ArrayList 类的一个对象。
**参数说明:**
* index - 索引位置
* element - 将在 index 位置替换进去的新元素
<br>
#### 4.1:返回值
返回之前在 index 位置的元素 。
如果 index 值超出范围,则抛出 IndexOutOfBoundsException 异常。
<br>
#### 4.2:实例
替换动态数组中的某元素:
```
importjava.util.ArrayList;
classMain{
publicstaticvoidmain(String[]args){
// 创建一个动态数组
ArrayList nums = new ArrayList<>();
sites.add("hhh");
sites.add("www");
sites.add("ooo");
System.out.println(">>>: "+ nums);
// 索引 2 的元素被替换
Stringelement=nums.set(2,"Wiki");
System.out.println("替换后: "+nums);
System.out.println("被替换的元素: "+element);
}
}
```
在上面的实例中,我们创建了一个名为 nums 的数组,set() 方法将索引位置为 2 的 ooo 替换成 Wiki。
注意:如果不确定元素的索引值,可以使用 ArrayList indexOf() 方法。
### ArrayList set() 与 add()方法
add() 和 set() 方法的语法看起来非常相似。
```
// add() 的语法
arraylist.add(int index, E element)
// set() 的语法
arraylist.set(int index, E element)
```
这两种方法都将新元素添加到数组中。
但是,它们之间有很大的不同:
* set() 方法在指定位置对元素进行更新。
* add() 方法将元素插入到指定位置的动态数组中。
```
import java.util.ArrayList;
class Main{
public static void main(String[]args){
// 创建一个动态数组
ArrayList nums = new ArrayList<>();
sites.add("hhh");
sites.add("www");
sites.add("ooo");
System.out.println(">>>: "+nums);
// 创建另一个 nums2 动态数组
ArrayList nums2 = new ArrayList<>();
// 将 nums 中的数组元素添加到 nums2
nums2.addAll(nums);
System.out.println("ArrayList: " + nums);
// 使用set()
sites.set(1,"Wiki");
System.out.println("ArrayList 使用 set() 后: "+ nums);
//使用 add()
nums2.add(1,"Wiki");
System.out.println("ArrayList 使用 add() 后: "+nums2);
}
}
```
- Java自动化测试
- 第一章:Java:基础内容
- 1.1:Java:Hello Word
- 1.2:Java:热身
- 1.3:Java:注释
- 1.4:Java:标识符
- 1.5:Java:常量
- 1.6:Java:基本数据类型
- 1.7:Java:引用类型
- 1.8:Java:String类
- 第二章:Java:运算符
- 2.1:Java:算数运算符
- 2.2:Java:关系运算符
- 2.3:Java:逻辑运算
- 2.4:Java:赋值运算符
- 2.5;Java:三元运算符
- 2.6:Java:位运算符
- 第三章:Java:循环控制语句
- 3.1:Java:for循环
- 3.2:Java:while循环
- 3.3:Java:switch
- 3.4:Java:if else
- 3.5:Java:练习题
- 第四章:Java:函数与全局/局部变量
- 4.1:Java:局部变量
- 4.2:Java:全局变量
- 第五章:Java:方法
- 5.1:Java:初识方法
- 5.2:Java:方法调用
- 5.3:Java:方法重载
- 5.4:Java:构造方法
- 5.5:Java:方法的注意事项
- 第六章:Java:面向对象
- 6.1:Java:小案例
- 6.2:Java:this 关键字
- 6.3:Java:super 关键字
- 6.4:Java:static 关键字
- 6.5:Java:final关键字
- 6.6:Java:instanceof 运算符
- 6.7:Java:面向对象之封装
- 6.8:Java:面向对象之继承
- 6.9:Java:面向对象之多态
- 第七章:Java:面向对象高级进阶
- 7.1:Java:抽象类
- 7.2:Java:Java中String类
- 7.3:Java:interface接口
- 7.4:Java:ArrayList
- 7.5:Java:HashSet
- 7.6:Java:HashMap
- 7.7:Java:反射(reflection)
- 第八章:Java:日志以及异常捕获
- 8.1:Java:log4j
- 8.2:Java:异常初识基础
- 8.3:Java:未被捕获的异常
- 8.4:Java:try和catch的使用
- 8.5:Java:多重catch语句的使用
- 8.6:Java:throws/throw 关键字
- 8.7:Java:finally关键字
- 8.8:Java:自定义异常
- 第九章:Java:xml and IO
- 9.1:Java:IO基本概念
- 9.2:java:properties
- 9.3:Java:xml基本介绍
- 9.4:Java:xml操作实例
- 第十章:Java:JDBC编程
- 10.1:Java:JDBC介绍
- 10.2:Java:JDBC查询
- 10.3:Java:JDBC插入
- 10.4:Java:Batch
- 10.5:Java:JDBC连接池
- 第十一章:Java:TestNG
- 11.1:java:TestNG简介
- 11.2:Java:TestNG小实例
- 11.3:Java:TestNG.xml文件配置
- 11.4:Java:TestNG基本注解
- 11.5:Java:TestNG注解代码
- 11.6:Java:TestNG预期异常
- 11.7:Java:TestNG忽略测试
- 11.8:Java:TestNG超时测试
- 11.9:Java:TestNG分组测试