目录
- 1、集合的介绍
- 1.1 概念
- 1.2 集合的分类
- 2、单列集合：Collection
- 2.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<String> 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);//trueSystem.out.println(b3);//trueSystem.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，删除不存在的对象则返回falseSystem.out.println(c);//[赵武] 可以发现马四已经被删除了//5、contains(Object obj):判断当前集合中是否包含给定的对象boolean contains1 = c.contains("平平");System.out.println(contains1);//false 不包含则返回falseboolean 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<E> iterator():获取遍历集合的迭代器* 1、public E next():从集合中获取一个元素* 注：如果next()调用超过了集合的大小，就会出现 NoSuchElementException 异常* 2、public boolean hasNext():如果任有元素可以迭代，则返回true*/public static void main(String[] args) {Collection<Student> 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<Student> 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<Student> 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<Student> 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<String> 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<Integer> 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<String> list = new ArrayList<>();list.add("111");list.add("222");list.add("333");list.add("444");//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、foreach方法list.forEach(item -> System.out.println(item));System.out.println("--------------------");//5、ListIterator（List集合特有的迭代器）ListIterator<String> 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<String> list = new ArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");list.add("ddd");/*下面代码使用的是增强for循环，其实底层也是使用迭代器的方法，但这个时候增加和删除只能拿到集合的方法，没法使用迭代器的方法【解决方法】：手写迭代器进行遍历---这就是为啥手写迭代器遍历虽然麻烦，但是有特定使用的场景*/
// for (String s : list){
// list.remove("bbb");
// }ListIterator<String> 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<String> 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<String> 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<String> 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<String> 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里。。。
