第11章 Java集合

发表于 2021-12-31 分类于程序设计， Java 阅读次数：本文字数： 23k 阅读时长 ≈ 21 分钟

第十一章、Java集合

一、Java集合框架概述

(一)、概述

集合、数组都是对多个数据进行存储操作的结构，简称为java容器【说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt, .jpg ...）】

一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。
- 数组在内存存储方面的特点：
  - 数组初始化以后，长度就确定了。
  - 数组声明的类型，就决定了进行元素初始化时的类型
- 数组在存储数据方面的弊端：
  - 数组初始化以后，长度就不可变了，不便于扩展
  - 数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。同时无法直接获取存储元素的个数
  - 数组存储的数据是有序的、可以重复的。---->存储数据的特点单一。对于无序、不可重复的需求不能满足
Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。

(二)、集合框架

Java 集合可分为 Collection 和 Map 两种体系

Collection接口：单列数据，定义了存取一组对象的方法的集合
- List：元素有序、可重复的集合。---> “动态”数组
  - List接口实现类：ArrayList、LinkedList、Vector
- Set：元素无序、不可重复的集合。---> 数学上的“集合”
  - Set接口实现类：HashSet、LinkedHashSet、TreeSet
Map接口：双列数据，保存具有映射关系“key-value对”的集合 ---> 数学上的“函数”：y = f(x) 【value = f(key)】
- Map接口实现类：HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
Collection接口继承树
Map接口继承树

二、Collection接口方法（抽象方法）

add(Object e)

1	add(Object e): 将元素e添加到集合中

size()
1
size(): 获取添加的元素个数

addAll(Collection coll1)

1	addAll(Collection coll1): 将coll1集合中的元素添加到当前的集合中

isEmpty()

1	isEmpty(): 判断当前集合是否为空

clear()

1	clear(): 清空集合中的所有元素

contains(Object obj)

1
2
3

contains(Object obj): 判断当前集合中是否包含obj
// 在判断时，会调用obj的equals()方法
// 向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()方法

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()方法

containsAll(Collection coll1)

1	containsAll(Collection coll1): 判断形参coll1中的所有元素是否都存在于当前集合中

remove(Object obj)

1	remove(Object obj): 从当前集合中移除obj元素，且在移除前使用equals()方法判断是否存在于当前集合中

removeAll(Collection coll1)

1	removeAll(Collection coll1): 从当前集合中移除coll1中的所有元素（移除的是当前集合和coll1的交集元素，同样在移除前会调用各元素的equals()方法），差集

retainAll(Collection coll1)

1	retainAll(Collection coll1): 交集，获取当前集合和coll1的交集，并直接将当前集合修改为结果

equals(Object obj)

1	equals(Object obj): 判断当前集合和形参是否相同（当形参为集合时，需要元素是相同的顺序且调用对应元素的equals()方法）

hashCode()

1	hashCode(): 返回当前对象的哈希值（Object类中已定义hashCode()方法）

toArray()

toArray(): 集合 --> 数组，方法返回一个Object[]类型
Arrays.asList(T... a): 数组 --> 集合，调用Arrays类的静态方法asList()，形参为可变形参
    List<String> arr = Arrays.asList(new String[]{"AA", String.valueOf(123), "BB"});
        System.out.println(arr); //[AA, 123, BB]

        List arr1 = Arrays.asList(new int[]{12, 45, 78}); 
		//提示：Call to 'asList()' with only one argument
		// 被识别为一个参数
        System.out.println(arr1); //[[I@4f8e5cde]

        List arr2 = Arrays.asList(new Integer[]{12, 45, 78});
        System.out.println(arr2); //[12, 45, 78]

        List arr3 = Arrays.asList(12, 45, 78);
        System.out.println(arr3); //[12, 45, 78]

toArray(T[] a)
1
toArray(T[] a)

iterator()

1	iterator(): 返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试

三、Iterator迭代器接口

Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。（无法遍历Map中的元素）
GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象，则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

next()

1
2
3

next(): 返回迭代器中的下一个元素
    // 执行next时：①指针下移 ②将下移后集合位置上的元素返回
    // Throws: NoSuchElementException - if the iteration has no more elements

hasNext()

1	hasNext(): 判断是否还有下一个元素

方法使用

Collection coll = new ArrayList();
coll.add(123);
coll.add("Aa");
coll.add(new Date());
coll.add(new Person(20));

Iterator iterator = coll.iterator();

// 不推荐写法
//        for (int i = 0; i < coll.size(); i++){
//            System.out.println(iterator.next());
//        }

// 推荐写法
while (iterator.hasNext()){
    System.out.println(iterator.next());
}

//jdk 5.0新增了foreach循环
// for(集合元素的类型 局部变量 : 集合对象)
// 内部仍然调用了迭代器 iterator
for (Object obj: coll) {
    System.out.println(obj);
}

// for(集合元素的类型 局部变量 : 数组对象)
int[] arr = new int[]{1, 2, 3, 4, 5, 6};
for (int i :
     arr) {
    System.out.println(i);
}

// 笔试题
String[] arr = new String[]{"MM", "MM", "MM"};

// 方式二：使用增强for循环（或foreach）
for (String s :
     arr) {
    s = "GG"; // 使用的局部变量进行赋值，不改变原有元素值
}
System.out.println(Arrays.toString(arr)); //[MM, MM, MM]

// 方式一：普通for循环
for (int i = 0; i < arr.length; i++){
    arr[i] = "GG";
}
System.out.println(Arrays.toString(arr)); //[GG, GG, GG]

remove()
1
remove(): 可在遍历时删除集合中的元素，删除当前iterator指针指向的元素。此方法不同于集合中的remove()方法。
- Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
- 如果还未调用过next()或在上一次调用 next 方法之后已经调用过了 remove 方法，再调用remove都会报IllegalStateException。

四、Collection子接口一：List

鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。
- 同：三个类都实现了List接口，存储数据的特点相同：存储有序、可重复的数据
- 异：
  - ArrayList：
    - 作为List接口的主要实现类
    - 线程不安全，因此效率高
    - 底层使用Object[] elementData存储
  - LinkedList：
    - 对于频繁的插入、删除操作，使用此类效率比ArrayList高
    - 底层使用双向链表
  - Vector：
    - 作为List接口的古老实现类。【JDK1.0时即存储有序、可重复的数据，JDK1.2后出现的List接口，且紧接着出现了两个实现类ArrayList、LinkedList，后把Vector归入List接口的实现类】
    - 线程安全，效率低
    - 底层使用Object[] elementData存储

(一)、ArrayList源码分析 - JDK7情况下

ArrayList list = new ArrayList(); // 空参构造器创建了一个长度为10的Object数组
list.add(123); // elementData[0] = new Integer(123);
...
list.add(11); // 如果此次的添加导致底层elementData数组容量不足，则扩容；默认情况下，扩容为原来的1.5倍，同时需将原有数组中的数据复制到新的数组中

// 结论：建议开发中使用带参构造器
ArrayList list = new ArrayList(int capacity);

(二)、ArrayList源码分析 - JDK8情况下

ArrayList list = new ArrayList(); // 底层Object[] elementData初始化为{}。并没有创建长度为10的数组
list.add(123); // 第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
...
// 后续添加和扩容操作与JDK7无异

JDK7中的ArrayList的创建类似于单例模式的饿汉式，而JDK8中的ArrayList的创建类似于单例模式的懒汉式，延迟了数组的创建，节省内存。

(三)、LinkedList源码分析

JDK7和JDK8中的LinkedList底层无差别

1 2	LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性，默认值为null list.add(123); // 将123封装到Node中，创建了Node对象

其中Node类为LinkedList的内部静态类，其定义体现了LinkedList的双向链表结构，定义为：

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

(四)、Vector源码分析

JDK7和JDK8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组；在扩容方面，默认每次扩容为当前数组长度的2倍

Stack类即栈是Vector子类

(五)、List接口中的常用方法

add

1	void add(int index, Object ele); //在index位置插入ele元素

addAll

1	Boolean addAll(int index, Collection eles); // 从index位置开始将eles中的所有元素加入到当前集合中

get

1	Object get(int index); //获取指定index位置的元素

indexOf

1	int indexOf(Object obj); //返回obj在集合中首次出现的位置，若不存在返回-1

lastIndexOf

1	int lastIndexOf(Object obj); //返回obj在集合中末次出现的位置，若不存在返回-1

remove

1	Object remove(int index); //移除指定index位置的元素，并返回此元素。是Collection中remove方法的重载

set

1	Object set(int index, Object ele); //设置指定index位置的元素为ele

subList

1	List subList(int fromIndex, int toIndex); //返回从fromIndex到toIndex位置的左闭右开区间内的元素

即List接口在Collection接口定义的方法基础上有定义了新的方法

(六)、总结：常用方法（不去看API就能用）

增：
1
add(Object obj)

删

1	remove(int index); / remove(Object obj)

改
1
set(int index, Object ele);
查
1
get(int index);
插
1
add(int index, Object ele)
长度
1
size()

遍历

1
2
3

iterator迭代器方式
增强for循环
普通循环

五、Collection子接口二：Set（重要性低于List、Map）

(一)、Set接口的框架

/----Collection接口：单列集合，用来存储一个一个的对象
    /----Set接口：存储无序的、不可重复的数据
    	/----HashSet：作为Set接口的主要实现类；线程不安全；可存储null值
    		/----LinkedHashSet：作为HashSet的子类；遍历其内部数据时可按照添加的顺序遍历
    	/----TreeSet：底层使用二叉树中的红黑树存储数据；只能添加同一个类new的对象，且可按照添加对象的指定属性进行排序

Set接口中没有额外定义的新方法，使用的都是Collection中声明过的方法

(二)、理解Set的无序性和不可重复性

以HashSet为例：

无序性：不等于随机性
- 存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值确定其位置
- 即不按照程序调用顺序添加元素
不可重复性：保证添加的元素按照equals()方法判断时，不能返回true，即相同的元素只能添加一个

(三)、添加元素的过程：以JDK7 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放在数组中，指向原来的所有元素的first；JDK8中原来的元素在数组或链表中，原来的元素的last指向元素a

HashSet底层：数组+链表的结构，new的HashSet实际上内部new 的HashMap，而HashSet中的add()方法实际上调用的是HashMap的put()方法。（JDK7的底层数据，与HashMap相关）

(四)、hashCode()的重写

要求：

向Set中添加的数据，其所在类一定要重写hashCode()和equals()
重写的hashCode()和equals()尽可能保持一致性：相等的对象(equals()返回true)必须具有相等的散列码
- 对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值
- 推荐使用IDE自动重写的方法

(五)、LinkedHashSet

LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。

优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet

(六)、TreeSet（了解）

向TreeSet中添加的数据，要求是相同类的对象，不能添加不同类的对象。从而实现按属性对对象排序（二叉树中的红黑树，排序复杂度为O(1)）

排序的两种方式：自然排序（实现Comparable接口） & 定制排序（实现Comparator接口）

自然排序（添加到TreeSet中的对象所属类实现Comparable接口）

package com.atguigu.javapack;

/**
 * @author Hunt Wu
 * @version V1.0
 * @create 2021-10-10-21:50
 */
public class User implements Comparable{
    private String name;
    private int age;

    public User() {
    }

    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 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 String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    // 按照姓名从小到大排序
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User) o;
            return this.name.compareTo(user.name);
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }
    }


}

@Test
public void TreeSetTest(){
    TreeSet treeSet = new TreeSet();

    treeSet.add(new User("Tom", 12));
    treeSet.add(new User("Jhon", 22));
    treeSet.add(new User("Jack", 15));
    treeSet.add(new User("Taylor", 25));
    treeSet.add(new User("Hunt", 24));

    Iterator iterator = treeSet.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
    /*
        User{name='Hunt', age=24}
        User{name='Jack', age=15}
        User{name='Jhon', age=22}
        User{name='Taylor', age=25}
        User{name='Tom', age=12}
         */

}

定制排序（）

使用TreeSet构造函数的Comparator参数构造器，将匿名实现类的对象或匿名实现类的匿名对象作为参数

@Test
public void TreeSetTest2(){
    TreeSet treeSet2 = new TreeSet(new Comparator() {
        // 年龄从小到大排序
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof User && o2 instanceof User){
                User user1 = (User) o1;
                User user2 = (User) o2;
                // return ((Integer)user1.getAge()).compareTo(user2.getAge());
                return Integer.compare(user1.getAge(), user2.getAge());
            }else{
                throw new RuntimeException("比较类型不一致");
            }
        }
    });

    treeSet2.add(new User("Tom", 12));
    treeSet2.add(new User("Jhon", 22));
    treeSet2.add(new User("Jack", 15));
    treeSet2.add(new User("Taylor", 25));
    treeSet2.add(new User("Hunt", 24));

    Iterator iterator = treeSet2.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
    /*
        User{name='Tom', age=12}
        User{name='Jack', age=15}
        User{name='Jhon', age=22}
        User{name='Hunt', age=24}
        User{name='Taylor', age=25}
         */
}

TreeSet中判断添加的两个对象是否相同：
- 自然排序中比较两个对象是否相同的标准：compareTo()方法返回0，不再是equals()
- 定制排序中比较两个对象是否相同的标准：compare()方法返回0，不再是equals()

六、Map接口

与Collection接口并列

(一)、Map接口继承树

/----Map：双列数据，保存具有映射关系“key-value对”的集合 ---> 数学上的“函数”：y = f(x) 【value = f(key)】
    /----HashMap:作为Map的主要实现类，线程不安全，效率高；可存储null的key和value，健壮性好。底层使用 数组+链表(JDK7)、数组+链表+红黑树(JDK8)
		/----LinkedHashMap：保证遍历map元素时，可按照添加的顺序实现遍历输出
        				原因：在原有的HashMap底层结构基础上，添加了一对引用分别记录当前HashMap节点的前一个和后一个元素
        				对于频繁的遍历操作，此类的执行效率高于HashMap
	/----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历；按照key排序（考虑key的自然排序和定制排序），底层使用红黑树
	/----Hashtable:作为Map的古老实现类，线程安全，效率低；不可存储null的key和value
		/----Properties:常用来处理配置文件；特点：key和value都是String类型
先出现的Hashtble，后出现Map接口来规范键值对的规则，并使用HashMap作为其主要实现类，TreeMap针对有顺序的Map，由于HashMap的插删数据不方便，因此出现了LinkedHashMap

(二)、Map结构的理解

Map中的key：无序的、不可重复的，使用Set存储所有的key ----> key所在的类要重写equals()和hashCode()（以HashMap为例）

Map中的value：无序的、可重复的，使用Collection存储所有的value ----> key所在的类要重写equals()（以HashMap为例）

一个键值对：key-value构成一个Entry对象

Map中的entry：无序的、不可重复的，使用Set存储所有的entry

(三)、HashMap的底层实现原理（JDK7为例）

实例化

1 2	HashMap map = new HashMap(); // 在实例化后，底层创建了长度是16的一维数组Entry[] table。

添加数据

....// 已经执行过0次或多次put方法
map.put(key1, value1);

// 首先，调用key1所在类的hashCode方法，计算key1哈希值，此哈希值经过某种算法计算后，得到在Entry数组中的存放位置
// 如果此位置上数据为空，此时的(key1, value1)添加成功。 ----情况1
// 如果此位置上的数据不为空，（此位置上存在着一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值：
// 		如果key1的哈希值与已经存在的数据的哈希值都不相同，此时的key1-value1添加成功 ----情况2
// 		如果key1的哈希值与已经存在的某一个数据(key2-value2)的哈希值相同，则调用key1所在类的equals(key2)方法
// 			如果equals(key2)方法返回false，则key1-value1添加成功  ----情况3
// 			如果equals(key2)方法返回true，则value2被替换为value1（put具有修改功能）

情况2和情况3：新添加的数据和原来的数据以链表的方式存储，新添加数据在数组中(JDK7)，或新添加数据放在最后(JDK8)，同一位置多个元素以单向链表形式存储
不断添加过程中，会涉及扩容问题，当当前数组中的已存元素超过临界值（且当前key-value要存放的位置非空时）则扩容。默认的添加方式：数组扩容为原来的2倍，并将原来的数据重新计算哈希值Map到新数组中。

(四)、JDK8相较于JDK7在底层实现方面的不同

实例化

1
2
3

new HashMap();
// 底层没有创建一个长度为16的数组。
// 底层的数组为Node[]，而不是Entry[]数组

首次调用put方法时，底层创建长度为16的数组
JDK7底层结构只有数组+链表；JDK8底层结构有数组+链表+红黑树
- 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所有数据改为使用红黑树存储（优化查找效率）

(五)、HashMap中的重要常量（JDK8）

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16 MAXIMUM_CAPACITY ： HashMap的最大支持容量，2^30 DEFAULT_LOAD_FACTOR：HashMap的默认加载因子
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树
UNTREEIFY_THRESHOLD：Bucket中红黑树存储的Node小于该默认值，转化为链表
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量。（当桶中Node的数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍。） table：存储元素的数组，总是2的n次幂 entrySet：存储具体元素的集 size：HashMap中存储的键值对的数量 modCount：HashMap扩容和结构改变的次数。 **threshold：扩容的临界值，=容量*填充因子** loadFactor：填充因子

(六)、LinkedHashMap的底层实现原理

LinkedHashMap底层使用的结构与HashMap相同，因为LinkedHashMap继承于HashMap。区别在于LinkedHashMap内部提供了Entry，替换HashMap中的Node

static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after; // 记录添加元素的先后顺序
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

(七)、Map中定义的方法

添加、删除、修改操作

put

1	Object put(Object key, Object value): 将指定key-value添加到（或修改）当前map对象中

putAll

1	void putAll(Map m): 将m中所有的key-value对添加到当前map中

remove

1	Object remove(Object key): 移除指定key的key-value对，并返回value

clear

1	void clear()：清空当前map中的所有数据

元素查询的操作

get

1	Object get(Object key)：获取指定key对应的value

containsKey

1	boolean containsKey(Object key)：是否包含指定的key

containsValue

1	boolean containsValue(Object value)：是否包含指定的value

size

1	int size()：返回map中key-value对的个数

isEmpty

1	boolean isEmpty()：判断当前map是否为空

equals

1	boolean equals(Object obj)：判断当前map和参数对象obj是否相等

元视图操作的方法

keySet

1	Set keySet()：返回所有key构成的Set集合

values

1	Collection values()：返回所有value构成的Collection集合

entrySet

1	Set entrySet()：返回所有key-value对构成的Set集合

总结：常用方法

添加：Object put(Object key, Object value)
删除：Object remove(Object key)
修改：Object put(Object key, Object value)
查询：Object get(Object key)
长度：int size()
遍历：Set keySet() / Collection values() / Set entrySet()

(八)、TreeMap

向TreeMap中添加key-value，要求key必须是由用一个类创建的对象。因为要按照key进行排序：自然排序、定制排序

(九)、Properties

Properties 类是 Hashtable 的子类，该对象用于处理属性文件
在程序中加载配置文件使用Properties对象的load(InputStream instream)方法
由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key和 value 都是字符串类型
存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法

IDEA下的配置文件：

一般在当前工程文件夹下
新建配置文件：右键工程名 -- New -- File 或者 Resource Bundle，扩展名为.properties

1
2
3

// 配置文件 jdbc.properties
name=Tom
password=123456

java代码

@Test
public void testProperties() throws Exception {
    Properties properties = new Properties();

    FileInputStream fis = new FileInputStream("../jdbc.properties");
    properties.load(fis); // 加载流对应的文件

    String name = properties.getProperty("name");
    String password = properties.getProperty("password");
    System.out.println("name = " + name + ", password = " + password);
    // name = Tom, password = 123456
}

七、Collections工具类

Collections 是一个操作 Collection 和 Map 等集合的工具类（操作数组的工具类：Arrays）
Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

排序操作：（均为static方法）

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 对象的所有旧值

Copy()方法：要求dest的size要大于list的size，否则抛异常

@Test
public void testCollections(){
    List list = new ArrayList();
    list.add(123);
    list.add(43);
    list.add(765);
    list.add(-97);
    list.add(0);

    //        // java.lang.IndexOutOfBoundsException: Source does not fit in dest
    //        List dest = new ArrayList();
    //        Collections.copy(dest, list);
    List dest = Arrays.asList(new Object[list.size()]);
    Collections.copy(dest, list);

    System.out.println(dest);
}

同步控制

1	Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题

面试题

ArrayList、LinkedList、Vector三者异同
- 同：三个类都实现了List接口，存储数据的特点相同：存储有序、可重复的数据
- 异：
  - ArrayList：
    - 作为List接口的主要实现类
    - 线程不安全，因此效率高
    - 底层使用Object[] elementData存储
  - LinkedList：
    - 对于频繁的插入、删除操作，使用此类效率比ArrayList高
    - 底层使用双向链表
  - Vector：
    - 作为List接口的古老实现类。【JDK1.0时即存储有序、可重复的数据，JDK1.2后出现的List接口，且紧接着出现了两个实现类ArrayList、LinkedList，后把Vector归入List接口的实现类】
    - 线程安全，效率低
    - 底层使用Object[] elementData存储

区分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.printl(list);
}

private void updateList(List list){
    list.remove(2);
}

HashMap的底层实现原理？
HashMap和Hashtable的异同？
CurrentHashMap和Hashtable的异同？
Collection和Collections的区别？
负载因子值的大小，对HashMap有什么影响
- 负载因子的大小决定了HashMap的数据密度。
- 负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长,造成查询或插入时的比较次数增多，性能会下降。
- 负载因子越小，就越容易触发扩容，数据密度也越小，意味着发生碰撞的几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建议初始化预设大一点的空间。
- 按照其他语言的参考及研究经验，会考虑将负载因子设置为0.7~0.75，此时平均检索长度接近于常数。

每日一考

说说你所理解的集合框架都有哪些接口，存储数据的特点是什么？
- Collection：单列集合，用于存储一个一个的对象
  - List：有序的、可重复的集合
  - Set：无序的、不可重复的集合
- Map：双列数据，保存具有映射关系“key-value对”的集合
比较throw和throws的异同
- throw：生成一个异常对象并抛出（手动抛出异常），使用在方法内部；和自动抛出异常对应
- throws：异常处理的一种方式。和try-catch-finally对象
谈谈你对同步代码块中同步监视器和共享数据的理解及各自要求
同步监视器：俗称锁，任何一个类的对象都可充当锁。多个线程共用一把锁
共享数据：多个线程共同操作的数据
需要使用同步机制将操作共享数据的代码包起来，既不能包多、也不能包少
集合Collection中存储的如果是自定义类的对象，需要自定义类重写哪个方法？为什么？‘
需要重写equals()方法，当集合对象调用contains方法时，会调用集合存储元素的equals()方法，如自定义类未重写equals()方法则默认使用Object类中的equals()方法即使用 == 符号判断
- List：重写equals()方法
- Set：
  - HashSet、LinkedHashSet：重写equals()、hashCode()
  - TreeSet：Comparable接口( compareTo(Object o) )、Comparator接口( compare(Object o1, Object o2) )
ArrayList、LinkedList、Vector三者的相同点与不同点？【面试题】
List接口的常用方法有哪些？(增、删、改、查、插、长度、遍历)
- 增：add(Object obj)
- 删：remove(int index) / remove(Object obj)
- 改：set(int index, Object ele)
- 查：get(int index)
- 插：add(int index, Object ele)
- 长度：size()
- 遍历：itertor()，for循环或增强for循环
如何使用Iterator和增强for循环遍历List
Set存储数据的特点是什么？常见的实现类有什么？说明彼此的特点
- 特点：存储无序、不可重复数据
- 实现类：HashSet、LinkedHashSet、TreeSet
  - HashSet：底层使用HashMap
  - LinkedHashSet：底层使用LinkedHashMap
  - TreeSet：底层使用TreeMap

练习

在List内去除重复数字值，要求尽量简单

@Test
public void testDuplicateList(){
    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);
    Iterator iterator = list2.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

private ArrayList duplicateList(List list) {
    HashSet hashSet = new HashSet();
    hashSet.addAll(list);
    return new ArrayList(hashSet);
}

Set

@Test
public void testSet(){
    // User类重写了HashCode和equals
    HashSet set = new HashSet();
    User u1 = new User(1001, "AA");
    User u2 = new User(1002, "BB");

    set.add(u1);
    set.add(u2);
    u1.setName("CC");// 属性变动，Hash值也会变，但add后变化不会检查
    set.remove(u1); // remove需要先判断
    System.out.println(set); //u1 u2
    // [User{name='CC', age=1001}, User{name='BB', age=1002}]
    set.add(new User(1001, "CC"));
    System.out.println(set);
    // [User{name='CC', age=1001}, User{name='CC', age=1001}, User{name='BB', age=1002}]
    set.add(new User(1001, "AA"));
    System.out.println(set);
    // [User{name='CC', age=1001}, User{name='CC', age=1001},
    // User{name='AA', age=1001}, User{name='BB', age=1002}]
}

Map存储数据的特点？并指明key、value、entry存储数据的特点
- 双列数据，存储key-value对数据
- key：无序的、不可重复的。相当于使用Set存储
- value：无序的、可重复的。相当于使用Collection存储
- entry：无序的、不可重复的。相当于使用Set存储
描述HashMap的底层实现原理（JDK8）
Map中常用实现类有哪些？各自有什么特点？
/----Map：双列数据，保存具有映射关系“key-value对”的集合 ---> 数学上的“函数”：y = f(x) 【value = f(key)】 /----HashMap:作为Map的主要实现类，线程不安全，效率高；可存储null的key和value，健壮性好。底层使用数组+链表(JDK7)、数组+链表+红黑树(JDK8) /----LinkedHashMap：保证遍历map元素时，可按照添加的顺序实现遍历输出原因：在原有的HashMap底层结构基础上，添加了一对引用分别记录当前HashMap节点的前一个和后一个元素对于频繁的遍历操作，此类的执行效率高于HashMap /----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历；按照key排序（考虑key的自然排序和定制排序），底层使用红黑树 /----Hashtable:作为Map的古老实现类，线程安全，效率低；不可存储null的key和value /----Properties:常用来处理配置文件；特点：key和value都是String类型
如何遍历Map中的key-value对，代码实现
Map中的常用方法
Collection和Collections的区别

Hunt's Blog