06.集合——14——List、Set、Collections

考点

• 1 能够说出List集合特点
• 2 能够说出常见的数据结构
• 3 能够说出数组结构特点
• 4 能够说出栈结构特点
• 5 能够说出队列结构特点
• 6 能够说出单向链表结构特点
• 7 能够说出Set集合的特点
• 8 能够说出哈希表的特点
• 9 使用HashSet集合存储自定义元素
• 10 能够说出可变参数的格式
• 11 能够使用集合工具类
• 12 能够使用Comparator比较器进行排序

一 List集合

java.util.List接口 extends Collection接口
List接口的特点:
1.有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)
2.有索引,包含了一些带索引的方法(因为所有的元素是以一种线性方式进行存储的)
3.允许存储重复的元素，通过元素的equals方法，来比较是否为重复的元素。

1.1 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):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
注意:
操作索引的时候,一定要防止索引越界异常
IndexOutOfBoundsException:索引越界异常,集合会报
ArrayIndexOutOfBoundsException:数组索引越界异常
StringIndexOutOfBoundsException:字符串索引越界异常

public static void main(String[] args) {
        //创建一个List集合对象,多态
        List<String> list = new ArrayList<>();
        //往 尾部添加 指定元素
        list.add("a");
        list.add("d");
        list.add("a");
        System.out.println(list);//[a,  d, a]  不是地址重写了toString

        //往指定位置添加  在a和d之间添加一个itheima
        list.add(1,"itheima");//[a, itheima, d, a]

        // 删除指定位置元素 返回被删除元素
        String removeE = list.remove(2);      //被移除的元素:d

        // 修改指定位置元素
        String setE = list.set(3, "A");     //被替换的元素:a

        //List集合遍历有3种方式
        //使用普通的for循环
        for(int i=0; i<list.size(); i++){
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("-----------------");
        //使用迭代器
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------");
        //使用增强for
        for (String s : list) {
            System.out.println(s);
        }
    }

1.2 ArrayList集合

	底层是数组结构。元素增删慢，查找快

1.3 LinkedList集合

	在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

java.util.LinkedList集合 implements List接口
LinkedList集合的特点:
     1.底层是一个链表结构:查询慢,增删快
     2.里边包含了大量操作首尾元素的方法
   注意:使用LinkedList集合特有的方法,不能使用多态
          public void addFirst(E e):将指定元素插入此列表的开头。
          public void push(E e):将元素推入此列表所表示的堆栈。
  
          public void addLast(E e):将指定元素添加到此列表的结尾。此方法等效于 add()
  
          public E getFirst():返回此列表的第一个元素。
          public E getLast():返回此列表的最后一个元素。
  
          public E removeFirst():移除并返回此列表的第一个元素。
          public E pop():从此列表所表示的堆栈处弹出集合中的栈顶元素
  
          public E removeLast():移除并返回此列表的最后一个元素。
          public boolean isEmpty()：如果列表不包含元素，则返回true。

private static void show01() {
	LinkedList<String> linked = new LinkedList<>();
    //使用add方法往集合中添加元素
    linked.add("a");
    linked.add("b");
    linked.add("c");//[a, b, c]

    //linked.addFirst("www");
    linked.push("www");//[www, a, b, c]

    linked.addLast("com");//[www, a, b, c, com]
}
private static void show02() {
	LinkedList<String> linked = new LinkedList<>();
    linked.add("a");
    linked.add("b");
    linked.add("c");
    //linked.clear();//清空集合中的元素 在获取集合中的元素会抛出NoSuchElementException
    if(!linked.isEmpty()){
    	String first = linked.getFirst();//a
        String last = linked.getLast();//c
    }
}
private static void show03() {
	LinkedList<String> linked = new LinkedList<>();
    linked.add("a");
    linked.add("b");
    linked.add("c");

    //String first = linked.removeFirst();
    String first = linked.pop();

    String last = linked.removeLast();
}

二 Set集合

java.util.Set接口 extends Collection接口
Set接口的特点:
     1.不允许存储重复的元素
     2.无序。没有索引,没有带索引的方法,也不能使用普通的for循环遍历

2.1 HashSet集合

java.util.HashSet集合 implements Set接口
HashSet特点:
     1.不允许存储重复的元素
     2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
     3.是一个无序的集合,存取顺序不一致
     4.底层是一个哈希表结构(查询的速度非常的快)    底层的实现其实是一个 java.util.HashMap 支持

public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(1);
        //使用迭代器遍历set集合
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()){
            Integer n = it.next();
            System.out.println(n);//1,2,3
        }
        //使用增强for遍历set集合
        System.out.println("-----------------");
        for (Integer i : set) {
            System.out.println(i);
        }
    }

HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性 的方式依赖于： hashCode 与 equals 方法。

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

2.1.2 HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保 证HashSet集合中的对象唯一

public class Person {
    private String name;
    private int 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);
    }
    getter和setter 、toString()、构造方法
}

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("小美女",19);
        System.out.println(p1.hashCode());//1967205423
        System.out.println(p2.hashCode());//42121758

        System.out.println(p1==p2);//false
        System.out.println(p1.equals(p2));//false
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set);
    }

2.2 LinkedHashSet

java.util.LinkedHashSet集合 extends HashSet集合
LinkedHashSet集合特点:
底层是一个哈希表(数组+链表/红黑树)+链表:多了一条链表(记录元素的存储顺序),保证元素有序

public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("www");
        set.add("abc");
        set.add("abc");
        set.add("itcast");
        System.out.println(set);//[abc, www, itcast] 无序,不允许重复

        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("www");
        linked.add("abc");
        linked.add("abc");
        linked.add("itcast");
        System.out.println(linked);//[www, abc, itcast] 有序,不允许重复
    }

2.3 哈希值

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

hashCode方法的源码:

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

toString方法的源码:

		return getClass().getName() + "@" + Integer.toHexString(hashCode());

    public static void main(String[] args) {
        //Person类继承了Object类,所以可以使用Object类的hashCode方法
        Person p1 = new Person();
        int h1 = p1.hashCode();
        System.out.println(h1);//1967205423  | 1

        Person p2 = new Person();
        int h2 = p2.hashCode();
        System.out.println(h2);//42121758   |  1

        System.out.println(p1);//com.itheima.demo03.hashCode.Person@75412c2f
        System.out.println(p2);//com.itheima.demo03.hashCode.Person@282ba1e
        System.out.println(p1==p2);//false

         //String类的哈希值           String类重写Obejct类的hashCode方法
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.hashCode());//96354
        System.out.println(s2.hashCode());//96354

        System.out.println("重地".hashCode());//1179395
        System.out.println("通话".hashCode());//1179395
    }

public class Person extends  Object{
    //重写hashCode方法
    @Override
    public int hashCode() {
        return  1;
    }
}

2.4 可变参数

     可变参数:是JDK1.5之后出现的新特性
使用前提:
     当方法的参数列表需要接受多个参数，并且多个参数类型一致,就可以使用可变参数.
 
使用格式:定义方法时使用
                    修饰符 返回值类型 方法名(数据类型…变量名){}
     等价于： 修饰符 返回值类型 方法名(参数类型[] 形参名){ }
 
可变参数的原理:
     可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数。传递的参数个数,可以是0个(不传递),1,2…多个。
     同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素 作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编 译.class文件时，自动完成了。
 
可变参数的注意事项
     1.一个方法的参数列表,只能有一个可变参数
     2.如果方法的参数有多个,那么可变参数必须写在参数列表的末尾
               public static void method(String b,double c,int d,int…a){}
 
可变参数的特殊(终极)写法
public static void method(Object...obj){ }

public class Demo01VarArgs {
    public static void main(String[] args) {
        int i = add(10,20);
        //int i = add(10,20,30,40,50,60,70,80,90,100);
        method("abc",5.5,10,1,2,3,4);
    }

    /*
        定义计算(0-n)整数和的方法
        add(); 就会创建一个长度为0的数组, new int[0]
        add(10); 就会创建一个长度为1的数组,存储传递来过的参数 new int[]{10};
        add(10,20); 就会创建一个长度为2的数组,存储传递来过的参数 new int[]{10,20};
        add(10,20,30,40,50,60,70,80,90,100); 就会创建一个长度为10的数组,存储传递来过的参数 new int[]{10,20,30,40,50,60,70,80,90,100};
     */
    public static int add(int...arr){
        //System.out.println(arr);//[I@2ac1fdc4 底层是一个数组
        //System.out.println(arr.length);//0,1,2,10
        //定义一个初始化的变量,记录累加求和
        int sum = 0;
        //遍历数组,获取数组中的每一个元素
        for (int i : arr) {
            //累加求和
            sum += i;
        }
        return sum;
    }
}

三 Collections

java.utils.Collections是集合工具类，用来对集合进行操作
    public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
    public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
    public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
        注意: sort(List<T> list)使用前提：
                被排序的集合里边存储的元素必须实现Comparable，重写接口中的方法compareTo定义排序的规则
                Comparable接口的排序规则：自己(this)-参数:升序
    public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。
    
Comparator和Comparable的区别
    Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
    Comparator:相当于找一个第三方的裁判,比较两个
    
Comparator的排序规则：o1-o2>0:升序

简述Comparable和Comparator两个接口的区别。

• Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法 被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现 此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中 的键或有序集合中的元素，无需指定比较器。
• Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或 有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

import java.util.ArrayList;
import java.util.Collections;
public class Demo02Sort {
    public static void main(String[] args) {
        ArrayList<String> list02 = new ArrayList<>();
        Collections.addAll(list02,"a","c","b");        //[a, c, b]
        Collections.shuffle(list02);
        Collections.sort(list02);//默认是升序  /[a, b, c]

        ArrayList<Person> list03 = new ArrayList<>();
        list03.add(new Person("张三",18));
        list03.add(new Person("李四",20));
        list03.add(new Person("王五",15));
        System.out.println(list03);//[Person{name='张三', age=18}, Person{name='李四', age=20}, Person{name='王五', age=15}]

        Collections.sort(list03);//要求该list03中元素类型必须实现比较器Comparable接口,否则会报错
        System.out.println(list03);
    }
}

public class Person implements Comparable<Person>{
    private String name;
    private int age;
	//构造方法，toString()，getter/setter
    //重写排序的规则
    @Override
    public int compareTo(Person o) {
        //return 0;//认为元素都是相同的
        //自定义比较的规则,比较两个人的年龄(this,参数Person)
        //return this.getAge() - o.getAge();//年龄升序排序
        return o.getAge() - this.getAge();//年龄升序排序
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Demo03Sort {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        Collections.addAll(list01,2,1,3);
        Collections.sort(list01, new Comparator<Integer>() {
            //重写比较的规则
            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;//升序
                return o2-o1;//降序
            }
        });

        ArrayList<Student> list02 = new ArrayList<>();
        Collections.addAll(list02,new Student("a迪丽热巴",18),new Student("古力娜扎",20),new Student("杨幂",17),new Student("b杨幂",18));
        Collections.sort(list02, 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(list02);
    }
}

public class Student {
    private String name;
    private int age;
	//构造方法，toString()，getter/setter
}