zoukankan html css js c++ java

java集合

集合框架

概述

集合、数组都是对多个数据进行存储操作的结构，简称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的源码分析：

底层采用双向链表实现。

1562640895052

在表头添加元素：

1562641042924

在表尾添加数据

1562641504540

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);
    }
}

查看全文

相关阅读:
还能这样偷懒？用Python实现网站自动签到脚本
 普通爬虫 VS 多线程爬虫！Python爬虫运行时间对比
 中文文献阅读方法及笔记模板
 约束
 可迭代对象补充
 练习题及补充
 内置函数的补充/super/异常值处理
 特殊成员
 嵌套
 面向对象知识点总结补充

原文地址：https://www.cnblogs.com/benjieqiang/p/11456183.html