List系列集合
- List系列集合
- 一、List集合特点、 特有API
- （1）List系列集合特点
- （2）List集合特有方法
- （3）总结
- ①List系列集合特点
- ②List的实现类的底层原理
- 二、List集合的遍历方式小结
- （1）List集合的遍历方式有几种？
- ArrayList集合的底层原理
- （1）ArrayList集合的底层原理
- （2）List集合存储的元素要超过容量怎么办?
- LinkedList集合的底层原理
- （1）LinkedList的特点
- （2）LinkedList集合的特有功能
- （3）链表的种类
List系列集合
一、List集合特点、 特有API
（1）List系列集合特点
●ArrayList、LinekdList ：有序，可重复，有索引。
●有序:存储和取出的元素顺序一致
●有索引：可以通过索引操作元素
●可重复：存储的元素可以重复
（2）List集合特有方法
●List集合因为支持索引，所以多了很多索引操作的独特api,其他Collection的功能List也都继承了。
方法名称 | 说明 |
void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |
E remove( int index) | 删除指定索引处的元素，返回被删除的元素 |
E set(int index,E element ) | 修改指定索引处的元素，返回被修改的元素 |
E get(int index) | 返回指定索引处的元素 |
// 1.创建一个ArrayList集合对象:
// List:有序，可重复，有索引的。
List<String> list = new ArrayList<>();//多态
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
System.out.println(list);
// 2.在某个索引位置插入元素。
list.add(2,"java");
System.out.println(list);
// 3.根据索引删除元素,返回被删除元素
System.out.println(list.remove(2));
System.out.println(list);
// 4. 根据索引获取元素:public E get(int index): 返回集合中指定位置的元素。
System.out.println(list.get(2));
// 5. 修改索引位置处的元素: public E set(int index, E element)
//返回修改前的数据
System.out.println(list.set(1,"1"));
System.out.println(list);（3）总结
①List系列集合特点
●ArrayList、LinekdList :有序，可重复，有索引。
②List的实现类的底层原理
●ArrayList底层 是基于数组实现的，根据查询元素快，增删相对慢。
●LinkedList底 层基于双链表实现的，查询元素慢，增删首尾元素是非常快的。
二、List集合的遍历方式小结
（1）List集合的遍历方式有几种？
①迭代器
②增强for循环
③Lambda表达式
④for循环 (因为List集合存在索引)
List<String> list = new ArrayList<>();//多态
list.add("one");
list.add("two");
list.add("three");
list.add("four");
list.add("five");
//（1）for循环
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
//（2）迭代器
System.out.println("--------------------");
Iterator<String> it = list.iterator();
while (it.hasNext()){
String ele = it.next();
System.out.println(ele);
}
//（3）foreach
System.out.println("--------------------");
for (String ele : list) {
System.out.println(ele);
}
//（4）JDK 1.8 开始以后的Lambda表达式
System.out.println("--------------------");
list.forEach(s -> {
System.out.println(s);
});ArrayList集合的底层原理
（1）ArrayList集合的底层原理
●ArrayList底层是基于数组实现的：根据索引定位元素快，增删需要做元素的移位操作。
●第一次创建集合并添加第一个元素的时候，在底层创建一个默认长度为10的数组。
List<String> list = new ArrayList<>();
list.add("a");
size既是元素个数，也是下一个插入元素的位置
（2）List集合存储的元素要超过容量怎么办?
一旦元素的个数超过了10，会按照1.5倍扩容，把元素重新迁移
LinkedList集合的底层原理
（1）LinkedList的特点
●底层数据结构是双链表，查询慢，首尾操作的速度是极快的，所以多了很多首尾操作的特有API。
（2）LinkedList集合的特有功能
方法名称 | 说明 |
public void addFirst(E e) | 在该列表开头插入指定的元素 |
public void addLast(E e) | 将指定的元素追加到此列表的末尾 |
public E getFirst() | 返回此列表中的第一个元素 |
public E getLast( ) | 返回此列表中的最后一个元素 |
public E removeFirst() | 从此列表中删除并返回第一个元素 |
public E removeLast( ) | 从此列表中删除并返回最后一个元素 |
// LinkedList 可以完成队列结构，和栈结构(双链表)
//栈
LinkedList<String> stack = new LinkedList<>();
//压栈，入栈
// stack.addFirst( "第1颗子弹");
// stack.addFirst( "第2颗子弹");
// stack.addFirst( "第3颗子弹");
// stack.addFirst( "第4颗子弹");
stack.push( "第1颗子弹");
stack.push( "第2颗子弹");
stack.push( "第3颗子弹");
stack.push( "第4颗子弹");
//这两种方法均可，但push更专业
System.out.println(stack);
//出栈,弹栈
// System.out.println(stack.removeFirst());
// System.out.println(stack.removeFirst());
// System.out.println(stack.removeFirst());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
//这两种方法均可，但pop更专业
System.out.println(stack);
//队列
LinkedList<String> queue = new LinkedList<>();
queue.addLast("1号");
queue.addLast("2号");
queue.addLast("3号");
queue.addLast("4号");
System.out.println(queue);
//出队
System.out.println(queue.removeFirst());
System.out.println(queue.removeFirst());
System.out.println(queue.removeFirst());
System.out.println(queue);（3）链表的种类
