java集合框架

Collection接口中声明的常用方法

判断是否包含contains

        Collection list = new ArrayList();
        list.add("obj");
        list.add(123);
        list.add(456);        
        boolean obj = list.contains("obj");//判断当前集合是否包含obj（判断的是内容调用equals方法）
        Collection list1 = Arrays.asList(123, 456);
        list.containsAll(list1);//true判断形参中的所有元素是否都存在当前集合中

移除某个元素remove

		Collection list = new ArrayList();
        list.add(123);
        list.add(456)
        list.remove(123);//会调用equals方法判断是否有，再经行移除
        Collection list1 = Arrays.asList(123, 456);
        list.removeAll(list1);//移除所有元素
        list.add(123);
        list.retainAll(list1);//获取当前集合和list1集合的交集，并返回给当前集合

equals判断当前集合和形参集合的元素是否相等

		Collection list = new ArrayList();
        list.add(123);
        Collection list1=Arrays.asList(123);
        boolean equals = list.equals(list1);//true

hashCode()返回当前对象的哈希值

		Collection list = new ArrayList();
        list.add(123);
        System.out.println(list.hashCode());//返回hash值

toArray()集合转换成数组

		Collection list = new ArrayList();
        list.add(123);
        Object[] objects = list.toArray();//集合转换成数组
        System.out.println(objects[0]);

iterator() 返回Iterator接口的实例，用于遍历元素

集合元素的遍历

hasNext() 判断是否还有元素，next()取出元素

		Collection list = new ArrayList();
        list.add(123);
        list.add(1234);
        list.add(12345);
        Iterator iterator = list.iterator();
        System.out.println(iterator.next());//123 获取元素
        System.out.println(iterator.next());//1234
        System.out.println(iterator.next());//12345
        //遍历方式一  仅用于演示不推荐
        for (int i = 0; i < list.size(); i++) {
            System.out.println(iterator.next());
        }
        //遍历方式二  推荐
        while (iterator.hasNext()){//判断迭代器是否还有内容
            System.out.println(iterator.next());
        }
        //遍历方法三  jdk5.0后新增的 内部仍然是调用迭代器
        for (Object o : list) {
            System.out.println(o);
        }

remove() 移除元素

		Collection list = new ArrayList();
        list.add(123);
        list.add(1234);
        list.add(12345);
        while (iterator.hasNext()){
            Object next = iterator.next();
            if (next.equals(123)){
                iterator.remove();//移除当前元素
            }
        }

List接口 ：存储有序的、可重复的数据

/**
问题：ArrayList、Linked业ist、Vector.三者的异同？
同：三个类都是实现了Lst接口，存储数据的特点相同：存储有序的、可重复的数据
不同：ArrayList:作为list接口的主要实现类，线程不安全，效率高，低层使用Object[] elementData存储
	  LinkedList:对于频繁的插入、删除操作，使用此类效率比ArrayList高：底层使用双向链表存储
	  Vector:作为list接口的古老实现类，线程安全效率低，低层使用Object[] elementData存储
*/

add() 添加元素

		ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(456);
        arrayList.add(1,"AAA");
        System.out.println(arrayList);//[123, AAA, 456]

addAll() 集合中的所有元素都添加到当前集合

		ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(456);
        arrayList.add(1,"AAA");
        List list = Arrays.asList(1, 2, 3);
        arrayList.addAll(list);
        System.out.println(arrayList);//[123, AAA, 456, 1, 2, 3]

get() 获取指定index位置的元素

		ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(456);
        arrayList.add(1,"AAA");
        System.out.println(arrayList.get(0));//123

indexOf() 返回首次出现的位置

 		ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(456);
        arrayList.add(1,"AAA");
        int i = arrayList.indexOf(456);//没找到返回-1
        System.out.println(i);

lastIndexOf() 返回最后出现的位置

remove() 移除指定index位置的元素

set() 设置指定index位置的元素

		ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(456);
        arrayList.add(1,"AAA");
        arrayList.remove(0);
        arrayList.set(0,"BBB");
        System.out.println(arrayList);//[BBB, 456]

sublist() 左闭右开[ ) 截取需要的集合返回

		ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(456);
        arrayList.add("AAA");
        List list = arrayList.subList(1, 3);
        System.out.println(list);//[456, AAA]

常用方法：

增：add
删：remove
改：set
查：get
插入：add（index,obj）
长度：size
遍历：Iterator、增强for

遍历

		//方式一
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //方式二
        for (Object o : arrayList) {
            System.out.println(o);
        }
        //方式三
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }

小考验

删除的到底是哪个

public void testListRemove(){
        List list =new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list);//
    }
    private void updateList(List list){
        list.remove(2);//删除下标2
        list.remove(new Integer(2));//删除内容2
    }

Set接口：存储无序的，不可重复的数据

HashSet:作为set接口的主要实现类：线程不安全的：可以存储null
LinkedHashSet：作为HashSet的子类：遍历其内部数据时，可以按照添加的顺序遍历
TreeSet：可以按照添加对象的指定属性，进行排序。

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

要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()
要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码

1.向TreeSet中添加的数据，要求是相同类的对象。
2,两种排序方式：自然排序和定制排序

小练习

Map接口

**Map:**双列数据，存储ey-value.对的数据
**HashMap:**作为Map的主要实现类：线程不安全的，效率高：存储null的key和value
**LinkedHashMap:**保证在遍历maP元素时，可以按照添加的顺序实现遍历。原因：在原有HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效事高于HashMap。
TreeMap:保证按照添加的key-value.对进行排序，实现排序遍历。底层使用红黑树。
**Hashtable:**作为古老的实现类：线程安全的，效率低：不能存储null的key和value
**Properties:**常用来处理配置文件。key 和 value都是String:类到

HashMap的底层：数组+链表（jdk7及.之前）
数组+链表+红黑树(jdk8)

HashMap的底层实现原理？jdk7为例
HashMap map new HashMap():
在实例化以后，底层创建了长度是16的一维数组Entry[] table.
。。。。这里可能己经执行过多次put。。。
map.put(key1,value1):
首先，调用key1所在类hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry.数组中的存放位置
如果此位置上的数据为空，此时的key1-value1添加成功
如果此位置上的效据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在))，比较key1和己经存在的一个或多个数据的哈希值，如果key1的哈希值与己经存在的数据的哈希值都不相同，此时key1-value.1添加成功。
如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：
如果equals()返回false:此时key1-value.1添加成功。
如果equals()返回true:使用value1.替换相同value2值，
在不断的添加过程中，会涉及到容间题，默以的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。
jdk8相较于)dk7在底层实现方面的不同：
1,new HashMap():底层没有创建一个长度为机6的数组
2,jdk8底层的数组是：Node[],而非Entry[]
3.首次调用那ut()方法时，底层创建长度为6的数组
4,jdh7底层结构只有：数组+链表、jdk8中底层结构：数组+链表+红黑树。
当数组的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64时，此时此索引位置上的所有数据改为红黑树存储

Map的常用方法

put()添加 putAll()同List中的addAll

		HashMap map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("AA",99);
        System.out.println(map);//{AA=99, 45=123}

remove() 移除 按照key

		HashMap map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("AA",99);
        map.remove("AA");
        System.out.println(map);//{45=123}

clear() 清除数据

 		HashMap map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("AA",99);
        map.clear();
        System.out.println(map.size());//0

get() 通过key查询value

        HashMap map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("AA",99);
        System.out.println(map.get(45));//123

containsKey() 是否包含指定的key

		HashMap map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("AA",99);
        boolean aa = map.containsKey("AA");
        System.out.println(aa);//true

Map的遍历

		HashMap map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("AA",99);
        //遍历所有的key集：KeySet
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println();
        //遍历所有的value：values
        Collection values = map.values();
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
        System.out.println();
        //遍历所有的key-values方法一：entrySet()
        Set set1 = map.entrySet();
        Iterator iterator2 = set1.iterator();
        while (iterator2.hasNext()){
            Object obj = iterator2.next();
            Map.Entry entry= (Map.Entry) obj;
            System.out.println(entry.getKey()+"---------->"+entry.getValue());
        }
        System.out.println();
        //遍历所有的key-values方法二：
        Set set3 = map.keySet();
        Iterator iterator3 = set.iterator();
        while (iterator3.hasNext()){
            Object key = iterator3.next();
            Object value = map.get(key);
            System.out.println(key+"===>"+value);
        }

总结常用方法：

添加：put
删除：remove
修改：put
查询：get
长度：size
遍历：KeySet / values / entrySet

properties

Collections工具类的使用

		List list=new ArrayList();
        list.add(123);
        list.add(143);
        list.add(43);
        list.add(-1);
        list.add(0);
        System.out.println(list);
        Collections.reverse(list);//反转
        System.out.println(list);
        Collections.shuffle(list);//对lis集合中元素经行随机排序
        Collections.sort(list);//根据元素的自然顺序对指定L1st袋合元素按升序排序
        Collections.swap(list,0,1);//将指定List集合中的i处元黄和j处元黄进行交换
        Collections.max(list);//根据元素的自然颇序，返回给定第合中的最大元素
        Collections.frequency(list,123);//返回指定集合中指定元素的出现次敬
        //todo 下面是错误写法
        List dest = new ArrayList();
        Collections.copy(dest,list);//将list复制到dest
        //正确写法
        List dest1 = Arrays.asList(new Object[list.size()]);
        Collections.copy(dest1,list);