JAVA笔记7.24

集合

集合的概念：
同一类事物放在一起组成了集合。（引用数据类型，这是和数组最大的区别）

集合：Collection（接口） 父类是Iterable（接口：功能是集合的迭代遍历）

集合的分类：

1. List（接口）：有序可以重复 常见实现类：ArrayList（数组实现）LinkedList（链表实现）
2. Set（接口）：无序不可重复 常见实现类： HashSet（哈希表实现）TreeSet（二叉树实现）

ArrayList集合

ArrayList实现了List接口（List继承了collection接口）

一个类实现了一个接口，那么我们就要重写这个接口里的（抽象）方法， 也就是说接口里的方法是大家都有的

集合里面的方法：主要是增删改查

ArrayList：书写格式

ArrayList<Object> 变量名 = new ArrayList<>();

<>中放的泛型，指的就是集合里面放入的数据类型
泛型的好处：引用数据类型

• 省去了从集合中取出数据时的强制类型转换
• 加了泛型，就会要求我们放入数据的时候，只能放入该数据类型的数据，那么取出来的时候也是这种数据类型
• <>放我们指定的数据类型

Object：是所有类的父类

ArrayList方法：

1. 底层就是数组（object[]）
2. Arraylist 元素个数 size（）方法
3. 增（添加） add（元素）
4. 数组长度和size不是一回事，如果size（）小于数组长度，直接将元素放入到数据中，如果size（）等于数组长度，会自动扩容
5. 删（删除） remove（索引）删除第一次出现的内容 remove（元素）删除指定位置
6. 改（修改） set（索引，元素）
7. 查（查找） get（索引）

集合的特点:
集合里所有内容被叫为元素

例：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("张三");
        System.out.println(list);
        list.remove(1);
        System.out.println(list);
        String s = list.set(0, "赵六");
        System.out.println("修改前的内容为："+s);
        System.out.println(list.get(0));
        for (String ss : list) {
            System.out.println(ss);
        }
    }

ArrayList是LinkedList的区别：

1. ArrayList底层是数组，查询快，增删慢
2. LinkedList查询慢。增删快
3. 底层结构不同 数组 链表

HashSet集合

HasSet：

1. 无序（没有索引）不重复（可以去重）
2. hashset开发时使用较少，一般集合都是用ArrayList
3. 在某些场合下也需要ArrayList去重，可以使用hashset

Hashset和hashTable的区别：

1. hashset是线程不安全的，效率高，允许null值
2. HashTable是线程安全的，效率低，不允许null值
   例：

 HashSet<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(1);
        System.out.println(set);
        for (Integer i:set) {
            System.out.println(i);
        }
        set.remove(1);
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
         set.clear();
        System.out.println(set);

HashSet去重：

 ArrayList<String> names = new ArrayList<>();
        names.add("张三");
        names.add("李四");
        names.add("张三");
        names.add("王五");
        names.add("赵六");
        HashSet<String> set1 = new HashSet<>(names);
        names = new ArrayList<>(set1);
        System.out.println(names);

For 和for each区别

for可以操作索引，但是语法结构相对复杂

for（循环变量，循环条件，迭代）{}

Foreach不可以操作索引，但语法结构相对简单

for（循环变量：集合）{
}

HashMap集合

Hashmap：双列集合

1. 增 map.Put（key，value） key键 value值 键值对
2. 改（和增加语法相同，如果键存在就是修改，如果不存在就是增加） map.Put（key，value）
3. 查 value类型 键 = map.get(键名)
4. 删 map.remove（键）
5. 拿到索引键的集合 集合名<键的数据类型> 新集合名 = map.set()
6. 遍历

拿到所有键的集合，可以根据键去拿值
Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(key+"---"+map.get(key));
        }

例：

public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("老王",73);
        map.put("小王",23);
        System.out.println(map);
        map.put("老王",46);
        System.out.println(map);
        Integer age = map.get("小王");
        System.out.println(age);
        for (String s : map.keySet()) {
            System.out.println(s+map.get(s));
        }
        map.remove("老王");
        System.out.println(map);

    }

Jdk8 hashmap

1. 底层是数组+列表+红黑树
2. hashmap负载因子：0.75 元素个数超过数组长度的0.75倍，数组就会扩容，是原数组的2倍
3. 链表的长度超过8，链表就会转换成红黑树，如果红黑树长度小于6，红黑树就会转换成链表
4. Hashmap的初始容量是16；