是一个容器,可以存放多个数据.通常用来替代数组
只能存放引用类型
所有集合都来自于java.util包
List、Set、Map都是接口
有序、有下标、元素可以重复
ArrayList（常用）
JDK1.2 底层数组实现 查询快，增删慢 线程不安全，效率高
LinkedList（一般不用）
JDK1.2 底层链表实现 查询慢，增删快 线程不安全，效率高
Vector（不用）
JDK1.0 底层数组实现 都慢 线程安全，效率低
推荐使用多态
List 集合名=new 实现类名();
boolean add(元素)：添加元素至集合末尾
void add(下标，元素)：将元素添加至指定下标位置
boolean addAll(集合)：将指定集合元素添加到当前集合末尾
boolean addAll(下标，集合)：将指定集合元素添加到当前集合指定下标位置
boolean contains(元素)：判断集合是否包含指定元素
boolean containsAll(集合)：判断当前集合中是否包含指定集合的所有元素
元素 get(下标)：获取指定下标的元素
下标 indexOf(元素)：获取指定元素第一次出现的下标，不存在返回-1
下标 lastIndexOf(元素)：获取指定元素最后一次出现的下标，不存在返回-1
boolean isEmpty()：判断集合长度是否为0
被删除的元素 remove(下标)：删除指定下标位置的元素
boolean remove(元素): 删除指定元素，只删除第一个匹配元素
当List集合存放内容为整型数值时，无法使用该传参方式进行删除
int size()：获取集合元素个数
用于集合，可以约束集合中存放的数据类型
List<泛型> 集合名=new 实现类名<泛型>();
如果存放基本类型，则泛型必须声明为其对应的包装类
声明泛型之后，集合中只能存放泛型数据
一个集合容器只能声明一种泛型
由左侧泛型决定泛型约束，右侧泛型可以只书写<>做语法占位
List<泛型> 集合名=new 实现类名<>();
for下标遍历
for(int i=0; i< 集合名.size(); i++){ ? ?//通过集合名.get(i)获取当前元素 }
迭代器遍历
//获取集合的迭代器 Iterator<集合的泛型> it=集合名.iterator(); //操作迭代器,获取集合元素 while(it.hasNext()){//条件:存在下一元素 ? ?//通过it.next()指针后移,获取下一元素 ? ? }
由于指针走向固定,所以循环操作迭代器的过程中不可增删集合元素
一次循环只能调用一次next()
外遍历forEach
for(泛型 元素名:集合名){ ? ?//元素名随便起,代表当前正在被操作的元素 }
JDK5.0
本质上仍为迭代器遍历,所以过程中不可增删元素
自遍历forEach
集合名.forEach(Consumer接口实现类对象)集合名.forEach(new Consumer<集合泛型>(){ ? public void accpet(泛型 元素名){ ? ? ? //元素名就代表正在被操作的集合元素 ? } });
集合名.forEach(参数名->{操作语句});
JDK8.0
不可使用外部的累加器和标识变量
List<Integer> list = new ArrayList<>();
? ? ? ?list.add(10);
? ? ?/* list.add(5.5);
? ? ? ?list.add("abc");*/
? ? ? ?list.add(20);
? ? ? ?list.add(30);
? ? ? ?list.add(40);
? ? ? ?list.add(50);
?
? ? ? ?//for+下标
? ? ? ?for (int i = 0; i < list.size(); i++) {
? ? ? ? ? ?System.out.print(list.get(i)+" ");
? ? ? }
? ? ? ?System.out.println();
? ? ? ?//迭代器遍历
? ? ? ?Iterator<Integer> it = list.iterator();
? ? ? ?while (it.hasNext()) {
? ? ? ? ? ?//先接收当前元素
? ? ? ? ? ?Integer i = it.next();
? ? ? ? ? ?//判断集合元素不为null
? ? ? ? ? ?if (i != null) {
? ? ? ? ? ? ? ?System.out.print(i + " ");
? ? ? ? ? }
? ? ? }
? ? ? ?System.out.println();
? ? ? ?//外遍历
? ? ? ?for (Integer i : list) {
? ? ? ? ? ?System.out.print(i+" ");
? ? ? }
? ? ? ?System.out.println();
? ? ? ?//自遍历
? ? ? ?list.forEach(new Consumer<Integer>() {
? ? ? ? ? ?@Override
? ? ? ? ? ?public void accept(Integer i) {
? ? ? ? ? ? ? ?System.out.print(i+" ");
? ? ? ? ? }
? ? ? });
? ? ? ?System.out.println();
? ? ? ?//lambda简化
? ? ? ?list.forEach(i-> System.out.print(i+" "));集合的特点
List的存储特点
List的常用实现类和特点
泛型在集合中的作用
List的遍历方式
所有集合都有Collection或者Map派生
是List和Set的父接口
存放List和Set的共性内容
没有直接实现类
没有明确的存储特点的要求
无序、无下标、元素不可重复
HashSet
JDK1.2 底层哈希表（数组+链表）实现 线程不安全，效率高
LinkedHashSet
JDK1.2 是HashSet的子类，底层哈希表实现 线程不安全，效率高
TreeSet
JDK1.2 是SortedSet的实现类，底层红黑树实现 线程不安全，效率高
建议使用多态
Set<泛型> 集合名=new 实现类名<>();
没有独有方法,所有方法都继承自父接口Collection
与下标相关的方式是List集合的独有方法
Iterator迭代器遍历
外遍历forEach
自遍历forEach
调用元素的hashCode方法获取哈希码值
根据哈希码值%数组长度得到存放下标
若下标位置未存有元素,则直接存放
若存有元素,则调用元素的equals方法与下标位置元素进行值的比较
都不相同,则链表存放
有相同,则舍弃添加元素
哈希表存放自定义类型时,必须重写hashCode方法和equals方法才能实现去重
LinkedHashSet可以保证元素存入和取出顺序一致
TreeSet可以对元素进行默认的升序排序(从小到大)
如果存放的为自定义类型,则必须提供排序规则
方式1: 实现Comparable接口,重写compareTo方法
原理: 让当前对象和参数对象进行比较
实现: 对谁排序,让谁实现
public class 类名 implements Comparable<类名>{
? ?
? ?public int compareTo(类名 o){
? ? ? ?/*
? ? ? ?从小到大: this的值>o的值 返回正数
? ? ? this的值<o的值 返回负数
? ? ? ?从大到小: this的值>o的值 返回负数
? ? ? this的值<o的值 返回正数
? ? ?
? ? ? 相等返回0
? ? ? ?*/
? }
}方式2: 实现Comparator接口,重写compare方法
原理: 让两个参数进行比较
实现: 在集合创建处的小括号内传入实现类对象
Set<泛型> 集合名=new TreeSet<泛型>(Comparator实现类对象);
默认识别Comparable,但是比较器Comparator优先级更高
更推荐使用比较器书写排序规则
Comparable会破坏自定义类的单一职责,并且无法扩展不同的排序规则
TreeSet是当排序规则返回值为0时去重
Collection的特点
Set的存储特点
Set的常用实现类
哈希表的去重原理
TreeSet自定义排序规则的方式
TreeSet