学习记录——进阶版03

@学习记录

开始学习Java

遵从同学的指导，从Java se开始学习

黑马的JavaSE零基础入门【List、Set、数据结构、Collections】

第一章 数据结构

1.1 数据结构有什么用

1.2 常见的数据结构

栈
队列
数组
链表
红黑树

day14-02 数据结构_栈（先进后出）

day14-03 数据结构_队列（先进先出）

day14-04 数据结构_数组（查询快，增删慢）

day14-05 数据结构_链表（查询慢，增删快）

　　感觉视频关于单向链表和双向链表的解释并没有很清楚，参考下述图表

day14-06 数据结构_红黑树（查询速度快）

　　完全二叉树和不完全二叉树，这一部分讲的不太好，不如去看数据结构相关的书

第二章 List集合（有序，有索引，允许重复元素）

2.1 List接口介绍

2.2 List接口中常用方法

day14-07 List集合＿介绍＆常用方法

package day_03.Demo01;

/*
java.util.List接口 extends Collection接口

List接口的特点：
1.有序的集合，存储元素和取出元素的顺序是一致的（存储123，取出123）
2.有索引，包含了一些带索引的方法
3.允许存储重复的元素

List接口中带索引的方法（特有）
    public void add(int index, E element); 将指定的元素添加到集合中指定位置上
    public E get(int index); 返回集合中指定位置的元素
    public E remove(int index); 移除列表中指定位置的元素，返回的是被移除的元素
    public E set(int index, E element); 用指定元素替换集合中指定位置的元素，返回更新前的元素
注意：操作索引的时候，一定要防止索引越界异常
 */

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo01List {
    
    
    public static void main(String[] args) {
    
    
        // 创建一个List集合对象，多态
        List<String> list = new ArrayList<>();
        // 使用add方法往集合中添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");
        // 打印集合
        System.out.println(list); // 不是地址，重写了toString方法
        System.out.println("=========================");

        // public void add(int index, E element); 将指定的元素添加到集合中指定位置上
        list.add(4, "cvo");
        System.out.println(list);
        System.out.println("=========================");

        // public E remove(int index); 移除列表中指定位置的元素，返回的是被移除的元素
        String remove = list.remove(2);
        System.out.println(remove);
        System.out.println(list);
        System.out.println("=========================");

        // public E set(int index, E element); 用指定元素替换集合中指定位置的元素，返回更新前的元素
        String set = list.set(3, "sdwe");
        System.out.println(set);
        System.out.println(list);
        System.out.println("=========================");

        // List集合有3种遍历方式
        // 1.使用普通for循环
        for (int i = 0; i < list.size(); i++) {
    
    
            // public E get(int index); 返回集合中指定位置的元素
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("=========================");

        // 2.使用迭代器
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
    
    
            String s = iterator.next();
            System.out.println(s);
        }
        System.out.println("=========================");

        // 3.使用增强for循环
        for (String s : list) {
    
    
            System.out.println(s);
        }
    }
}

第三章 List的子类

3.1 ArrayList集合(多线程?)

day14-08 List集合＿介绍＆常用方法

3.2 LinkedList集合(List接口的链接列表实现,多线程)

day14-09 LinkedList集合

package day_03.Demo01;

/*
java.util.LinkedList集合 implements List接口

LinkedList集合的特点：
1.底层是一个链表结构：查询慢，增删快
2.包含了大量操作守卫元素的方法
注意：使用LinkedList集合特有的方法，不能使用多态

    public void addFirst(E e); 将指定元素插入此列表的开头
    public void addLast(E e); 将指定元素插入此列表的结尾，等效于add方法
    public void push(E e); 将元素推入此列表所表示的堆栈,等效于addFirst方法

    public E getFirst(); 返回此列表的第一个元素
    public E getLast(); 返回此列表的最后一个元素

    public E removeFirst(); 移除并返回此列表的第一个元素
    public E removeLast(); 移除并返回此列表的最后一个元素
    public E pop(); 从此列表所表示的堆栈处弹出一个元素,相当于removeFirst

    public boolean isEmpty(); 如果此列表不包含元素，则返回true

 */

import java.util.LinkedList;

public class Demo02LinkedList {
    
    
    public static void main(String[] args) {
    
    
//        show01();
//        show02();
        show03();

    }

    private static void show01() {
    
    
        // 创建LinkedList集合对象
        LinkedList<String> list = new LinkedList<>();
        // 使用add方法往集合中添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        System.out.println(list);
        System.out.println("==================");

        // public void addFirst(E e); 将指定元素插入此列表的开头
        list.addFirst("e");
        System.out.println(list);
        System.out.println("==================");

        // public void addLast(E e); 将指定元素插入此列表的结尾
        list.addLast("g");
        System.out.println(list);
        System.out.println("==================");

        // public void push(E e); 将元素推入此列表所表示的堆栈
        list.push("q");
        System.out.println(list);
        System.out.println("==================");

    }

    private static void show02() {
    
    
        // 创建LinkedList集合对象
        LinkedList<String> list = new LinkedList<>();
        // 使用add方法往集合中添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        System.out.println(list);
        System.out.println("==================");

//        list.clear();

        if (!list.isEmpty()) {
    
    
            // public E getFirst(); 返回此列表的第一个元素
            String first = list.getFirst();
            System.out.println(first);

            // public E getLast(); 返回此列表的最后一个元素
            String last = list.getLast();
            System.out.println(last);

        }

    }

    private static void show03() {
    
    
        // 创建LinkedList集合对象
        LinkedList<String> list = new LinkedList<>();
        // 使用add方法往集合中添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        System.out.println(list);
        System.out.println("==================");

        // public E removeFirst(); 移除并返回此列表的第一个元素
        String first = list.removeFirst();
        System.out.println(first);
        System.out.println(list);
        System.out.println("==================");

        // public E removeLast(); 移除并返回此列表的最后一个元素
        String last = list.removeLast();
        System.out.println(last);
        System.out.println(list);
        System.out.println("==================");

        // public E pop(); 从此列表所表示的堆栈处弹出一个元素
        String pop = list.pop();
        System.out.println(pop);
        System.out.println(list);

    }


}

第四章 Set接口

4.1 HashSet集合介绍

day14-11 HashSet集合介绍

package day_03.Demo02;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/*
java.util.Set接口 extends Collection集合

Set接口的特点：
1.不允许存储重复的元素
2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历

java.util.HashSet集合 implements Set接口
HashSet特点：
1.不允许存储重复的元素
2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
3.是一个无需的集合，存储元素和取出元素的顺序有可能不一致
4.底层是一个哈希表结构（查询速度非常快）

 */
public class Demo01Set {
    
    
    public static void main(String[] args) {
    
    
        Set<Integer> set = new HashSet<>();
        // 使用add方法往集合中添加元素
        set.add(3);
        set.add(9);
        set.add(4);
        set.add(47);
        set.add(9);
        // 遍历HashSet，利用迭代器
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
    
    
            Integer i = iterator.next();
            System.out.println(i);
        }
        System.out.println("===================");
        // 遍历HashSet，利用增强for循环
        for (Integer integer : set) {
    
    
            System.out.println(integer);
        }
    }
}

day14-14 Set集合存储元素不重复的原理

4.2 HashSet集合存储数据的结构（哈希表）

day14-12 哈希值

package day_03.Demo03;

/*
哈希值：是一个十进制的整数，由系统随机给出（是对象的地址值，是一个逻辑地址，是模拟出来的地址，而不是数据实际存储的物理地址）
在Object类有一个方法，可以获取对象的哈希值：int hashCode(); 返回该对象的哈希码值

hashCode方法的源码：
    public native int hashCode();
    native:代表该方法调用的是本地操作系统的方法
 */
public class Demo01HashSet {
    
    
    public static void main(String[] args) {
    
    
        // Person类继承了Object类，所以可以使用Object类的hashCode方法
        Person person = new Person();
        int hashCode = person.hashCode();
        System.out.println(hashCode);

        // toString方法重写了hashCode方法
        String str1 = new String("abc");
        String str2 = new String("abc");
        System.out.println(str1.hashCode()); // 96354
        System.out.println(str2.hashCode()); // 96354
    }
}

day14-13 HashSet集合存储数据的结构（哈希表）

4.3 HashSet存储自定义类型元素

day14-15 HashSet存储自定义类型元素

package day_03.Demo02;

import java.util.Objects;

public class Person {
    
    
    private String name;
    private int age;

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

    @Override
    public boolean equals(Object o) {
    
    
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
    
    
        return Objects.hash(name, age);
    }

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }

    public Person() {
    
    
    }

    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }
}

package day_03.Demo02;

import java.util.HashSet;

/*
HashSet存储自定义类型元素

set集合存储元素唯一：
	存储的元素（String, Integer...Student, Person...），必须重写toString方法和equals方法

要求：
	同名同年龄的人，视为同一人，只能存储一次
 */
public class Demo03HashSetSavePerson {
    
    
    public static void main(String[] args) {
    
    
        // 创建HashSet集合存储Person
        HashSet<Person> set = new HashSet<>();
        Person p1 = new Person("张三", 18);
        Person p2 = new Person("张三", 18);
        Person p3 = new Person("张三", 20);
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set);


    }
}

4.4 LinkedHashSet

day14-16 LinkedHashSet集合

package day_03.Demo02;

import java.util.HashSet;
import java.util.LinkedHashSet;

/*
java.util.LinkedHashSet集合 extends HashSet集合
LinkedHashSet集合特点：
    底层是一个哈希表（数组+链表/红黑树）+链表，多了一条链表（记录元素的存储顺序），保证元素有序
 */
public class Demo04LinkedHashSet {
    
    
    public static void main(String[] args) {
    
    
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("www");
        hashSet.add("abc");
        hashSet.add("kved");
        hashSet.add("abc");
        System.out.println(hashSet); // 无序，不允许重复
        System.out.println("=====================");

        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("www");
        linkedHashSet.add("abc");
        linkedHashSet.add("kved");
        linkedHashSet.add("abc");
        System.out.println(linkedHashSet); // 有序，不允许重复

        // 上述提及的有序和无需是指数据存储和取出的顺序是否一致的判断
    }
}

4.5 可变参数

day14-17 可变参数

package day_03.Demo04;

/*
可变参数：是JDK1.5之后出现的新特性
使用前提：
    当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数
使用格式：定义方法时使用
    修饰符 返回值类型 方法名（数据类型...变量）{}
可变参数的原理：
    可变参数底层是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数
    传递的参数个数，可以是0个（不传递），1，2...多个

可变参数的注意事项：
    1.一个方法的参数列表，只能有一个可变参数
    2.如果方法的参数有多个，那么可变参数必须写在参数列表的末尾

可变参数的特殊（终极）写法：
    public static void method(Object obj) {

    }

 */
public class Demo01VarArgs {
    
    
    public static void main(String[] args) {
    
    
        int i = add(15, 18);
        System.out.println(i);
    }

    // 定义计算0-n整数和的方法
    // 已知数据类型，但数据个数未知
    public static int add(int...arr) {
    
    
        // 定义一个初始化的变量，记录累加求和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
    
    
            sum += arr[i];
        }
        return sum;
    }
}

第五章 Collections

5.1 常用功能

day14-18 Collections集合工具类的方法_addAll&shuffle

package day_03.Demo05;

import java.util.ArrayList;
import java.util.Collections;

/*
java.util.Collections是集合工具类，用来对集合进行操作。部分方法如下：
    public static <T> boolean addAll(Collection<T> c, T...elements); 往集合中添加一些元素
    public static void shuffle(List<?> list); 打乱集合顺序
 */
public class Demo01Collections {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<String> list = new ArrayList<>();

        // public static <T> boolean addAll(Collection<T> c, T...elements); 往集合中添加一些元素
        Collections.addAll(list, "s", "a", "g", "s");
        System.out.println(list);

        // public static void shuffle(List<?> list); 打乱集合顺序
        Collections.shuffle(list);
        System.out.println(list);
    }
}

day14-19 Collections集合工具类的方法_sort(List)

package day_03.Demo05;

import java.util.ArrayList;
import java.util.Collections;

/*
java.util.Collections是集合工具类，用来对集合进行操作。部分方法如下：
    public static <T> void sort(List<T> list); 将集合中元素按照默认规则排序

sort(List<T> list)使用前提：
    被排序的集合里存储的元素必须实现Comparable，重写接口中的方法compareTo定义排序的规则

Comparable接口的排序规则：
    自己（this） - 参数：升序
 */
public class Demo02Sort {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "g","d","s","G");
        System.out.println(list);

        // public static <T> void sort(List<T> list); 将集合中元素按照默认规则排序
        // 默认是升序
        Collections.sort(list);
        System.out.println(list);

        ArrayList<Person> list1 = new ArrayList<>();
        list1.add(new Person("张三", 88));
        list1.add(new Person("狂徒", 48));
        list1.add(new Person("法外", 34));
        System.out.println(list1);
        Collections.sort(list1);
        System.out.println(list1);
    }
}

package day_03.Demo05;

public class Person implements Comparable<Person>{
    
    
    private String name;
    private int age;

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

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }

    public Person(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }

    public Person() {
    
    
    }

    // 重写排序的规则
    @Override
    public int compareTo(Person o) {
    
    
//        return 0; // 认为元素都是相同的
        //自定义，比较两个人的年龄
        return this.getAge() - o.getAge(); // 年龄升序
    }
}

5.2 Comparator比较器

day14-20 Collections集合工具类的方法_sort(List,Comparator)

package day_03.Demo05;

import java.sql.Struct;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/*
java.util.Collections是集合工具类，用来对集合进行操作。部分方法如下：
    public static <T> void sort(List<T> list, Comparator<? superT>); 将集合中元素按照指定规则排序

Comparator和Comparable的区别：
    Comparable：自己（this）和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
    Comparator：相当于找一个第三方的裁判进行比较

Comparator接口的排序规则：
    o1 - o2：升序

 */
public class Demo03Sort {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(2);
        System.out.println(list);

        // public static <T> void sort(List<T> list, Comparator<? superT>); 将集合中元素按照指定规则排序
        Collections.sort(list, new Comparator<Integer>() {
    
    
            // 重写比较的规则
            @Override
            public int compare(Integer o1, Integer o2) {
    
    
                return o1 - o2; // 升序
            }
        });
        System.out.println(list);
        System.out.println("=================");

        ArrayList<Student> list1 = new ArrayList<>();
        list1.add(new Student("张三", 88));
        list1.add(new Student("狂徒", 48));
        list1.add(new Student("法外", 34));
        list1.add(new Student("罗翔", 48));
        System.out.println(list1);

//        Collections.sort(list1, new Comparator<Student>() {
    
    
//            @Override
//            public int compare(Student o1, Student o2) {
    
    
//                return o1.getAge() - o2.getAge();
//            }
//        });

        // 组合扩展，了解即可
        Collections.sort(list1, new Comparator<Student>() {
    
    
            @Override
            public int compare(Student o1, Student o2) {
    
    
                // 如果年龄相同，以姓名排序
                int result = o1.getAge() - o2.getAge();
                if (result == 0) {
    
    
                    result = o1.getName().charAt(0) - o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println(list1);


    }
}

package day_03.Demo05;

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

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

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }

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

    public Student() {
    
    
    }

}