JavaSE集合
Java集合框架概述
集合框架的概述
集合，数组都是对多个数据进行存储操作的结构，简称 Java容器。
说明：此时的存储，主要指的是内存方面的存储，不涉及到持久化的存储(例，.txt .jpg 数据库)
数组在存储多个数据方面的特点：
- 一旦初始化以后，其长度就确定了
- 数组一旦定义好，其元素的类型也就确定，我们只能操作指定类型的数据。比如：String[] arr，int[] arr1,
数组在存储多个数据方面的缺点：
- 一旦初始化以后，其长度就不可更改
- 数组中提供的方法非常有限，对于添加，删除，插入数据等操作，非常不便，同时效率不高
- 获取数组中实际元素的个数的需求，数组没有线程的属性或方法可用
- 数组存储数据的特点：有序，可重复。对于无序，不可重复的需求，不能满足
集合框架
|----- Colllection 接口：单列集合，用来存储一个一个的对象
|-----List 接口：存储有序的，可重复的数据 "动态"数组
|----ArrayList，LinkedList，Vector
|-----Set接口：存储无序的，不可重复的数据 高中的"集合"
|----HashSet，LinkedHashSet，TreeSet
|-----Map接口：双列集合，用来存储一对( key - value ) 一对的数据 高中的函数 y = f(x)
|----HashMap，LinkedHashMap，TreeMap，Hashtable，Properities
Colllection 接口的 toString()
AbstractCollection抽象类种重写 toString() 方法
public String toString() {
Iterator<E> it = iterator();
if (! it.hasNext())
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
E e = it.next();
sb.append(e == this ? "(this Collection)" : e);
if (! it.hasNext())
return sb.append(']').toString();
sb.append(',').append(' ');
}
}
Collection接口方法
注：向 Collection接口的实现类的对象中添加数据 obj时，要求 obj所在类要重写 equlas()
package com.atguigu.java;
import org.junit.Test;
import java.util.*;
public class CollectionTest {
@Test
public void test1(){
Collection coll = new ArrayList();
//1 add(object e):将元素e添加到集合 coll中
coll.add("AA");
coll.add("BB");
coll.add(123);
coll.add(new Date());
//2 size():获取添加的元素个数
System.out.println(coll.size());//4
//3 addAll():将coll1集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add("CC");
System.out.println(coll.size());//6
System.out.println(coll);//
//4 clear():清空集合元素
coll.clear();
//5 isEmpty():判断当前集合是否为空
System.out.println(coll.isEmpty());//true
}
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(new Person("Tom",18));
//6 contains(Object obj):判断当前集合中是否包含 obj
//我们在判断时,会调用 obj对象所在类的 equals()
System.out.println(coll.contains(123));//true
System.out.println(coll.contains("Tom"));//true String中重写了 equals()方法
//Person中需要重写 equals()方法才能比较内容,否则,是按照 Object类中比较地址值
System.out.println(coll.contains(new Person("Tom",18)));//true
//7 containsAll(Collection coll1):判断形参 coll1中所有元素是否都存在于当前集合中
Collection coll1 = Arrays.asList(123,456);
System.out.println(coll.contains(coll1));//true
}
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(new Person("Tom",18));
coll.add(false);
//8 remove(Object obj):从当前集合中移除 obj元素
coll.remove(123);
System.out.println(coll);//[456, Tom, Person{name='Tom', age=18}, false]
//9 removeAll(Collection coll1):差集：从当前集合中移除 coll1中的所有元素
Collection coll1 = Arrays.asList(456,true,false);
coll.removeAll(coll1);
System.out.println(coll);//[Tom, Person{name='Tom', age=18}]
}
@Test
public void test4(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(new Person("Tom",18));
coll.add(false);
Collection coll1 = Arrays.asList(456,true,false);
//10 retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集,并返回给当前集合
coll.retainAll(coll1);
System.out.println(coll);//[456, false]
//11 equals(Object obj):要想返回 true,需要当前集合和形参集合的元素都相同
Collection coll2 = Arrays.asList(456,true,false,123);
Collection coll3 = Arrays.asList(456,true,false,123);
System.out.println(coll2.equals(coll3));//true
}
@Test
public void test5(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(new Person("Tom",18));
coll.add(false);
//12 hashCode()；返回当前对象的哈希值
System.out.println(coll.hashCode());
//13 集合 ---> 数组：toArray()
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//拓展：数组 ----> 集合:调用 Arrays类的静态方法 asList()
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);
//14 iterator():返回 Iterator接口中的实例,用于遍历集合元素,放在方面讲
}
}
Iterator迭代器接口
集合元素的遍历操作，使用 Iterator接口
- 内部的方法：hasNext() 和 next()
- 集合对象每次调用iterator() 方法之前都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前
- 内部定义了 remove()，可以在遍历的时候，删除集合中的元素，此方法不同于集合直接调用 remove()
package com.atguigu.java;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorTest {
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(new Person("Tom",18));
coll.add(false);
Iterator iterator = coll.iterator();
//不推荐 ：遍历元素
// for (int i = 0; i < coll.size(); i++) {
// System.out.println(iterator.next());
// }
//推荐使用
//hasNext():判断是否还有下一个元素
while (iterator.hasNext()){
//next():指针下移,将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
}
//测试 Iterator中的 remove()方法
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(new Person("Tom",18));
coll.add(false);
Iterator iterator = coll.iterator();
//删除集合中的 "Tom"
//如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法
// 再调用remove都会报IllegalStateException。
while(iterator.hasNext()){
Object obj = iterator.next();
if("Tom".equals(obj)){
iterator.remove();
}
}
//遍历集合
Iterator iterator1 = coll.iterator();
while(iterator1.hasNext()){
System.out.println(iterator1.next());
}
}
}
Java 5.0 提供了 foreach 循环迭代访问 Collection和数组。遍历集合的底层调用Iterator完成操作
package com.atguigu.java;
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 String("Tom"));
coll.add(new Person("Tom",18));
coll.add(false);
//for(集合元素的类型 局部变量 : 集合对象){}
//内部仍然调用了 迭代器
for (Object obj :
coll) {
System.out.println(obj);
}
}
@Test
public void test2(){
int[] arr = new int[]{1,2,3,4,5,6};
//for(数组元素的类型 局部变量 : 数组对象){}
for(int i : arr){
System.out.println(i);
}
}
@Test
public void test3(){
String[] arr = new String[]{"MM","MM","MM"};
//方式一;普通 for循环
// GG GG GG
// for (int i = 0; i < arr.length; i++) {
// arr[i] = "GG";
// }
//方式二：增强 for循环
// MM MM MM
for(String s : arr){
s = "GG";
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
Collection子接口一：List
List接口的结构框架
|----- Colllection 接口：单列集合，用来存储一个一个的对象
|-----List 接口：存储有序的，可重复的数据 "动态"数组
|----ArrayList
|----LinkedList
|----Vector
面试题：ArrayList，LinkedList，Vector 三者的异同？
同 ：三个类都是实现了 List接口，存储数据的特点相同：存储有序的，可重复的数据
异：
- ArrayList ：作为 List接口的主要实现类；线程不安全的，效率高；底层使用 Object[] elementData 存储
- LinkedList：对于频繁的插入，删除操作，使用此类效率比 ArrayList高；底层使用双向链表存储
- Vector ：作为 List接口的古老实现类；线程安全的，效率低；底层使用 Object[] elementData 存储
ArrayList 的源码分析
jdk 7.0 情况下：
ArrayList list = new ArrayList(); // 底层创建了长度是10的 Object[]数组 elementData
list.add(123);//elementData[0] = new Integer(123);
...
list.add(11);//如果此次添加导致底层 elementData 数组容量不够,则扩容
//默认情况下,扩容为原来容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中
//结论:建议开发中使用带参的构造器,ArrayList list = new ArrayList(int capacity);
jdk 8.0 情况下：
ArrayList list = new ArrayList(); // 底层Object[]数组 elementData初始化为{},并没有创建长度为10的数组
list.add(123);//第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到 elementData中
...
//后续操作与 jdk 7.0无异
小结
jdk 7.0中的 ArrayList的对象创建类似于单例的饿汉式，而 jdk 8.0中的 ArrayList的对象创建类似于单例的懒汉式，延迟了数组的创建，节省内存
List接口方法
List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法。
void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
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位置的子集合
package com.atguigu.java;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ListTest {
@Test
public void test1(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add(false);
list.add(new Person("mary",15));
list.add(456);
System.out.println(list);
//[123, 456, false, Person{name='mary', age=15}, 456]
//void add(int index, Object ele):在index位置插入ele元素
list.add(1,"BB");
System.out.println(list);
//[123, BB, 456, false, Person{name='mary', age=15}, 456]
//boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1, 2, 3);
list.addAll(list1);
System.out.println(list.size());//9
//Object get(int index):获取指定index位置的元素
System.out.println(list.get(2));//456
}
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add(false);
list.add(new Person("mary",15));
list.add(456);
//int indexOf(Object obj):返回obj在集合中首次出现的位置,如果不存在,返回 -1
int index = list.indexOf(456);
System.out.println(index);//1
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
int index1 = list.lastIndexOf(456);
System.out.println(index1);//4
//Object remove(int index):移除指定index位置的元素，并返回此元素
Object obj = list.remove(0);
System.out.println(obj);//123
System.out.println(list);//[456, false, Person{name='mary', age=15}, 456]
//Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1,"CC");
System.out.println(list);//[456, CC, Person{name='mary', age=15}, 456]
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置左闭右开的子集合
List subList = list.subList(2, 4);
System.out.println(subList);//[Person{name='mary', age=15}, 456]
}
@Test
public void test3(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add(false);
//方式一： Iterator迭代器
Iterator iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("******************");
//方式二：增强for循环
for (Object obj : list) {
System.out.println(obj);
}
System.out.println("******************");
//方式三：for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
总结：常用方法
- 增：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循环，for循环
练习题
package com.atguigu.java;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class ListTest {
@Test
public void testListRemove() {
//区分list中的 remove方法
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
updateList(list);
System.out.println(list);//
}
private static void updateList(List list) {
list.remove(2);
}
}
Collection子接口二：Set
Set接口的结构框架
|----- Colllection 接口：单列集合，用来存储一个一个的对象
|-----Set接口：存储无序的，不可重复的数据 高中的"集合"
|----HashSet：作为 set 接口的主要实现类;线程不安全的;可以存储 null 值
|----LinkedHashSet：作为 HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历
|----TreeSet：可以按照添加对象的指定属性,进行排序
Set接口中没有额外定义新的方法，使用的都是 Collection 中声明的方法。
要求：向 Set 中添加的数据，其所在的类一定要重写 hashCode() 和 equals()
要求：重写的 hashCode() 和 equals() 尽可能保持一致性，相等的对象必须具有相等的散列码 (快捷方式生成)
Set接口的说明：HashSet为例
一 Set:存储无序的,不可重复的数据，以HashSet为例说明：
- 无序性：不等于随机性,存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值决定的
- 不可重复性：保证添加的元素按照 equals()判断时,不能返回 true,即：相同的元素只能添加一个
二 添加元素的过程，以HashSet为例说明：
向HashSet 中添加元素 a，首先调用元素 a 所在类的hashCode() 方法，计算元素 a 的哈希值
此哈希值通过某种算法计算出在 HashSet 底层数组中的存放位置 (即为索引位置) ，判断此位置上是否已经存在元素
如果此位置上没有其他元素，则元素 a 添加成功。 情况一
如果此位置上有其他元素 b (或以链表形式存在的多个元素) ，则比较 元素a 和 元素b 的哈希值：
如果 哈希值不相同，则元素a 添加成功 情况二
如果 哈希值相同，进而需要调用元素 a 所在类的 equals() 方法：
equals() 返回 true，元素 a 添加失败
equals() 返回 false，元素 a 添加成功 情况三
注：对于添加成功的情况2 和 情况3 而言，元素 a 与已经存在指定索引位置上的数据 以链表的形式存储
对于 jdk 7.0：元素a 放在数组中，指向其他的元素，对于 jdk8.0：原来的元素放在数组中，指向元素 a ，总结：七上八下
HashSet底层：数组 + 链表的结构
package com.atguigu.java;
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(){
Set set = new HashSet();
set.add(456);
set.add(123);
set.add("AA");
set.add("CC");
set.add(new Person("mary",13));
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
LinkedHashSet的使用
LinkedHashSet作为 HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个数据和后一个数据
优点：对于频繁的遍历操作，LinkedHashSet效率高于 HashSet
package com.atguigu.java;
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 test2(){
Set set = new LinkedHashSet();
set.add(456);
set.add(123);
set.add("AA");
set.add("CC");
set.add(new Person("mary",13));
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
TreeSet
向 TreeSet 中添加的数据，要求是相同类的对象
两种排序方式：自然排序 (实现Comparable接口) 和 定制排序 (Comparator)
自然排序中，比较两个对象是否相同的标准为：compareTo() 返回 0，不再是 equals()
定制排序中，比较两个对象是否相同的标准为：compare() 返回 0，不再是 equals()
package com.atguigu.java;
import org.junit.Test;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetTest {
@Test
public void test1(){
TreeSet tree = new TreeSet();
//失败：不能采用这种方式添加
// tree.add(123);
// tree.add(456);
// tree.add(true);
// tree.add(new Person("Tom",12));
//整形数据测试：
// tree.add(34);
// tree.add(-34);
// tree.add(43);
// tree.add(22);
// tree.add(8);
//自定义类测试：
tree.add(new Person("Tom",12));
tree.add(new Person("Mary",23));
tree.add(new Person("Jack",30));
tree.add(new Person("Mike",18));
tree.add(new Person("Jack",48));
Iterator iterator = tree.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test
public void test2(){
Comparator com = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Person && o2 instanceof Person){
Person p1 = (Person)o1;
Person p2 = (Person)o2;
return Integer.compare(p1.getAge(),p2.getAge());
}else{
throw new RuntimeException("输出数据类型不匹配！");
}
}
};
TreeSet tree = new TreeSet(com);
tree.add(new Person("Tom",12));
tree.add(new Person("Mary",23));
tree.add(new Person("Jack",30));
tree.add(new Person("Mike",18));
tree.add(new Person("Jack",48));
Iterator iterator = tree.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
package com.atguigu.java;
import java.util.Objects;
public class Person implements Comparable{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
System.out.println("Person equals()");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
//按照姓名从小到大排列
@Override
public int compareTo(Object o) {
if(o instanceof Person){
Person p = (Person)o;
//return this.name.compareTo(p.name);
int compareTo = this.name.compareTo(p.name);
if(compareTo != 0){
return compareTo;
}else{
return Integer.compare(this.age,p.age);
}
}else{
throw new RuntimeException("输入数据不匹配！");
}
}
}
Set课后练习题
练习：在List内去除重复数字值，要求尽量简单
package com.atguigu.java;
import org.junit.Test;
import java.util.*;
public class TreeSetTest {
public static List duplicateList(List list) {
HashSet set = new HashSet();
set.addAll(list);
return new ArrayList(set);
}
@Test
public void test3(){
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);
}
}
}
package com.atguigu.java;
import org.junit.Test;
import java.util.*;
public class TreeSetTest {
@Test
public void test4(){
HashSet set = new HashSet();
User p1 = new User(1001,"AA");
User p2 = new User(1002,"BB");
set.add(p1);
set.add(p2);
System.out.println(set);
//[User{id=1002, name='BB'}, User{id=1001, name='AA'}]
p1.name = "CC";
set.remove(p1);
System.out.println(set);
//[User{id=1002, name='BB'}, User{id=1001, name='CC'}]
set.add(new User(1001,"CC"));
System.out.println(set);
//[User{id=1002, name='BB'}, User{id=1001, name='CC'}, User{id=1001, name='CC'}]
set.add(new User(1001,"AA"));
System.out.println(set);
//[User{id=1002, name='BB'}, User{id=1001, name='CC'}, User{id=1001, name='CC'}, User{id=1001, name='AA'}]
}
}
Map接口
Map实现类的结构
|----Map：双列数据，存储 key-value 对的数据。 ----类似于高中的函数：y = f(x)
|----HashMap:作为 Map 的主要实现类;线程不安全的,效率高;存储 null 的 key 和 vlaue
|----LinkedHashMap:保证遍历 Map 元素时,可以按照添加的顺序实现遍历
原因：在原有的 HashMap 底层结构基础上,添加了一对指针,指向前一个和后一个元素
对于频繁的遍历操作,此类执行效率高于 HashMap
|----TreeMap: 保证按照添加的 key-value 对进行排序,实现排序便利,此时考虑 key 的自然排序或者定制排序
底层使用红黑树
|----Hashtable:作为 Map 的古老实现类;线程安全的,效率低;不能存储 null 的 key 和 vlaue
|----Properties:常用来处理配置文件, key 和 value 都是 String 类型
HashMap 的底层：数组 + 链表 (jdk 7.0及以前) 数组 + 链表 + 红黑树 (jdk 8.0)
Map结构的理解
Map 中的 key ：无序的，不可重复的，使用 Set 存储所有的 key ------ key 所在的类需要重写 equals() 和 hashCode() ( 以 HashMap 为例)
Map 中的 value ：无序的，可重复的，使用 Collection 存储所有的 value ------ value 所在的类需要重写 equals()
一个键值对：key - value 构成了一个 Entry 对象
Map 中的 entry ：无序的，不可重复的，使用 Set 存储所有的 entry
HashMap 的底层实现原理:以jdk 7.0 为例
HashMap map = new HashMap();
在实例化以后,底层创建了长度是16的一维数组Entry[] table
...可能已经执行过多次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倍,并将原有的数据复制过来
jdk 8.0 相较于 jdk 7.0 在底层实现方面的不同：
- new HashMap()：底层没有创建一个长度是16的数组
- jdk 8.0 底层的数组是：Node[ ] ，而非 Entry[ ]
- 首次调用 put() 方法时，底层创建长度为16的数组
- HashMap 的底层：数组 + 链表 (jdk 7.0及以前) 数组 + 链表 + 红黑树 (jdk 8.0)
当数据的某一个索引位置上的元素一链表的形式存在的数据个数 > 8 且 当前数组的长度 > 64，此时索引位置上的所有数据改为使用红黑树存储
jdk 8.0 HashMap底层源码的常见参数：
- DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
- DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
- threshold：扩容的临界值，=容量*填充因子 16 * 0.75 = 12
- TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树：8
- MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量：64
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中的所有数据
package com.atguigu.java;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
public class MapTest {
@Test
public void test1(){
Map map = new HashMap();
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
//修改
map.put("AA",87);
System.out.println(map);//{AA=87, BB=56, 45=123}
Map map1 = new HashMap();
map1.put("CC",64);
map1.put("DD",97);
map.putAll(map1);
System.out.println(map);//{AA=87, BB=56, CC=64, DD=97, 45=123}
//remove(Object key):移除
Object value = map.remove("DD");
System.out.println(value);//97
System.out.println(map);//{AA=87, BB=56, CC=64, 45=123}
//clear()
map.clear();// 与 map = null 不同
System.out.println(map.size());//0
System.out.println(map);//{}
}
}
元素查询的操作：
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是否相等
package com.atguigu.java;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
public class MapTest {
@Test
public void test2(){
Map map = new HashMap();
map.put("AA",123);
map.put(45,123);
map.put("BB",56);
//Object get(Object key)
System.out.println(map.get(45));//123
//containsKey(Object key)
System.out.println(map.containsKey("AA"));//true
//containsValue(Object value)
System.out.println(map.containsValue(123));//true
map.clear();
//boolean isEmpty()
System.out.println(map.isEmpty());//true
}
}
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合
package com.atguigu.java;
import org.junit.Test;
import java.util.*;
public class MapTest {
@Test
public void test3(){
Map map = new HashMap();
map.put("AA",123);
map.put(45,123);
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(values);
}
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());
}
//方式二:
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);
}
//方式三：使用增强fro循环
Map<String,Integer> map = new HashMap();
map.put("AA",123);
map.put("BB",56);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + "--->" + entry.getValue());
}
}
}
TreeMap 中添加 key-value ，要求 key 必须是由同一个类创造的对象。
因为要按照 key 进行排序： 自然排序，定制排序
Collections工具类
Collections ：操作 Set、List 和 Map 等集合的工具类
Collections中的常用静态方法
排序操作：
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 对象的所有旧值
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题
扫一扫
453
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
