Java集合入门

集合的框架概述

1.集合，数组都是对多个数据进行存储操作的结构，简称Java容器
说明：此时的存储，主要指内存层面的存储，不涉及持久性的存储
2.数组在存储多个数据方面的特点：
 		> 一旦初始化以后，长度就确定了
 		> 数组一旦定义好，其元素类型也就确定了
3.数组在存储多个数据方面的缺点
		>  一旦初始化后长度不可修改
		>  数组中提供的方法非常有限，且效率不高
		>  数组存储数据的特点：有序，可重复。对于无须，不可重复的需求不能满足

Collection

Collection常用方法

    public boolean add(E e)： 把给定的对象添加到当前集合中 。
 
    public void clear() :清空集合中所有的元素。
 
    public boolean remove(E e): 把给定的对象在当前集合中删除。
 
    public boolean contains(E e): 判断当前集合中是否包含给定的对象。
 
    public boolean isEmpty(): 判断当前集合是否为空。
 
    public int size(): 返回集合中元素的个数。
 
    public Object[] toArray(): 把集合中的元素，存储到数组中。

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

Iterator迭代器

1.集合每次调用iterator方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素前。
2.内部定义了remove方法，可以在遍历的时候直接删除集合中的元素，区别于集合直接调用的remove（）

public static void main(String[] args) {
      
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(789);
        
		Iterator iterator = coll.iterator();        //迭代器
        while(iterator.hasNext())                   //迭代器运用
        {
            Object ob = iterator.next();
            if(ob.equals(123))
                iterator.remove();
        }
        
        Iterator iterator1 = coll.iterator();       //遍历方式一
        while(iterator1.hasNext())
        {
            System.out.println(iterator1.next());
        }

        for (Object o:coll      //遍历方式二
             ) {
            System.out.println(o);
        }
    }

List

ArrayList，LinkedList源码分析

ArrayList分析：jdk7
	ArrayList list = new ArrayList();	底层创建长度为10 的Object[]数组elementDate
	list.add(123);		elementDate[0] = new Integer(123);
	...
	list.add(123);		如果此次添加导致底层的elementDate数组容量不够则扩容
	默认情况下，扩容为原来的1.5倍；同时需要将原有数组中的数据复制到新的数组中
-----------------------------------------------------------------------------------------
jdk8中ArrayList中的变化：
ArrayList list = new ArrayList();		底层数组初始化，并未创建长度
list.add(123)		第一次调用add才创建了长度为10 的数组

LinkedList的分析：
LinkedList list	= new LinkedList();		内部声明了Node类型的first和last属性并赋为null
list.add(123);		将123封装到Node中，创建了Node对象

ArrayList，LinkList，Vector三者异同

同：三者都是实现了List接口，存储数据的特点相同：有序，可重复
异：ArrayList：线程不安全，效率高，底层使用Object[] elementDate储存
	LinkedList：底层使用双向链表储存
	Vector：线程安全，效率低，底层使用Object[] elementDate储存

List常用方法

void add​(int index, E element)	将指定元素插入此列表中的指定位置
boolean	addAll​(int index,Collection else)	从index位置开始将else中所有的元素插入
Object get(int index)  	获取指定index位置的元素
int indexOf​(Object o)	返回此列表中第一次出现的指定元素的下标，如果此列表不包含该元素，则返回-1。
int lastIndexOf​(Object o)	返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
Object remove​(int index)	删除此列表中指定位置的元素。
Object	set​(int index, E element)	使用指定的元素替换此列表中指定位置的元素
asList(T[] t)	数组转 List
toArray()	List 转数组

Set

Set：储存无序的，不可重复的数据
以HashSet举例
1.无序性：无序性不等于随机性。储存的数据在底层数组中并非按照索引 的顺序添加，而是根据哈希值
2.不可重复性：保证添加的元素按照equals()判断时，不能返回true，即相同元素只能添加一个

注意：向Set接口的实现类的对象中添加数据obj时，要求obj所在类重写equals方法和HashCode方法。

HashSet

HashSet底层其实是用HashMap实现存储的

具体实现唯一性的比较过程：存储元素首先会使用hash()算法函数生成一个int类型hashCode散列值，然后已经的所存储的元素的hashCode值比较，如果hashCode不相等，则所存储的两个对象一定不相等，此时存储当前的新的hashCode值处的元素对象；如果hashCode相等，存储元素的对象还是不一定相等，此时会调用equals()方法判断两个对象的内容是否相等，如果内容相等，那么就是同一个对象，无需存储；如果比较的内容不相等，那么就是不同的对象，就该存储了，此时就要采用哈希的解决地址冲突算法，在当前hashCode值处类似一个新的链表， 在同一个hashCode值的后面存储存储不同的对象，这样就保证了元素的唯一性。

Set的实现类的集合对象中不能够有重复元素，HashSet也一样他是使用了一种标识来确定元素的不重复，HashSet用一种算法来保证HashSet中的元素是不重复的， HashSet采用哈希算法，底层用数组存储数据。默认初始化容量16，加载因子0.75。达到16*0.75后扩容（2倍）

Object类中的hashCode()的方法是所有子类都会继承这个方法，这个方法会用Hash算法算出一个Hash（哈希）码值返回，HashSet会用Hash码值去和数组长度取模， 模（这个模就是对象要存放在数组中的位置）相同时才会判断数组中的元素和要加入的对象的内容是否相同，如果不同才会添加进去。

LinkedHashSet

作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序遍历

TreeSet

1.向TreeSet中添加的数据，要求是相同类的对象
2.俩种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator）
3.对象是否相同的标准不再是equals而是俩种排序

Map

Map结构的理解：
1.Map中的key：无序的，不可重复的，使用Set存储所有的key
------>所在的类要重写equals，hashcode
2.Map中的values：无序的，可重复的，使用Collection存储所有的values
------>所在的类要重写equals
3.Map中的entry：无序的，不可出发点，使用Set存储所有的entry

HashMap

HashMap的底层原理：
jdk7
HashMap map = new HashMap();
在实例化后，底层创建了长度为16的一维数组Entry[] table
...经历多次put...
map.put(xxx,xxx);
首先，调用key所在类的hashcode计算key的哈希值，此哈希值经历算法计算后，得到Entry数组中存放的位置。
如果此位置为空，此时key-values添加成功 ---------情况1
如果此位置不为空，（意味着此位置存在一个或多个数据（以链表的形式存在）），比较key和已经存储的数据的哈希值：
		如果key的哈希值与已经存在的数据的哈希值都不同，则此时key-values添加成功 --------情况2
		如果key的哈希值和已经存在的某个数据的哈希值相同，继续比较（调用key所在的类的equals）
					如果不相同，则此时key-values添加成功 --------情况3
					如果相同，则将原来的values替换成新的values

补充：情况2，情况3的数据以链表形式存储

当数组达到：默认容量（16）*默认加载因子（0.75）= 扩容临界值（12）后数组扩容，扩容到原来的2倍
------------------------------------------------------------------------------------------------
jdk8
1.new 的时候仅声明，put的时候才创建长度为16的数组
2.底层为Node而非Entry
3.当数组某一个索引位置上的元素以链表形式存在的数据个数 > 8个 且当前数组长度 > 64时，
此时此索引上的所有数据改为用红黑树存储

遍历HashMap的四种方式

● keys() 获取所有 key，values() 获取所有 value

HashMap map = new HashMap();
map.put(1,1);
map.put(2,2);
map.put(3,3);
map.put(4,4);
map.put(5,5);
map.put(6,6);
 
Set<Integer> keys = map.keySet();
for (Integer key : keys) {
    System.out.println(key);
}
Collection<Integer> values = map.values();
for (Integer value : values) {
    System.out.println(value);
}

● 使用 Iterator 迭代器迭代

Iterator iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<Integer, Integer> mapEntry = (Map.Entry<Integer, Integer>) iterator.next();
    System.out.println(mapEntry.getKey() + " === " + mapEntry.getValue());
}

● 使用 get 方式

Set<Integer> keySet = map.keySet();
for(Integer item: keySet) {
    System.out.println( item + "====" + map.get(item));
}

● jdk1.8 后使用 Map 接口中的默认方法

map.forEach((key,value) -> {
    System.out.println(key + "========" + value);
});

HashMap常用方法

Object put(Object key,Object values)：插入/更新
void putAll(Map m)：将m中的全部元素存放到现有的map中
Object 	remove(Object key)：将指定key的key-values对删除
void clear()：清空当前map所有数据

LinkedHashMap

TreeMap

Properties

public class MyProp {
    public static void main(String[] args) throws IOException {
        Properties prop = new Properties();
        FileReader fileReader =
                new FileReader(new File("Day12\\prop.properties"));
        //读取
        prop.load(fileReader);
        fileReader.close();
        System.out.println(prop);
        System.out.println("===============");
        Set<String> keys = prop.stringPropertyNames();
        for (String key : keys) {
            String value = prop.getProperty(key);
            System.out.print(key+"\t"+value);
        }
    }

Collections

Collections与Collection的不同

Collections是工具类，不能被实例化。
而Collection是集合接口，包括List，Set。

Collections常用方法

public class CollectionsTest {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(34);
        list.add(55);
        list.add(56);
        list.add(89);
        list.add(12);
        list.add(23);
        list.add(126);
        System.out.println(list);

        //对集合进行排序
        Collections.sort(list);
        System.out.println(list);

        //对集合进行随机排序
        Collections.shuffle(list);
        System.out.println(list);

        //获取集合最大值、最小值
        int max = Collections.max(list);
        int min = Collections.min(list);
        System.out.println("Max:" + max + " Min: " + min);

        List<String> list2 = Arrays.asList("Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday".split(","));
        System.out.println(list2);

        //查找集合指定元素，返回元素所在索引
        //若元素不存在，n表示该元素最有可能存在的位置索引
        int index1 = Collections.binarySearch(list2, "Thursday");
        int index2 = Collections.binarySearch(list2, "TTTTTT");
        System.out.println(index1);
        int n = -index2 - 1;

        //查找子串在集合中首次出现的位置
        List<String> subList = Arrays.asList("Friday,Saturday".split(","));
        int index3 = Collections.indexOfSubList(list2, subList);
        System.out.println(index3);
        int index4 = Collections.lastIndexOfSubList(list2, subList);
        System.out.println(index4);

        //替换集合中指定的元素，若元素存在返回true，否则返回false
        boolean flag = Collections.replaceAll(list2, "Sunday", "tttttt");
        System.out.println(flag);
        System.out.println(list2);

        //反转集合中的元素的顺序
        Collections.reverse(list2);
        System.out.println(list2);

        //集合中的元素向后移动k位置，后面的元素出现在集合开始的位置
        Collections.rotate(list2, 3);
        System.out.println(list2);

        //将集合list3中的元素复制到list2中，并覆盖相应索引位置的元素
        List<String> list3 = Arrays.asList("copy1,copy2,copy3".split(","));
        Collections.copy(list2, list3);
        System.out.println(list2);

        //交换集合中指定元素的位置
        Collections.swap(list2, 0, 3);
        System.out.println(list2);

        //替换集合中的所有元素，用对象object
        Collections.fill(list2, "替换");
        System.out.println(list2);

        //生成一个指定大小与内容的集合
        List<String> list4 = Collections.nCopies(5, "哈哈");
        System.out.println(list4);

        //为集合生成一个Enumeration
        List<String> list5 = Arrays.asList("I love my country!".split(" "));
        System.out.println(list5);
        Enumeration<String> e = Collections.enumeration(list5);
        while (e.hasMoreElements()) {
            System.out.println(e.nextElement());
        }
    }
}