文章目录
一、集合框架的概述
-
集合、数组都是对多个数据进行存储操作的结构,简称Java容器。
- 说明:此时的存储,主要指的是内存层面的存储,不涉及到持久化的存储(.txt,.jpg,.avi,数据库中)
-
数组在存储多个数据方面的特点:
- 一旦初始化以后,其长度就确定了。
- 数组一旦定义好,其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
- 比如:String[] arr;int[] arr1;Object[] arr2;
-
数组在存储多个数据方面的缺点:
- 一旦初始化以后,其长度就不可修改。
- 数组中提供的方法非常有限,对于添加、删除、插入数据等操作,非常不便,同时效率不高。
- 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用
- 数组存储数据的特点:有序、可重复。对于无序、不可重复的需求,不能满足。
二、集合框架
-
Collection接口:单列集合,用来存储一个一个的对象
- List接口:存储有序的、可重复的数据。–>“动态”数组
- ArrayList:作为List接口的主要实现类;线程不安全的,效率高 LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表存储
- Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储
- **Set接口:**存储无序的、不可重复的数据 -->高中讲的“集合”
- HashSet:作为Set接口的主要实现类;线程不安全的;可以存储null值
- LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历,对于频繁的遍历操作,LinkedHashSet效率高于HashSet.
- TreeSet:可以按照添加对象的指定属性,进行排序。
- HashSet:作为Set接口的主要实现类;线程不安全的;可以存储null值
- List接口:存储有序的、可重复的数据。–>“动态”数组
-
**Map接口:**双列集合,用来存储一对(key - value)一对的数据 -->高中函数:y = f(x)
- HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
三、Collection接口中的方法的使用
添加
- add(Object obj)
- addAll(Collection coll)
获取有效元素的个数
- int size()
清空集合
- void clear()
是否是空集合
-
boolean isEmpty()
代码演示
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
public class CollectionTest {
@Test
public void test1(){
//add(Object e); 将元素e添加到集合coll中
Collection coll = new ArrayList();
coll.add("AA");
coll.add("BB");
coll.add(123);//自动装箱
coll.add(new Date());
//size() 获取添加的元素的个数
System.out.println(coll.size());//4
//addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add("CC");
coll.addAll(coll1);
System.out.println(coll.size());//6
System.out.println(coll);
//clear():清空集合元素
coll.clear();
//isEmpty():判断当前集合是否为空
System.out.println(coll.isEmpty());//false
}
}
是否包含某个元素
- boolean contains(Object obj):是通过元素的equals方法来判断是否 是同一个对象
- 向Collection接口的实现类的对象中添加数据obj时,要求obj所在类要重写equals().
- boolean containsAll(Collection c):也是调用元素的equals方法来比 较的。拿两个集合的元素挨个比较。
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person("Jerry",20));
Person p = new Person("Jerry",20);
coll.add(p);
//contains(Object obj):判断当前集合中是否包含obj
boolean contains = coll.contains(123);
System.out.println(contains);
System.out.println(coll.contains(new String("Tom")));//掉的String重写的equals 就是比内容
System.out.println(coll.contains(p));
System.out.println(coll.contains(new Person("Jerry",20)));//调的Object中的equals 就是== 就是false 重写之后就是true
//containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
Collection coll1 = Arrays.asList(123,4567);
System.out.println(coll.containsAll(coll1));//false
}
删除
- boolean remove(Object obj) :通过元素的equals方法判断是否是 要删除的那个元素。只会删除找到的第一个元素
- boolean removeAll(Collection coll):取当前集合的差集
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//remove(Object obj):从当前集合中移除obj元素。
coll.remove(123);//也会先执行equals 123 是一个Integer已经重写过了equals
System.out.println(coll);//[456, Person{name='Jerry', age=20}, Tom, false]
//removeAll(Collection coll1):差集:从当前集合中移除coll1中有的元素。
Collection coll1 = Arrays.asList(123,456);
coll.removeAll(coll1);
System.out.println(coll);//[Person{name='Jerry', age=20}, Tom, false]
}
取两个集合的交集
- boolean retainAll(Collection c):把交集的结果存在当前集合中,不 影响c
@Test
public void test4(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//retainAll(Collection coll1):交集:获取当前集合和coll1集合的交集,并返回给当前集合
Collection coll1 = Arrays.asList(123,456,789);
coll.retainAll(coll1);
System.out.println(coll);//[123, 456]
}
集合是否相等
- boolean equals(Object obj)
@Test
public void test4(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
// equals(Object obj):要想返回true,需要当前集合和形参集合的元素都相同。
Collection coll1 = new ArrayList();
coll1.add(123);
coll1.add(456);
coll1.add(new Person("Jerry",20));
coll1.add(new String("Tom"));
coll1.add(false);
System.out.println(coll.equals(coll1));//true
}
获取集合对象的哈希值
- hashCode()
@Test
public void test5(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//hashCode():返回当前对象的哈希值
System.out.println(coll.hashCode());//-783340298 随机数
}
转成对象数组
- Object[] toArray()
@Test
public void test5(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//集合 --->数组:toArray()
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
/*123
456
Person{name='Jerry', age=20}
Tom
false
*/
//数组 --->集合:调用Arrays类的静态方法asList()
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);//[AA, BB, CC]
List arr1 = Arrays.asList(new int[]{123, 456});
System.out.println(arr1);//[[I@78e03bb5] 把{123, 456}整体当成一个元素了
System.out.println(arr1.size());//1
List arr2 = Arrays.asList(123, 456);
System.out.println(arr2);//[123, 456]
List arr3 = Arrays.asList(new Integer[]{123, 456});
System.out.println(arr3.size());//2
}
数组 --->集合:调用Arrays类的静态方法asList()
遍历
- iterator():返回迭代器对象,用于集合遍历
四、Iterator迭代器接口
1、集合元素的遍历操作
- 使用迭代器Iterator接口
- 内部的方法:hasNext() 和 next()
- 在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用,且 下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
- 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合 的第一个元素之前。
- 内部的方法:hasNext() 和 next()
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorTest {
//iterator():返回Iterator接口的实例,用于遍历集合元素。放在IteratorTest.java中测试
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
Iterator iterator = coll.iterator();
/*
//方式一
System.out.println(iterator.next());//123
System.out.println(iterator.next());//456
System.out.println(iterator.next());//Person{name='Jerry', age=20}
System.out.println(iterator.next());//Tom
System.out.println(iterator.next());//false
//报异常 NoSuchElementException
// System.out.println(iterator.next());//NoSuchElementException
*/
/*
//方式二 不推荐
for(int i = 0 ; i < coll.size() ; i++){
System.out.println(iterator.next());
}*/
//方式三 推荐
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next():①指针下移 ②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
/*
/*
//错误方式
Iterator iterator = coll.iterator();
while(iterator.next() != null){
System.out.println(iterator.next());//打印456 Tom然后越界异常
}
*/
//错误方式二:
//集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
while (coll.iterator().hasNext()){
System.out.println(coll.iterator().next());//123死循环
}
*/
}
}
注意:Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象,则必须有一个被迭代的集合。
Iterator迭代器接口
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zp8XwndB-1638200694132)(C:\Users\吴金融\AppData\Roaming\Typora\typora-user-images\image-20211104160906714.png)]
2、集合元素的删除操作
- 内部定义了remove(),可以在遍历的时候,删除集合中的元素。此方法不同于集合直接调用remove()
@Test
public void test3() {
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry", 20));
coll.add(new String("Tom"));
coll.add(false);
Iterator iterator = coll.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
if("Tom".equals(obj)){
iterator.remove();
}
}//删除集合中的Tom
iterator = coll.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}// 123 456 Person{name='Jerry', age=20} false
}
3、使用 foreach 循环遍历集合元素
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0rKwLuCX-1638200694137)(C:\Users\吴金融\AppData\Roaming\Typora\typora-user-images\image-20211104170926303.png)]
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
public class ForTest {
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//for( 集合中元素的类型 局部变量 : 集合对象)
for(Object obj : coll){
System.out.println(obj);//123 456 Person{name='Jerry', age=20} Tom false
}
}
@Test
public void test2(){
int arr[] = new int[]{1,2,3,4,5,6};
for(int i :arr){
System.out.println(i);//1 2 3 4 5 6
}
}
@Test
public void test3(){
String[] arr = new String[]{"MM","MM","MM"};
//方式一:普通for赋值
for(int i = 0;i < arr.length;i++){
arr[i] = "GG";//这个可以使输出为GG
}
//方式二:增强for循环
for(String s : arr){
s = "GG";//这个不可以使输出为GG 因为这是新建String s 把arr赋值给s
}
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
}
}
五、Collection子接口
1、 List接口
鉴于Java中数组用来存储数据的局限性,我们通常使用List替代数组
List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据 序号存取容器中的元素。
JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector。
1、List实现类之一:ArrayList
ArrayList源码分析
1、jdk 7情况下的ArrayList
ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
这是空参开辟的源码
public ArrayList() {//空构造器 刚开始开辟10空间的数组
this(10);
}
public ArrayList(int initialCapacity) {//进来一个10
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
这是增添元素的源码
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
list.add(123);//elementData[0] = new Integer(123);
list.add(11);//如果此次的添加导致底层elementData数组容量不够,则扩容。
这是增添元素尺寸计算的代码
private void ensureCapacityInternal(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);//扩容代码
}
默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。
这是扩容的源码
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//右移 如10是1010 右移1位就是去掉右边一位 变成101 就是5
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
2、jdk 8中ArrayList的变化
ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
这是空参开辟的源码
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//刚开始空间为空
}
//下面是DEFAULTCAPACITY_EMPTY_ELEMENTDATA的源码定义
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
list.add(123);//第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]
这是增添元素的源码
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
//这是ensureCapacityInternal的源码
private void ensureCapacityInternal(int minCapacity) {//size + 1是下面的 minCapacity 应该是0 + 1 二 1+1
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {// DEFAULTCAPACITY_EMPTY_ELEMENTDATA刚开始是空
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//DEFAULT_CAPACITY 是static final = 10
}//所以这里会把10赋值给minCapacity
ensureExplicitCapacity(minCapacity);
}
//这是ensureExplicitCapacity的源码
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//刚开始是0 二 1
// overflow-conscious code
if (minCapacity - elementData.length > 0)//刚开始添加第一个元素时 elementData.length == 0
grow(minCapacity);//刚开始扩容10的空间
}
//这是grow的源码
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;//刚开始还是0 10
int newCapacity = oldCapacity + (oldCapacity >> 1); 10 + 10 >> 1 == 15
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);//造了一个10的数组
}
后续的添加和扩容操作与jdk 7 无异
jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象
的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。
2、List实现类之二:LinkList
双向链表,内部没有声明数组,而是定义了Node类型的first和last, 用于记录首末元素。同时,定义内部类Node,作为LinkedList中保存数据的基 本结构。Node除了保存数据,还定义了两个变量:
- prev变量记录前一个元素的位置
- next变量记录下一个元素的位置
LinkList源码分析
LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性,默认值为null
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
transient Node<E> first;
transient Node<E> last;
private static class Node<E> {
E item;//这就是存的元素
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {//内部的Node内部类
this.item = element;
this.next = next;
this.prev = prev;
}
}
list.add(123);//将123封装到Node中,创建了Node对象。
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;//首次就是null
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
3、List 实现类之三:Vector
Vector的源码分析
jdk7和jdk8中通过Vector()构造器创建对象时,底层都创建了长度为10的数组。
x在扩容方面,默认扩容为原来的数组长度的2倍。
4、List中操作集合元素的方法、
- void add(int index, Object ele):在index位置插入ele元素
- boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
- Object get(int index):获取指定index位置的元素、
@Test
public void test1(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
System.out.println(list);//[123, 456, AA, Person{name='Tom', age=12}, 456]
// void add(int index, Object ele):在index位置插入ele元素
list.add(1 , "BB");
System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456]
// boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1, 2, 3);
list.addAll(list1);
System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456, 1, 2, 3]
// Object get(int index):获取指定index位置的元素
System.out.println(list.get(2));//456
}
- int indexOf(Object obj):返回obj在集合中首次出现的位置
- int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
- Object remove(int index):移除指定index位置的元素,并返回此元素
- Object set(int index, Object ele):设置指定index位置的元素为ele
- List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
// int indexOf(Object obj):返回obj在集合中首次出现的位置
int index = list.indexOf(456);
System.out.println(index);//1
int index2 = list.indexOf(4562);
System.out.println(index2);//-1
// int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
System.out.println(list.lastIndexOf(456));//4
// Object remove(int index):移除指定index位置的元素,并返回此元素
Object obj = list.remove(0);
System.out.println(obj);//123
System.out.println(list);//[456, AA, Person{name='Tom', age=12}, 456]
// Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1,"CC");
System.out.println(list);//[456, CC, Person{name='Tom', age=12}, 456]
// List subList(int fromIndex, int toInd*//*ex):返回从fromIndex到toIndex位置的左闭右开的子集合,对本身集合不造成影响
List sublist = list.subList(2, 4);
System.out.println(sublist);//[Person{name='Tom', age=12}, 456]
}
总结:常用方法
- 增:add(Object obj)
- 删:remove(int index) / remove(Object obj)
- 改:set(int index, Object ele)
- 查:get(int index)
- 插:add(int index, Object ele)
- 长度:size()
- 遍历:① Iterator迭代器方式
② 增强for循环
③ 普通的循环
2、Set接口
1、Set实现类之一:HashSet
- 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值决定的。
- 不可重复性:保证添加的元素按照equals()判断时,不能返回true.即:相同的元素只能添加一个
- HashSet 不是线程安全的
- 集合元素可以是 null
- 对于存放在Set容器中的对象,对应的类一定要重写equals()和hashCode(Object obj)方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”。
- HashSet底层:数组+链表的结构。
- 底层也是数组,初始容量为16,当如果使用率超过0.75,(16*0.75=12) 就会扩大容量为原来的2倍。(16扩容为32,依次为64,128…等)
添加元素的过程
向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置),判断数组此位置上是否已经有元素:
- 如果此位置上没有其他元素,则元素a添加成功 —>情况1
- 如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的hash值
- 如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的hash值
- 如果hash值不相同,则元素a添加成功 —>情况2
- 如果hash值相同,进而需要调用元素a所在类的equals()方法
- equals()返回true,元素a添加失败
- equals()返回false,则元素a添加成功 —>情况2
对于添加成功的情况2和情况3而言:元素a 与已经存在指定索引位置上数据以链表的方式存储。
- jdk 7 :元素a放到数组中,指向原来的元素。
- jdk 8 :原来的元素在数组中,指向元素a
总结:七上八下
关于hashcode()方法
如果对于存放在Set容器中的对象,该对象没有重写hashcode()方法,则调用Object中的该方法,这个就是完全等于随机数
重写 hashCode() 方法的基本原则
- 在程序运行时,同一个对象多次调用 hashCode() 方法应该返回相同的值。(哈希值就是散列码)
- 当两个对象的 equals() 方法比较返回 true 时,这两个对象的 hashCode() 方法的返回值也应相等。
- 对象中用作 equals() 方法比较的 Field,都应该用来计算 hashCode 值。
2、Set实现类之二:LinkedHashSet
LinkedHashSet 是 HashSet 的子类
LinkedHashSet作为HashSet的子类,在添加数据的同时,每个数据还维护了两个引用,记录此数据前一个数据和后一个数据。
优点:对于频繁的遍历操作,LinkedHashSet效率高于HashSet
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a94rZdrd-1638200694142)(C:\Users\吴金融\AppData\Roaming\Typora\typora-user-images\image-20211105232118731.png)]
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置, 但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入 顺序保存的。
import org.junit.Test;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
public class SetTest {
@Test
public void test1(){//HashSet
Set set = new HashSet();
set.add(456);
set.add(123);
set.add("AA");
set.add("CC");
set.add(new User("Tom",12));
set.add(new User("Tom",12));
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test
public void test2(){//LinkedHashSet
Set set = new LinkedHashSet();
set.add(456);
set.add(123);
set.add("AA");
set.add("CC");
set.add(new User("Tom",12));
set.add(new User("Tom",12));
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
3、Set实现类之三:TreeSet
TreeSet 是 SortedSet 接口的实现类,TreeSet 可以确保集合元素处于排序状态。
TreeSet底层使用红黑树结构存储数据
向TreeSet中添加的数据,要求是相同类的对象。
两种排序方式:自然排序(实现Comparable接口) 和 定制排序(Comparator)
-
自然排序中,比较两个对象是否相同的标准为:compareTo()返回0.不再是equals().
- TreeSet类的add()方法中会把存入的对象提升为Comparable类型
- 调用对象的comparaTo方法和集合中的对象比较
- 根据comparaTo方法返回的结果进行存储
-
定制排序中,比较两个对象是否相同的标准为:compare()返回0.不再是equals().
- 创建TreeSet的时候可以制定一个Comparator
- 如果传入了Comparator的子类对象,那么TreeSet就会按照比较器的顺序排序
- add()方法内部会自动调用Comparator接口中的compare方法的第二个参数
- 利用int compare(T o1,T o2)方法,比较o1和o2的大小:如果方法返回正整数,则表 示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2。
两种排序方式区别:
- TreeSet构造函数什么都不传,默认按照类中Comparable的顺序(没有就报错ClassCastException)
- TreeSet如果传入Comparator,默认按照Comparator
import org.junit.Test;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetTest {
@Test
public void test1(){//自然排序
TreeSet set = new TreeSet();
//失败:不能添加不同类的对象
// set.add(123);
// set.add(456);
// set.add("AA");
// set.add(new User("Tom",12));
//举例一:
// set.add(34);
// set.add(-34);
// set.add(43);
// set.add(11);
// set.add(8);
//举例二:
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
set.add(new User("Jim",2));
set.add(new User("Mike",65));
set.add(new User("Jack",33));
set.add(new User("Jack",56));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
/*
User{name='Jack', age=33}
User{name='Jack', age=56}
User{name='Jerry', age=32}
User{name='Jim', age=2}
User{name='Mike', age=65}
User{name='Tom', age=12}
*/
}
@Test
public void test2(){//定制排序
Comparator com = new Comparator() {
//按照年龄从小到大排列
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
return Integer.compare(u1.getAge(),u2.getAge());
}else{
throw new RuntimeException("输入的数据类型不匹配");
}
}
};
TreeSet set = new TreeSet(com);
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
set.add(new User("Jim",2));
set.add(new User("Mike",65));
set.add(new User("Mary",33));
set.add(new User("Jack",33));
set.add(new User("Jack",56));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
public class User implements Comparable {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
//按照姓名、年龄从小到大排
@Override
public int compareTo(Object o) {
if(o instanceof User){
User user = (User)o;
// return this.name.compareTo(user.name);
int compara = this.name.compareTo(user.name);
if(compara != 0){
return compara;
}else{
return Integer.compare(this.age , user.age);
}
}else{
throw new RuntimeException("输入类型不匹配");
}
}
}
4、Set的两个练习
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
/**
* @author shkstart
* @create 2019 上午 9:36
*/
public class CollectionTest {
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(343);
coll.add(343);
coll.forEach(System.out::println);
}
//练习:在List内去除重复数字值,要求尽量简单
public static List duplicateList(List list) {
HashSet set = new HashSet();
set.addAll(list);
return new ArrayList(set);
}
@Test
public void test2(){
List list = new ArrayList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(2));
list.add(new Integer(4));
list.add(new Integer(4));
List list2 = duplicateList(list);
for (Object integer : list2) {
System.out.println(integer);
}
}
@Test
public void test3(){
HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
System.out.println(set);
p1.name = "CC";
set.remove(p1);//这个删除找的hash值是cc时候的 和aa时候不一样所以删不掉
System.out.println(set);//两个 一个1002 bb 一个1001 cc
set.add(new Person(1001,"CC"));//这个是拿cc算的hash值 所以能加进来
System.out.println(set);//三个 一个1002 bb 两个1001 cc
set.add(new Person(1001,"AA"));//hash相同但是equals时候还是可以存
System.out.println(set);//链表吧aacc存了 4个
}
}
六、Map接口
1、Map的实现类的结构
-
Map:双列数据,存储key-value对的数据 —类似于高中的函数:y = f(x)
-
HashMap:作为Map的主要实现类;线程不安全的,效率高;存储null的key和value
-
LinkedHashMap:保证在遍历map元素时,可以按照添加的顺序实现遍历。
原因:在原有的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素。对于频繁的遍历操作,此类执行效率高于HashMap。
-
-
TreeMap:保证按照添加的key-value对进行排序,实现排序遍历。此时考虑key的自然排序或定制排序底层使用红黑树
-
Hashtable:作为古老的实现类;线程安全的,效率低;不能存储null的key和value
- Properties:常用来处理配置文件。key和value都是String类型
-
Map结构理解
Map中的key:无序的、不可重复的,使用Set存储所有的key —> key所在的类要重写equals()和hashCode() (以HashMap为例)
Map中的value:无序的、可重复的,使用Collection存储所有的value —>value所在的类要重写equals()
一个键值对:key-value构成了一个Entry对象。
Map中的entry:无序的、不可重复的,使用Set存储所有的entry
2、HashMap的底层实现原理
jdk7中
-
HashMap map = new HashMap():
在实例化以后,底层创建了长度是16的一维数组Entry[] table。、public HashMap() { this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);//16 0.75 }
public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); // Find a power of 2 >= initialCapacity int capacity = 1; while (capacity < initialCapacity) capacity <<= 1;//2 4 8 16 this.loadFactor = loadFactor;//loadFactor就是加载因子 threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//扩容时候的临界值 table = new Entry[capacity];//造了一个长度16的数组 useAltHashing = sun.misc.VM.isBooted() && (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD); init(); }
…可能已经执行过多次put…
-
map.put(key1,value1);//添加元素
-
首先,调用key1所在类的hashCode()计算key1哈希值,此哈希值经过某种算法计算以后,得到在Entry数组中的存放位置。
如果此位置上的数据为空,此时的key1-value1添加成功。 ----情况1 -
如果此位置上的数据不为空,(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据
的哈希值:-
如果key1的哈希值与已经存在的数据的哈希值都不相同,此时key1-value1添加成功。----情况2
-
如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同,继续比较:调用key1所在类的equals(key2)方法,比较:
-
如果equals()返回false:此时key1-value1添加成功。----情况3
-
如果equals()返回true:使用value1替换value2。
-
-
-
补充:关于情况2和情况3:此时key1-value1和原来的数据以链表的方式存储。
在不断的添加过程中,会涉及到扩容问题,当超出临界值(且要存放的位置非空)时,扩容。默认的扩容方式:扩容为原来容量的2倍,并将原有的数据复制过来。
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);//通过这个获取到hash值在数组对应的位置
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);//添加元素
return null;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);//扩容之前的2倍
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);//计算对应哈希值在数组的位置
}
createEntry(hash, key, value, bucketIndex);
}
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
jdk8相比较jdk7在底层实现方面的不同
- new HashMap():底层没有创建一个长度为16的数组
- jdk 8底层的数组是:Node[],而非Entry[]
- 首次调用put()方法时,底层创建长度为16的数组
- jdk7底层结构只有:数组+链表。jdk8中底层结构:数组+链表+红黑树。
4.1 形成链表时,七上八下(jdk7:新的元素指向旧的元素。jdk8:旧的元素指向新的元素)
4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时,此时此索引位置上的所数据改为使用红黑树存储。
3、Map中定义的方法
- Object put(Object key,Object value):将指定key-value添加到(或修改)当前map对象中
- void putAll(Map m):将m中的所有key-value对存放到当前map中
- Object remove(Object key):移除指定key的key-value对,并返回value
- void clear():清空当前map中的所有数据
@Test
public void test3(){
Map map = new HashMap();
//添加
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
//修改
map.put("AA",87); // 因为可以、是aa时候已经有值了 所以找到key修改他的数据
System.out.println(map);//{AA=87, BB=56, 45=123}
Map map1 = new HashMap();
map1.put("CC",123);
map1.put("DD",123);
map.putAll(map1);
System.out.println(map);//{AA=87, BB=56, CC=123, DD=123, 45=123}
//remove(Object key)
Object value = map.remove("CC");
System.out.println(value);//123
System.out.println(map);//{AA=87, BB=56, DD=123, 45=123}
//clear()
map.clear();//与map = null操作不同
System.out.println(map.size());//0
System.out.println(map);//{}
}
- Set keySet():返回所有key构成的Set集合
- Collection values():返回所有value构成的Collection集合
- Set entrySet():返回所有key-value对构成的Set集合
@Test
public void test5(){
Map map = new HashMap();
map.put("AA",123);
map.put(45,1234);
map.put("BB",56);
//遍历所有的key集:keySet()
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println();
//遍历所有的value集:values()
Collection values = map.values();
for(Object obj : values){
System.out.println(obj);
}
System.out.println();
//遍历所有的key-value
//方式一:entrySet()
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
//entrySet集合中的元素都是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "---->" + entry.getValue());
}
/*
AA---->123
BB---->56
45---->1234*/
System.out.println();
//方式二:
Set keySet = map.keySet();
Iterator iterator2 = keySet.iterator();
while(iterator2.hasNext()){
Object key = iterator2.next();
Object value = map.get(key);
System.out.println(key + "=====" + value);
}
}
- Object get(Object key):获取指定key对应的value
- boolean containsKey(Object key):是否包含指定的key
- boolean containsValue(Object value):是否包含指定的value
- int size():返回map中key-value对的个数
- boolean isEmpty():判断当前map是否为空
- boolean equals(Object obj):判断当前map和参数对象obj是否相等
七、Collection工具类常用方法
reverse(List):反转 List 中元素的顺序
shuffle(List):对 List 集合元素进行随机排序
sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List,int, int):将指定 list 集合中的 i 处元素和 j 处元素进行交换
Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
Object max(Collection,Comparator):根据 Comparator 指定的顺序,返回给定集合中的最大元素
Object min(Collection)
Object min(Collection,Comparator)
int frequency(Collection,Object):返回指定集合中指定元素的出现次数
void copy(List dest,List src):将src中的内容复制到dest中
boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换 List 对象的所有旧值
@Test
public void test3(){
List list = new ArrayList();
list.add(123);
list.add(43);
list.add(765);
list.add(765);
list.add(765);
list.add(-97);
list.add(0);
System.out.println(list);
Collections.reverse(list);
Collections.shuffle(list);
Collections.sort(list);
Collections.swap(list,1,2);
int frequency = Collections.frequency(list, 123);
System.out.println(list);
System.out.println(frequency);
}
@Test
public void test2(){
List list = new ArrayList();
list.add(123);
list.add(43);
list.add(765);
list.add(-97);
list.add(0);
//报异常:IndexOutOfBoundsException("Source does not fit in dest")
// List dest = new ArrayList();
// Collections.copy(dest,list);
//正确的:
List dest = Arrays.asList(new Object[list.size()]);
System.out.println(dest.size());//list.size();
Collections.copy(dest,list);
System.out.println(dest);
/*
Collections 类中提供了多个 synchronizedXxx() 方法,
该方法可使将指定集合包装成线程同步的集合,从而可以解决
多线程并发访问集合时的线程安全问题
*/
//返回的list1即为线程安全的List
List list1 = Collections.synchronizedList(list);
}