集合框架
概述
集合、数组都是对多个数据进行存储操作的结构,简称Java容器。此时的存储,主要指的是内存层面的存储,不涉及到持久化的存储。(.txt,.jpg,.avi,数据库中的存储)
数组存储多个数据的特点
- 数组初始化以后,长度就确定了
- 数组声明的类型,就决定了进行元素初始化时的类型
数组存储多个数据的缺点
- 数组初始化以后,长度就不可变了,不便于扩展;
- 数组中提供的属性和方法少,不便于进行添加、删除、插入等操作, 且效率不高。同时无法直接获取存储元素的个数
- 数组存储的数据是有序的、可以重复的。对于无序、不可重复的需求,不能满足。
Java集合类
Java 集合可分为 Collection 和 Map 两种体系
Collection接口: 单列集合,用来存储一个一个的对象。
- List: 元素有序、可重复的集合。"动态"数组
- ArrayList、LinkedList、Vector
- Set: 元素无序、不可重复的集合。
- HashSet、LinkedHashSet、TreeSet
Map接口: 双列数据,保存具有映射关系“ key-value对”的集合
- HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
Collection接口
集合按照其存储结构可以分为两大类,分别是单列集合java.util.Collection
和双列集合java.util.Map
Collection 接口是 List、 Set 和 Queue 接口的父接口,该接口里定义的方法既可用于操作 Set 集合,也可用于操作 List 和 Queue 集合。 JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如: Set和List)实现。
常用方法
add(object e):将元素e 添加到集合中;
addAll(Collection coll): 将coll集合中的元素添加到当前的集合中;
size(): 获取集合元素的个数;
clear(): 清空集合元素;
isEmpty: 判断当前集合是否为空;
contains(Object e): 判断当前集合中是否包含e;
containsAll(Collection coll):判断形参coll中所有元素是否都存在于当前集合中;
remove(Object obj): 从当前集合中移除obj元素
removeAll(Collection coll1):从当前集合中移除coll1中所有的元素
retainAll(Collection coll1):交集,获取当前集合和coll1集合的交集,并返回给当前的集合;
equals(Object obj): 要想返回true,需要当前集合和形参集合的元素都相同;
hashCode():返回当前对象的哈希值
toArray(): 集合-->数组;
iterator(): 返回迭代器对象,用于集合遍历
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("bb");
coll.add(new String("JavaEE"));
coll.add(new Date());
coll.add(new Person("joey",19));
System.out.println(coll.size());//4
System.out.println(coll);//[123, bb, JavaEE, Mon May 06 22:03:29 CST 2019]
}
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("bb");
coll.add(new String("JavaEE"));
coll.add(new Date());
coll.add(new Person("joey",19));
Collection coll1 = new ArrayList();
coll1.add("AAA");
coll1.addAll(coll);
System.out.println(coll1);//[AAA, 123, bb, JavaEE, Mon May 06 22:04:54 CST 2019]
coll.clear(); // 清空集合元素
System.out.println(coll.size()); //0
System.out.println(coll.isEmpty()); // true
}
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("bb");
coll.add(new String("JavaEE"));
coll.add(new Date());
coll.add(new Person("joey",19));
System.out.println(coll.contains("bb"));//true
System.out.println(coll.contains(new String("JavaEE") ));//true
Collection coll2 = Arrays.asList("bb","java");
coll.removeAll(coll2);
System.out.println(coll);
}
public static void test4(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("bb");
coll.add(new String("JavaEE"));
coll.add(new Date());
coll.add(false);
//
// Collection coll2 = Arrays.asList(123,456,789);
// coll.retainAll(coll2);
// System.out.println(coll);//[123]
Collection coll1 = new ArrayList();
coll1.add(123);
coll1.add("bb");
coll1.add(new String("JavaEE"));
coll1.add(new Date());
coll1.add(false);
System.out.println(coll.equals(coll1));//true
System.out.println(coll.hashCode());//315007673
}
public static void test5(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("bb");
coll.add(new String("JavaEE"));
coll.add(new Date());
coll.add(false);
// 将集合转换成数组,遍历输出;
Object[] arr = coll.toArray();
for(int i = 0; i< arr.length;i++){
System.out.println(arr[i]);
}
}
}
class Person{
private String name;
private int age;
Person(){
}
Person(String name,int age){
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
@Override
public boolean equals(Object obj) {
return super.equals(obj);
}
}
Collection接口中声明的方法的测试:
向Collection接口的实现类的对象中添加数据obj时,要求obj所在类要重写equals()
package collectiondemo;
import java.util.*;
public class CollectionTest {
public static void main(String[] args) {
test2();
}
public static void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("bb");
coll.add(new String("JavaEE"));
coll.add(new Date());
coll.add(new Person("Tom",23));
System.out.println(coll.contains(new Person("Tom", 23)));
}
}
class Person{
private String name;
private int age;
Person(){
}
Person(String name,int age){
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
//不重写本方法默认对比的是对象内存地址
//所以要在方法里面重写方法
@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 hashCode() {
// return Objects.hash(name, age);
// }
}
扩展:数组--》集合:调用Arrays类的静态方法asList()
// 数组- 集合
List<String> list = Arrays.asList(new String[]{"aa", "bb", "cc"});
System.out.println(list);//[aa, bb, cc]
List arr1 = Arrays.asList(new Integer[]{123,233});
System.out.println(arr1.size());//2
Iterator迭代器接口
作用:遍历集合中的元素
用法:
Iterator iterator = coll.iterator();//定义了一个迭代器,默认游标都在集合的第一个元素之前。
while(iterator.hasNext()){//hasNext():判断是否还有下一个元素
System.out.println(iterator.next());//next():1.指针下移;2.将下移以后集合位置上的元素返回;
}
程序开发中,经常需要遍历集合中的所有元素。针对这种需求,JDK专门提供了一个接口java.util.Iterator
集合内部的遍历操作
-
两个方法: hasNext() 和next()
-
集合对象每次调用Iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前;
hasNext():判断集合位置是否还有下一个元素 next():1.指针下移;2.将下移以后集合位置上的元素返回;
-
内部定义了remove(),可以在遍历的时候,删除集合中的元素。此方法不同于集合直接调用remove()。
-
如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法,再调用remove都会报IllegalStateException
举例:
package collectiondemo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
public class IteratorDemo {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add(123);
coll.add("bb");
coll.add(new String("JavaEE"));
coll.add(new Date());
coll.add(false);
Iterator iterator = coll.iterator();
// 方式一:报异常
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
//
// System.out.println(iterator.next());//NoSuchElementException
// 方式二:不推荐
// for(int i = 0;i<coll.size();i++){
// System.out.println(iterator.next());
// }
// 方式三:推荐
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
常见的错误方式:
// 错误方式一:跳着输出;报错NoSuchElementException
while(iterator.next()!=null){
System.out.println(iterator.next());
}
//bb
//Wed May 08 09:37:42 CST 2019
// 错误方式二:死循环,不断打印123;集合对象每次调用Iterator()方法都得到一个全新的迭代器对象,
while(coll.iterator().hasNext()){
System.out.println(coll.iterator().next());
}
remove方法:
public static void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("bb");
coll.add(new String("JavaEE"));
coll.add(new Date());
coll.add(false);
Iterator iterator = coll.iterator();
// 删除集合中的"JavaEE"
while(iterator.hasNext()){
Object obj = iterator.next();
if("JavaEE".equals(obj)){
iterator.remove();
System.out.println("JavaEE已经删除了");
}
}
Iterator iterator1 = coll.iterator();
while(iterator1.hasNext()){
System.out.println(iterator1.next());
}
}
}
增强for循环
Java 5.0 提供了 foreach 循环迭代访问 Collection和数组。
for(元素类型 变量 : Collection集合or数组){
//写操作代码
}
package collectiondemo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
public class ForDemo {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add(123);
coll.add("bb");
coll.add(new String("JavaEE"));
coll.add(new Date());
coll.add(false);
//for(集合元素类型 局部变量:集合对象)
for(Object obj : coll){
System.out.println(obj);
}
int [] arr = new int[]{1,32,4,5,6,67};
// for(数组元素类型 局部变量:数组对象)
for(int i: arr){
System.out.println(i);
}
}
}
Collection子接口一:List
Collection接口: 单列集合,用来存储一个一个的对象。
- List: 元素有序、可重复的集合。"动态"数组
- ArrayList:作为List接口的主要实现类;线程不安全,效率高;底层使用Object[] elementData存储
- LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层采用双向链表存储;
- Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储;
面试题:ArrayList、LinkedList、Vector三者的异同?
同:
- 都实现了List接口,存储数据特点相同:有序可重复。
不同:
- ArrayList:作为List接口的主要实现类;线程不安全,效率高;底层使用Object[] elementData存储
- LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层采用双向链表存储;
- Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储;
ArrayList的源码分析:
jdk7
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);
源码部分:
this.elementData = new Object[initialCapacity];//
public ArrayList() {
this(10);//Constructs an empty list with an initial capacity of ten.
}
add操作:
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容为原来的1.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);
}
private void ensureCapacityInternal(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
jdk8
ArrayList list = new ArrayList();//底层Object[]数组elementData初始化为{}
list.add(123);//第一次调用add()时,底层才创建了长度为10的数组,并将数据123添加到elementData[0]中;
//源码部分
transient Object[] elementData; // non-private to simplify nested class access
private int size; // size =0;
//空参构造器
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;// 默认为{}
}
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//add操作
public boolean add(E e) {
ensureCapacityInternal(size + 1); // size=1
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
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);
}
小结:
jdk7中的ArrayList的对象的创建类似于单例的饿汉式
jdk8中的ArrayList的对象的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。
LinkedList的源码分析:
底层采用双向链表实现。
在表头添加元素:
在表尾添加数据
LinkedList linkedList = new LinkedList();//内部声明了Node类型的first和last属性,默认值为null
linkedList.add(123);//将123封装到Node中,创建了Node对象;
//链表的节点个数
transient int size = 0;
//指向头节点的指针
transient Node<E> first;
//指向尾节点的指针
transient Node<E> last;
// 在表头添加元素
private void linkFirst(E e) {
final Node<E> f = first;
// 当前节点的前驱指向null,后继节点是first指针指向的节点
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;//头指针指向新的头节点
//如果原来有头节点,则更新原来节点的前驱指针,否则更新尾指针。
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
//表尾添加元素
void linkLast(E e) {
final Node<E> l = last; // last是当前链表的最后一个元素,首次调用为null
//当前节点的前驱指向尾节点,后继指向 null
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;//添加的新元素作为当前链表的最后一个元素
//如果l == null,说明此事first=null,链表中就只有这一个元素。
if (l == null)
first = newNode;
else
//l.next指向最后一个元素,构成双向链表
l.next = newNode;
size++;
modCount++;
}
Vector的源码分析:
jdk7和jdk8中通过Vector()构造器创建对象时,底层都创建了长度为10的数组,在扩容方面,默认扩容为原来的数组长度的2倍。
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
public Vector() {
this(10);
}
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
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位置的元素,并返回此元素 。索引
Boolean remove(Object obj): 删除该obj元素。返回
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
代码:
package collectiondemo;
import java.util.*;
public class ArrayListTest1 {
public static void main(String[] args) {
// test1();
// test2();
test3();
}
public static void test1(){
ArrayList list = new ArrayList();
// 增:add(Object obj)
list.add(123);
list.add("AAAA");
list.add("bb");
list.add(new String("JavaEE"));
list.add(new Date());
list.add(false);
System.out.println(list);
//addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1,2,3,4);
list.addAll(list1);
System.out.println(list);
// 删:Object remove(int index):移除指定index位置的元素,并返回此元素
Object obj = list.remove(0); // 123
System.out.println(list.remove("AAAA"));// true
System.out.println(list);
System.out.println(obj);
// 改:set:Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(2,"哈哈");
System.out.println(list);
//查:Object get(int index):获取指定index位置的元素
Object obj1 = list.get(2);
System.out.println(obj1);
//插:add(int index, Object ele):在index位置插入ele元素
list.add(3,"呵呵");
}
public static void test2(){
ArrayList list = new ArrayList();
// 增:add(Object obj)
list.add(123);
list.add("AAAA");
list.add("bb");
list.add(new String("JavaEE"));
list.add(new Date());
list.add(false);
//int indexOf(Object obj):返回obj在集合中首次出现的位置
int index = list.indexOf(123);
System.out.println(index);//0
int index1 = list.indexOf(112212);
System.out.println(index1);//-1
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
int lastIndex = list.lastIndexOf("bb");
System.out.println(lastIndex);//2
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
List sublist = list.subList(2,6);
System.out.println(sublist);//[bb, JavaEE, Sat May 11 16:33:59 CST 2019, false]
}
public static void test3(){
ArrayList list = new ArrayList();
list.add(123);
list.add("AAAA");
list.add("bb");
list.add(new String("JavaEE"));
list.add(new Date());
list.add(false);
// 遍历
//1.Iterator迭代器方式
Iterator iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
//2.增强for循环
for(Object obj:list){
System.out.println(obj);
}
//3.普通for循环
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
}
面试题:
区分list中remove(int index)和remove(Object obj)
@Test
public void testListRemove() {
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
updateList(list);
System.out.println(list);//[1,2]
}
private void updateList(List list) {
// list.remove(2);// 传入的是index,所以主程序得到的结果为[1,2]
// list.remove(new Integer(2));// 传入的是一个对象,结果是[1,3]
Boolean obj = list.remove(new Integer(2));
System.out.println("测试remove:"+obj);
}
Collection子接口二:Set
Set: 元素无序、不可重复的集合。
- HashSet:作为Set接口的主要实现类;线程不安全的;可以存储null值;
- LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历;
- TreeSet:可以按照添加对象的指定属性进行排序。
Set的无序性与不可重复性的理解
以HashSet为例:
- 无序性:不等于随机性,存储的数据在底层数组中并非按照数组索引的顺序添加。而是根据数据的哈希值添加;
- 不可重复性:保证添加的元素按照equals()判断时,不能返回true,即相同的元素只能添加一个。
HashSet中元素的添加过程
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode方法,计算元素a的哈希值,此哈希值接着通过某种算法计算出HashSet底层数组中的存放位置(即为:索引位置),判断数组此位置上是否已经有元素:
如果此位置上没有其他元素,则元素a添加成功。-->情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的hash值:
如果hash值不同,则元素a添加成功。-->情况2
如果hash值相同,进而需要调用元素a所在类的equals方法:
equals()返回true,元素a添加失败;
equals()返回false,则元素a添加成功。-->情况3
对于情况2和情况3来说,元素a与已经存在指定索引位置上数据以链表的方式存储。
jdk7:元素a放到数组中,指向原来的元素。
jdk8:原来的元素在数组中,指向元素a。
总结:七上八下。
hashCode和equals方法的重写
以Eclipse/IDEA为例,在自定义类中可以调用工具自动重写equals和hashCode。问题: 为什么用Eclipse/IDEA复写hashCode方法,有31这个数字?
- 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大,所谓的“冲突”就越少,查找起来效率也会提高。(减少冲突)
- 并且31只占用5bits,相乘造成数据溢出的概率较小。
- 31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。 ( 提高算法效率)
- 31是一个素数,素数作用就是如果我用一个数字来乘以这个素数,那么最终出来的结果只能被素数本身和被乘数还有1来整除! (减少冲突)
-
set接口中没有额外定义新的方法,使用的都是Collection中声明过的方法;
-
要求:向Set中添加的数据,其所在的类一定要重写hashCode和equals;
重写的hashCode和equals尽可能保持一致性:相等的对象必须具有相等的散列码
重写两个方法的小技巧:对象中用作equals方法比较的field,都应该用来计算hashCode值
LinkedHashSet的使用
LinkedHashSet作为HashSet的子类,在添加数据的同时,每个数据还维护了两个引用,记录此数据前一个数据和后一个数据。
优点:对于频繁的遍历操作,LinkedHashSet的效率高于HashSet
Map接口
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类型。
HashMap的底层:数组+链表(jdk7之前)
数组+链表+红黑树(jdk8)
面试题:
- HashMap的底层实现原理?
- HashMap和Hashtable的异同?
- CurrentHashMap和Hashtable的异同?(暂时不讲)
Map结构的理解:
- key: 无序的、不可重复的,使用Set存储所有的key,key所在类要重写equals()和HashCode()
- value:无序的、不可重复的。使用Collection存储所有的value
- 一个键值对:key-value构成了一个Entry对象
- entry: 无序的、不可重复的,使用Set存储所有的entry
- Map 中的 key 和 value 都可以是任何引用类型的数据
- Map 中的 key 用Set来存放, 不允许重复,即同一个 Map 对象所对应的类,须重写hashCode()和equals()方法
- 常用String类作为Map的“键”
- key 和 value 之间存在单向一对一关系,即通过指定的 key 总能找到唯一的、确定的 value
- Map接口的常用实现类: HashMap、 TreeMap、 LinkedHashMap和Properties。 其中, HashMap是 Map 接口使用频率最高的实现类
HashMap的底层实现原理?
jdk7
Hashmp的底层实现原理?以idk7为例说明:
HashMap map = new HashMap();
在实例化以后,底层创建了长度是16的一维数组Entry[ ] table。
...可能已经执行过多次put...
map.put(key1,value1):
首先,调用key1所在类的HashCode()方法计算key1的哈希值,此哈希值经过某种算法计算以后,得到在Entry数组中的存放位置。
如果此位置上的数据为空,此时的key1-vakue1添加成功。----情况 1
如果此位置上的数据不为空,(意味着此位置上存在一个或多个数据(以链表形式存在)比较key1和已经存在的一个或多个数据的哈希值:
如果key1的哈希值与已经存在的数据的哈希值都不相同,此时key1-vakue1添加成功。----情况2
如果key1的哈希值和已经存在的某一个数据(key2-vakue2)的哈希值相同,继续比较:调用key1所在类的equals(key2)
如果equals()返回false:此时key1-vakue1添加成功。-------情况3
如果equals()返回true:使用value1替换value2
补充:关于情况2和情况3:此时key1-value1和原来的数据以链表的方式存储;
在不断的添加过程中,会涉及到扩容问题,默认的扩容方式:扩容为原来容量的2倍,并将原有的数据复制过来。
jdk8
相较于jdk7在底层实现方面的不同:
- new HashMap(): 此时底层没有创建一个长度为16的数组
- jdk 8底层的数组是:Node[],而非Entry[]
- 首次调用put()方法时,底层创建长度为16的数组
- jdk7底层结构只有:数组 +链表。 jdk8中底层结构:数组 +链表 +红黑树。
当数组的某一个索引位置上的元素以链表形式存在的数据个数> 8且当前数组的长度> 64时,
此时此索引位置上的所有数据改为使用红黑树存储。
HashMap的源码:
常用方法
添加、 删除、修改操作:
- 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中的所有数据
public static void test1(){
Map map = new HashMap();
//add
map.put("1","alex");
map.put("2","eric");
map.put("3","ben");
//改
map.put("3","echo");
System.out.println(map);
Map map1 = new HashMap();
map1.put(22,1232);
map1.put(33,"334");
map.putAll(map1);
System.out.println(map);
// remove:移除指定key的key-value对,并返回value
Object value = map.remove("3");
System.out.println(value);
System.out.println(map);
//clear():清空当前map中的所有数据
map.clear();
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是否相等
public static void test2(){
Map map = new HashMap();
//add
map.put("1","alex");
map.put("2","eric");
map.put("4","eric");
map.put("3","ben");
System.out.println(map.get("3"));//ben
System.out.println(map.get("eric"));//null
//containsKey
System.out.println(map.containsKey("3"));//true
System.out.println(map.containsKey("55"));//false
// containsValue
System.out.println(map.containsValue("eric"));//true
System.out.println(map.containsValue("ben"));//true
// isEmpty:
System.out.println(map.isEmpty());//false
// size:返回当前map中的键值对个数
System.out.println(map.size());//4
}
元视图操作的方法:
- Set keySet():返回所有key构成的Set集合
- Collection values():返回所有value构成的Collection集合
- Set entrySet():返回所有key-value对构成的Set集合
public static void test3(){
Map map = new HashMap();
//add
map.put("1","alex");
map.put("2","eric");
map.put("4","eric");
map.put("3","ben");
//keySet
Set set = map.keySet();
//遍历输出所有key构成的Set集合
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
//keyValue
Collection values = map.values();
//遍历输出所有value构成的Collection集合
// 方式1:
Iterator iterator1 = values.iterator();
while(iterator1.hasNext()){
System.out.println(iterator1.next());
}
// 方式2:
for(Object obj:values){
System.out.println(obj);
}
}
public static void test4(){
Map map = new HashMap();
//add
map.put("1","alex");
map.put("2","eric");
map.put("4","eric");
map.put("3","ben");
// entrySet:
Set entrySet = map.entrySet();
// 方式1:
Iterator iterator2 = entrySet.iterator();
while(iterator2.hasNext()){
Object obj = iterator2.next();
System.out.println(obj);
//entrySet集合中的元素都是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + ":" + entry.getValue());
}
// 方式2:
for(Object obj:entrySet){
System.out.println(obj);
}
}
总结:
- 增:put(Object key, Object value)
- 删:remove(Object key)
- 改:put(Object key, Object value)
- 查:get(Object key)
- 长度:size()
- 遍历:keySet()/values()/entrySet()
TreeMap的两种排序方式
向TreeMap中添加key-value,要求key必须是由同一个类创建的对象;
因为要按照key进行排序:自然排序、定制排序。
Properties
Properties 类是 Hashtable 的子类,该对象用于处理配置文件
- 由于属性文件里的 key、 value 都是字符串类型,所以 Properties 里的 key和 value 都是字符串类型
- 存取数据时,建议使用setProperty(String key,String value)方法和getProperty(String key)方法
Properties pros = new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
System.out.println(user);
public class PropertiesDemo {
public static void main(String[] args) throws Exception{
//Properties:常用来处理配置文件。key和value都是String类型
Properties pros = new Properties();
FileInputStream fileInputStream = new FileInputStream("jdbc.properties");
pros.load(fileInputStream);//加载流对应的文件,这里idea报错,不知原因;
String name = pros.getProperty("name");
System.out.println(name);
}
}