7月19日 List集合
1.List集合
Collection 集合上层接口
存储单个数据值,多个元素的集合
常用方法
遍历方式
foreach
迭代器Iterator
Map 多个元素的集合,每个元素由键值对组成
List 接口
有序可重复
新增 : 一些根据索引操作的方法
添加null元素
public class Class001_List {
public static void main(String[] args) {
//List容器
/*
泛型: 规定集合存储数据的类型 | 规定数据的类型
表示 : <数据类型> 数据类型只能为引用数据类型
位置 : 定义在数据类型的后面
优点 : 帮助增强程序的稳定性与可读性
*/
List<String> list = new ArrayList();
//List<Integer> list2 = new ArrayList();
list.add(null);
list.add(null);
list.add("abc");
list.add("cde");
list.add("mnb");
System.out.println(list);
//新增方法
//void add(int index, E element) 将指定元素插入此列表中的指定位置(可选操作)。
list.add(1,"你好");
System.out.println(list);
//E get(int index) 返回此列表中指定位置的元素。
System.out.println(list.get(3));;
//int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引,如果此列表不包含该元素,则返回-1。
//int lastIndexOf(Object o) 返回此列表中指定元素最后一次出现的索引,如果此列表不包含该元素,则返回-1。
System.out.println(list.lastIndexOf(null));
//static <E> List<E> of(E... elements) 返回包含任意数量元素的不可修改列表。
List<Integer> list1 = List.of(1,2,3,4,5);
System.out.println(list1);
//E remove(int index) 删除此列表中指定位置的元素(可选操作)。
System.out.println(list.remove(2));
System.out.println(list);
//E set(int index, E element) 用指定的元素替换此列表中指定位置的元素(可选操作)。
System.out.println(list.set(4,"nb"));
System.out.println(list);
//List<E> subList(int fromIndex, int toIndex) 返回指定的 fromIndex (包含)和 toIndex (不包括)之间的此列表部分的视图。
System.out.println(list.subList(1,3));
System.out.println(list+"adf");
//Object[] toArray()
System.out.println(Arrays.toString(list.toArray()));
List list3 = new ArrayList();
//List<Integer> list2 = new ArrayList();
list3.add(3);
list3.add(false);
list3.add("abc");
list3.add("cde");
list3.add("mnb");
System.out.println(list3);
}
}
[null, null, abc, cde, mnb]
[null, 你好, null, abc, cde, mnb]
abc
2
[1, 2, 3, 4, 5]
null
[null, 你好, abc, cde, mnb]
mnb
[null, 你好, abc, cde, nb]
[你好, abc]
[null, 你好, abc, cde, nb]adf
[null, 你好, abc, cde, nb]
[3, false, abc, cde, mnb]
import java.util.ArrayList;
import java.util.List;
/*
有序: 存放的顺序与内部真实存储的顺序相同
注意: 存储的数据为整数的时候,默认以索引优先
定义: 一个list集合,存储你喜欢的漫威英雄人物
如果包含灭霸,就向集合中添加一个惊奇队长
*/
public class Class002_List {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(3);
list.add(1);
list.add(2);
list.add(5);
list.add(4);
List<Boolean> list2 = new ArrayList<>();
list2.add(false);
list2.add(true);
list2.add(false);
list2.add(true);
System.out.println(list2);
//删除
list.remove(3);
System.out.println(list);
/*移出第一个数据*/
list2.remove(false);
System.out.println(list2);
}
}
[false, true, false, true]
[3, 1, 2, 4]
[true, false, true]
2.Iterator迭代器
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/*
定义: 一个list集合,存储你喜欢的漫威英雄人物
如果包含灭霸,就向集合中添加一个惊奇队长
List集合遍历方式:
1.普通for循环
2.增强for循环
3.iterator迭代器
4.listIterator 列表迭代器
*/
public class Class003_List {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("钢铁侠");
list.add("美国队长");
list.add("黑寡妇");
list.add("灭霸");
list.add("毒液");
System.out.println(list);
//1. contains
/*if(list.contains("灭霸")){
list.add("惊奇队长");
}
System.out.println(list);*/
//2.for
/* for(int i=0;i<list.size();i++){
if("灭霸".equals(list.get(i))){
list.add("惊奇队长");
}
}
System.out.println(list);*/
//3.foreach
//ConcurrentModificationException 当不允许这样的修改时,检测到对象的并发修改的方法可能抛出此异常。强制for循环相当于iterator迭代器,与list.add有并发风险。
/* for(String str : list){
if("灭霸".equals(str)){
list.add("惊奇队长");
}
}
System.out.println(list);*/
//4.迭代器 iterator
/*for(Iterator<String> it = list.iterator();it.hasNext();){
if("灭霸".equals( it.next())){
list.add("惊奇队长");
}
}
System.out.println(list);*/
//5.列表迭代器
//1)获取列表迭代器对象
/* ListIterator<String> it2 = list.listIterator();
//2)判断是否存在下一个|上一个元素
//正向遍历
while(it2.hasNext()){
//3)获取上一个或者下一个元素 | 操作集合
System.out.println(it2.nextIndex());
System.out.println(it2.next());//运行一次,迭代器就转移到下一个
*//*if("灭霸".equals( it2.next())){
it2.add("惊奇队长");
}*//*
}
System.out.println(list);*/
//反向遍历
ListIterator<String> it3 = list.listIterator(4);
while(it3.hasPrevious()){
System.out.println(it3.previousIndex()+"-->"+it3.previous());
}
}
}
[钢铁侠, 美国队长, 黑寡妇, 灭霸, 毒液]
3–>灭霸
2–>黑寡妇
1–>美国队长
0–>钢铁侠
3.ArrayList
List 接口的实现类 : 有序 可重复
ArrayList
底层实现: 可变数组
特点:
根据索引做查询效率高
增删效率低,设计到新数组的创建,数据的拷贝等问题
应用场景: 大量做查询,少量做增删的时候适合使用ArrayList
扩容: int newCapacity = oldCapacity + (oldCapacity >> 1); 通过Arrays.copyOf方法实现扩容,每次扩容原容量的1.5倍
第一次添加数据内部构建数组的初始容量为10
新增内容: void forEach(Consumer<? super E> action) 对 Iterable每个元素执行给定操作,直到处理 Iterable所有元素或操作引发异常。
遍历方式:
1.普通for
2.增强for
3.iterator迭代器
4.listIterator迭代器
定义ArrayList,存储自定义的javabean类型学生类型数据,简单操作
Vector 向量
有序 可重复
底层结构: 数组
与ArrayList很像
Vector与 ArrayList之间的区别:
1.同步问题
ArrayList 线程不安全|不同步,相对效率高
Vector 线程安全|同步
2.扩容问题
ArrayList 每次扩容原容量的1.5倍,更有利于节约内存
Vector 每次扩容原容量的2倍
注意:
使用集合存储自定义引用数据类型数据时候,需要重写equals方法,使用indexOf,constains()..,默认使用equals的返回值决定是否存在,包含,相等
可以实现比较对象的内容,而非地址
public class Class004_ArrayList{
public static void main(String[] args) {
//ArrayList() 构造一个初始容量为10的空列表。
List<String> list = new ArrayList<>();
//ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
//ArrayList(Collection<? extends E> c) 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。
//添加
list.add("haha");
list.add("hehe");
System.out.println(list);
//遍历输出每一个元素
list.forEach(System.out::println);
//定义存储学生信息的集合
ArrayList<Student> stus = new ArrayList();
stus.add(new Student("王玉波",19,"yjxxt"));
stus.add(new Student("王光涛",20,"yjxxt"));
stus.add(new Student("王济程",18,"yjxxt"));
System.out.println(stus);
System.out.println(stus.indexOf(new Student("王光涛",20,"yjxxt")));
System.out.println(stus.contains(new Student("王济程",18,"yjxxt")));
}
}
[haha, hehe]
haha
hehe
[Student{name=‘王玉波’, age=19, schoolName=‘yjxxt’}, Student{name=‘王光涛’, age=20, schoolName=‘yjxxt’}, Student{name=‘王济程’, age=18, schoolName=‘yjxxt’}]
1
true
4.Linkedlist
LinkedList :
有序 可重复
底层结构: 双向链表
特点:
根据索引查询效率低
做增删效率高
应用场景:
大量做增删少量做查询的时候适合使用
新增功能:
新增了一些可以直接操作头尾的方法
public class Class005_LinkedList {
public static void main(String[] args) {
//链表结构
LinkedList<Double> linked = new LinkedList<>();
linked.add(1.1);
linked.add(2.1);
linked.add(3.1);
linked.add(4.1);
System.out.println(linked);
linked.addFirst(0.1);
linked.addLast(5.1);
System.out.println(linked);
System.out.println(linked.removeFirst());
System.out.println(linked);
}
}
[1.1, 2.1, 3.1, 4.1]
[0.1, 1.1, 2.1, 3.1, 4.1, 5.1]
0.1
[1.1, 2.1, 3.1, 4.1, 5.1]
5.自制Mylinkedlist
/*
手写LinkedList --> 扩容
通过单向链表简单实现
*/
public class Class006_MyLinkedList {
public static void main(String[] args) {
MyLinkedList list = new MyLinkedList();
System.out.println(list.size());
list.add("haha");
System.out.println(list.size());
list.add("hehe");
System.out.println(list.size());
list.add("xixi");
System.out.println(list.size());
System.out.println(list);
}
}
//自定义的链表
class MyLinkedList{
//记录链表头节点
private Node head;
private int size;
public MyLinkedList() {
}
/**
* 在链表结构的最后添加一个数据
* @param value 要添加的数据
*/
public void add(Object value) {
//1.创建新节点
Node node = new Node(value,null);
//2.判断是否为第一个节点,作为链表头节点
if (head == null && size == 0){
head = node;
//长度+1
size++;
return;
}
//3.存在原链表.遍历原链表,找到原链表的最后一个节点,新节点挂上去
//定义一个临时变量,指向首节点
Node temp = head;
while(temp.getNext()!=null){
//指向下一个节点
temp = temp.getNext();
}
//新节点地址挂在原链表的最后
temp.setNext(node);
//4.长度+1
size++;
}
//size()
public int size(){
return this.size;
}
//toString()
@Override
public String toString(){
StringBuilder sb = new StringBuilder("[");
//临时变量用于遍历这个链表
Node temp = head;
//遍历链表结构
while(temp!=null){
// 获取到每一个节点的数据值,拼接到字符串中
sb.append(temp.getData()+", ");
//temp指向下一个节点
temp = temp.getNext();
}
String str = sb.toString();
//判断字符串是否以, 结尾,如果是去掉,
if(str.endsWith(", ")){
str = str.substring(0,str.length()-2);
}
return str+"]";
}
}
//链表中的节点
class Node{
private Object data;
private Node next; //Node next = new Node();
public Node(Object data, Node next) {
this.data = data;
this.next = next;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", next=" + next +
'}';
}
0
1
2
3
[haha, hehe, xixi]