学习java的第11天

与集合相关的数据结构

栈

队列

数组

链表

红黑树

List集合

特点

1. 有序集合，存储元素和取出元素顺序一致
2. 有索引，包含一些索引的方法
3. 允许存储重复元素

常用带索引的方法

public void add (int index,E element);
public E get (int index);
public E remove (int index);
public E set (int index,E element);
//使用时，注意数组越界

public class Main {
    public static void main(String[] args) {
        //创建一个List的对象，利用多态
        List<String> list = new ArrayList<>();

        list.add("aa");
        list.add("bb");
        list.add("dd");
        list.add("ee");
        list.add("ff");
        //有序存储，且重写了toString方法
        System.out.println(list);

        list.set(2,"cc");//替换
        System.out.println(list);

        list.add(3,"dd");//添加
        System.out.println(list);

        System.out.println(list.get(3));

        list.remove(4);
        System.out.println(list);
        
        Iterator<String> iterator = list.iterator();
        for (int i = 0; i < list.size(); i++) {
			System.out.println(iterator.next());
        }
    }
}

List的子类

ArrayList集合

底层由数组实现，所以元素增删慢，查找快

LinkedList集合

1. 底层由链表实现，所以增删快，查找慢
2. 里边包含大量操作首尾元素的方法
3. 使用LinkedList集合中的方法不能使用多态

//常用方法
public void addFirst(E e);
public void addLast(E e);
public void push(E e);

public E getFirst();
public E getLast();

public E removeFirst();
public E removeLast();
public E pop();//相当于removeFirst

public boolean isEmpty();

//要注意数组的越界

public class Demo1 {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();

        //用父类方法
        linkedList.add("aa");
        linkedList.add("bb");
        linkedList.add("cc");
        linkedList.add("dd");
        linkedList.add("ee");

        linkedList.addFirst("ff");//在头部添加
        System.out.println(linkedList);

        linkedList.addLast("gg");//在尾部添加
        System.out.println(linkedList);

        System.out.println(linkedList.getFirst());//获得头部
        System.out.println(linkedList.getLast());//获得尾部

        linkedList.removeFirst();//删除头部
        System.out.println(linkedList);

        linkedList.removeLast();//删除尾部
        System.out.println(linkedList);
    }
}

Vector集合（所有单列集合的父类）（了解）

1. 实现了可增长的对象数组

Set接口（继承了Collection接口）

1. 不允许存储重复元素

2. 没有索引，没有带索引的方法，也不能使用普通的for循环

3. HashSet集合实现了Set接口

   • 不允许存储重复元素
   • 没有索引，没有带索引的方法，也不能使用普通的for循环
   • 无序集合
   • 底层是一个哈希表结构

4. 可用迭代器遍历集合或增强for

public class Demo2 {
    public static void main(String[] args) {
        Set<Integer> integers = new HashSet<>();

        integers.add(12);
        integers.add(13);
        integers.add(14);
        integers.add(12);

        Iterator<Integer> it = integers.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        for (Integer integer : integers) {
            System.out.println(integer);
        }
    }
}

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

1. 哈希值：是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来的地址，不是真实的物理地址）
2. int hashCode()返回该对象的哈希值
3. 保证元素唯一

public native int hashCode();
native:代表该方法调用的是本地操作系统的方法

public class Person {}

public class Demo3 {
    public static void main(String[] args) {
        Person p1 = new Person();
        int num = p1.hashCode();
        System.out.println(num);
    }
}

public class Person {
    @Override
    public int hashCode() {
        //return super.hashCode();//父类为Object类
        return 1;
    }
}
public class Demo3 {
    public static void main(String[] args) {
        Person p1 = new Person();
        int num1 = p1.hashCode();
        System.out.println(num1);

        Person p2 = new Person();
        int num2 = p1.hashCode();
        System.out.println(num2);

        System.out.println(p1==p2);//false, 只是哈希值相同而已，物理地址不同
    }
}

3. 哈希表

不能存储重复元素的原理

HashSet存储自定义元素

HashSet存储自定义元素时，可以重复存储，要想不重复需要重写hashCode()和equals()

public class Phone {
    public String name;
    public int ID;

    //重写equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Phone phone = (Phone) o;
        return ID == phone.ID && Objects.equals(name, phone.name);
    }
    //重写hashCode
    @Override
    public int hashCode() {
        return Objects.hash(name, ID);
    }

    public Phone() {

    }

    public Phone(String name, int ID) {
        this.name = name;
        this.ID = ID;
    }

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

public class Demo4 {
    public static void main(String[] args) {
        Phone p1 = new Phone("vivo",20001);
        Phone p2 = new Phone("vivo",20001);
        Phone p3 = new Phone("vivo",2000);

        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        System.out.println(p3.hashCode());

        HashSet<Phone> hashSet = new HashSet<>();
        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);

        System.out.println(hashSet);
    }
}

LinkedHashSet

1. 保证存储的元素有序
2. 底层是一个哈希表

public class Demo5 {
    public static void main(String[] args) {
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("cc");
        linkedHashSet.add("aa");
        linkedHashSet.add("bb");
        linkedHashSet.add("ee");
        linkedHashSet.add("dd");
        System.out.println(linkedHashSet);//[cc, aa, bb, ee, dd]

        HashSet<String> hashSet =new HashSet<>();
        hashSet.add("aaqw");
        hashSet.add("cceee");
        hashSet.add("ddww");
        hashSet.add("eeff");
        hashSet.add("bb");
        System.out.println(hashSet);//[bb, cceee, aaqw, ddww, eeff]
    }
}

可变参数

//格式
修饰符 返回值 方法名 （参数类型... 参数名）{}

//前提
当方法的参数列表的数据类型确定，但是参数的个数不确定，可用可变参数
    
//原理
可变参数底层是一个数组，根据传递个数会创建不同长度的数组，来存储这些参数，传递的参数个数，可以是0个，也可以是多个

 public class Dome6 {
    public static void main(String[] args) {

        System.out.println(add(2,4,5,6,7,8));
    }
    public static int add(int... arr){
        int all=0;
        for (int i : arr) {
            all+=i;
        }
        return all;
    }
}

注意：
    1. 一个参数列表，只能有一个可变参数
    2. 可变参数要在最后一个 例： public static int add(int... arr，int a); 错误

Collections（工具类）

public static <T> boolean addAll(Collection<T> c,T...elements);
public static void shuffle(List<?> list);//打乱集合顺序
public static <T> sort(List<T> list);//按照默认排序
//前提：被排序的集合里存储的元素，必须实现Comparable,并重写接口中的方法comparaTo定义排序规则
public static <T> void sort(List<T> list,Comparator<? super T>);//将元素安装指定规则排序

public class Demo7 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

        /*list.add(1);
        list.add(2);
        list.add(4);
        list.add(6);*/

        Collections.addAll(list,1,6,2,5);//一次性添加元素
        System.out.println(list);

        Collections.shuffle(list);//打乱顺序
        System.out.println(list);

        Collections.sort(list);//按照默认方式排序，默认为升序
        System.out.println(list);

    }
}

//排序自定义类型，
public class Teacher implements Comparable<Teacher>{
    public int ID;

    public int getID() {
        return ID;
    }

    public void setID(int ID) {
        this.ID = ID;
    }

    //重写排序规则
    @Override
    public int compareTo(Teacher o) {

        return this.getID() - o.getID();//升序
    }
}

public class Student {
    public int ID;
    public Student(int ID) {
        this.ID = ID;
    }
    @Override
    public String toString() {
        return "Student{" +
                "ID=" + ID +
                '}';
    }
    public int getID() {
        return ID;
    }
    public void setID(int ID) {
        this.ID = ID;
    }
}
public class Demo9 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

        Collections.addAll(list,22,55,77,83,12);

        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;//升序
            }
        });
        System.out.println(list);

        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(11));
        students.add(new Student(12));
        students.add(new Student(13));
        students.add(new Student(10));

        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getID() - o2.getID();
            }
        });
        System.out.println(students);
    }
}

扩展

块注释快捷键：ctrl+shift+/
ArrayList<>();
students.add(new Student(11));
students.add(new Student(12));
students.add(new Student(13));
students.add(new Student(10));

    Collections.sort(students, new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getID() - o2.getID();
        }
    });
    System.out.println(students);
}

}

# 扩展

块注释快捷键：ctrl+shift+/