集合
集合是java中提供的一种容器，可以用来存储多个数据,并且可以存储任意类型的数据
集合与数组的区别
数组的长度是固定的。集合的长度是可变的。
数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。
集合的体系
Collection集合
Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
所有通用的 Collection 实现类（通常通过它的一个子接口间接实现 Collection）应该提供两个“标准”构造方法：一个是 void（无参数）构造方法，用于创建空 collection；另一个是带有 Collection 类型单参数的构造方法，用于创建一个具有与其参数相同元素新的 collection。
collection常用方法
boolean add(E e) 确保此 collection 包含指定的元素（可选操作）。
void clear() 移除此 collection 中的所有元素（可选操作）。
boolean contains(Object o) 如果此 collection 包含指定的元素，则返回 true。
boolean equals(Object o) 比较此 collection 与指定对象是否相等。
boolean isEmpty() 如果此 collection 不包含元素，则返回 true。
Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。
boolean remove(Object o) 从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
int size() 返回此 collection 中的元素数。
Object[] toArray() 返回包含此 collection 中所有元素的数组。
<T> T[] toArray(T[] a) 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
collection集合的创建方式
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/22 11:32
*/
public class CollectionDemo01 {
public static void main(String[] args) {
/**
* Collection集合的创建方式
* （1）Collection col = new Collection();
* 可以存出任意类型的数据
* （2）Collection<数据类型> col = new ArrayList<数据类型>();
* 存储指定类型的数据
*/
collectionMethod01();
collectionMehtod02();
}
private static void collectionMehtod02() {
Collection<String> col = new ArrayList<>();
col.add("小明");
col.add("小张");
col.add("小李");
System.out.println(col);
}
private static void collectionMethod01() {
Collection col = new ArrayList();
System.out.println(col);//输出结合的内容
col.add("张三");
col.add('a');
col.add(123);
col.add(12.3);
col.add(true);
System.out.println(col);
}
}collection常用方法的练习
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/22 11:48
*/
public class CollectionDemo03 {
public static void main(String[] args) {
/**
* boolean add(E e)
* 确保此 collection 包含指定的元素（可选操作）。
* void clear()
* 移除此 collection 中的所有元素（可选操作）。
* boolean contains(Object o)
* 如果此 collection 包含指定的元素，则返回 true。
* boolean equals(Object o)
* 比较此 collection 与指定对象是否相等。
* boolean isEmpty()
* 如果此 collection 不包含元素，则返回 true。
* Iterator<E> iterator()
* 返回在此 collection 的元素上进行迭代的迭代器。
* boolean remove(Object o)
* 从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
* int size()
* 返回此 collection 中的元素数。
* Object[] toArray()
* 返回包含此 collection 中所有元素的数组。
* <T> T[]
* toArray(T[] a)
* 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
*/
Collection<String>col = new ArrayList<>();
//boolean add(E e)
// 确保此 collection 包含指定的元素（可选操作）。
col.add("小张");
col.add("小白");
col.add("大黄");
col.add("小陈");
col.add("小李");
System.out.println(col);
System.out.println("--------");
//int size()
// 返回此 collection 中的元素数。
System.out.println(col.size());//5
System.out.println("--------");
// boolean isEmpty()
// 如果此 collection 不包含元素，则返回 true。
System.out.println(col.isEmpty());//false
System.out.println("--------");
//boolean contains(Object o)
// 如果此 collection 包含指定的元素，则返回 true。
System.out.println(col.contains("小张"));//true
System.out.println(col.contains("小明"));//false
System.out.println("--------");
//boolean equals(Object o)
// 比较此 collection 与指定对象是否相等。
System.out.println(col.equals("小李"));//false
System.out.println(col.equals("小花"));//false
System.out.println("--------");
//boolean remove(Object o)
// 从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
System.out.println(col.remove("大黄"));//true
System.out.println(col.remove("小黄"));//false
//void clear()
// 移除此 collection 中的所有元素（可选操作）。
//col.clear();
System.out.println(col.size());//0
//Object[] toArray()
// 返回包含此 collection 中所有元素的数组。
Object[] objects = col.toArray();
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
System.out.println("--------");
//<T> T[]
// toArray(T[] a)
// 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
/* String[] str = new String[col.size()];
str = col.toArray(str);*/
String[] str = col.toArray(new String[col.size()]);
for (int i = 0; i < str.length; i++) {
System.out.println(str[i]);
}
}
}迭代器iterator()接口的常用方法
方法名 说明
public E next() 返回迭代的下一个元素。
public boolean hasNext() 如果仍有元素可以迭代，则返回 true。
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/22 12:06
*/
public class CollectionDemo04 {
public static void main(String[] args) {
/**
* 迭代器的使用
* Iterator<E> iterator()
* 返回在此 collection 的元素上进行迭代的迭代器。
*/
Collection<String>col = new ArrayList<>();
col.add("小张");
col.add("小白");
col.add("大黄");
col.add("小陈");
col.add("小李");
Iterator<String> iterator = col.iterator();
boolean flag = iterator.hasNext();
String str = iterator.next();
System.out.println(flag);
System.out.println(str);
System.out.println("--------");
while (iterator.hasNext()){
String string = iterator.next();
System.out.println(string);
}
}
}迭代器在遍历Collection集合出现的问题
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/22 12:15
*/
public class CollectionDemo05 {
public static void main(String[] args) {
/**
* Exception in thread "main" java.util.ConcurrentModificationException
*
* ConcurrentModificationException: 并发修改异常
* 并发：两个或多个动作同时执行
*
* 遍历的同时，我操作了元素(add)
*
*
* 出现问题的原因分析:
*
* 迭代器再遍历Collection集合中元素的时候，会拿到Collection集合中元素的副本。
* 我们再使用迭代器时，会去判断集合中的元素的长度或跟集合中元素的内容是否一致，如果一致不会报错，就可以获取元素
*
* 在代码中我们对集合添加了一个元素，发再迭代器中的元素内容或长度不一致，就认为你改动了集合中的内容了，此时就会报
* ConcurrentModificationException并发修改异常，迭代器只有一个功能遍历集合中元素的功能
*
* 如何解决：
* 不使用迭代器就不会出现这个问题
* 可以使用ListIterator子接口进行操作元素
* 必须使用迭代器接口提供的方法，进行操作元素，同步集合中的元素
*/
Collection<String> col = new ArrayList<>();
col.add("小张");
col.add("小白");
col.add("大黄");
col.add("小陈");
col.add("小李");
Iterator<String> iterator = col.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}增强for循环
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/22 13:54
*/
public class CollectionDemo06 {
public static void main(String[] args) {
/**
* A:foreach 概述
* 增强for循环
*
* B:foreach 作用
* 遍历集合和数组，可以简化迭代器的遍历Collection集合的方式
*
* C:foreach 格式
*
* for (数组/集合中元素的类型 变量名 : 数组/集合的对象 ) {
* 遍历操作
*/
Collection<String> col = new ArrayList<>();
col.add("小张");
col.add("小白");
col.add("大黄");
col.add("小陈");
col.add("小李");
for (String str : col) {
System.out.println(str);
}
System.out.println("--------");
Iterator<String> iterator = col.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}list集合
有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
与 set 不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望这种用法越少越好。
List 接口在 iterator、add、remove、equals 和 hashCode 方法的协定上加了一些其他约定，超过了 Collection 接口中指定的约定。为方便起见，这里也包括了其他继承方法的声明。
List 接口提供了 4 种对列表元素进行定位（索引）访问方法。列表（像 Java 数组一样）是基于 0 的。注意，这些操作可能在和某些实现（例如 LinkedList 类）的索引值成比例的时间内执行。因此，如果调用者不知道实现，那么在列表元素上迭代通常优于用索引遍历列表。
List 接口提供了特殊的迭代器，称为 ListIterator，除了允许 Iterator 接口提供的正常操作外，该迭代器还允许元素插入和替换，以及双向访问。还提供了一个方法来获取从列表中指定位置开始的列表迭代器。
特点
它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
特有方法
List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法
方法名 说明
public void add(int index, E element) 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) 返回集合中指定位置的元素·。
public E remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) 用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
特有方法的练习
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/22 18:46
*/
public class ListDemo02 {
public static void main(String[] args) {
/**
* 常用方法
* void add(int index,E element) 在此集合中的指定位置插入指定的元素
* E remove(int index) 删除指定索引处的元素，返回被删除的元素
* E set(int index,E element) 修改指定索引处的元素，`返回被修改的元素
* E get(int index) 返回指定索引处的元素
*/
ArrayList<Integer> list = new ArrayList<>();
//void add(int index,E element) 在此集合中的指定位置插入指定的元素
list.add(1);
list.add(6);
list.add(5);
list.add(8);
//E remove(int index) 删除指定索引处的元素，返回被删除的元素
boolean b = list.remove(Integer.valueOf(8));
System.out.println(b);
//E set(int index,E element) 修改指定索引处的元素，`返回被修改的元素
list.set(0,10);
//E get(int index) 返回指定索引处的元素
Integer integer = list.get(2);
System.out.println(integer);
System.out.println(list);
}
}常用方法练习
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/22 18:33
*/
public class Test02 {
public static void main(String[] args) {
/**
* boolean add(E e)
* 向列表的尾部添加指定的元素（可选操作）。
* void add(int index, E element)
* 在列表的指定位置插入指定元素（可选操作）。
* void clear()
* 从列表中移除所有元素（可选操作）。
* boolean contains(Object o)
* 如果列表包含指定的元素，则返回 true。
* E get(int index)
* 返回列表中指定位置的元素。
* boolean isEmpty()
* 如果列表不包含元素，则返回 true。
* Iterator<E> iterator()
* 返回按适当顺序在列表的元素上进行迭代的迭代器。
* E remove(int index)
* 移除列表中指定位置的元素（可选操作）。
* boolean remove(Object o)
* 从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
* E set(int index, E element)
* 用指定元素替换列表中指定位置的元素（可选操作）。
* int size()
* 返回列表中的元素数。
* Object[] toArray()
* 返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
* <T> T[]
* toArray(T[] a)
* 返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
*/
//创建List集合对象
List<String> list = new ArrayList<>();
//boolean add(E e)
// 向列表的尾部添加指定的元素（可选操作）。
list.add("张三");
list.add("李四");
list.add("王二");
list.add("码子");
//void add(int index, E element)
// 在列表的指定位置插入指定元素（可选操作）。
list.add(1,"小张");
for (String s : list) {
System.out.println(s);//张三 小张 李四 王二 码子
}
//boolean contains(Object o)
// 如果列表包含指定的元素，则返回 true。
System.out.println(list.contains("张三"));//true
System.out.println(list.contains("王五"));//false
//E get(int index)
// 返回列表中指定位置的元素。
System.out.println(list.get(2));//李四
//boolean isEmpty()
// 如果列表不包含元素，则返回 true。
System.out.println(list.isEmpty());//false
//E remove(int index)
// 移除列表中指定位置的元素（可选操作）。
System.out.println(list.remove(2));//李四
//Iterator<E> iterator()
// 返回按适当顺序在列表的元素上进行迭代的迭代器。
Iterator<String> it = list.iterator();//李四
while (it.hasNext()){
System.out.print(it.next()+" ");//张三 小张 王二 码子
}
System.out.println();
System.out.println("==============");
//E set(int index, E element)
// 用指定元素替换列表中指定位置的元素（可选操作）。
System.out.println(list.set(0, "小三"));//张三
for (String s : list) {
System.out.print(s+" ");//小三 小张 王二 码子
}
System.out.println();
//int size()
// 返回列表中的元素数。
System.out.println(list.size());//4
//Object[] toArray()
// 返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
Object[] objects = list.toArray();
for (Object object : objects) {
System.out.print(object+" ");
}
}
}list集合的子类
arrayList集合
List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）
size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。
每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。
注意，此实现不是同步的。
arrayList中常用方法
方法名 说明
public void add(int index, E element) 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) 返回集合中指定位置的元素·。
public E remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) 用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
public boolean add(E e) 将指定的元素添加到此列表的尾部ArrayList集合中常用的方法，我们在使用List接口的时候，已经给大家演示过了，在这里我们就不需要再一次进行演示了。
linkedList集合
List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。
此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。
所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。
注意，此实现不是同步的
linkedList集合常用方法
方法名 说明
public void addFirst(E e) 将指定元素插入此列表的开头。
public void addLast(E e) 将指定元素添加到此列表的结尾。
public E getFirst() 返回此列表的第一个元素。
public E getLast() 返回此列表的最后一个元素。
public E removeFirst() 移除并返回此列表的第一个元素。
public E removeLast() 移除并返回此列表的最后一个元素。
public E pop() 从此列表所表示的堆栈处弹出一个元素。
public void push(E e) 将元素推入此列表所表示的堆栈。
public boolean isEmpty() 如果列表不包含元素，则返回true。
LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。
linkedList使用练习
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/22 19:00
*/
public class LinkedListDemo02 {
public static void main(String[] args) {
/**
* public void addFirst(E e) 在该列表开头插入指定的元素
* public void addLast(E e) 将指定的元素追加到此列表的末尾
* public E getFirst() 返回此列表中的第一个元素
* public E getLast() 返回此列表中的最后一个元素
* public E removeFirst() 从此列表中删除并返回第一个元素
* public E removeLast() 从此列表中删除并返回最后一个元素
* public E pop() 从此列表所表示的堆栈处弹出一个元素。
* public void push(E e) 将元素推入此列表所表示的堆栈。
* public boolean isEmpty() 如果列表不包含元素，则返回true。
*
* LinkedList 主要是用于模拟一些数据结构的特点(队列 栈)
* 后期做一些功能的时候，只要是分析出来操作的内容是关于头和尾的或者是说跟(队列 栈)有关系
* 就可以使用LinkedList集合完成你所需要的功能即可
*/
LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
//public void addFirst(E e) 在该列表开头插入指定的元素
linkedList.addFirst(10);//[10, 1, 2, 3]
System.out.println(linkedList);
//public void addLast(E e) 将指定的元素追加到此列表的末尾
linkedList.addLast(30);
System.out.println(linkedList);//[10, 1, 2, 3, 30]
//public E getFirst() 返回此列表中的第一个元素
System.out.println(linkedList.getFirst());//10
//public E getLast() 返回此列表中的最后一个元素
System.out.println(linkedList.getLast());//30
//public E removeFirst() 从此列表中删除并返回第一个元素
linkedList.removeFirst();
System.out.println(linkedList);//[1, 2, 3, 30]
//public E removeLast() 从此列表中删除并返回最后一个元素
linkedList.removeLast();
System.out.println(linkedList);//[1, 2, 3]
//public E pop() 从此列表所表示的堆栈处弹出一个元素。
Integer num = linkedList.pop();
System.out.println(num);//1
System.out.println(linkedList);//[2, 3]
//public void push(E e) 将元素推入此列表所表示的堆栈。
linkedList.push(1);
System.out.println(linkedList);//[1, 2, 3]
//public boolean isEmpty() 如果列表不包含元素，则返回true。
boolean empty = linkedList.isEmpty();
System.out.println(empty);//false
}
}
206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
