JavaSE进阶系列(八)、Set接口、Collections

2023-01-01 15:24:08

第四章 Set接口

java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，它与 Collection 接口中的方法基本一致，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。与 List 接口不同的是， Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

Set 集合有多个子类，这里我们介绍其中的 java.util.HashSet 、 java.util.LinkedHashSet 这两个集合。
tips:Set集合取出元素的方式可以采用：迭代器、增强for。

4.1 HashSet集合介绍

java.util.HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。 java.util.HashSet 底层的实现其实是一个 java.util.HashMap 支持，由于我们暂时还未学习，先做了解。

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

我们先来使用一下Set集合存储，看下现象，再进行原理的讲解:

public class HashSetDemo {
    public static void main(String[] args) {
        //创建 Set集合
        HashSet<String> set = new HashSet<String>();
        //添加元素
        set.add(new String("cba"));
        set.add("abc");
        set.add("bac");
        set.add("cba");
        //遍历
        for (String name : set) {
        		System.out.println(name);
        }
    }
}

输出结果如下，说明集合中不能存储重复元素：

cba
abc
bac

tips:根据结果我们发现字符串"cba"只存储了一个，也就是说重复的元素set集合不存储。

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

什么是哈希表呢？

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。

但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。

看到这张图就有人要问了，这个是怎么存储的呢？
为了方便大家的理解我们结合一个存储流程图来说明一下：

总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，

其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，

就必须复写hashCode和equals方法建立属于当前对象的比较方式。

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

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

创建自定义Student类

public class Student {
    private String name;
    private int age;
  
    public Student() {
    } 
  	public Student(String name, int age) {
      this.name = name;
      this.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;
      } 
  
    @Override
    public boolean equals(Object o) {
        if (this == o)
        		return true;
        if (o == null || getClass() != o.getClass())
        		return false;
        Student student = (Student) o;
        
      	return age == student.age && Objects.equals(name, student.name);
    } 
  
  	@Override
    public int hashCode() {
    		return Objects.hash(name, age);
    }
}

public class HashSetDemo2 {
        public static void main(String[] args) {
            //创建集合对象 该集合中存储 Student类型对象
            HashSet<Student> stuSet = new HashSet<Student>();
            //存储
            Student stu = new Student("于谦", 43);
            stuSet.add(stu);
            stuSet.add(new Student("郭德纲", 44));
            stuSet.add(new Student("于谦", 43));
            stuSet.add(new Student("郭麒麟", 23));
            stuSet.add(stu);
            for (Student stu2 : stuSet) {
              System.out.println(stu2);
            }
        }
}

执行结果：

Student [name=郭德纲, age=44]
Student [name=于谦, age=43]
Student [name=郭麒麟, age=23]

4.4linkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？
在HashSet下面有一个子类 java.util.LinkedHashSet ，它是链表和哈希表组合的一个数据存储结构。

演示代码如下:

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<String>();
        set.add("bbb");
        set.add("aaa");
        set.add("abc");
        set.add("bbc");
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
        		System.out.println(it.next());
        }
    }
} 

结果：
  bbb
  aaa
  abc
  bbc

4.5 可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格
式：

修饰符 返回值类型 方法名(参数类型... 形参名){ }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){ }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。
JDK1.5以后。出现了简化操作。… 用在参数上，称之为可变参数。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

代码演示：

public class ChangeArgs {
    public static void main(String[] args) {
        int[] arr = { 1, 4, 62, 431, 2 };
        int sum = getSum(arr);
        System.out.println(sum);
        // 6 7 2 12 2121
        // 求 这几个元素和 6 7 2 12 2121
        int sum2 = getSum(6, 7, 2, 12, 2121);
        		System.out.println(sum2);
     } 
  			/**
        完成数组 所有元素的求和 原始写法
        public static int getSum(int[] arr){
        int sum = 0;
        for(int a : arr){
        sum += a;
        } r
        eturn sum;
        }
        */
        //可变参数写法
        public static int getSum(int... arr) {
          int sum = 0;
          for (int a : arr) {
          sum += a;
       		} 
          return sum;
    		}
}

tips: 上述add方法在同一个类中，只能存在一个。因为会发生调用的不确定性
注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末
尾位置。`

第五章 Collections

5.1 常用功能

java.utils.Collections 是集合工具类，用来对集合进行操作。部分方法如下：
public static boolean addAll(Collection c, T… elements) :往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
public static void sort(List list) :将集合中元素按照默认规则排序。
public static void sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排序。

代码演示：

public class CollectionsDemo {
    public static void main(String[] args) {
      ArrayList<Integer> list = new ArrayList<Integer>();
      //原来写法
      //list.add(12);
      //list.add(14);
      //list.add(15);
      //list.add(1000);
      //采用工具类 完成 往集合中添加元素
      Collections.addAll(list, 5, 222, 1，2);
      System.out.println(list);
      //排序方法
      Collections.sort(list);
      System.out.println(list);
    }
} 
结果：
[5, 222, 1, 2]
[1, 2, 5, 222]

代码演示之后，发现我们的集合按照顺序进行了排列，可是这样的顺序是采用默认的顺序，如果想要指定顺序那该怎么办呢？

我们发现还有个方法没有讲， public static void sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排序。接下来讲解一下指定规则的排列。

5.2 Comparator**比较器

**我们还是先研究这个方法public static void sort(List list) :将集合中元素按照默认规则排序。不过这次存储的是字符串类型。

public class CollectionsDemo2 {
    public static void main(String[] args) {
      ArrayList<String> list = new ArrayList<String>();
      list.add("cba");
      list.add("aba");
      list.add("sba");
      list.add("nba");
      //排序方法
      Collections.sort(list);
      System.out.println(list);
    }
}

结果：

[aba, cba, nba, sba]

我们使用的是默认的规则完成字符串的排序，那么默认规则是怎么定义出来的呢？

说到排序了，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用 java.lang.Comparable 接口去实现，一种是灵活的当我需要做排序的时候在去选择的java.util.Comparator 接口完成。

那么我们采用的 public static void sort(List list) 这个方法完成的排序，实际上要求了被排序的类型需要实现Comparable接口完成比较的功能，在String类型上如下：

public final class String implements java.io.Serializable,Comparable<String>,CharSequence {

String类实现了这个接口，并完成了比较规则的定义，但是这样就把这种规则写死了，那比如我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，这是不可能的了，那么这个时候我们可以使用public static void sort(List list，Comparator<? super T> ) 方法灵活的完成，这个里面就涉及到了Comparator这个接口，位于位java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，通俗地讲需要比较两个对象谁排在前谁排在后，那么比较的方法就是：

public int compare(String o1, String o2) ：比较其两个参数的顺序。

两个对象比较的结果有三种：大于，等于，小于。
如果要按照升序排序，则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数）如果要按照
降序排序则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）

操作如下:

public class CollectionsDemo3 {
  public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<String>();
    list.add("cba");
    list.add("aba");
    list.add("sba");
    list.add("nba");
    //排序方法 按照第一个单词的降序
    Collections.sort(list, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o2.charAt(0) ‐ o1.charAt(0);
        }
    });
    System.out.println(list);
  }
}

结果如下：

[sba, nba, cba, aba]

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

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

5.4 练习

创建一个学生类，存储到ArrayList集合中完成指定排序操作。
Student 初始类

public class Student{
    private String name;
    private int age;
    public Student() {
    } 
    public Student(String name, int age) {
      this.name = name;
      this.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;
      } 
    @Override
    public String toString() {
      return "Student{" +
      "name='" + name + '\'' +
      ", age=" + age +
      '}';
    }
}

测试类：

public class Demo {
  public static void main(String[] args) {
    // 创建四个学生对象 存储到集合中
    ArrayList<Student> list = new ArrayList<Student>();
    list.add(new Student("rose",18));
    list.add(new Student("jack",16));
    list.add(new Student("abc",16));
    list.add(new Student("ace",17));
    list.add(new Student("mark",16));
    /*
    让学生 按照年龄排序 升序
    */
    // Collections.sort(list);//要求 该list中元素类型 必须实现比较器Comparable接口
    for (Student student : list) {
    	System.out.println(student);
    }
  }
}

发现，当我们调用Collections.sort()方法的时候程序报错了。
原因：如果想要集合中的元素完成排序，那么必须要实现比较器Comparable接口。
于是我们就完成了Student类的一个实现，如下：

public class Student implements Comparable<Student>{
  ....
  @Override
  public int compareTo(Student o) {
  	return this.age‐o.age;//升序
  }
}

再次测试，代码就ok了：

Student{name='jack', age=16}
Student{name='abc', age=16}
Student{name='mark', age=16}
Student{name='ace', age=17}
Student{name='rose', age=18}

5.5 扩展

如果在使用的时候，想要独立的定义规则去使用可以采用Collections.sort(List list,Comparetor c)方式，自己定义
规则：

Collections.sort(list, new Comparator<Student>() {
  @Override
  public int compare(Student o1, Student o2) {
 		 return o2.getAge()‐o1.getAge();//以学生的年龄降序
  }
});

效果：

Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='jack', age=16}
Student{name='abc', age=16}
Student{name='mark', age=16}

如果想要规则更多一些，可以参考下面代码：

Collections.sort(list, new Comparator<Student>() {
  @Override
  public int compare(Student o1, Student o2) {
    // 年龄降序
    int result = o2.getAge()‐o1.getAge();//年龄降序
    if(result==0){
      //第一个规则判断完了 下一个规则 姓名的首字母 升序
    result = o1.getName().charAt(0)‐o2.getName().charAt(0);
    } 
    return result;
  }
});

效果如下：

Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='abc', age=16}
Student{name='jack', age=16}
Student{name='mark', age=16}

码农公寓