集合框架Collection系列集合
一、Collection的常用方法
Collectio是单例集合的祖宗，他规定的方法是全部单例集合都会继承
| 方法名 | 说明 |
|---|---|
| public boolean add（E e） | 把给定的对象添加到当前集合中 |
| public void clear() | 清空集合中所有元素 |
| public boolean remove(E e) | 把给定的对象在当前集合删去 |
| public boolean contains(Object obj) | 判断当前集合中是否包含给定的对象 |
| public boolean isEmpty() | 判断当前集合是否为空 |
| public int size() | 返回集合中元素的个数 |
| public Object [ ] toArray() | 把集合中的元素，储存到数组中 |
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest1 {
public static void main(String[] args) {
Collection<String> a1 = new ArrayList<>();
a1.add("java1");
a1.add("java2");
a1.add("java3");
a1.add("java3");
System.out.println(a1);
// 清空了集合的所有元素
//a1.clear();
// 把给定的对象在当前集合中删除 若有重复的默认删除第一个
a1.remove("java3");
// 判断当前集合是否包含给定的对象
a1.contains("java2");
// 判断当前集合是否为空
a1.isEmpty();
// 返回集合中元素个数
a1.size();
//把集合中的元素，储存到数组中
Object[] arr1 = a1.toArray();
// 把集合中的元素储存到对应数组中
String[] arr2 = a1.toArray(new String[a1.size()]);
// 把一个集合中的数据全部倾倒入另一个集合中
Collection<String> a2 = new ArrayList<>();
Collection<String> a3 = new ArrayList<>();
a2.add("java1");
a2.add("java2");
a3.add("java3");
a3.add("java4");
a2.addAll(a3);
}
}
二、Collection的遍历方式
1、迭代器
概述：迭代器是用来遍历集合的专用方式（数组没有迭代器），在java中迭代器的代表是iterator
- Collection集合获取迭代器的方法
| 方法名称 | 说明 |
|---|---|
| Iterator< E > iterator() | 返回集合中迭代器对象，该迭代器对象默认指向当前集合的第一个元素 |
- Iterator迭代器中的常用方法
import java.util.*;
import java.util.function.BiConsumer;
public class a {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("张三");
c.add("赵四");
c.add("王五");
System.out.println(c);
//使用迭代器遍历集合
//1、从集合对象中获取迭代器对象
Iterator<String> it = c.iterator();
System.out.println(it.next());
System.out.println(it.next());
System.out.println(it.next());//多取会出现异常
}
}
| 方法名称 | 说明 |
|---|---|
| boolean hasNext() | 询问当前位置是否有元素存在，存在返回true，不存在返回false |
| E next() | 获取当前位置的元素，并同时将迭代器对象指向下一处元素 |
import java.util.*;
import java.util.function.BiConsumer;
public class a {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("张三");
c.add("赵四");
c.add("王五");
System.out.println(c);
//使用迭代器遍历集合
//循环结合迭代器使用
Iterator<String> it = c.iterator();
while (it.hasNext()){
String ele = it.next();
System.out.println(ele);
}
}
}
2、增强for循环
格式：for(元素的数据类型 变量名 ：数组或集合){
}
- 增强for循环可以用来遍历集合或数组
- 增强for遍历集合，本质就是迭代器遍历集合的简化写法
import java.util.*;
import java.util.function.BiConsumer;
public class a {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("张三");
c.add("赵四");
c.add("王五");
System.out.println(c);
//使用增强for遍历集合或者数组
for (String ele:c){
System.out.println(ele);
}
}
}
3、Lambda表达式
| 方法名称 | 说明 |
|---|---|
| default void forEach(Consumer action) | 结合lambda遍历集合 |
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class a {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("张三");
c.add("赵四");
c.add("王五");
System.out.println(c);
//结合Lambda表达式遍历集合
c.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
}
}
三、List集合
1、特点、特有方法
Lsit系列集合特点：有序、可重复、有索引
- ArrayList：有序、可重复、有索引
- LinkedList：有序、可重复、有索引
特有方法：List集合因为支持索引，所以多了很多与索引相关的方法，Collection的功能List也都继承了
| 方法说明 | 说明 |
|---|---|
| void add (int index,E element) | 在此集合中指定位置插入指定元素 |
| E remove(int index) | 删除指定索引处的元素，返回被删除元素 |
| E set(int index,E element) | 修改制定索引处的元素，返回被修改的元素 |
| E get(int index) | 返回指定索引处的元素 |
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class a {
public static void main(String[] args) {
//1.创建一个ArrayLIst集合对象
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
System.out.println(list);
//2.void add (int index,E element) 在此集合中指定位置插入指定元素
list.add(2,"赵六");
System.out.println(list);
//3.E remove(int index) 删除指定索引处的元素，返回被删除元素
System.out.println(list.remove(2));
System.out.println(list);
//4.E set(int index,E element) 修改制定索引处的元素，返回被修改的元素
System.out.println(list.set(3,"哈哈"));
System.out.println(list);
//5.E get(int index) 返回指定索引处的元素
System.out.println(list.get(3));
}
}
2、遍历方式
- for循环
- 迭代器
- foreach
- JDK 1.8开始以后的Lambda表达式
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class a {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
System.out.println(list);
//1.for循环
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
//2.迭代器
Iterator<String> it = list.listIterator();
while (it.hasNext()){
System.out.println(it.next());
}
//3.增强for循环
for (String s : list){
System.out.println(s);
}
//4.JDK 1.8开始以后的Lambda表达式
list.forEach(s -> {
System.out.println(s);
});
}
}
3、ArrayList集合的底层原理
- 基于数组实现的
- 特点
查询速度快：查询数据通过地址值个索引位置定位，查询任意数值耗时相同。
删除效率低：可能需要包后面很多的数据进行前移
添加效率极低：可能需要把后面很多的数据后移，在添加元素；或者也需要进行数组扩容 - 原理：利用无参构造器创建的集合，会在底层创建一个·默认长度为0的数组，添加第一个元素时，底层会创建一个新的长度为10的数组，存满时，会扩容1.5倍，如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准
4.LinkedList集合的底层原理
1.方法
| 方法名称 | 说明 |
|---|---|
| public void addFirst(E e)= push | 在该列表开头插入指定元素 |
| public void addLast(E e) | 将指定的元素追加到此列表的末尾 |
| public E getFirst() | 返回此列表中的第一个元素 |
| public E getLast() | 返回此列表中的最后一个元素 |
| public E removeFirst() =pop | 从此列表中删除并返回第一个元素 |
| public E removeLast | 从此列表中删除并返回最后一个元素 |
import java.util.LinkedList;
public class LinkedList {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.addFirst("张三");
list.addLast("李四");
list.getLast();
list.getFirst();
//从列表中删除并返回第一个元素
System.out.println(list.removeFirst());
//从列表中删除并返回最后一个元素
System.out.println(list.removeLast());
}
}
四、set集合
1. 特点：
无序；添加数据的顺序和获取出的数据顺序不一致；不重复；无索引。
·HashSet：无序、不重复、无索引。
·LinkedHashSet：有序、不重复、无索引。
·TreeSet：可排序（升序）、不重复、无索引。
public class SetListTest1 {
public static void main(String[] args) {
// Set s = new HashSet<>(); // 无序 无重复 无索引
// Set s = new LinkedHashSet<>(); // 有序 无重复 无索引
Set<Integer> s = new TreeSet<>(); // 排序（默认是升序排序） 无重复 无索引
s.add(555);
s.add(555);
s.add(666);
s.add(777);
s.add(777);
s.add(111);
System.out.println(s);
}
}
注意：Set要用到的常用方法，基本上就是Collection提供的！！自己几乎没有额外新增一些常用功能！
2.哈希值
概念
- 就是一个int类型的数值，Java中每个对象都有一个哈希值
- java中的所有对象，都可以调用Obj类提供的hashCode方法，返回该对象自己的哈希值
public int hashCode():返回对象的哈希值
对象哈希值特点
- 同一个对象多次调用hashCode()方法返回的哈希值是相同的
- 不同的对象，他们的哈希值一般不相同，但也有可能会有相同（哈希碰撞）
public class HashCodeTest {
public static void main(String[] args) {
//哈希值不同
Student a1 = new Student("张三",170);
Student a2 = new Student("李四",160);
System.out.println(a1.hashCode());//1163157884
System.out.println(a2.hashCode());//1956725890
//哈希值相同
String str1 = new String("Abc");
String str2 = new String("AcD");
System.out.println(str1.hashCode());//65602
System.out.println(str2.hashCode());//65602
}
}
3.HashSet集合的底层原理
- 是基于哈希表实现
- 哈希表是一种增删改查数据，性能都较好的数据结构
哈希表
- JDK8之前，哈希表=数组+链表
- Jdk8开始，哈希表=数组+链表+红黑树
JDK8之前HashSet集合的底层原理，基于哈希表：数组+链表
①创建一个默认长度为16的数组，默认加载因子为0.75，数组名为table。
②使用元素的哈希值对数组的长度求余计算出应存入的位置。
③判断当前位置是否为null，如果是null直接存入。
④如果不为null，表示有元素，则调用equals方法比较相等，则不存；不相等，则存入数组。
JDK8之前，新元素存入数组，占老元素位置，老元素挂下面。
JDK8开始之后，新元素直接挂在老元素下面。
JDK8开始HashSet集合的底层原理，基于哈希表：数组+链表+红黑树
了解数据结构（树）
二叉查找树存在的问题：当数据已经是排好序的，导致查询的性能与单链表一样，查询速度变慢
平衡二叉树：在满足查找二叉树的大小规则下，让树尽可能矮小，以此提高查数据的性能
红黑树就是可以自动平衡的二叉树，是一种增删改查数据性能相对都较好的结构。
深入了解HashSet集合去重复的机制。
HashSet集合默认不能对内容一样的两个不同对象去重复！
比如内容一样的两个对象存入到HashSet集合中去，HashSet集合是不能去重复的！
若希望Set集合认为两个内容一样的对象是重复的，必须重写对象的hashCode()和equals()方。
//只要两个对象的内容一样就返回true
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return high == student.high && Objects.equals(name, student.name);
}
//只要两个对象的内容一样返回的哈希值就是一样的
@Override
public int hashCode() {
return Objects.hash(name, high);
}
4.LinkedHashSet集合的底层原理
- 依然是基于哈希表实现的
- 但是，他的每个元素都额外的多了一个双链表的机制记录它前后元素的位置
5.TreeSet集合
特点：不重复、无索引、可排序（默认升序排序，按照元素的大小，由小到大排序）