Java集合

1. Java集合框架概述

1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
2. 数组在存储多个数据方面的特点：
1）一旦初始化之后，其长度就确定了。
2） 定义数组是必须要定义化其存储元素的类型。
缺点：
1）一旦初始化之后，器长度就不可修改。
2）数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不变，同时效率不高。
3）获取数组中实际元素的个数需求，数组没有现成的属性和方法可用。
4）数组存储数据的特点：有序、可重复、对于无序、不可重复的需求，不能满足。


上图中iterator应为iterable！！！

2. Collection接口方法

/**
* 返回集合中元素的个数，当元素个数超过Integer.MAX_VALUE，返回Integer.MAX_VALUE。
*/
int size();

/**
* 当集合中没有元素时返回true，否则返回false.
*/
boolean isEmpty();

/**
* 判断集合中是否有元素e，满足o.equals(e).
*/
boolean contains(Object o);

/**
* 判断某一集合是否包含集合c中的所有元素。
*/
boolean containsAll(Collection<?> c);

/** 
* 向集合中添加该元素。添加成功返回true。
* 如果此集合不允许重复，并且已经包含指定元素，返回false。
*/
boolean add(E e);

/**
* 向集合中添加集合c中的所有元素，如果集合因此操作而改变(添加了c中的元素）,则返回true.
*/
boolean addAll(Collection<? extends E> c);
/**
* 从集合中移除一个元素e满足o.equals(e)，如果集合中存在多个相同的e,只移除一个（先找到的那个【待定】）。
*/
boolean remove(Object o);

/**
* 从该集合中移除所有集合c中存在的元素。
*/
boolean removeAll(Collection<?> c);

/**
* 只保留该集合与集合c中元素相同的元素（交集）。
*/
boolean retainAll(Collection<?> c);

/**
* 清除该集合中的所有元素。
*/
void clear();

/**
* 返回该集合的迭代器
*/
Iterator<E> iterator();

/**
* 集合转数组
*/
Object[] toArray();

/**
* 集合转数组
*/
<T> T[] toArray(T[] a);

/**
* 判断该集合和o是否相等
*/
boolean equals(Object o);

/**
* 返回此集合的hashcode
*/
int hashcode();

3. Iterator迭代器接口

/**
 * 集合的遍历操作，使用迭代器Iterator接口
 * <p>
 * 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
 * 默认游标都在集合的第一个元素之前。
 */
public interface Iterator<E> {
	/**
	* 判断是否有下一个元素
	*/
	boolean hasNext();

	/**
	* 返回迭代器指向的下一个元素。
	*/
	E next();
	
	/**
	* 移除当前指向的元素
	*/
	default void remove();
}

foreach循环内部其实就是调用了迭代器。

4. Collection子接口一：List

/**
 * 1.List接口：
 * 1）ArrayList：作为List接口的主要实现类，线程不安全，效率高。底层使用Object[]存储。
 * 2）LinkedList：对于频繁的插入和删除操作，使用此类效率比ArrayList高；底层使用双向链表存储。
 * 3)Vector：作为List接口的古老实现类，线程安全，效率低。底层使用Object[]存储。
 *
 * 2. ArrayList源码分析：
 * 2.1 jdk7情况下：
 * ArrayList list = new Arraylist();//底层创建了长度为10的Object[]数组elementData.
 * list.add(1);//elementData[0] = new Integer(1);
 * ...
 * list.add(11);//如果此次的添加导致底层的elementData数组容量不够，则扩容。
 * 默认情况下，扩容为原来的容量的1.5倍，同时需要将原有的数组中的数据复制到新数组中。
 * 建议开发中使用带参的构造器 ArrayList list = new ArrayList(int capacity);
 * 2.2 jdk8中ArrayList的变化：
 * ArrayList list = new ArrayList();//底层Object[] elementData初始化为{},并没有创建长度为
 * 10的数组。
 * list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData.
 * 2.3 小结：jdk7中ArrayList的对象的创建类似与单例的饿汉式，而jdk8中的ArrayList的对象的创建类似与
 * 单例的懒汉式，延迟了数组的创建，节省了内存。
 *
 * 3. LinkedList源码分析：
 * LinkedList list = new LinkedList();
 * list.add(1);//将1封装到Node中，创建了Node对象。
 *
 * 其中，Node定义为：（体现了LinkedList的双向链表的说法）
 * private static class Node<E> {
 *         E item;
 *         Node<E> next;
 *         Node<E> prev;
 *         }
 *
 * 4. Vector源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层到创建了长度为10的数组。
 * 在扩容方面，默认扩容为原来的数组长度的2倍。
 *
 *
 *
 * 面试题：ArrayList、LinkedList、Vector三者有何异同？
 * 同：三个类都实现了List接口。
 * 不同：如上
 */

List接口中remove有两种方法，一个继承Collection接口的remove方法,一个是重载的remove方法。注意区分！！！
subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开的子集合。
总结：List常用方法
增：add(Object obj)
删：remove(int index)/ remove(Object obj)
改：set(int index, Object o)
查：get(int index)
插入：add(int index, object o);
长度：size()
遍历：1）Iterator迭代器。2）for 。3) for each

5. Collection子接口二：Set

/**
 * 1. Set接口的框架结构：无序的，不可重复的数据。
 * 1）HashSet:作为Set接口的主要实现类：线程不安全；可以存储null值。底层是数组加链表的形式存储的。
 * 2) LinkedHashSet: HashSet子类；遍历其内部数据时，可以按照添加的顺序进行遍历。
 * 3)TreeSet:可以按照添加对象的指定属性进行排序。
 * <p>
 * 1. set接口中没有额外定义新的方法
 * 2. 要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()
 * 重写的hashCode()和equals()尽可能保持一致性：相等的对象不许具有相同的散列码。
 * 重写两个方法的小技巧：对象中用作equals()方法比较的Field,都应该用来计算hashCode。
 * 尽量通过IDE来生成。
 * <p>
 * 一、Set:存储无序的，不可重复的数据。
 * 以HashSet为例说明
 * 1. 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定存储位置。
 * <p>
 * 2. 不可重复性：保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个。
 * <p>
 * 二、添加元素的过程：以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
 * <p>
 * 对于添加成功的情况2和情况3而言：元素a已经存在指定索引位置上数据以链表的方式存储。
 * jdk7：元素a放在数组中，指向原来的元素。
 * jdk8：原来的元素在数组中，指向元素a.
 * 总结：七上八下
 * <p>
 * <p>
 * 三、LinkedHashSet的使用
 * LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个数据和后一个数据。
 * 优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
 * <p>
 * 四、TreeSet的使用
 * 1. 向TreeSet中添加的数据，要求是相同类的对象。
 * 2. 两种排序方式：自然排序(Comparable)、定制排序(Comparator)
 * 3. 自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals().
 * 4. 定制排序中，比较两个对象是否相同的标准为：compare() 返回0，不再是equals().
 *
 */

TreeSet两种排序方式的实现

1. 自然排序：需要TreeSet中存储的对象的对应类实现Comparable接口

class User implements Comparable {
        String name;
        int age;

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return 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 test3() {
        TreeSet set = new TreeSet();
        set.add(new User("Tom", 20));
        set.add(new User("Jim", 21));
        set.add(new User("Jack", 26));
        set.add(new User("Mike", 23));

        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

2. 定制排序：需要在新建TreeSet对象时传入实现Comparator接口的对象。

@Test
    public void test4(){
        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);

    }

6. Map接口

/**
 * Map双列数据，存储key-value对的数据。
 * ->HashMap:作为Map的主要实现类；线程不安全；效率高；存储null的key和value
 * -->HashLinkedMap:保证在遍历Map元素时，可以按照添加的顺序实现遍历。
 * ----------------原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
 * ----------------对于频繁的遍历操作，此类执行效率高于HashMap.
 * <p>
 * ->TreeMap:保证按照添加的key-value对进行排序，是排序遍历。排序考虑key的自然排序或定制排序。
 * -----------底层使用红黑树。
 * ->Hashtable:作为古老的实现类；线程安全；效率低；不能存储null的key和value
 * -->Properties:常用来处理配置文件。key和value都是String类型。
 * <p>
 * HashMap的底层：数组+链表 （jdk7之前）。 数组+链表+红黑树 （jdk8）
 * <p>
 * 面试题：
 * 1. HashMap的底层实现原理？
 * <p>
 * 2. HashMap和Hashtable的异同？
 * <p>
 * 3. CurrentHashMap和Hashtable的异同？（暂时不讲）
 * <p>
 * 二、Map结构的理解：
 * Map中的key:无序的、不可重复的，使用Set存储所有的key -->key所在的类要重写equals()和hashcode()。以hashMap为例）
 * Map中的value:无序的、可重复的，使用Collection存储所有的value.-->value所在类要重写equals().
 * 一个键值对：key-value构成一个Entry对象。
 * Map中的entry:无序的、不可重复的，使用Set存储所有的entry.
 * <p>
 * 三、HashMap的底层实现原理？（以jdk7为例说明）
 * HashMap map = new HashMap();
 * 在实例化以后，底层创建了长度为16的一维数组Entry[] table.
 * ....已经执行多次put...
 * map.put(key1,value1);
 * 首先，调用key1所在类的hashcode()计算key1的哈希值，此哈希值经过某种算法计算以后，得到在entry数组的
 * 存放位置，如果此位置上的数据为空，此时的key1-value1添加成功。
 * 如果此位置上的数据不为空，（意味着此位置上存放一个或多个数据（以链表的形式存在），比较key1和已经存在的一个或多个
 * 数据的哈希值：
 * ---------如果key1的哈希值与已经存在的数据的哈希值都不同，此时key1-value1添加成功。---情况2
 * ---------如果相同，继续比较：调用key1所在类的equals()方法，比较：
 * ----------------如果equals()方法返回false:此时key1-value1添加成功。---情况3
 * ----------------如果返回true，使用value1替换以前的value2.(相当于修改key1对应的value）
 * <p>
 * 补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
 * <p>
 * 在不断的添加过程中，会涉及到扩容问题，当超出临界值（且要存放的位置非空时）默认扩容方式：扩容为原来容量的2倍。并将原有的数据复制过来。
 * <p>
 * jdk8相较于jdk7在底层实现方式的不同：
 * 1.new HashMap()：底层没有创建一个长度为16的数组。
 * 2.jdk8底层数组是：Node[]而非Entry[]。
 * 3.首次调用put()方法时，底层创建长度为16的数组。
 * 4.jdk7底层结构只有数组+链表。jdk8底层结构：数组+链表+红黑树。
 * 当数组的某一个索引位置上的元素以链表的方式存储的数据个数>8且当前数组的长度>64时，
 * 此时此索引位置上的所有数据改为使用红黑树存储。（红黑树提高查找效率）
 * <p>
 * 四、LinkedHashMap的底层实现原理（了解）
 * 源码中：
 * 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);
 * }
 * }
 * <p>
 *五、Map常用方法
 * 
 * 六、TreeMap的使用
 * 向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
 * 因为要按照key进行排序：自然排序，定制排序
 *
 * @author AmorFati
 * 2020/10/5 10:50
 */

properties 的使用

package org.example.map;

import java.io.FileInputStream;
import java.util.Properties;

/**
 * Properties:常用来处理配置文件。key和value都是String类型。
 * @author AmorFati
 * 2020/10/5 16:24
 */
public class PropertiesTest {
    public static void main(String[] args) 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");

        fis.close();
    }
}

7. Collections工具集

//Collections.copy()
        List dest = Arrays.asList(new Object[list.size()]);
        Collections.copy(dest, list);