Java基础——ArrayList方法全解(字典版)
引言
在使用集合 ArrayList
的时候,经常使用add
、remove
等,其他的没用过,甚至没听说过的还有很多.现在在这个教程中,简单的了解一下,不要求全都记下.相当于在你脑袋里建一个索引,就是有些方法在用到的时候,不要去重复的造轮子而已.
ArrayList 结构体如下
包含构造方法总共是33
个方法.
开始
以下基于JDK1.8版本,以下方法排名不分先后
ArrayList()
可以使用new ArrayList()
创建一个 ArrayList
集合,如下:
/**
* 1 简单的ArrayList
*/
public static ArrayList getArrayList(){
ArrayList arrayList = new ArrayList();
arrayList.add("张三");
arrayList.add("里斯");
return arrayList;
}
一些编辑器中会报黄线或者淡黄背景提示,如下图
这个需要给 ArrayList
一个类型,例如 ArrayList<String>
.
ArrayList(Collection<? extends E> c)
可以放入一个集合体来初始化 ArrayList
,示例代码如下:
HashSet<String> temp1 = new HashSet<>();
temp1.add("张三");
temp1.add("里斯");
ArrayList<String> arrayList2 = new ArrayList<>(temp1);
arrayList2.forEach(System.out::println);
ArrayList(int initialCapacity)
构造一个具有指定初始容量的空列表,应用场景就是当你大概知道这个集合存储的数据量,直接定义好容量,避开集合自增空间浪费资源
.
ArrayList<String> arrayList3 = new ArrayList<>(1000);
add() 与 add(int, E)
add()
方法是将括号内的值增加到集合末尾.
add(int, E)
是将数据插入的具体的下标上,下表从零开始.
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add(0,"在天");
arrayList.add("里斯");
arrayList.forEach(System.out::println);
addAll(Collection<? extends E> c)
指集合中的所有元素
追加到此列表的末尾;
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("王二");
ArrayList<String> arrayList2 = new ArrayList<>();
arrayList2.add("麻子");
arrayList2.add("铁子");
arrayList.addAll(arrayList2);
System.out.println(arrayList);
输出:
[张三, 李四, 王二, 麻子, 铁子]
addAll(int index,Collection<? extends E> c)
相当于是add(int index,E)
与 addAll(Collection<? extends E> c)
结合版
在指定的索引下标,依次追加指定集合中的所有元素.例如上一个例子,我想在张三
后面就把麻子
与铁子
都插队进去,那么如下来实现一下.
public static void testAddAllByIndex(){
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("王二");
ArrayList<String> arrayList2 = new ArrayList<>();
arrayList2.add("麻子");
arrayList2.add("铁子");
arrayList.addAll(1,arrayList2);
System.out.println(arrayList);
}
输出:
[张三, 麻子, 铁子, 李四, 王二]
clear()
看名字就应该清楚.从此列表中删除所有元素
.此调用返回后,列表将为空,不是Null
.
public static void testClear() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("王二");
System.out.println("执行 clear() 前,arrayList.size=" + arrayList.size());
arrayList.clear();
System.out.println("执行 clear() 后,arrayList.size=" + arrayList.size());
}
输出:
执行 clear() 前,arrayList.size=3
执行 clear() 后,arrayList.size=0
clone()
在说明这个之前我们先举一个栗子.
拷贝对象
public static void testCloneTemp() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("王二");
ArrayList<String> arrayList2 = arrayList;
arrayList.add("混子");
arrayList2.add("王多鱼");
System.out.println(arrayList2);
}
输出:
[张三, 李四, 王二, 混子, 王多鱼]
我们其实想达到的效果是arrayList2
不要混子
,只需要王多鱼
.但是我们使了=
导致了他们两个的物理地址指向了同一个,这个时候就体现到了clone的重要性.
public static void testClone() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("王二");
ArrayList<String> arrayList2 = (ArrayList<String>) arrayList.clone();
arrayList.add("混子");
arrayList2.add("王多鱼");
System.out.println(arrayList2);
}
输出:
[张三, 李四, 王二, 王多鱼]
这样他们就不会互相影响到.
contains(Object o)
列表包含元素o
就返回true
,否则就返回false
;
public static void testContains() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("王二");
boolean existMazi = arrayList.contains("麻子");
boolean existZhangsan = arrayList.contains("张三");
System.out.printf("存在张三:%s,存在麻子:%s%n", existZhangsan, existMazi);
}
输出:
存在张三:true,存在麻子:false
ensureCapacity(int size)
变更ArrayList
的容量为size
.
public static void testChangeCapacity() throws NoSuchFieldException, IllegalAccessException {
ArrayList<String> arrayList = new ArrayList<>(100);
int sizeBefore = getCapacity(arrayList);
arrayList.ensureCapacity(1000);
int sizeAfter = getCapacity(arrayList);
System.out.printf("更改前的size=%d,更改后的size=%d", sizeBefore, sizeAfter);
}
输出:
更改前的size=100,更改后的size=1000
方法getCapacity
为ArrayList
获取容量大小的自定义方法,如下:
public static int getCapacity(ArrayList<?> arrayList) throws NoSuchFieldException, IllegalAccessException {
Class<ArrayList> arrayListClass = ArrayList.class;
Field field = arrayListClass.getDeclaredField("elementData");
field.setAccessible(true);
Object[] objects = (Object[]) field.get(arrayList);
return objects.length;
}
forEach 方法遍历集合
不要在使用forEach
的同时使用remove
和 add
方法, 不然会报异常.
至于为什么,这里就不拉开来讲了,因为我还没看懂,搜索一下后在评论给我讲讲.
使用蛮便捷的,就是上面的使用方法,只是不要调用新增与删除的方法就好.
get(int index)
根据下标
获取对应下标的值
.
public static void testGet(){
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("王二");
for (int i = 0; i < arrayList.size(); i++) {
String valueByIndex = arrayList.get(i);
System.out.println(valueByIndex);
}
}
输出:
张三
李四
王二
indexOf()
根据值获取对应的下标.
public static void testindexOf() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
System.out.printf("获取李四的下标:%d%n", arrayList.indexOf("张三"));
System.out.printf("获取李四一的下标:%d%n", arrayList.indexOf("李四一"));
}
输出:
获取李四的下标:0
获取李四一的下标:-1
isEmpty()
判断是否为空集合,空返回true
,否则反之返回true
.不能用于null
.
public static void testIsEmpty() {
ArrayList<String> arrayList = new ArrayList<>(100);
System.out.printf("获取是否为空集合:%s%n", arrayList.isEmpty());
}
输出:
获取是否为空集合:true
iterator()
获取迭代器
,使用迭代器遍历集合.只能使用一次
,二次使用需要重新获取.例如下面代码我注释的地方,再去使用已经没有效果.
public static void testIterator() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
Iterator<String> iterator = arrayList.iterator();
while (iterator.hasNext()){
String str = iterator.next();
System.out.println(str);
if("张三".equals(str)){
iterator.remove();
}
}
// while (iterator.hasNext())
System.out.println(arrayList);
}
输出:
张三
李四
[李四]
lastIndexOf(Object o)
返回指定对象在此集合中最后一次出现处的下标.如果找到对象,返回下标
,找不到对象就返回-1
.
public static void testLastIndexOf() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("张三");
int lastIndexZs = arrayList.lastIndexOf("张三");//应该返回2
int lastIndexLsy = arrayList.lastIndexOf("李四一");
System.out.printf("张三最后出现的下标为:%d,李四一最后出现的下标为:%d%n", lastIndexZs, lastIndexLsy);
}
输出:
张三最后出现的下标为:2,李四一最后出现的下标为:-1
listIterator()
像是iterator
的升级版,可以正逆向遍历
.支持遍历过程中修改数据,例如set
、remove
、add
.
public static void testListIterator() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
ListIterator<String> listIterator = arrayList.listIterator();
String firstIndex = listIterator.next();
System.out.printf("开始删除:%s,arrayList:%s%n", firstIndex, arrayList);
listIterator.remove();
System.out.printf("删除后,arrayList%s%n" , arrayList);
listIterator.add("张三");
listIterator.next();
listIterator.set("李四替身");
System.out.printf("set后,arrayList%s%n" , arrayList);
int prevIndex = listIterator.previousIndex();
System.out.printf("获取上一个元素的下标%d%n" , prevIndex);
listIterator.previous();
listIterator.set("张三替身");
System.out.printf("set后,arrayList%s%n" , arrayList);
}
输出:
开始删除:张三,arrayList:[张三, 李四]
删除后,arrayList[李四]
set后,arrayList[张三, 李四替身]
获取上一个元素的下标1
set后,arrayList[张三, 张三替身]
listIterator(int index)
从指定下标开始遍历.
public static void testListIteratorStartIndex() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("王二");
// 因法外狂徒张三入狱,只取后面的值
ListIterator<String> iterator = arrayList.listIterator(1);
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
输出:
李四
王二
remove(int index)
通过下标移除对象,如果进入下标不存在,会出现IndexOutOfBoundsException
异常.移除成功会返回对象.
public static void testRemove() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
String removeStr = arrayList.remove(1);
System.out.println(removeStr);
}
输出:
李四
remove(Object obj)
移除对象,测试后只会移除第一个匹配的值.移除成功返回true
,否之返回false
.
public static void testRemoveByObject() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("张三");
arrayList.add(null);
System.out.printf("arrayList.remove("张三")返回=%s%n",arrayList.remove("张三"));
System.out.printf("arrayList=%s%n",arrayList);
}
输出:
arrayList.remove("张三")返回=true
arrayList=[李四, 张三, null]
removeAll(Collection<?> c)
移除传入集合中的对象.
public static void testremoveAll() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("张三");
arrayList.removeAll(new ArrayList<String>() {{
add("张三");
}});
System.out.printf("arrayList=%s%n", arrayList);
}
输出:
arrayList=[李四]
removeIf()
删除满足特定条件的对象.
public static void testRemoveIf() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("张三");
System.out.printf("删除张三前,arrayList=%s%n", arrayList);
arrayList.removeIf("张三"::equals);
System.out.printf("删除张三后,arrayList=%s%n", arrayList);
}
输出:
删除张三前,arrayList=[张三, 李四, 张三]
删除张三后,arrayList=[李四]
replaceAll()
替换元素,例如将集合内元素全转为大写,或者全部元素进行计算.
public static void testReplaceAll() {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("张三");
arrayList.add("李四");
arrayList.add("王五");
arrayList.add("赵六");
arrayList.replaceAll(item -> "姓名:" + item);
System.out.printf("arrayList=%s%n", arrayList);
}
输出:
arrayList=[姓名:张三, 姓名:李四, 姓名:王五, 姓名:赵六]
retainAll(Collection<?> c)
取两个集合的并集,剔除不在两集合中同时存在的元素;
public static void testRetainAll() {
ArrayList<String> arrayList = new ArrayList<String>() {{
add("张三");
add("李四");
add("王五");
add("赵六");
}};
arrayList.retainAll(Arrays.asList("王五", "赵六"));
System.out.printf("arrayList=%s%n", arrayList);
}
输出:
arrayList=[王五, 赵六]
set(int index, E element)
根据下标替换或者插入对象.
示例,设置集合中下标为1
的值为鲁班七号
.
public static void testSet() {
ArrayList<String> arrayList = new ArrayList<String>() {{
add("张三");
add("李四");
add("王五");
add("赵六");
}};
System.out.printf("设置前,arrayList=%s%n", arrayList);
arrayList.set(1,"鲁班七号");
System.out.printf("设置后,arrayList=%s%n", arrayList);
}
方法运行输出结果为:
设置前,arrayList=[张三, 李四, 王五, 赵六]
设置后,arrayList=[张三, 鲁班七号, 王五, 赵六]
size()
返回集合中的数据条数.
sort(Comparator<? super E> c)
对集合内对象进行以指定方式排序.
public static void testSort() {
ArrayList<Integer> arrayList = new ArrayList<Integer>() {{
add(100);
add(200);
add(40);
add(80);
}};
System.out.printf("排序前,arrayList=%s%n", arrayList);
arrayList.sort(Comparator.naturalOrder());
System.out.printf("自然顺序排列后,arrayList=%s%n", arrayList);
arrayList.sort(Comparator.reverseOrder());
System.out.printf("倒序排列后,arrayList=%s%n", arrayList);
}
方法运行输出结果为:
排序前,arrayList=[100, 200, 40, 80]
自然顺序排列后,arrayList=[40, 80, 100, 200]
倒序排列后,arrayList=[200, 100, 80, 40]
spliterator()
并行迭代器,就是把集合中的对象放到迭代器中.
然后,可以开启多个线程并行处理这些对象.
示例代码如下:
public static void testSpliterator() {
ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));
Spliterator<Integer> sItr = arrayList.spliterator();
// 遍历后迭代器中的值也会消失
// sItr.forEachRemaining(d -> System.out.print(d)); //123456
new Thread(() -> {
for (int i = 0; i < 4; i++) {
sItr.tryAdvance(d -> System.out.printf("线程:%s,抢到了:%d%n", Thread.currentThread().getName(), d));
}
}).start();
new Thread(() -> {
for (int i = 0; i < 4; i++) {
sItr.tryAdvance(d -> System.out.printf("线程:%s,抢到了:%d%n", Thread.currentThread().getName(), d));
}
}).start();
}
方法运行输出结果为:
线程:Thread-0,抢到了:1
线程:Thread-0,抢到了:3
线程:Thread-0,抢到了:4
线程:Thread-0,抢到了:5
线程:Thread-1,抢到了:2
线程:Thread-1,抢到了:6
subList(int formIndex,int toIndex)
截取集合的一部分并返回一个List
集合.
图来自菜鸟教程
示例代码如下:
public static void testSubList() {
ArrayList<String> arrayList = new ArrayList<>(Arrays.asList("p", "r", "o", "g", "r", "a", "m"));
List<String> subList1 = arrayList.subList(0, 7);
System.out.printf("arrayList.subList(0,7) result:%s%n", subList1);
List<String> subList2 = arrayList.subList(3, 7);
System.out.printf("arrayList.subList(3,7) result:%s%n", subList2);
List<String> subList3 = arrayList.subList(3, 6);
System.out.printf("arrayList.subList(3,6) result:%s%n", subList3);
}
方法运行输出结果为:
arrayList.subList(0,7) result:[p, r, o, g, r, a, m]
arrayList.subList(3,7) result:[g, r, a, m]
arrayList.subList(3,6) result:[g, r, a]
toArray() && toArray(T[] a)
返回一个当前集合顺序排列
并且包含 ArrayList
中所有元素的数组.
示例代码如下:
public static void testToArray() {
// 1. toArray()
ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(10, 20, 3, 41, 15, 26));
Object[] num = arrayList.toArray();
System.out.println(Arrays.toString(num));
// 2. toArray(T[] a)
Integer[] arr = new Integer[arrayList.size()];
arr = arrayList.toArray(arr);
System.out.println(Arrays.toString(arr));
}
方法运行输出结果为:
[10, 20, 3, 41, 15, 26]
[10, 20, 3, 41, 15, 26]
trimToSize()
去除ArrayList多余的容量.
示例代码如下:
public static void testTrimToSize() throws NoSuchFieldException, IllegalAccessException {
ArrayList<Integer> arrayList = new ArrayList<>(100);
arrayList.add(11);
arrayList.add(12);
arrayList.add(13);
System.out.printf("trimToSize之前ArrayList容量大小:%d%n", getCapacity(arrayList));
arrayList.trimToSize();
System.out.printf("trimToSize之后ArrayList容量大小:%d%n", getCapacity(arrayList));
}
方法运行输出结果为:
trimToSize之前ArrayList容量大小:100
trimToSize之后ArrayList容量大小:3
写完辽
不用死记硬背,收藏起来当成字典查一查.
上面代码的地址
https://github.com/cuifuan/house/blob/master/src/test/java/com/home/test/TestArrayListFun.java
告辞!
Java基础——ArrayList方法全解(字典版)的更多相关文章
- Java基础之方法详解
方法的所属性 在Java的语言中,方法相当于C语言中的函数,但是它与传统的函数也有着明确的不同:在结构化的语言中,函数是一等公民,整个程序是由一个个函数组成的:但是在面向对象的语言里,类是一等公民,整 ...
- Java基础——ArrayList
Java基础--ArrayList 作用:提供一个可变长度的集合,底层实际上是一个可变长度的数组 格式:ArrayList <E> arr=new ArrayList<>(); ...
- Windows系统下MySQL添加到系统服务方法(mysql解压版)
MySQL软件版本:64位 5.7.12 1.首先配置MySQL的环境变量,在系统环境变量Path的开头添加MySQL的bin目录的路径,以“;”结束,我的路径配置如下: 2.修改MySQL根目录下的 ...
- java的sleep方法详解
java的sleep方法详解: sleep并不是永久占有CPU,没有那个线程能永久占用CPU.它是指在自己时间片内睡眠,而不是急着交出CPU.yield()就是自己愿意立即交出时间片.因此一个线程sl ...
- java基础: ArrayList集合应用, ArrayList增删改查详解,综合java基础实现学生管理系统,
1.ArrayList 集合和数组的区别 : 共同点:都是存储数据的容器 不同点:数组的容量是固定的,集合的容量是可变的 1.1 -ArrayList的构造方法和添加方法 public ArrayLi ...
- JAVA笔试题(全解)
目录 一. Java基础部分................................................................. 9 1.一个".java& ...
- Java基础-ArrayList和LinkedList的区别
大致区别: 1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构. 2.对于随机访问get和set,ArrayList觉得优于LinkedList,因为Lin ...
- Java中ArrayList类详解
1.什么是ArrayList ArrayList就是传说中的动态数组,用MSDN中的说法,就是Array的复杂版本,它提供了如下一些好处: 动态的增加和减少元素 实现了ICollection和ILis ...
- Java多线程——多线程方法详解
本系列文章是Java多线程的详解介绍,对多线程还不熟悉的同学可以先去看一下我的这篇博客Java基础系列3:多线程超详细总结,这篇博客从宏观层面介绍了多线程的整体概况,接下来的几篇文章是对多线程的深入剖 ...
随机推荐
- Reactive 理解 SpringBoot 响应式的核心-Reactor
Reactive 理解 SpringBoot 响应式的核心-Reactor bestcoding 2020-02-23 17:26:43 一.前言 关于 响应式 Reactive,前面的两篇文章谈了不 ...
- 『言善信』Fiddler工具 — 17、Fiddler常用插件(Willow)
目录 1.Traific Difer插件 2.PDF View插件 3.JavaScript Formatter插件 4.CertMaker for iOS and Android插件 5.Synta ...
- [Linux网络、命名空间、veth设备对、docker的host模式、container模式、none模式、brideg模式、网桥的增删查,容器与网桥的连接断开]
[Linux网络.命名空间.veth设备对.docker的host模式.container模式.none模式.brideg模式.网桥的增删查,容器与网桥的连接断开] 网络名称空间 为了支持网络协议栈的 ...
- 循序渐进BootstrapVue,开发公司门户网站(4)--- 使用b-carousel-slide组件实现图片轮播以及vue-awesome-swiper实现图片滑动展示
在BootstrapVue组件库里面,提供了很多对Bootstrap同等类似的组件封装,其中图片轮播可以采用b-carousel-slide组件实现,而有一些小的图片,如客户/合作伙伴Logo或者友情 ...
- C# 位图BitArray 小试牛刀
前面聊了布隆过滤器,回归认识一下位图BitMap,阅读前文的同学应该发现了布隆过滤器本身就是基于位图,是位图的一种改进. 位图 先看一个问题, 假如有1千万个整数,整数范围在1到1亿之间,如何快速确定 ...
- 05 jumpserver权限管理
5.权限管理: 在同一个组下的用1户之间,资产是共享的. (1)为10.0.0.121_slavenode1资产授权: (2)为10.0.0.201_lc-pc资产授权: (3)查看授权列表:
- 8、负载均衡HAproxy部署
8.1.基本环境说明: 服务器名(centos7) ip地址 安装软件 slave-node1 172.16.1.91 haproxy1.8.15,tomcat8.5.37(8080.8081实例), ...
- BGV方案
BGV方案 SIMD技术 中国剩余定理 在<孙子算经>中有这样一个问题:"今有物不知其数,三三数之剩二(除以3余2),五五数之剩三(除以5余3),七七数之剩二(除以7余2),问物 ...
- (数据科学学习手札124)pandas 1.3版本主要更新内容一览
本文示例代码及文件已上传至我的Github仓库https://github.com/CNFeffery/DataScienceStudyNotes 1 简介 就在几天前,pandas发布了其1.3版本 ...
- 并发王者课-铂金10:能工巧匠-ThreadLocal如何为线程打造私有数据空间
欢迎来到<并发王者课>,本文是该系列文章中的第23篇,铂金中的第10篇. 说起ThreadLocal,相信你对它的名字一定不陌生.在并发编程中,它有着较高的出场率,并且也是面试中的高频面试 ...