|
目录
1、集合的介绍1.1 概念1.2 集合的分类
2、单列集合：Collection2.1 Collection的使用2.2 集合的通用遍历方式`2.2.1 迭代器遍历：`（1）例子：（2）迭代器遍历的原理：（3）迭代器源码分析：（4）总结：
`2.2.2 增强for循环遍历：``2.2.3 foreach遍历：`
2.3 List集合（1）和索引相关的方法：（2）list集合的遍历方法：
2.4 数据结构2.4.1 栈和队列2.4.2 数组2.4.3 链表2.4.4 总结
2.5 ArrayList类和LinkedList类2.5.1 ArrayList类：（1）ArrayList长度可变原理：
2.5.2 LinkedList类：
1、集合的介绍
1.1 概念
1.2 集合的分类
注：集合分为单列集合 和 双列集合
单列集合：一次添加一个元素，实现了Collection接口。双列集合：一次添加两个元素，实现了Map接口。
2、单列集合：Collection
 注：Collection集合，可以分为List集合 和 Set集合
List集合：存取有序、有索引、可以存储重复的元素。Set集合：存取无序、没有索引、不可以存储重复的元素。
2.1 Collection的使用
package com.itheima.collection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest1 {
/**
* Collection的常用方法：
* public boolean add(E e):把给定的对象添加到当前集合中
* public void clear():清空集合中所有的元素
* public boolean isEmpty():判断当前集合是否为空
* public boolean remove(E e):把给定的对象在当前集合中删除
* public boolean contains(Object obj):判断当前集合中是否包含给定的对象
* public int size():返回集合中元素的个数（集合的长度）
*
*/
public static void main(String[] args) {
//以多态的形式创建集合对象，调用单列集合中的共有方法
Collection c = new ArrayList();
//1、add(E e):把给定的对象添加到当前集合中
boolean b1 = c.add("张三");
boolean b2 = c.add("李四");
boolean b3 = c.add("王五");
System.out.println(b1);//true 返回是否添加成功的状态
System.out.println(b2);//true
System.out.println(b3);//true
System.out.println(c);//[张三, 张三, 张三]
//2、clear():清空集合中所有的元素
c.clear();
System.out.println(c);//[]
//3、isEmpty():判断当前集合是否为空
System.out.println(c.isEmpty());//true
//4、remove(E e):把给定的对象在当前集合中删除
c.add("马四");
c.add("赵武");
boolean remove = c.remove("马四");//返回值为是否删除成功的标记：删除存在的对象则返回true，删除不存在的对象则返回false
System.out.println(c);//[赵武] 可以发现马四已经被删除了
//5、contains(Object obj):判断当前集合中是否包含给定的对象
boolean contains1 = c.contains("平平");
System.out.println(contains1);//false 不包含则返回false
boolean contains2 = c.contains("赵武");
System.out.println(contains2);//true 包含则返回true
//6、size():返回集合中元素的个数（集合的长度）
System.out.println(c.size());//1
}
}
2.2 集合的通用遍历方式
2.2.1 迭代器遍历：
（1）例子：
package com.itheima.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionTest3 {
/**
* public Iterator iterator():获取遍历集合的迭代器
* 1、public E next():从集合中获取一个元素
* 注：如果next()调用超过了集合的大小，就会出现 NoSuchElementException 异常
* 2、public boolean hasNext():如果任有元素可以迭代，则返回true
*/
public static void main(String[] args) {
Collection c = new ArrayList();
Student s1 = new Student("张三", 11);//Student是自定义创建的类
Student s2 = new Student("李四", 21);
Student s3 = new Student("王五", 31);
//添加三个对象
c.add(s1);
c.add(s2);
c.add(s3);
//1、获取迭代器
Iterator iterator = c.iterator();
//2、循环判断集合中是否还有元素
while (iterator.hasNext()){//
//3、调用next方法，从集合中获取一个元素
Student next = iterator.next();
System.out.println(next);
}
}
}
（2）迭代器遍历的原理：
总结：next()方法取出一个元素后，指针会向后移动一位。
（3）迭代器源码分析：
（4）总结：
2.2.2 增强for循环遍历：
package com.itheima.collection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest4 {
/**
* 使用增强for循环遍历
*
*/
public static void main(String[] args) {
Collection c = new ArrayList();
Student s1 = new Student("张三", 11);//Student是自定义创建的类
Student s2 = new Student("李四", 21);
Student s3 = new Student("王五", 31);
//添加三个对象
c.add(s1);
c.add(s2);
c.add(s3);
//使用增强for循环遍历
for (Student s : c){
System.out.println(s);
}
}
}
注：增强for循环的遍历方式，其实就是迭代器遍历，当编译成字节码文件后，发现增强for循环代码就会转换为迭代器遍历方式。
2.2.3 foreach遍历：
package com.itheima.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;
public class CollectionTest4 {
public static void main(String[] args) {
Collection c = new ArrayList();
Student s1 = new Student("张三", 11);//Student是自定义创建的类
Student s2 = new Student("李四", 21);
Student s3 = new Student("王五", 31);
//添加三个对象
c.add(s1);
c.add(s2);
c.add(s3);
//使用foreach方法遍历
c.forEach(e-> System.out.println(e));
}
}
注：foreach底层也是迭代器遍历。
2.3 List集合
（1）和索引相关的方法：
package com.itheima.collection.list;
import java.util.ArrayList;
import java.util.List;
public class ListDemo1 {
/**
* List接口的特点：存取有序、有索引、可以存储重复
* 和索引有关的API:
* public void add(int index, E element):在指定的索引位置，添加元素
* public E set(int index, E element):根据索引修改集合中的元素
* public E remove(int index):根据索引删除集合中的元素
* public E get(int index):返回指定索引处的元素
*/
public static void main(String[] args) {
List list = new ArrayList();
//1、add(int index, E element):在指定的索引位置，添加元素
list.add("lisi");
list.add("wangwu");
list.add("maliu");
list.add(1, "lisi");//在1号位置添加元素，原来1号位置及后面的元素都向后移动一位
System.out.println(list);//[lisi, lisi, wangwu, maliu]
//2、set(int index, E element):根据索引修改集合中的元素
list.set(1, "马四");//修改索引为1的元素为马四
System.out.println(list);//[lisi, 马四, wangwu, maliu]
//3、remove(int index):根据索引删除集合中的元素
list.remove(1);//删除索引为1的元素
System.out.println(list);//[lisi, wangwu, maliu]
//4、get(int index):返回指定索引处的元素
System.out.println(list.get(1));//wangwu 获取索引为1的元素
}
}
注意：remove()方法，如果list集合中存储的本身就是int类型，那么删除时会被当做索引，因此需要手动装箱，如下例子：
package com.itheima.collection.list;
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
List ll = new ArrayList();
ll.add(111);
ll.add(222);
ll.add(333);
// ll.remove(222);//222会被当作索引，这里就会报空指针，手动装箱，如下
ll.remove(Integer.valueOf(222));
System.out.println(ll);//[111, 333]
}
}
（2）list集合的遍历方法：
package com.itheima.collection.list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo2 {
/**
* List集合的遍历方式：
* 1、普通for循环
* 2、迭代器遍历
* 3、增强for循环
* 4、foreach方法
* 5、ListIterator（List集合特有的迭代器）
*
*/
public static void main(String[] args) {
List list = new ArrayList();
list.add("111");
list.add("222");
list.add("333");
list.add("444");
//1、普通for循环
for (int i = 0; i
System.out.println(iterator.next());
}
System.out.println("--------------------");
//3、增强for循环
for (String s : list){
System.out.println(s);
}
System.out.println("--------------------");
//4、foreach方法
list.forEach(item -> System.out.println(item));
System.out.println("--------------------");
//5、ListIterator（List集合特有的迭代器）
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()){
System.out.println(listIterator.next());
}
//上述ListIterator遍历和正常的一样，不一样的是可以倒叙遍历，同时增加了add()方法
while (listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}
}
}
注意：在遍历过程中做删除、增加操作，可能会发生并发修改异常。  
package com.itheima.collection.list;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/**
* Title: ListDemo3
* Describe: 类的功能
* Name: masizhou
* Date: 2024/7/13
* Copyright: @2022 by masizhou
*/
public class ListDemo3 {
/**
* 在遍历过程中，如果有添加、删除元素操作时，会出现并发修改异常：ConcurrentModificationException
* 【场景】：使用[迭代器]遍历集合的过程中，调用了[集合对象]的添加，删除方法，机会出现此异常
* 【解决方案】：迭代器的遍历过程中，不允许使用集合对象的添加或删除，那就是用迭代器，自己的添加或删除方法
* 删除方法：普通的迭代器有
* 添加方法：普通的迭代器没有，需要使用list集合特有的迭代器
*
*/
public static void main(String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
/*
下面代码使用的是增强for循环，其实底层也是使用迭代器的方法，
但这个时候增加和删除只能拿到集合的方法，没法使用迭代器的方法
【解决方法】：手写迭代器进行遍历---这就是为啥手写迭代器遍历虽然麻烦，但是有特定使用的场景
*/
// for (String s : list){
// list.remove("bbb");
// }
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()){
String s = listIterator.next();
if ("aaa".equals(s)){
listIterator.remove();
listIterator.add("我是增加的元素");
}
}
System.out.println(list);//[我是增加的元素, bbb, ccc, ddd]
}
}
注意： （1）我们在写代码，在遍历过程中需要对一个集合做增加或者删除操作时，一般会放在一个新的集合中，避免索引乱了的问题而导致空指针。 （2）但是为了节省内存，就是要操作原集合，那就使用迭代器的遍历方法，然后用迭代器的add和remove方法做增加和删除操作就可以解决这个问题。
2.4 数据结构
2.4.1 栈和队列
2.4.2 数组
2.4.3 链表
2.4.4 总结
2.5 ArrayList类和LinkedList类
2.5.1 ArrayList类：
package com.itheima.collection.list;
import java.util.ArrayList;
import java.util.List;
public class ListDemo3 {
public static void main(String[] args) {
List list = new ArrayList();//多态
list.add("aaa");
list.add("bbb");
System.out.println(list);
}
}
（1）ArrayList长度可变原理：
注意：  
2.5.2 LinkedList类：
package com.itheima.collection.list;
import java.util.LinkedList;
import java.util.List;
public class ListDemo4 {
/**
* LinkedList特有方法：
* public void addFirst(E e):头部添加
* public void addLast(E e):尾部添加
* public E getFirst():获取第一个
* public E getLast():获取最后一个
* public E removeFirst():删除第一个
* public E removeLast():删除最后一个
*
*/
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add("张三");
linkedList.add("李四");
linkedList.add("王五");
//1、addFirst(E e):头部添加
linkedList.addFirst("玛尔");
System.out.println(linkedList);//[玛尔, 张三, 李四, 王五]
//2、addLast(E e):尾部添加
linkedList.addLast("马六");
System.out.println(linkedList);//[玛尔, 张三, 李四, 王五, 马六]
//3、getFirst():获取第一个
System.out.println(linkedList.getFirst());//玛尔
//4、getLast():获取最后一个
System.out.println(linkedList.getLast());//马六
//5、removeFirst():删除第一个
LinkedList l1 = new LinkedList();
l1.add("aaa");
l1.add("bbb");
l1.add("ccc");
l1.add("ddd");
//l1 = [aaa, bbb, ccc, ddd]
l1.removeFirst();
System.out.println(l1);//[bbb, ccc, ddd]
//6、removeLast():删除最后一个
LinkedList l2 = new LinkedList();
l2.add("aaa");
l2.add("bbb");
l2.add("ccc");
l2.add("ddd");
//l2 = [aaa, bbb, ccc, ddd]
l2.removeLast();
System.out.println(l2);//[aaa, bbb, ccc]
}
}
 答：实际上就是从头或者从尾部开始遍历查找：
如果索引比集合长度的一半小，则从头找；如果索引比集合长度的一半大，则从尾找；
注意！！！ 注意！！！ 注意！！！ 双列集合在Day10里。。。
|