Set Interface

Set<> Collection<> {
    size();

    isEmpty();

    contains(Object o);

    Iterator<> iterator();

    Object[] toArray();

    <> [] toArray([] a);


    add(e);


    remove(Object o);


    containsAll(Collection<?> c);

    addAll(Collection<? > c);

    retainAll(Collection<?> c);

    removeAll(Collection<?> c);

    clear();


    equals(Object o);

    hashCode();
}

1.HashSet:

  HashSet使用的是相当复杂的方式来存储元素的,使用HashSet能够最快的获取集合中的元素,效率非常高(以空间换时间)。会根据hashcode和equals来庞端是否是同一个对象,如果hashcode一样,并且equals返回true,则是同一个对象,不能重复存放。

package com.set;

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

class Student{
    int id;
    public Student(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return this.id+"";
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student){
            Student  stu = (Student) obj;
            if (stu.id == this.id)
                return true;
        }
        return false;
    }
}
public class HashSetTest {
    public static void main(String[] args) {
        Set<Student> set = new HashSet<Student>();
        Student s1 = new Student(1);
        Student s2 = new Student(1);
        Student s3 = new Student(2);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        for (Student s : set) {
            System.out.println(s);
        }
    }
}

正如上例所示,重写了hashCode()和equals()方法来区分同意对象后,就不能存放同以对象了。如果注释这两个方法,则所有Student对象视为不同对象,都可以存放。

 

  2.TreeSet

  TreeSet也不能存放重复对象,但是TreeSet会自动排序,如果存放的对象不能排序则会报错,所以存放的对象必须指定排序规则。排序规则包括自然排序和客户排序。

  ①自然排序:TreeSet要添加哪个对象就在哪个对象类上面实现java.lang.Comparable接口,并且重写comparaTo()方法,返回0则表示是同一个对象,否则为不同对象。

  ②客户排序:建立一个第三方类并实现java.util.Comparator接口。并重写方法。定义集合形式为TreeSet ts = new TreeSet(new 第三方类());


package com.set;

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

class Student1 implements Comparable<Student1>{
    int id;
    public Student1(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return this.id+"";
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student1){
            Student1  stu = (Student1) obj;
            if (stu.id == this.id)
                return true;
        }
        return false;
    }
    public int compareTo(Student1 o) {
        return (this.id-o.id);
    }
}

public class TreeSetTest {
    public static void main(String[] args) {
        Set<Student1> set = new TreeSet<Student1>();
        Student1 s1 = new Student1(5);
        Student1 s2 = new Student1(1);
        Student1 s3 = new Student1(2);
        Student1 s4 = new Student1(4);
        Student1 s5 = new Student1(3);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        for (Student1 s : set) {
            System.out.println(s);
        }
    }

}
package com.set;

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

class MySort implements java.util.Comparator<Student2>{

    public int compare(Student2 o1, Student2 o2) {
        return o2.id-o1.id;
    }
}
class Student2{
    int id;
    public Student2(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return this.id+"";
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student2){
            Student2  stu = (Student2) obj;
            if (stu.id == this.id)
                return true;
        }
        return false;
    }
}
public class TreeSetTest2 {
    public static void main(String[] args) {
        Set<Student2> set = new TreeSet<Student2>(new MySort());
        Student2 s1 = new Student2(5);
        Student2 s2 = new Student2(1);
        Student2 s3 = new Student2(2);
        Student2 s4 = new Student2(4);
        Student2 s5 = new Student2(3);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        for (Student2 s : set) {
            System.out.println(s);
        }
    }

}
package com.set;

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

class MySort1 implements java.util.Comparator<Student3>{
    public int compare(Student3 o1, Student3 o2) {
        return o2.id-o1.id;
    }
}
class Student3 implements Comparable<Student3>{
    int id;
    public Student3(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return this.id+"";
    }
    public int compareTo(Student3 o) {
        return (this.id-o.id);
    }
}

public class ListSort {
    public static void main(String[] args) {
        List<Student3> list = new ArrayList<Student3>();
        Student3 s1 = new Student3(5);
        Student3 s2 = new Student3(1);
        Student3 s3 = new Student3(2);
        Student3 s4 = new Student3(4);
        Student3 s5 = new Student3(3);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);
        System.out.println(list);
        //自然排序:
        Collections.sort(list);
        System.out.println(list);
        //客户排序
        Collections.sort(list, new MySort1());
        System.out.println(list);
    }
}

  3.LinkedHashSet

  LinkedHashSet按照插入顺序保存对象,同时还保存了HashSet的查询速度。


对 set 的遍历


1.迭代遍历:

Set<String> set = new HashSet<String>();
Iterator<String> it = set.iterator();
while (it.hasNext()) {
  String str = it.next();
  System.out.println(str);
}


2.for循环遍历:

for (String str : set) {
      System.out.println(str);
}
Set<Object> set = new HashSet<Object>();
for (Object obj: set) {
      if(obj instanceof Integer){
                int aa= (Integer)obj;
             }else if(obj instanceof String){
               String aa = (String)obj
             }
}


你可能感兴趣的:(Set Interface)