第四天Java基础02（集合）

1.栈、队列、数组、链表、红黑树

1.栈的结构为桶型，（先进后出）
2.队列为管型，（先进后先出）
3.数组长度不变，增删的时候会新建数组（查询快，增删慢）
4.链表的地址不是连续的，所以查询慢，增删的时候对整体没有影响（查询慢，增删块）

5.红黑树
查询速度非常快

2.List接口（ArrayList、LinkedList）

1.有序、有索引、允许重复元素
2.ArrayList底层使用数组，所以查询快
（System.arraycopy(,)）
3.LinkedList列表结构，查询慢，增删快，里面包含了大量操作首尾元素的方法

3.Vector

1.祖先级别的集合

4.Set接口（HashSet、哈希值、哈希表）

1.HashSet集合，实现了Set接口，不允许储存重复元素，没有索引不能用for遍历。无序集合，底层是个哈希表结构，查询速度非常快。
2.由于没有索引，所以可以用迭代器遍历，也可以用foreach遍历。
3.哈希值是十进制的数，是一个逻辑地址，不是实际地址。
4.hashCode()；方法可以打印哈希地址，

5.HashSet在存值的时候分为两步判断，第一步hashCode(),如果不同就存入，如果相同就调用equals判断。
6.哈希表（数组+链表（红黑树））

5.HashSet存自定义的类型

1.必须重写hashCode和equals.

6.LinkedHashSet

1.在HashSet的基础上又加上了链表。
2.由于这条链表记录了存入位置，所以它是有序的。

7.可变参数的使用与原理

1.其底层原理是数组
2.一个方法中只能有一个可变参数
3.可变参数只能写在最末尾
4.终极写法

public void name(int...arr){
	//这就是可变参数
}

8.集合的工具类（Collections）

1.Collections.addAll(list,“A”,“B”,“C”,…);//批量添加
2.Collections.shuffle(list);//打乱顺序；
3.Collections.sort(lsit);//按照默认排序
4.如果需要对自定义的类进行排序，类中必须实现Comparable接口，并重写compareTo()方法，重新定义排列规则。
5.compareTo（this）- 参数 升序反过来降序。

6.sort方法的另一种使用方式

public static void main(String[] args) {
        ArrayList<User> arr = new ArrayList<>();
        arr.add(new User("迪丽热巴",15));
        arr.add(new User("古力娜扎",16));
        arr.add(new User("玛尔扎哈",14));
        Collections.sort(arr, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o2.getAge() - o1.getAge();
            }
        });
    }

9.Map集合

9.1Map<K,V>

1.双列集合Key,Value
2.Key,Value两者的类型可以不同
3.Key不允许重复，Value允许
4.K与V一一对应

9.2HashMap<K,V>

1.继承Map<k,v>
2.使用了哈希表
3.是无序集合

9.3LinkedHashMap<K,V>

1.加上链表后成为有序集合，存取元素的顺序一致。

9.4Map中常用的方法

9.1.四种方法

Map<String,String> map = new HashMap<>();
        //1.put方法往集合中添加k,v返回被替换的v,如果没有返回null
        String m1 = map.put("A","a");
        //2.remove方法删除K元素返回被删除的V
        String a = map.remove("A");
        //3.get方法获取K对应的V,没有返回null
        String a1 = map.get("A");
        //4.containsKey判断是否存在指定的K
        boolean a2 = map.containsKey("A");

9.2.第一种遍历Map

 public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        String m1 = map.put("A","a");
        String m2 = map.put("B","b");
        String m3 = map.put("C","c");
		//使用迭代器也可以使用增强for循环
        Set<String> k = map.keySet();
        Iterator<String> iterator = k.iterator();
        while(iterator.hasNext()){
            String k = iterator.next();
            String v = map.get(next);
            System.out.println(v);
        }

    }

9.3.第二种遍历方式（Entry）

public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        String m1 = map.put("A","a");
        String m2 = map.put("B","b");
        String m3 = map.put("C","c");

        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String,String> e:entries) {
            String key = e.getKey();
            String value = e.getValue();
            System.out.println(key+":"+value);
        }

    }

9.4.HashMap储存自定义类型的K与V

存自定义的Map时一定要注意，重写hashMap和equals方法，确保K的唯一性。

9.5.LinkedHashMap集合

区别在于有序集合。

9.6.Hashtable集合

1.不允许存null
2.早期的双列集合，比较冷门
3.线程安全
4.Hashtable的子类，Properties与IO流集合，仍然热门。

10.map小练习

public static void main(String[] args) {
        Map<Character,Integer> map = new HashMap<>();
        Scanner sc = new Scanner(System.in);
        System.out.println("亲输入字符串：");
        String str = sc.next();
        char[] chars = str.toCharArray();
        for (char aChar : chars) {
            if(map.containsKey(aChar)){
                Integer Value = map.get(aChar);
                map.put(aChar,++Value);
            }else{
                map.put(aChar,1);
            }
        }
        Set<Character> cs = map.keySet();
        for (Character key : cs) {
            Integer Value = map.get(key);
            System.out.println(key+":"+Value);
        }
    }