Java集合

Java集合：

1.collection接口：

/*
* 集合和数组的区别 --
*   继承：共性抽取
*   Collection<E>接口 单列集合最顶层接口（抽象）
*   Collection接口（父）：List接口（子）  Set接口（子）
* List：有序集合（存储和取出有序） 允许存储重复的元素 有索引（可以用普通for循环）
*         代表： Vector    LinkedList  ArrayList
*       ArrayList：底层数组实现，查询快，增删慢
*       LinkedList：底层链表实现，查询慢，增删快(含有大量操作首位元素的方法)
*              addFirst addLast getFirst getLast removeLast。。
*       Vector：底层数组（同步 单线程）
* Set：不允许有重复的元素  没有索引（不能用普通的for循环遍历）
*         代表： HashSet（LinkedHashSet）  TreeSet
*       HashSet：底层哈希表实现，存取无序 （哈希表查找很快）
*			HashSet如何判定两个元素相同：
*      		  先判断HashCode值，若相同则再调用equals方法判断，当两个都成立时，则相同元素。
*       LinkedHashSet：底层哈希表+链表实现，有序存取	继承HashSet			
*       TreeSet：底层二叉树实现，一般用于排序
*
* Collection接口 提供了很多方法：
*       add remove clear（清空集合） contains（是否包含某个元素）
*       isEmpty（判断集合是否为空） size  Object[] toArray(转成数组)
*
* Iterator接口 迭代器：
* 迭代：Collection集合中通用的获取方式（取出元素）
*       步骤：1.取出元素之前先判断是否有元素
*            2.有，取出，继续判断，直到取完为止
*       方法：Boolean hasNext() 有元素返回true
*            Next() 返回迭代器下一个元素
*       使用步骤：Iterator接口无法直接使用，需要实现类对象
*           1.使用集合中的iterator方法，获取实现类对象，使用Iterator接收
*           2.使用hasNext()判断是否有元素
*           3.使用Next()取出元素
*
* 泛型：未知类型 类 接口等都可以使用泛型
*       泛型通配符：？
*
*  Collections集合工具类
*       static <T> boolean addAll(Collection<? super T> c, T... elements)
*               将所有指定元素添加到指定 collection 中。
*       static void shuffle(List<?> list, Random rnd)
*               使用指定的随机源对指定列表进行置换。static <T> void
*       sort(List<T> list, Comparator<? super T> c)
*               根据指定比较器产生的顺序对指定列表进行排序。
*               sort使用前提：被排序里面参数必须实现Comparable，重写接口中compareTo定义的排序规则
*               this-参数：升序
*        static <T extends Comparable<? super T>> void sort(List<T> list)
*               根据元素的自然顺序 对指定列表按升序进行排序。
*
* */
public class JavaCollection {

    public static void main(String[] args) {
        Collection<String> coll=new HashSet<>();
        coll.add("1");
        coll.add("2");
        coll.add("3");
        coll.add("4");
        coll.add("5");
        //转换成数组
        Object[] obj=coll.toArray();
        for (int i = 0; i < obj.length; i++) {}

        //Iterator接口 迭代器
        Iterator<String> iter=coll.iterator();
       while(iter.hasNext()){
            System.out.println(iter.next());
        }
//        for (String s : coll) {
//            System.out.println(s);
//        }
//       //for循环格式 增强for 低底层也是迭代器
//        for (Iterator<String> iter2=coll.iterator();iter.hasNext();) {
//            System.out.println(iter2.next());
//        }
        // 泛型通配符：？使用
        ArrayList<String> coll1=new ArrayList<>();//字符
        coll1.add("abc");
        ArrayList<Integer> coll2=new ArrayList<>();//数字
        coll2.add(1);
        printArray(coll1);
        printArray(coll2);

//        addAll  shuffle  sort
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"a","b","c","c","d");
        Collections.shuffle(list);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        ArrayList<Integer> list1=new ArrayList<>();
        Collections.addAll(list1,1,2,3,4,5);
        Collections.sort(list1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(list1);

    }
    public static void printArray(ArrayList<?> list){
       Iterator<?> iter=list.iterator();
       while(iter.hasNext()){
           System.out.println(iter.next());
       }
    }

}

Map集合：

/*
*   Map<K,V>接口
*       特点：
*           1.map是一个双列集合，由键值对构成，一个元素包含两个值（key，value）
*           2.K和V的数据类型可以相同，也可以不同
*           3.K的元素不能重复，value可以重复，K和V是一一对应的
* 实现类：
*       1.HashMap<k,v> 底层是哈希表，查询速度特别快
*               1.JDK1.8之前 数组+链表
*               2.JDK1.8之后 数组+链表/红黑树
*               3.HashMap是一个无序的集合，存取的顺序可能会不一致
*       2.LinkedHashMap<K,V>：extends HashMap<k,v>
*               1.底层是一个哈希表+链表（保证迭代的顺序）
*               2.是一个有序的集合，存取的顺序一致
*       3.Hashtable<K,V>：底层是一个哈希表
*                1.不能存储null值
*                2.单线程（慢）
*                3.hashtable和vector已被取代 但hashtable的子类properties依旧活跃
*                   properties集合是唯一一个和IO流相结合的集合
* */
public class JavaMap {
    //Map中的方法：
    /*
      1.V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。
      2.V get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返null。
      3.boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
      4.V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
      遍历1：5. Set<K> keySet() 返回此映射中包含的键的 Set 视图。 Map集合的key值存储到set集合中。
      遍历2：6.Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。
      map集合中有一个内部接口Enter，作用：map集合一创建，就会创建一个Enter对象，来记录键和值
               此方法相当于把这Enter对象放到set集合中，遍历set集合可以获得enter对象
               Enter里面有getKey和getValue方法
         280
         存储自定义类型 person自定义类
         例如HashMap<String,Person> map=new HashMap<>();
         map.put("String",new Person());
         注意点：若person作为value可以存在同名现象
                若person作为key则需要重写hashCode方法和equals方法
         */
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();
        //put若key相同，则添加时会替代
        map.put(1,"aaa");
        map.put(2,"bbb");
        map.put(3,"ccc");
        //Map从1开始
        for (int i = 1; i <=map.size(); i++) {
            System.out.println(map.get(i));
        }
        //remove移除后元素不会向前移，但长度会减少
        map.remove(1);
        for (int i = 1; i <=map.size(); i++) {
            System.out.println(map.get(i));
        }
        //Set<K> keySet() 遍历Map
        Set<Integer> set=map.keySet();
        //增强for
        for (Integer o : set) {
            System.out.println(map.get(o));
        }
        for (Integer o : map.keySet()) {
            System.out.println(map.get(o));
        }
        //迭代器
        Iterator<Integer> it=set.iterator();
        Iterator<Integer> it1=map.keySet().iterator();
        while(it.hasNext()){
            System.out.println(map.get(it.next()));
        }
        //boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
        System.out.println(map.containsKey(1));//true
        System.out.println(map.containsKey(4));//false
        //Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。
        //Map.Entry<Integer,String>-->指定就是Enter对象
        Set<Map.Entry<Integer,String>> set1=map.entrySet();
        Iterator<Map.Entry<Integer,String>> iterator=set1.iterator();
        while (iterator.hasNext()){
            //获取Enter对象
            Map.Entry<Integer,String> enter=iterator.next();
            System.out.println(enter.getKey());
            System.out.println(enter.getValue());
        }
        //增强for循环
        for (Map.Entry<Integer, String> integerStringEntry : set1) {
            integerStringEntry.getValue();
            integerStringEntry.getKey();
        }
        //Hashtable不允许出现空值
        Hashtable<String,String> table=new Hashtable();
        table.put("a","a");
        table.put(null,null);//报错NullPointerException
        HashMap<String,String> map1=new HashMap<>();
        map1.put(null,null);
    }
}

哈希表：

/*
* 哈希表：
*   在jdk1.8版本之前：哈希表=数组+链表
*              之后：哈希表=数组+链表/红黑树速度快
* 即链表长度超过8位自动转换红黑树
*/