List系列集合
特点：有序、可重复、有索引
- ArrayList：有序、可重复、有索引
- LinkedList：有序、可重复、有索引
List集合的特有方法
- List集合因为支持索引，所以多了很多与索引相关的方法，当然，Collection的功能List也都继承了
代码演示：
import java.util.ArrayList;
import java.util.List;
public class ListTest1 {
public static void main(String[] args) {
// 1.创建一个ArrayList集合对象(有序、可重复、有索引)
List<String> list = new ArrayList<>(); //一行经典代码,多态写法
list.add("愚者");
list.add("正义");
list.add("倒吊人");
list.add("太阳");
System.out.println(list); //[愚者, 正义, 倒吊人, 太阳]
//2.public void add(int index，E element):在某个索引位置插入元素。
list.add(2,"魔术师"); //在索引位置为2的地方插入元素
System.out.println(list); //[愚者, 正义, 魔术师, 倒吊人, 太阳]
//3.public E remove(int index):根据索引删除元素,返回被删除元素
String name = list.remove(3); //删除索引为3的元素并返回
System.out.println(list); //[愚者, 正义, 魔术师, 太阳]
System.out.println(name); //倒吊人
// 4.public E get(int index):返回集合中指定位置的元素。
String name2 = list.get(3); //返回索引为3的元素
System.out.println(list); //[愚者, 正义, 魔术师, 太阳]
System.out.println(name2); //太阳
//5.public E set(int index,E element): 修改索引位置处的元素,修改成功后，会返回原来的数据
String name3 = list.set(3,"隐者"); //修改索引为3的元素的内容,原内容返回
System.out.println(name3); //太阳
System.out.println(list); //[愚者, 正义, 魔术师, 隐者]
}
}运行结果：
List集合的遍历方式
- for循环(因为List集合有索引)
- 迭代器
- 增强for循环
- Lambda表达式
代码演示：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListTest2 {
public static void main(String[] args) {
// 1.创建一个ArrayList集合对象(有序、可重复、有索引)
List<String> list = new ArrayList<>(); //一行经典代码,多态写法
list.add("愚者");
list.add("正义");
list.add("倒吊人");
list.add("太阳");
System.out.println(list); //[愚者, 正义, 倒吊人, 太阳]
//(1)for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i)); //愚者 正义 倒吊人 太阳
}
System.out.println("-------------------------------------");
//(2)迭代器
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next()); //愚者 正义 倒吊人 太阳
}
System.out.println("-------------------------------------");
//(3)增强for循环()
for (String s : list) {
System.out.println(s); //愚者 正义 倒吊人 太阳
}
System.out.println("-------------------------------------");
//(4)JDK 1.8开始之后的Lambda表达式
list.forEach(System.out::println); //愚者 正义 倒吊人 太阳
}
}
运行结果：
ArrayList集合的底层原理
ArrayList集合与LinkedList集合底层采用的数据结构不同，应用场景不同
- 数据结构：存储、组织数据的方式
ArrayList集合的底层原理
ArrayList集合是基于数组实现的
- 数组：内存中的一块连续区域，把该区域分成若干个相等的小区域，每个区域都有自己的索引，每个区域都存一个数据
- 数组的基本特点：
查询速度快（注意，是根据索引查询数据快）
删除效率低：可能需要把后面很多数据进行前移
添加效率极低：可能需要把后面很多的数据后移，再添加元素；或者也可能需要进行数组的扩容 - 总结：查询快，增删慢
Arraylist集合的底层原理：
- 利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组
- 添加第一个元素时，底层会创建一个新的长度为10的数组
- 存满时，会扩容1.5倍
- 如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准
ArrayList集合适合的应用场景
1、ArrayLis集合t适合:根据索引查询数据比如根据随机索引取数据:(高效)!或者数据量不是很大时!
2、ArrayList集合不适合:数据量大的同时又要频繁的进行增删操作!
LinkedList集合的底层原理
LinkedList集合是基于双链表实现的
什么是链表？
- 一种数据结构
- 链表中的结点是独立的对象，在内存中是不连续的，每个结点包含数据值和下一个结点的地址
链表的特点1:查询慢，无论查询哪个数据都要从头开始找
链表的特点2:链表增删相对快
双链表：在记录下一个结点的基础上，也记录了上一个结点的位置
LinkedList的特点：查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的
LinkedList新增了:很多首尾操作的特有方法
LinkedList集合适合的应用场景
- LinkedList的应用场景之一:可以用来设计队列（先进先出，后进后出），只是在首尾增删元素,用Linkecllist来实现很合适!
代码演示：
import java.util.LinkedList;
public class ListTest3 {
public static void main(String[] args) {
LinkedList<String> queue = new LinkedList<>();
//入队
queue.addLast("one");
queue.addLast("two");
queue.addLast("three");
queue.addLast("four");
System.out.println(queue); //[one, two, three, four]
//出队
System.out.println(queue.removeFirst()); //one
System.out.println(queue.removeFirst()); //two
System.out.println(queue.removeFirst()); //three
System.out.println(queue); //[four]
}
}- LinkedList的应用场景之二:可以用来设计栈（后进先出，先进后出），只是在首部增删元素,用Linkecllist来实现很合适!
代码演示：
import java.util.LinkedList;
public class ListTes4 {
public static void main(String[] args) {
LinkedList<String> stack = new LinkedList<>();
//压栈push
stack.push("第一颗子弹");
stack.push("第二颗子弹");
stack.push("第三颗子弹");
stack.push("第四颗子弹");
System.out.println(stack); //[第四颗子弹, 第三颗子弹, 第二颗子弹, 第一颗子弹]
//出栈pop
System.out.println(stack.pop()); //第四颗子弹
System.out.println(stack.pop()); //第三颗子弹
System.out.println(stack.pop()); //第二颗子弹
System.out.println(stack); //[第一颗子弹]
}
}
