前言
Hello，大家好！很开心与你们在这里相遇，我是一个喜欢文字、喜欢有趣的灵魂、喜欢探索一切有趣事物的女孩，想与你们共同学习、探索关于IT的相关知识，希望我们可以一路陪伴~
1. 集合概述
什么是集合
集合：集合是java中提供的一种容器，可以用来存储多个数据,并且可以存储任意类型的数据！
集合与数组的区别
数组的长度是固定的。集合的长度是可变的。
数组中存储的是同一类型的元素，可以存储基本数据类型值。
集合存储的都是对象。而且对象的类型可以不一致，不能存放基本数据类型
集合体系
2. Collection集合
Collection概述
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。
Collection常用方法
| 方法名 | 说明 |
|---|---|
| public boolean add(E e) | 把给定的对象e添加到当前集合中 。E:element 元素 |
| public boolean remove(E e) | 把给定的对象在当前集合中删除e。 |
| public boolean contains(E e) | 判断当前集合中是否包含给定的对象e。 |
| public boolean isEmpty() | 判断当前集合是否为空。 |
| public int size() | 返回集合中元素的个数。 |
| public Object[] toArray() | 把集合中的元素，存储到数组中。 |
| public void clear() | 清空集合中所有的元素。 |
代码示例：
import java.util.ArrayList;
import java.util.Collection;
public class Demo1Collection {
public static void main(String[] args) {
// 创建集合对象
// 使用多态形式
Collection<String> coll = new ArrayList<String>();
// 使用方法
// 添加功能 boolean add(String s)
coll.add("小李广");
coll.add("扫地僧");
coll.add("石破天");
System.out.println(coll);
// boolean contains(E e) 判断o是否在集合中存在
System.out.println("判断 扫地僧 是否在集合中"+coll.contains("扫地僧"));
//boolean remove(E e) 删除在集合中的o元素
System.out.println("删除石破天："+coll.remove("石破天"));
System.out.println("操作之后集合中元素:"+coll);
// size() 集合中有几个元素
System.out.println("集合中有"+coll.size()+"个元素");
// Object[] toArray()转换成一个Object数组
Object[] objects = coll.toArray();
// 遍历数组
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
// void clear() 清空集合
coll.clear();
System.out.println("集合中内容为："+coll);
// boolean isEmpty() 判断是否为空
System.out.println(coll.isEmpty());
}
}3. Iterator迭代器
为什么要有Iterator
由于Collection集合，是没有索引的。如果我们遍历Collection集合，使用for循环是无法使用的。我们可以借Collection中的toArray方法转换成数组，来遍历集合！这种方式也能实现，但总觉得不太舒服，这时，JDK提供了一个Iterator接口来专门用于遍历集合。
Iterator概述
在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口
java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。
- 什么是迭代
迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
- 获取Iterator
想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作。在Collection集合中，专门提供了一个方法，用来获取Iterator
public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。- Iterator接口的常用方法
| 方法名 | 说明 |
|---|---|
| public E next() | 返回迭代的下一个元素。 |
| public boolean hasNext() | 如果仍有元素可以迭代，则返回 true。 |
代码示例：
public class IteratorDemo {
public static void main(String[] args) {
// 使用多态方式 创建对象
Collection<String> coll = new ArrayList<String>();
// 添加元素到集合
coll.add("串串星人");
coll.add("吐槽星人");
coll.add("汪星人");
//遍历
//使用迭代器 遍历 每个集合对象都有自己的迭代器
Iterator<String> it = coll.iterator();
// 泛型指的是 迭代出 元素的数据类型
while(it.hasNext()){ //判断是否有迭代元素
String s = it.next();//获取迭代出的元素
System.out.println(s);
}
}
}4. 增强for
什么是增强for
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
增强for格式
for(元素的数据类型 变量 : Collection集合or数组的变量名){
//写操作代码
}增强for遍历数组和集合
遍历数组
public class NBForDemo1 {
public static void main(String[] args) {
int[] arr = {3,5,6,87};
//使用增强for遍历数组
for(int a : arr){//a代表数组中的每个元素
System.out.println(a);
}
//数组的另一种遍历方式（jdk8以上才能使用）
Arrays.stream(str).forEach(System.out::println);
}
}遍历集合
public class NBForDemo2 {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<String>();
coll.add("小河神");
coll.add("老河神");
coll.add("神婆");
//使用增强for遍历
for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
System.out.println(s);
}
//集合的另一种遍历方式（jdk8以上才能使用）
con.forEach(System.out::println);
}
}5. List集合
什么是List集合
java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。
List集合的特点
它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
List集合常用方法
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) | 用指定元素替换集合中指定位置的元素,返回值的更新前的元素。 |
代码示例：
public class ListDemo {
public static void main(String[] args) {
// 创建List集合对象
List<String> list = new ArrayList<String>();
// 往 尾部添加 指定元素
list.add("图图");
list.add("小美");
list.add("不高兴");
System.out.println(list);
// add(int index,String s) 往指定位置添加
list.add(1,"没头脑");
System.out.println(list);
// String remove(int index) 删除指定位置元素 返回被删除元素
// 删除索引位置为2的元素
System.out.println("删除索引位置为2的元素");
System.out.println(list.remove(2));
System.out.println(list);
// String set(int index,String s)
// 在指定位置 进行 元素替代（改）
// 修改指定位置元素
list.set(0, "三毛");
System.out.println(list);
//获取集合的元素个数
int size = list.size();
System.out.println(size);
//根索引来获取元素
// String get(int index) 获取指定位置元素
String s = list.get(0);
System.out.println(s);
// 跟size() 方法一起用 来 遍历的
for(int i = 0;i<list.size();i++){
System.out.println(list.get(i));
}
//还可以使用增强for
for (String string : list) {
System.out.println(string);
}
}
}List集合的实现类
List的实现类特点：
ArrayList:
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
LinkedList:
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
Vector:
底层数据结构是数组，查询快，增删慢
线程安全，效率低
ArrayList集合
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 存储自定义对象并遍历
/
public class ArrayListDemo2 {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
Student s1 = new Student();
s1.setId(11);
s1.setName("小包面");
Student s2 = new Student();
s2.setId(22);
s2.setName("小肉丝");
list.add(s1);
list.add(s2);
System.out.println(list);
Iterator<Student> it = list.iterator();
while (it.hasNext()){
//注意返回的类型为是Student对象
Student stu = it.next();
System.out.println(stu.getId());
System.out.println(stu.getName());
}
System.out.println("=====================");
for (Student s : list){
System.out.println(s.getName()+": "+s.getId());
}
System.out.println("=====================");
for(int x = 0; x < list.size(); x++){
Student stu = list.get(x);
System.out.println(stu.getId()+": "+stu.getName());
}
}
}6. LinkedList集合
LinkedList:
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
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的特有功能：
* A:添加功能
* public void addFirst(Object e)
* public void addLast(Object e)
* B:获取功能
* public Object getFirst()
* public Obejct getLast()
* C:删除功能
* public Object removeFirst()
* public Object removeLast()
*/
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> link = new LinkedList<String>();
// 添加元素
link.add("hello");
link.add("world");
link.add("java");
//添加元素
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
System.out.println(link);
// 获取元素
System.out.println(link.getFirst());
System.out.println(link.getLast());
// 删除元素
System.out.println(link.removeFirst());
System.out.println(link.removeLast());
while (!link.isEmpty()) { //判断集合是否为空
System.out.println(link.pop());
}
System.out.println(link);
}
}7. Vector集合
Vector:
底层数据结构是数组，查询快，增删慢
线程安全，效率低
代码示例：
/*
* Vector：
vector是list的实现类，list中所有方法vector都可以使用，这里就介绍vector特有方法
* 1：添加功能
* public void addElement(Object obj) -- add()
* 2：获取功能
* public Object elementAt(int index) -- get()
*/
public class VectorDemo {
public static void main(String[] args) {
// 创建集合对象
Vector v = new Vector();
// 添加功能
v.addElement("hello");
v.addElement("world");
v.addElement("java");
// 遍历
for (int x = 0; x < v.size(); x++) {
String s = (String) v.elementAt(x);
System.out.println(s);
}
System.out.println("------------------");
}
}
8. Collections
什么是Collections
Collections是针对集合操作的工具类
Collections常用的方法
| 方法名 | 说明 |
|---|---|
| public static void sort(List<T> list) | 将指定的列表按升序排序 |
| public static void reverse(List<?> list) | 反转指定列表中元素的顺序 |
| <T extends Object & Comparable<? super T>> T max() | 获取集合中最大值 |
代码示例：
public class CollectionsDemo01 {
public static void main(String[] args) {
//创建集合对象
List<Integer> list = new ArrayList<Integer>();
//添加元素
list.add(30);
list.add(20);
list.add(50);
list.add(10);
list.add(40);
// 将指定的列表按升序排序
Collections.sort(list);
//反转指定列表中元素的顺序
Collections.reverse(list);
//获取集合是最大值
Integer max = Collections.max(list);
System.out.println(max);//50
//获取集合是最小值
Integer min = Collections.min(list);
System.out.println(min);//10
System.out.println(list);
}
}collection和collectons的区别？
Collection 是一个集合接口,它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
Collections 是一个操作集合的工具类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
9. list集合的总结
List的子类特点：
ArrayList:
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
LinkedList:
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
Vector:
底层数据结构是数组，查询快，增删慢
线程安全，效率低
list集合特点：有序可重复
今后我们如何选择list的三个子类？
如果你想查询快：选ArrayListVector
如果你想增删快：选LinkedList
如果你想要效率高：选ArrayList，LinkedList
如果你想要效率低：选Vector
如果你想要线程安全：选Vector
如果你想要线程不安全：选ArrayList，LinkedList
以上都是分业务情况来决定你要用哪一个集合。如果你实在不知道该如何选择，你就选译：ArrayList
阳光明媚，今天的你也要开开心心哒~ 喜欢我就关注我叭~
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
