List集合,Set集合,Collections集合工具类的方法，Map集合

List

介绍&常用方法

list接口特点：

• 有序的集合，存储和取出元素的顺序是一致的
• 有索引，包含一些带索引的方法
• 允许存储重复的元素

list接口中带索引的方法：

注意：操作索引时要防止越界异常

代码：

 public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("a");
        System.out.println(list);    //[a, b, c, d, e, a]    允许重复元素。打印的不是地址而是元素，说明重写了toString方法
       list.add(3,"theme");  // [a, b, c, theme, d, e, a]  在c和d之间加入theme
        String removeE=list.remove(2); //[a, b, theme, d, e, a]   删除c
        System.out.println("被移除的是"+removeE);  //  被移除的是c
        String setE=list.set(4,"wang");  //[a, b, theme, d, wang, a]  把e替换成wang
        System.out.println("被替换的是"+setE);  //被替换的是e
        System.out.println(list);

 //遍历方式
        //1.普通的for
        for (int i = 0; i < list.size(); i++) {
            String s=list.get(i);   //get方法
            System.out.println(s);
        }
        //2.使用迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        //3.增强for循环(迭代器简化版本）
        for (String s : list) {
            System.out.println(s);
        }
    }

List的子类

Arraylist集合

底层是大小可变的数组，采用多线程

LinkedList集合

pop（）=removeFirst（）
push（）=addFirst（）
1.底层是链表结构——查询慢，增删快
2.里边包含了大量操作首尾元素的方法
注意：使用LinkedList集合特有的方法时，不能用多态

LinkedList<String> linked = new LinkedList<>();
        linked.add("a");
        linked.add("b");
        linked.add("c");
        linked.add("d");
        System.out.println(linked);   //[a, b, c, d]

        linked.addFirst("www");
        linked.addLast("ttttttt");
        System.out.println(linked);    //[www, a, b, c, d, ttttttt]

        linked.push("zzzz");
        System.out.println(linked);   //[zzzz, www, a, b, c, d, ttttttt] 等效于addFirst
        linked.pop();
        System.out.println(linked);  //[www, a, b, c, d, ttttttt]  等效于removeFirst

Vector集合

所有单列集合的原始起源。单线程，慢，被替代了。

Set

继承自Collection接口，不包含重复元素
没有索引，没有带索引的方法，也不能使用普通的for循环遍历

HashSet

特点

• 实现set接口，底层由哈希表支持。
• 没有索引，没有带索引的方法，也不能使用普通的for循环遍历
• 允许null元素。不支持重复元素
• 无序集合，存储和取出元素顺序可能不一样。

代码：

Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(1);
        //使用迭代器遍历set集合
        Iterator<Integer> it=set.iterator();
        while (it.hasNext()){
            Integer n=it.next();
            System.out.println(n);  //1,2,3
        }
        //使用增强for遍历set集合
        for(Integer i:set){
            System.out.println(i);
        }

哈希值

哈希值：是一个十进制的整数，由系统随机给出（就是对象的地址，是一个逻辑地址，是模拟出来得到的地址，不是数据实际存储的物理地址。

// public native int hashCode();    native:代表该方法调用的时本地操作系统的方法
public class hash {
    //Person类继承了Object类，所以可以使用Object类的hashCode方法
    public static void main(String[] args) {
        Person p1=new Person();
        int h1=p1.hashCode();
        System.out.println(h1);

        Person p2=new Person();
        int h2=p2.hashCode();
        System.out.println(h2);
        /*
        toString方法的源码：
          return getClass().getName() + "@" + Integer.toHexString(hashCode());
        */
        System.out.println(p1);      //hash.Person@27f674d
        System.out.println(p1);      //hash.Person@27f674d
        System.out.println(p1==p2);  //false
//        String 类的哈希值：String类重写Object类的hashCode方法
        String s1=new String("abc");
        String s2=new String("abc");
        System.out.println(s1.hashCode());   //96354
        System.out.println(s2.hashCode());   //96354
    }
}

HashSet集合存储数据的结构

• 特点：速度快
• jdk8以后：哈希表=数组+链表；
  哈希表=数组+红黑树（提高查询速度）；
• 数据结构：把元素进行分组（相同哈希值（哈希冲突）的元素为一组）链表/红黑树结构把相同哈希值的元素连接到一起。
• 如果链表长度超过8位，就会把链表转换为红黑树，提高查询速度

Set集合存储元素不重复的原理

Set集合在调用add方法的时候，add方法会调用元素的hashCode方法和equals方法，判断元素是否重复。
前提：存储的元素必须重写hashCode方法和equals方法

LinkedHashSet集合

底层是一个哈希表（数组+链表/红黑树）+链表：多了一条链表（记录元素的存储顺序），保证元素有序。

Collections

• Collections.addAll(list,“a”,“b”,“c”,“d”,“e”); 往集合中添加多个元素
• public static void shuffle（list<?> list) ； 打乱集合顺序
• public static void sort(list list):将集合中的元素按照默认规则排序 – 默认升序

 public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"a","c","b");
        System.out.println(list);    //[a, c, b]
        //public static <T> void sort(list<T> list):将集合中的元素按照默认规则排序 -- 默认升序
        Collections.sort(list);
        System.out.println(list);    //[a, b, c]
    }

• 如果要存储自定义类型的数据，需要重写Comparable接口C
• Comparable接口：自己（this）和别人（参数）比较
• Comparator接口：相当于找一个第三方裁判，比较两个
  Comparable接口的排序规则：自己（this）-参数 （升序）
  Comparator接口的排序规则： o1-o2：升序

Map

特点：

1. 双列集合，一个元素包含两个值（key，value）
2. key和value的数据类型可以相同，也可以不同
3. key是不允许重复的，value是可以重复的
4. key和value是一一对应的

子类：

LinkedHashMap：

 HashMap<String, String> map = new HashMap<>();
        map.put("a","a");
        map.put("c","c");
        map.put("d","d");
        map.put("b","b");
        map.put("a","e");
        System.out.println(map);   //{a=e, b=b, c=c, d=d}  不允许key重复，无序

 LinkedHashMap<String, String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("a","a");
        linkedHashMap.put("c","c");
        linkedHashMap.put("b","b");
        linkedHashMap.put("e","e");
        linkedHashMap.put("a","d");
        System.out.println(linkedHashMap);  //{a=d, c=c, b=b, e=e}   不允许key重复，有序

HashTable集合

• HashTable：底层也是一个哈希表，是一个线程安全的集合，是单线程集合，速度慢

• HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快

• HashMap集合（之前学的所有集合）：可以存储null值，null键

• HashTable集合，不能存储null值，null键

• HashTable和Vector集合一样，在jdk1.2版本后被更先进的集合（HashMap，ArrayList）取代了

• HashTable的子类 Properties依然活跃在历史舞台