2021-7-20集合

1.集合的继承结构

Collection—接口

 

List---接口--序列，元素是有下标有序的，允许存放重复的数据

        ArrayList--底层结构是数组，查询快，增删慢，适合查询,连续的内存空间（将ArrayList的容量变为10；之后扩容会按照1.5倍增长。）

        LinkList--底层结构是链表，查询慢，增删快 不连续的内存空间

import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class TestList2 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("喜洋洋");
        list.add("美洋洋");
        list.add("懒洋洋");
        list.add("沸洋洋");
        list.add("小肥洋");
        list.add("肥羊卷");
        System.out.println(list);
        for (int i = 0; i <list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("==================================");
        for (String a:list) {
            System.out.println(a);
        }
        System.out.println("==================================");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("==================================");
        ListIterator<String> stringListIterator = list.listIterator();
        while (stringListIterator.hasNext()){

            System.out.println(stringListIterator.next());
    }
    }
}

Set--接口

        无序的,不允许重复的数据，允许有null，最多一个

        自定义对象想去重，重写equals()与hashCode()

Map--接口

底层结构 ：数组+链表

                   数组+红黑树

底层为Entry Map的初始容量是16,默认的加载因子是0.75

1）会拿到当前entry中的key做运算，得出当前entry应该放在entry【】的哪个位置

2）如果两个entry的key值经过运算，余数相等，表示这两个entry的数组下标一致

3）如果存在冲突的情况，可以把新entry链接到旧entry之后，形成链表

4）当链表长度大于8时会转成红黑树，小于6会恢复成链表

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*本类用于测试map接口*/
public class TestMap {
    /*Map中的数据符合对应规则，一定要同时指定K和V的数据类型
    * key不允许重复，如果重复则value覆盖，
    * map存放着的都是无序的数据
    * value可以重复
    * */
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap();
        map.put(9527, "白骨精");
        map.put(9528, "黑熊精");
        map.put(9529, "鲤鱼精");
        map.put(9530, "黄毛怪");
        System.out.println(map);
        /*方法测试*/
        /*  map.clear(); 清除*/
        /*  System.out.println(map.hashCode());
        System.out.println(map.equals(""));
        System.out.println(map.isEmpty());
        System.out.println(map.size());
        System.out.println(map.containsKey(9528));
        System.out.println(map.containsValue("黄毛怪"));
        System.out.println(map.get(9530));*/
        //key value 全部删除
        //System.out.println(map.remove(9529));
        //所有values
        // System.out.println(map.values());
        //map迭代
        /*方式一:遍历map中的数据，但是mao本身没有迭代器，所以需要
        先转换成set集合
        * 把map所有key值存入到set集合当中--keySet（）；
        * */
        Set<Integer> integers = map.keySet();
        Iterator<Integer> iterator = integers.iterator();
        while (iterator.hasNext()){
            System.out.println(map.get(iterator.next()));
        }
        /*方式二
        * 遍历map集合，需要先把map集合先转成set集合
        * 是把map中的一对键值对key&value作为一个Entry<k,v>整体放入set
        * 一对k，v就是一个Entry
        * */
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iterator1 = entries.iterator();
        while (iterator1.hasNext()){
            System.out.println(map.get(iterator1.next().getKey()));
        }
    }
}

2.集合的学习方法：学习父级的公共方法，学习子类如何创建对象

注意：  我们所说的慢与快是相对而言的，建立在数据量比较大的情况

            链表结构针对查询而言，首尾操作比较快，中间操作比较慢

泛型的作用：为了在编译时就检查数据类型，限制集合的元素类型，还可以

                      帮我们写出更加通用的代码，比如泛型方法

注意！！！

如果集合不加泛型，不会报错，但是集合元素可以任意；

使用泛型方法时，有两处位置需要添加泛型，这是语法；

<type>必须是引用数据类型，不可以基本数据类型；

泛型是一颗“语法糖”，泛型只在编译生效，字节码文件中没有泛型。

//统计字符串字符个数
package cn.tedu.list;

import sun.security.action.PutAllAction;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class TestMap2 {
    /*统计字符个数*/
    public static void main(String[] args) {
        String a=new Scanner(System.in).nextLine();
        Map<Character,Integer> map = new HashMap();
        for (int i = 0; i <a.length() ; i++) {
            char key=a.charAt(i);
            if (map.containsKey(key)){
               Integer value = map.get(key);
                System.out.println(value);
                map.put(key,++value);
            }else {
                map.put(key,1);
            }
            /*Integer value = map.get(key);
            if (value==null){
                map.put(key,1);
            }else{
                map.put(key,value+1);
            }*/
        }
        System.out.println(map);
    }
}