【java】ArrayList，LinkedList晚自习整理

Array和ArrayList的区别是什么？

Array是数组，ArrayList是类

Array是定长的（需要手动扩容），ArrayList长度可变（使用过程中自动扩容）

ArrayList的底层是Array

ArrayList和LinkedList的区别是什么？

1.底层数据结构的实现：ArrayList底层数据结构是动态数组，而LinkedList的底层数据结构是双向链表

2.随机访问（即读）效率：ArrayList比LinkedList在随机访问的时候效率要高，因为ArrayList底层是数组，可以通过索引号快速访问，LinkedList是通过二分查找法遍历链表节点进行查找的

3.增加和删除效率：在非首尾的增加和删除操作，LinkedList要比ArrayList效率要高，因为ArrayList增删操作需要大量的前移或后移，在这个过程中涉及到大量的赋值操作比较耗时，LinkedList只需要修改节点对象的左右指针即可。

4.内存占用空间：LinkedList比ArrayList更占内存，因为LinkedList的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素

5.总和来说，在需要频繁读取集合中元素的时候，更推荐使用ArrayList，而在插入和删除操作较多时推荐使用LinkedList

你知道几种遍历ArrayList的方式？

遍历ArrayList和LinkedList的几种方式：

普通for循环
增强型for循环
forEach循环
迭代器

ArrayList<String> list=new ArrayList<>();
list.add("张飞");
list.add("关羽");
list.add("马超");
list.add("赵云");
list.add("黄忠");
System.out.println("********遍历方式一：普通for循环********");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("********遍历方式二：增强型for循环********");
//1.增强型for循环中不需要写循环四要素
//2.不需要手动执行list.get()操作了
for (String item : list) {//每循环一次会自动从list中取出元素赋给临时变量，直到没有下一个元素自动退出
System.out.println(item);
}
System.out.println("********遍历方式三：forEach循环********");
//list调用forEach函数
//forEach函数的参数是一个箭头函数
//箭头函数的语法是（参数名）->{}
//隐式循环forEach函数中循环
//forEach函数会遍历list，取出每一个值后，会回调你的箭头函数，把参数传给箭头函数的参数
list.forEach((item)->{
System.out.println(item);
});
list.forEach((item)-> System.out.println(item));
System.out.println("********遍历方式四：迭代器********");
//调用iterator（）方法，取出一个迭代器对象
//使用iterator类声明一个迭代器指针，迭代器的泛型必须与list的泛型一致
Iterator<String> iterator=list.iterator();
//迭代器的hasNext可以判断是否还有下一个元素
while (iterator.hasNext()){
//迭代器的next方法可以取出下一个元素
String item=iterator.next();
System.out.println(item);
}

整理ArrayList和LInkedList的常用方法

ArrayList

方法名	参数说明	返回值说明	方法功能说明
add(E e)	泛型	boolean	将指定的元素追加到此列表的末尾
size()	无参	return size;	返回此列表中的元素个数
get(int index)	int	泛型	返回此列表中指定位置的元素
remove(int index)	int	泛型	删除该列表中指定位置的元素
remove(Object o)	Object	boolean	从列表中删除指定元素的第一个出现（如果存在）
contains(Object o)	Object	boolean	如果此列表包含指定的元素，则返回 true
addAll(int index, Collection<? extends E> c)	int 泛型	boolean	将指定集合中的所有元素插入到此列表中，从指定的位置开始
clear()	无参	void	从列表中删除所有元素
for / iterator	无参	泛型	集合遍历

public class ArrayListTest {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
// boolean add(E e) 将指定的元素追加到此列表的末尾
list.add(111);
list.add(666);
list.add(333);
list.add(888);
list.add(111);
list.add(999);
// int size() 返回此列表中的元素个数
System.out.println(list.size()); // 6
System.out.println(list); // [111, 666, 333, 888, 111, 999]

// E get(int index) 返回此列表中指定位置的元素
System.out.println(list.get(3)); // 888

// E remove(int index) 删除该列表中指定位置的元素。
list.remove(3);
System.out.println(list); // [111, 666, 333, 111, 999]

// boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）
System.out.println(list.remove(Integer.valueOf(111))); // true
System.out.println(list); // [666, 333, 111, 999]

System.out.println("******************************");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}

// 用三种方式遍历集合
System.out.println("******************************");
Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}

System.out.println("******************************");
for (Integer integer : list) {
System.out.println(integer);
}

System.out.println("******************************");
// boolean contains(Object o) 如果此列表包含指定的元素，则返回 true
boolean contains = list.contains(666);
System.out.println(contains); // true

System.out.println("******************************");
ArrayList<Integer> list1 = new ArrayList<Integer>();
list1.add(123);
list1.add(456);
// boolean addAll(int index, Collection<? extends E> c)
// 将指定集合中的所有元素插入到此列表中，从指定的位置开始。
list.addAll(1, list1);
System.out.println(list); // [666, 123, 456, 333, 111, 999]
System.out.println(list1); // [123, 456]

// void clear() 从列表中删除所有元素
list1.clear();
System.out.println(list1); // []
}
}

LInkedList

方法名	参数说明	返回值说明	方法功能说明
add(E e)	泛型	boolean return true;	将指定的元素追加到此列表的末尾
size()	无参	int return size;	返回此列表中的元素数
get(int index)	int	泛型	返回此列表中指定位置的元素
remove(int index)	int	泛型	删除该列表中指定位置的元素
addFirst(E e)	泛型	void	在该列表开头插入指定的元素
addLast(E e)	泛型	void	将指定的元素追加到此列表的末尾
getFirst()	无参	泛型	返回此列表中的第一个元素
getLast()	无参	泛型	返回此列表中的最后一个元素
push(E e)	泛型	void	将元素推送到由此列表表示的堆栈上
pop()	无参	泛型	从此列表表示的堆栈中弹出一个元素

public class LinkedListTest {

public static void main(String[] args) {

LinkedList<String> list = new LinkedList<String>();
// boolean add(E e) 将指定的元素追加到此列表的末尾。
list.add("aaa");
list.add("ddd");
list.add("ccc");
list.add("111");
list.add("aaa");
list.add("eee");

// int size() 返回此列表中的元素数
System.out.println(list.size()); // 6
System.out.println(list); // [aaa, ddd, ccc, 111, aaa, eee]

// E get(int index) 返回此列表中指定位置的元素。
System.out.println(list.get(0)); // aaa
System.out.println(list.get(list.size() - 1)); // eee

System.out.println("*****************************");
// E remove(int index) 删除该列表中指定位置的元素
System.out.println(list.remove(3)); // 111

System.out.println("*****************************");
// void addFirst(E e) 在该列表开头插入指定的元素
list.addFirst("111");
System.out.println(list); // [111, aaa, ddd, ccc, aaa, eee]

// void addLast(E e) 将指定的元素追加到此列表的末尾。
list.addLast("666");
System.out.println(list); // [111, aaa, ddd, ccc, aaa, eee, 666]

// E getFirst() 返回此列表中的第一个元素
System.out.println(list.getFirst()); // 111

// E getLast() 返回此列表中的最后一个元素。
System.out.println(list.getLast()); // 666

System.out.println("*****************************");
// void push(E e) 将元素推送到由此列表表示的堆栈上
list.push("888");
System.out.println(list); // [888, 111, aaa, ddd, ccc, aaa, eee, 666]

// E pop() 从此列表表示的堆栈中弹出一个元素
String pop = list.pop();
System.out.println(pop); // 888

System.out.println("****************************");

for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}

System.out.println("****************************");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}