20220806 第一组 于芮 list和map（第二十六天）

 

小白成长记——第二十六天

 

    今天主要学习了list和map集合的用法，好像又发现了新大陆，又发现了代码的奥秘，好像写的代码可以越来越少，但是实现的功能可以越来越多，果然，更加努力地学习就会发现更多新的乐趣，来看看今天的学习笔记吧！

list：有顺序的，数据可以重复

vector：和ArrayList几乎一样，

collection和map 的区别
collection：存放单值最大父接口
map：存放对值最大父接口

ArrayList和linklist的区别
arraylist :内部结构是数组，比较适合和高频率的查找和遍历
linklist：双向链表，比较适合高频率的新增和删除

ArrayList和vector的区别
ArrayList线程异步，线程不安全，效率高
vector线程同步，线程安全，效率低

set和list的区别
list：有顺序（先后顺序），元素可以重复
set：无顺序，元素不可以重复，顺序是先后顺序，其实有顺序，内部有一个专门排序的算法，
无序不等于随机，无序是没有按照先后添加顺序

treeset可以排序的集合
排序规则：需要排序的对象的类必须实现compareable接口
compareto方法（返回值int，代表排序结果）
负数-1：比较的两个值调用者小
0：比较的两个值相等
正数1：比较的两个值调用者大

hashset和linkset的区别和联系

比较接口
comparable：自然排序，排序规则固定
compareto：临时排序

map：接口，泛型接口（两个泛型）
存储对值key value(key不能重复，value可以重复)
没有顺序（添加的先后顺序）

hashtable和hashmap的区别
1.hashmap线程异步，线程不安全，hashtable线程同步，线程安全
2.hashmap的key可以为null，hashtable不可以为null的
linkedhashmap：双向链表

priperties：属性
是hashtable的子类，更多的是用来操作属性文件

集合的遍历
list集合的遍历方式
for循环
foreach增强for循环
迭代器（接口）-----iterator

set集合的遍历方式
map集合的遍历
1.for循环
2.增强for循环
entry是hashmap的内部类，每一组键值对是一个entry对象
3.增强for循环
4.迭代器

其他的集合
linkedhashmap
hashmap基础上，维护了一个双向链表
treemap 支持排序
collections是一个工具类

并发修改异常（线程安全问题）
迭代器以来集合存在，判断成功以后，如果集合中新增了元素，迭代器不知道，所以报错

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

     今天主要的实例主要是一些集合的使用实验，还有一些循环、迭代器的应用，实例让我更加理解了集合的应用有多么便捷！

package F0806;

import com.sun.source.tree.Tree;

import javax.xml.transform.Source;
import java.nio.charset.MalformedInputException;
import java.sql.SQLOutput;
import java.time.chrono.MinguoChronology;
import java.util.*;

public class Ch01 {
    /*public static void main(String[] args) {
        LinkedList<String >list=new LinkedList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list .addFirst("z");
        list .addLast("x");
        System.out.println(list.get(2));
        System.out.println(list);
    }*/
    /*public static void main(String[] args) {
        Set<Integer>set=new HashSet<>();
        set.add(Integer.valueOf(200));
        set.add(4);
        set.add(15);
        set.add(38);
        set.add(Integer.valueOf(200));
        System.out.println(set);
    }*/
    /*public static void main(String[] args) {
        Set<Integer>tree=new TreeSet<>();

        tree.add(-100);
        tree.add(50);
        tree.add(10);
        tree.add(100);
        tree.add(-19);
        Set<String>tree1=new TreeSet<>();
        tree1.add("1");
        tree1.add("a");
        tree1.add("hhhhhh");
        System.out.println(tree);
        System.out.println(tree1);
    }*/
    /*public static void main(String[] args) {
        LinkedHashSet<String>set=new LinkedHashSet<>();

        set.add("q");
        set.add("1");
        set.add("e");
        set.add("hhhh");
        System.out.println(set);


    }*/
   /* public static void main(String[] args) {
        List<Person> list = new ArrayList<>(16);
        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().equals(o2.getId())){
                    return 0;
                }
                return 1;
            });
        System.out.println(list);
    }*/
    /*public static void main(String[] args) {
        Map<String,String>map=new HashMap<>();

        map.put("1001","qq");
        map.put("1002","qy");
        map.put("1003","qr");
        map.put("1004","qe");
        map.put("1005","ww");
        System.out.println(map);
        System.out.println(map.get(1002));
        System.out.println(map.values());
        System.out.println(map.keySet());

    }*/
    /*public static void main(String[] args) {
        Map<String,String>map=new HashMap<>();
        map.put(null,null);
        System.out.println(map);
        Hashtable<String,String>table=new Hashtable<>();
        //table(null,null);
        System.out.println(table);
    }*/
    /*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");
       *//* for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }*//*
        *//*for (String s1:list){
            System.out.println(s1);
        }*//*
        //迭代器
        Iterator<String>iterator=list.listIterator();
        while (iterator.hasNext()){
            String s=iterator.next();
            iterator.remove();
            System.out.println(s);
        }
        System.out.println(list);
    }*/
    /*public static void main(String[] args) {
       Set<Integer>set=new HashSet<>();
       set.add(4);
       set.add(12);
       set.add(99);
       //迭代器
        *//*Iterator<Integer>iterator=set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }*//*
        for (Integer integer:set){
            System.out.println(integer);
        }
        *//*for (int i = 0; i < set.size(); i++) {
            System.out.println(set);
        }*/
    /*public static void main(String[] args) {
        Map<String,String>map=new HashMap<>();
        map.put("1001","qq");
        map.put("1002","qw");
        map.put("1003","qe");
        map.put("1004","qr");
        map.put("1005","qt");
        Set<String>strings=map.keySet();
        Iterator<String>iterator=strings.iterator();
        while (iterator.hasNext()){
            String s=iterator.next();
            System.out.println(s+"->"+map.get(s));
        }*/
        //增强for循环
        //entry是hasnmap的一个内部类，每一组键值对就是一个entry对象
        //Set<Map.Entry<String, String>> entries = map.entrySet();
//        for (Map.Entry<String, String> entry : entries) {
//            System.out.print(entry.getKey() + "->");
//            System.out.println(entry.getValue());
//        }

        // 2.增强for循环
//        Set<String> strings = map.keySet();
//        Collection<String> values = map.values();

        // 1.for循环
//        Set<String> strings = map.keySet();
//        for (String s : strings) {
//            System.out.println(s + "->" + map.get(s));
//        }
        /*public static void main(String[] args) {
            List<String>names=new ArrayList<>();
            names.add("qq");
            names.add("q2");
            names.add("qw");
            names.add("qr");
            names.add("q4");
            for (int i = 0; i < names.size(); i++) {
                if(Objects.equals(names.get(i),"l")){
                    names.remove(i);
                    i--;
                }
                if("l".equals(names.get(i))){
                }
            }
            //倒序遍历
            for (int i = names.size()-1; i >=0 ; i--) {
                if(Objects.equals(names.get(i),"l")){
                    names.remove(i);
                }
            }
            //使用迭代器
            Iterator<String>iterator=names.iterator();
            while (iterator.hasNext()){
                String s=iterator.next();
                if(Objects.equals(s,"l")){
                    iterator.remove();
                }
            }
            //增强for循环
            for (String s:names){
                if(Objects.equals(s,"l")){
                    names.remove(names.indexOf(s));
                }
            }
            System.out.println(names);
        }*/
    
    }