ArrayList 、LinkList 、HashSet 、HashMap学习记录

我将学习到的内容和自己的一些理解写在了代码的注释里，以下贴几段代码：

一张图：

 Student类：

public class Student {
    private int id;
    private String name;
    private String gender;
    private int age;

    public Student() {
    }
    public Student(int id, String name, int age, String gender) {
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}

下面一段代码是ArrayList与LinkedList的使用和一些方法的比较；在代码中写了一些注释用来解释代码的含义

 public void test1(){
        ArrayList<Student> list = new ArrayList();
        //list是定长的，每次添加时实际上是定义了一个新的array数组，
        // 将原数组和添加的数据加入新数组，将原来的数组替代，
        // 使用时会产生一些中间变量，不适合大规模频繁的增删数据

        // ArrayList底层使用Array数组实现的，是对数组的封装，添加、遍历元素时候可以不用考虑下标
        Student student1 = new Student(1,"zhp",18,"man");
        Student student2 = new Student(2,"zhp",18,"man");
        Student student3 = new Student(3,"zhp",18,"man");
        LinkedList<Student> list1 = new LinkedList<Student>();
        //LinkedList是依据链表的结构建立的，适用于频繁的增删，但本身不能快速定位到下标，只能从头或某个暂存的位置往后查询

        list.add(student1);//在数组表中添加新的对象
        list.add(student2);
        list.add(student3);
        list1.add(student1);//add方法默认是尾插的
        list1.addFirst(student2);//在链表首部添加新节点
        list1.addLast(student3);//在链表尾部添加新节点
        list1.add(1,student3);//在第index个节点后插入
        //list1.pop();//栈方法，抛出最后一个添加的对象
        for (Student student : list1) {
            System.out.println(student);
        }
    /*  输出：
        Student{id=2, name='zhp', age=18, gender='man'}
        Student{id=3, name='zhp', age=18, gender='man'}
        Student{id=1, name='zhp', age=18, gender='man'}
        Student{id=3, name='zhp', age=18, gender='man'}
        */
        for (Student student : list) {
            System.out.println(student);
        }
   /*     Student{id=1, name='zhp', age=18, gender='man'}
        Student{id=2, name='zhp', age=18, gender='man'}
        Student{id=3, name='zhp', age=18, gender='man'}*/
    }

对ArrayList的一些特性的理解

 public void test2(){
        ArrayList list = new ArrayList();//不加< >时list中可以存储多种类型的数据
        list.add("abc");
        list.add(23);
        System.out.println(list);//输出[abc, 23]

        ArrayList<Integer> list1 = new ArrayList();
        /*
        < >中只能写Integer而不能写int，显示：类型参数不能为基元类型。
        < >中只能写封装好的基本数据类型，
        区别：
            Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况；
            即Integer如果未初始化是null，int未初始化会自动为值赋为0；
            Integer将int的各种特性封装到一个类中，通过调用类的方法来实现对数据的操作
        */
        //list1.add("abc");//这句会报错，此时list1只能添加String类型的数据
        list1.add(23);
        System.out.println(list1);//输出[23]
    }

HashSet

public void test3(){
        // ArrayList<Student> list = new ArrayList();
        List<Student> list = new ArrayList<>();
        Student student1 = new Student(1, "zhansgan1", 23, "男");
        Student student2 = new Student(2, "zhansgan2", 23, "男");
        Student student3 = new Student(3, "zhansgan3", 23, "男");
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student1);
        List<Student> list1 = new ArrayList<>();
        list1.addAll(list);
        //上述两行效果等同于List<Student> list1 = new ArrayList<>(list);
        //addAll将list中所有元素添加到list1中，默认添加到尾部
        //可以通过addAll(index,list)指定list1的位置添加
        for (Student student : list1) {
            System.out.println(student);
        }
        /*上述语句输出：
        Student{id=1, name='zhansgan1', age=23, gender='男'}
        Student{id=2, name='zhansgan2', age=23, gender='男'}
        Student{id=3, name='zhansgan3', age=23, gender='男'}
        Student{id=1, name='zhansgan1', age=23, gender='男'}*/
        System.out.println("--------------");
        HashSet<Student> set = new HashSet<Student>();
        /*
        HashSet的存储是无序的，即通过Hash方法按照一定规律插入到set表中，表中数据不一定按照插入顺序排列
        set表中的数据不允许重复，重复的添加会被自动忽略，不会报错
         */
        set.add(student1);
        set.add(student2);
        set.add(student3);
        set.add(student1);//该添加会被忽略
        for (Student student : set) {
            System.out.println(student);
        }
        /*上述语句输出：(此处碰巧按照添加顺序排列，实际上不一定有序)
        Student{id=1, name='zhansgan1', age=23, gender='男'}
        Student{id=2, name='zhansgan2', age=23, gender='男'}
        Student{id=3, name='zhansgan3', age=23, gender='男'}
        */
    }

HashMap

public void test4() {
        Map<String, String> map = new HashMap();
        //HashMap的本质是将map的两个属性(key,value)封装成一个Entry，然后将Entry添加到Set表中
        map.put("cn", "华夏国");
        map.put("us", "漂亮国");
        map.put("uk", "老鹰国");
        // Entry:条目，是对key-value封装
        // Map.Entry<String, String> entry;
        Set<Map.Entry<String, String>> set = map.entrySet();
        //因为Map本身是一个Set表，Map.Entry就是表中的对象类型，<String,String>代表Entry的两个属性key，value是String类型
        //Map提供了方法将map转存到set表中，通过遍历set表实现对map的遍历；
        for (Map.Entry<String, String> entry : set) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
        /*
        输出：（在此体现出了set表的无序性）
        uk : 老鹰国
        cn : 华夏国
        us : 漂亮国
         */
    }