集合的学习

List

List:数据是有顺序的（添加的先后顺序）的，数组是可以重复的。
ArrayList:内部结构是数组，比较适合做高频率的查找遍历。线程异步的不安全。
LinkList:双向链表。比较适合做高频率的新增和删除。
Vector：和ArrayList几乎一摸一样，线程同步的安全。

面试题：

1.collection和map接口的区别：存储单值，存储复值

2.ArrayList和LinkedList的区别

3.ArrayList和Vector的区别

public static void main(String[] args) {
    //List<String> list=new LinkedList<>();
    LinkedList<String> list=new LinkedList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    //我们在创建对象的时候是多态
    //父类对象指向子类引用
    //我们创建出来的对象只能够调用父类和子类中都有的方法
    list.addFirst("z");
    //根据下标索引获取指定位置的元素
    String z = list.get(list.indexOf("z"));
    System.out.println(z);
    System.out.println(list);
}

Set

List：有顺序，元素一颗重复，顺序值得是添加的先后顺序

Set（二叉树加链表）：无序，没有顺序，元素不可以重复，顺序指的是添加的先后顺序

Set集合其实是有顺序的，内部有一个专门排序的算法。

1.所谓的无序不等于随机

2.所谓的无序指的是没有按照添加的先后顺序，其实内部是做了排序的。

public static void main(String[] args) {
    Set<Integer> set=new HashSet<>();
    set.add(1);
    set.add(3);
    set.add(4);
    set.add(5);
    set.add(1);
    System.out.println(set);
}

面试题：

1.List和Set的区别

2.HashSet和LinkedHashSet(链表)的区别和联系？

Set集合如何确保数据的不重复

保证数据类型的类要重写hashCode和equals方法。

TreeSet默认从小到大排序的

TreeSet的排序规则

要排序的对象的类必须事项Comparable接口

LinkHashSet(链表):在添加数据的同时维护数据的添加顺序
效率要比HashSet略低一些。

比较接口：
Comparable：接口：自然排序，排序规则是固定的
Comparator：接口：临时排序

public static void main(String[] args) {
    List<Person> list = new ArrayList<>();
    list.add(new Person("李四", 1100));
    list.add(new Person("张岳", 1010));
    list.add(new Person("刘海柱", 1020));
   /* list.sort(new Comparator<Person>() {
        @Override
        public int compare(Person o1, Person o2) {
            return 0;
        }
    });*/
    list.sort((o1, o2) -> {
        //临时排序
        if (o1.getId() < o2.getId()) {
            return -1;
        }
        if(o1.getId()==o2.getId()){
            return 0;
        }
        return 1;
    });
    System.out.println(list);
}

Map

Map:接口

1.存储对值的K-V

2.key是不能重复的，value是可以重复的

3没有添加的先后顺序

HashMap的内部存储结构：

jdk1.7之前；链表+二叉树

jdk1.8及之后：链表+数组+红黑树

HashMap面试上90%会问。

public static void main(String[] args) {
    Map<String ,String> map=new HashMap<>();
    map.put("1001","张岳");
    map.put("1002","赵红兵");
    map.put("1003","小北京");
    map.put("1004","李四");
    map.put("1004","张浩然");
    map.put("1005","张浩然");
    String s = map.get("1003");
    Collection<String> values = map.values();
    Set<String> strings = map.keySet();
    System.out.println(strings);
    System.out.println(values);
    //System.out.println(s);
    //System.out.println(map);

}

Hashtable和HashMap几乎一摸一样

Hashtable线程安全

面试题：Hashtable和HashMap的区别

1. HashMap是线程异步，线程不安全，Hashtable是线程同步，线程安全

2. HashMap的key是可以为null的Hashtable是不可以为null的

LinkedHashMap：双线链表。

集合的遍历

public static void main(String[] args) {
    List<String> list=new ArrayList<>();
    list.add("1");
    list.add("1");
    list.add("1");
    list.add("1");
    //普通for循环遍历
 /*   for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
	增强for循环遍历
    for (String s : list) {
        System.out.println(s);
    }*/
    //3.迭代器遍历数组
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()){//判断是否有下一个元素
        System.out.println(iterator.next());//拿到下一个元素
        
    }

set集合的遍历

public static void main(String[] args) {
    Set<Integer> set = new HashSet<>();
    set.add(1);
    set.add(2);
    set.add(3);
    set.add(4);
    //增强for循环遍历
    /*for (Integer integer : set) {
        System.out.println(integer);
    }*/
    //迭代器遍历
    Iterator<Integer> iterator = set.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

map集合的遍历

public static void main(String[] args) {
    Map<String,String> map=new HashMap<>();
    map.put("sun","sss");
    map.put("sun1","sss");
    map.put("sun2","sss");
    map.put("sun3","sss");
    Set<String> keySet = map.keySet();
    Collection<String> values = map.values();
    //Entry是HashMap的内部类
    //每一组键值对就是一个Entry
    Set<Map.Entry<String, String>> entries = map.entrySet();
    for (Map.Entry<String, String> entry : entries) {
        System.out.println(entry.getKey()+"-->"+entry.getValue());
    }
}

在迭代中删除元素

public static void main(String[] args) {
    List<String> names=new ArrayList<>();
    names.add("tom");
    names.add("lucy");
    names.add("lucy");
    names.add("lucy");
    names.add("jerry");
    //1.回调指针
   /* for (int i = 0; i < names.size(); i++) {
        if("lucy".equals(names.get(i))) {
            names.remove(i);
            //回调指针
            i--;
        }
    }*/
    //2.逆序遍历
   /* for (int i = names.size()-1; i >=0 ; i--) {
        if("lucy".equals(names.get(i))) {
            names.remove(i);
        }
    }*/
    //3.使用迭代器
   /* Iterator<String> iterator = names.iterator();while(iterator.hasNext( )) {
        String s = iterator.next();
        if(Objects.equals(s, b: "lucy" )){
            iterator.remove();
        }
    }*/

    System.out.println(names);
}

其他的集合

其他的集合：
1.LinkedHashMap，在HashMap的基础上维护了一个双向链表。
2.TreeMap:天然支持排序的
3.Collections:Collections是一个工具类

线程安全问题

线程安全问题:
迭代器是依赖于集合而存在的，判断成功以后，集合中新增了元素，
迭代器不知道，所以就报错了

解决：
1.迭代器遍历元素，迭代器删除元素
2.普通for循环遍历，集合删除