Java学习总结：53(单对象保存父接口：Collection)

单对象保存父接口：Collection

java.util.Collection是进行单对象保存的最大父接口，即每次利用Collection接口都只能保存一个对象信息。单对象保存父接口定义如下：

public interface Collection<E> extends Iterable<E>

由该定义我们可以发现Collection接口中使用了泛型，保证了集合中操作数据的统一，同时Collection接口属于Iterable的子接口。

Collection接口的核心方法

No.	方法名称	类型	描述
1	public boolean add(E e)	普通	向集合里面保存数据
2	public boolean addAll(Collection<? extends E> c)	普通	追加一个集合
3	public void clear()	普通	向集合里面保存数据
4	public boolean contains(Object o)	普通	判断是否包含指定的内容，需要equals()支持
5	public boolean isEmpty()	普通	判断是否是空集合(不是null)
6	public boolean remove(Object o)	普通	删除对象，需要equals()支持
7	public int size()	普通	取得集合中保存元素个数
8	public Object[] toArray()	普通	将集合变为对象数组保存
9	public Iterator< E > iterator()	普通	为Iterator接口实例化(Iterable接口定义)

虽然Collection是单对象集合操作的最大父接口，但是Collection接口本身却存在一个问题，即：无法区分保存的数据是否重复。所以在实际的开发中，往往会使用Collection的两个子接口：List子接口(数据允许重复)、Set子接口(数据不允许重复)。

List子接口

List子接口最大的功能是里面保存的数据可以存在重复内容，在Collection子接口中，List子接口是最为常用的一个子接口。

List子接口扩充的方法

No.	方法名称	类型	描述
1	public E get(int index)	普通	取得索引编号的内容
2	public E set(int index,E element)	普通	修改指定索引编号的内容
3	public ListIterator< E > listIterator()	普通	为ListIterator接口实例化

在使用List接口时可以ArrayList或Vector两个子接口来进行接口对象的实例化操作。

新的子类：ArrayList

例：List基本操作

package Project.Study.ArrayListClass;

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

public class Test1 {
    public static void main(String[]args){
        //使用了泛型，从而保证集合中所有的数据类型都一致
        List<String>all = new ArrayList<>();        //实例化List集合
        System.out.println("长度：" + all.size() + ",是否为空："+all.isEmpty());
        all.add("Hello");                           //保存数据
        all.add("Hello");                           //保存重复数据
        all.add("World");
        System.out.println("长度："+all.size()+",是否为空："+all.isEmpty());
        //Collection接口定义size()方法取得了集合长度，List子接口扩充get()方法根据索引取得了数据
        for (String str : all) {                    //取得索引数据
            System.out.println(str);                //直接输出内容
        }
    }
}
//结果：
//长度：0,是否为空：true
//长度：3,是否为空：false
//Hello
//Hello
//World

上程序通过ArrayList子类实例化List对象，这样就可以使用List接口中定义的方法(包括Collection接口定义的方法)。

例：在集合里面保存对象

package Project.Study.ArrayListClass;

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

class Book{
    private String title;
    private double price;
    public Book(String title,double price){
        this.title=title;
        this.price=price;
    }
    @Override
    public boolean equals(Object obj){//必须覆写此方法，否则remove()、contains()无法使用
        if (this==obj){
            return true;
        }
        if (obj==null){
            return false;
        }
        if (!(obj instanceof Book)){
            return false;
        }
        Book book = (Book)obj;
        if (this.title.equals(book.title)&&this.price==book.price){
            return true;
        }
        return false;
    }
    @Override
    public String toString(){
        return "书名："+this.title+",价格："+this.price+"\n";
    }
}
public class Test2 {
    public static void main(String[]args){
        List<Book>all = new ArrayList<>();              //List接口对象
        all.add(new Book("Java",99));       //保存自定义类对象
        all.add(new Book("C++",99.9));
        all.add(new Book("Python",89));
        all.remove(new Book("Java",99));    //删除对象
        System.out.println(all);
    }
}
//结果：
//[书名：C++,价格：99.9
//, 书名：Python,价格：89.0
//]

Set子接口

Set子接口并不像List子接口一样对Collection接口进行了大量的扩充，而是简单地继承了Collection接口。在Set子接口下有两个常用的子类：HashSet、TreeSet。

• HashSet是散列存放数据；
• TreeSet是有序存放的子类。

关于“Hash”的说明：
在HashSet这个子类上采用了Hash算法(一般称为散列、无序)。采用该Hash算法保存的集合都是无序的，但是其查找速度较快。

HashSet子类

例：观察HashSet子类的特点

package Project.Study.SetClass;

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

public class Test1 {
    public static void main(String[]args){
        Set<String>all = new HashSet<>();   //实例化Set接口
        all.add("Hello");                   //保存数据
        all.add("World");
        all.add("!!!");
        all.add("!!!");                     //重复数据
        System.out.println(all);            //直接输出集合
    }
}
//结果：
//[!!!, Hello, World]

由上程序我们可以发现，在Set集合里面是不允许保存重复数据的。
像上面的保存的是重复数据的话在IDEA里面是会有提示的，提示这是一个重复数组元素，如下图：

关于重复元素的说明

TreeSet利用Comparable接口实现重复元素的判断，但是这样的操作只适合支持排序类集操作环境。而其他子类如果要消除重复元素，则必须依靠Object类中提供的两个方法。

• 取得哈希码：public int hashCode();
  先判断对象的哈希码是否相同，依靠哈希码取得一个对象的内容。
• 对象比较：public boolean equals(Object obj)；
  再将对象的属性进行依次的比较。
  例：利用HashSet子类保存自定义类对象

package Project.Study.SetClass;

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

class Student{
    private String name;
    private double score;
    public Student(String name,double score){
        this.name = name;
        this.score = score;
    }
    @Override
    public int hashCode(){
        final int prime = 31;
        int result = 1;
        long temp;
        temp = Double.doubleToLongBits(score);
        result = prime*result+(int)(temp^(temp>>>32));
        result = prime*result+((name==null)?0:name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj){
        if (this==obj){
            return true;
        }
        if (obj==null){
            return false;
        }
        if (getClass()!=obj.getClass()){
            return false;
        }
        Student other = (Student)obj;
        if (Double.doubleToLongBits(score)!=Double.doubleToLongBits(other.score)){
            return false;
        }
        if (name==null){
            if (other.name!=null){
                return false;
            }
        }else if (!name.equals(other.name)){
            return false;
        }
        return true;
    }
    @Override
    public String toString(){
        return "学生姓名："+this.name+",成绩："+this.score+"\n";
    }
}
public class Test4 {
    public static void main(String[]args){
        Set<Student>all = new HashSet<>();                  //实例化Set接口
        all.add(new Student("小明",88));      //保存数据
        all.add(new Student("小黄",87.2));
        all.add(new Student("小黄",87.5));    //部分重复
        all.add(new Student("小黄",87.2));    //全部重复
        all.add(new Student("小欢",88));
        System.out.println(all);
    }
}
//结果：
//[学生姓名：小欢,成绩：88.0
//, 学生姓名：小明,成绩：88.0
//, 学生姓名：小黄,成绩：87.2
//, 学生姓名：小黄,成绩：87.5
//]

TreeSet子类

如果希望保存的数据有序，那么可以使用Set接口的另一个子类：TreeSet子类。
例：使用TreeSet子类

package Project.Study.SetClass;

import java.util.Set;
import java.util.TreeSet;

public class Test2 {
    public static void main(String[]args){
        Set<String>all = new TreeSet<>();   //实例化Set接口
        Set<Integer>num = new TreeSet<>();
        all.add("b");                       //保存数据
        all.add("a");
        all.add("c");
        num.add(122);
        num.add(12);
        num.add(232);
        System.out.println(all);            //直接输出集合
        System.out.println(num);
    }
}
//结果：
//[a, b, c]
//[12, 122, 232]

由上程序我们可以看到，当使用TreeSet子类实例化了Set接口之后，所保存的数据将会变为有序数据，默认情况下按照升序排列。

关于数据排序的说明

TreeSet子类排序的实现依靠的是比较器接口(Comparable)，即如果要利用TreeSet子类保存任意类的对象，那么该对象所在的类必须要实现java.lang.Comparable接口。

例：利用TreeSet保存自定义类对象

package Project.Study.SetClass;

import java.util.Set;
import java.util.TreeSet;

class Book implements Comparable<Book>{     //需要实现Comparable接口
    private String title;
    private double price;
    public Book(String title,double price){
        this.title=title;
        this.price=price;
    }
    @Override
    public String toString(){
        return "书名："+this.title+",价格："+this.price+"\n";
    }
    @Override
    public int compareTo(Book o){           //排序方法，比较所有属性
        if (this.price>o.price){
            return 1;
        }else if (this.price<o.price){
            return -1;
        }else{
            return this.title.compareTo(o.title);//调用String类的比较大小
        }
    }
}
public class Test3 {
    public static void main(String[]args){
        Set<Book>all = new TreeSet<>();                 //实例化Set接口
        all.add(new Book("Java",99));       //保存数据
        all.add(new Book("C++",99));        //部分数据重复
        all.add(new Book("Python",89.2));
        System.out.println(all);
    }
}
//结果：
//[书名：Python,价格：89.2
//, 书名：C++,价格：99.0
//, 书名：Java,价格：99.0
//]