一.List接口
List接口是Collection接口的子接口,List有一个重要的实现类–ArrayList类,List中的元素是有序排列的而且可重复,所以被称为是序列。
List可以精确的控制每个元素的插入位置,或删除某个位置元素,它的实现类ArrayList底层是由数组实现的。
List中有增删改查的方法,我们可以通过例子演示:
1, 测试List接口中 特有的方法
1.add(E e)
向列表的尾部添加指定的元素(可选操作)
2.add(int index, E element)
在列表的指定位置插入指定元素(可选操作)。
3.set(int index, E element)
用指定元素替换列表中指定位置的元素(可选操作)
4.get(int index)
返回列表中指定位置的元素。
5.remove(int index)
移除列表中指定位置的元素(可选操作)。
//add 添加
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
// 向指定索引添加元素 (相当于插入)(不能越界添加)
//list.add(4, "w");
// 替换指定索引的元素(不能越界 不能替换超出集合长度的索引)
//list.set(4, "m");
// 获取指定下标位置的元素(不能越界)
//Object object = list.get(1);
// 利用List遍历
for (int i = 0; i < list.size(); i++) {
Object object2 = list.get(i);
System.out.println(object2);
// 指定位置删除
Object remove = list.remove(1);
Iterator iterator = list.iterator();
二.ArrayList集合
1.什么是ArrayList?
可以简单的认为是一个动态数组;实际上ArrayList就是用数组实现的
Java.util.ArrayList类是一个动态数组类型,也就是说,ArrayList对象既有数组的特征,也有链表的特征。可以随时从链表中添加或删除一个元素。ArrayList实现了List接口。
大家知道,数组是静态的,数组被初始化之后,数组长度就不能再改变了。ArrayList是可以动态改变大小的。那么,什么时候使用Array(数组),什么时候使用ArrayList?答案是:当我们不知道到底有多少个数据元素的时候,就可使用ArrayList;如果知道数据集合有多少个元素,就用数组。
2.下面是总结了一些比较常用的ArrayList类成员方法:
增加元素到集合中
boolean add(Element e)
增加指定元素到列表尾部.
void add(int index, Element e)
增加指定元素到列表指定位置.
从列表中删除元素
void clear()
从列表中删除所有元素.
E remove(int index)
删除列表中指定位置的元素.
protected void removeRange(int start, int end)
删除列表中从某一个位置开始到某一个位置结束的元素。
获取链表中的元素
E get(int index)
获取链表中指定位置处的元素.
Object[] toArray()
获取一个数组,数组中所有元素是列表中的元素.(即将列表转换为一个数组)
修改某个元素
E set(int index, E element)
将列表中指定位置上的元素替换成新元素。
搜索元素
boolean contains(Object o)
如果列表包含指定元素,返回true.
int indexOf(Object o)
返回元素在链表中第一次出现的位置,如果返回-1,表示列表中没有这个元素。
int lastIndexOf(Object o)
返回元素在列表中最后一次出现的位置,如果返回-1,表示列表中没有这个元素。
检查链表是否为空
boolean isEmpty()
返回true表示列表中没有任何元素.
获取列表大小
int size()
返回列表长度(链表包含元素的个数)
以上是ArrayList类中使用比较多的成员方法。每个方法的更详细的说明或其它没有提及到的方法,读者可以参考java官方api
3.代码来实现一下:
public class Test {
public static void main(String args[]) {
// 创建一个空的list集合
ArrayList list = new ArrayList();
// 增加元素到list对象中
list.add("a");
list.add("b");
list.add(2, "c"); // 此条语句将会把“c”字符串增加到list的第3个位置。
list.add("d");
// 通过元素找索引
int index = list.indexOf("b");
System.out.println("index = " + index);
// 检查集合是否为空
boolean check = list.isEmpty();
System.out.println(check);
// 获取集合的大小
int size = list.size();
System.out.println(size);
// 检查集合中是否包含某元素
boolean b1 = list.contains("b");
System.out.println(element);
// 获取指定位置上的元素
String index = list.get(0);
System.out.println(index);
// 遍历arraylist中的元素
// 使用迭代器
// hasNext(): 返回true表示集合中还有元素
// next(): 返回下一个元素
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(list);
}
// 替换元素
list.set(1, "Newa");
System.out.println(list);
// 移除元素
// 移除第0个位置上的元素
list.remove(0);
// 移除第一次找到的 "b"元素
list.remove("b");
System.out.println(list);
// 转换 ArrayList 为 Array
// 集合转为数组
String[] simpleArray = list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(simpleArray));
}
}
三.LinkedList集合
LinkedList也和ArrayList一样实现了List接口,但是它执行插入和删除操作时比ArrayList更加高效,因为它是基于链表的。基于链表也决定了它在随机访问方面要比ArrayList逊色一点。
1.一些常用方法
LinkedList linkedList = new LinkedList();
// 添加元素
linkedList.add("a");
linkedList.add("b");
linkedList.add("c");
// 从集合 头 和 集合 尾 进行添加
linkedList.addFirst("d");
linkedList.addLast("e");
System.out.println(linkedList);
// 获取 集合第一个值 和 集合最后一个值
System.out.println(linkedList.getFirst());
System.out.println(linkedList.getLast());
// 获取指定位置的元素
Object object = linkedList.get(1);
System.out.println(object);
2.查找元素
LinkedList List = new LinkedList();
List.add("1");
List.add("2");
List.add("3");
List.add("4");
List.add("5");
List.add("2");
// 根据索引查找元素
System.out.println(lList.indexOf("2"));
// 查找集合的最后一位元素
System.out.println(lList.lastIndexOf("2"));
3.替换元素
LinkedList List = new LinkedList();
List.add("1");
List.add("2");
List.add("3");
List.add("4");
List.add("5");
System.out.println(lList);
lList.set(3, "a");//使用set方法替换元素,方法的第一个参数是元素索引,后一个是替换值
System.out.println(lList);
4.利用LinkedList 模拟栈的 出栈 和 入栈
首先知道栈和队列的区别
// 入栈就是添加 出栈 删除
// 栈和队列 什么是栈 和 什么是队列
// 栈结构 : 先入后出(main函数最后弹栈 程序结束)
// 队列结果: 先入先出(比如排队买早点 先买先走)
// 模拟栈的 入栈 和 出栈
LinkedList<String> linkedList = new LinkedList<>();
linkedList.addFirst("a");
linkedList.addFirst("b");
linkedList.addFirst("c");
while (!linkedList.isEmpty()) {
System.out.println(linkedList.removeFirst());
}
// 模拟队列的 入栈 和 出栈
LinkedList<String> linkedList = new LinkedList<>();
linkedList.addFirst("a");
linkedList.addFirst("b");
linkedList.addFirst("c");
while (!linkedList.isEmpty()) {
System.out.println(linkedList.removeLast());
}
四.总结
数组实现 ArrayList
特点:查询快 增删慢
查询: 依赖下标查询
增删: 把要插入位置后面的所有元素 向后移一位
(或者删除时 向前移一位)
数组在创建时 默认有10个位置 当要保存11个值时
系统会自动创建一个新数组 长度为原来数组长度1.5倍
链表实现 LinkedList
特点:查询慢 增删快
1.链表中的元素 保存了上一个元素和下一个元素的地址
通过这个地址 可以找到上一个元素 和 下一个元素
2.在进行查找的时候 先判断出 要查找的元素 距离头近还是尾近
3.例如头近 就从头位置 一个一个向下查询(通过保存的地址)
4.增删时 直接找到插入的位置 重新保存下 上一个元素 和下一个元素的地址 就可以
什么时候使用 ArrayList和LinkedList?
功能是 查询多(建议用ArrayList)
还是增删多(建议用LinkedList)
五.练习
1.遍历集合(使用迭代器) 如果数组中 有”b”这个元素 就添加”s”这个元素
// 创建集合
List<String> list = new ArrayList<>();
// 添加元素
list.add("a");
list.add("b");
list.add("c");
// 用List独有的迭代器
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
if (listIterator.next().equals("b")) {
listIterator.add("s");
}
}
System.out.println(list);
结果
[a, b, s, c]
2.在集合中存储 a a a b b c c 要求 去除重复元素
ArrayList arrayList = new ArrayList();
arrayList.add("a");
arrayList.add("a");
arrayList.add("b");
arrayList.add("b");
arrayList.add("c");
arrayList.add("c");
//创建新集合
ArrayList arrayList2 = new ArrayList();
// 遍历原集合
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()) {
// 取出每一个元素
Object next = iterator.next();
// 判断包不包括
if (!arrayList2.contains(next)) {
// 不包括就添加进去新集合里
arrayList2.add(next);
}
}
System.out.println(arrayList2);
结果
[a, b, c]