java集合(4)-Set集合

　　Set集合,类似于一个罐子,程序可以把多个对象"丢进"Set集合,而Set集合通常不能记住每个元素的添加顺序.Set集合与Collection基本相同,没有提供任何额外的方法.实际上Set就是Collection,只是行为有所不同(Set不允许有重复元素)

　　Set集合不允许包含相同的元素,如果试图把两个相同的元素添加入同一个Set集合中,则添加操作失败,add()返回false,且新元素不会被加入.

　　上面介绍Set的通用知识,因此完全适合后面介绍的HashSet,TreeSet和EnumSet三个实现类,只是这三个实现类各有特色.

一 HashSet

　　HashSet是Set接口的典型实现,大多数时候使用的Set集合时就是使用这个实现类.HashSet按Hash算法来存储集合中的元素，因此具有良好的存取和查找性能。

　　HashSet具有以下特点：

　　　　1.不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。

　　　　2.HashSet不是同步的，如果多个线程同时访问一个HashSet。假设有两个或者以上的线程同时修改了HashSet集合时，则必须通过代码来保证其同步。

　　　　3.集合元素可以是null.

　　当使用HashSet集合来存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode()值，然后根据该hashCode值决定该对象在HashSet中的存储位置。如果有两个元素通过equals()方法比较返回true，但是它们的hashCode()方法返回值不相等，HashSet将会把它们存入不同的位置，依然可以添加成功。

　　也就是说，HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法返回值也相等。

示例代码：类A,B,C，分别重写了equals()方法，hashCode()方法这两个中的一个或者两个。

package com.j1803.collectionOfIterator;

import java.util.HashSet;

import java.util.Set;

//类A重写了equals()方法,总是返回true,但没有重写hashCode()方法.

class A{

    @Override

    public boolean equals(Object obj){

        return true;

    }

}

//类B重写了hashCode()方法,总是返回2,但没有重写equals()方法

class B{

    @Override

    public int hashCode(){

        return 2;

    }

}

//类C重写了equals()方法,总是返回true,重写了hashCode()方法,总是返回2

class C{

    @Override

    public boolean equals(Object obj){

        return true;

    }

    @Override

    public int hashCode(){

        return 2;

    }

}

public class HashSetTest {

    public static void main(String[] args) {

        Set book=new HashSet();

        HashSet books=new HashSet();

        A a=new A();

        B b=new B();

        C c=new C();

        books.add(a);

        books.add(a);

        books.add(b);

        books.add(b);

        books.add(c);

        books.add(c);

        System.out.println(books);

    }

}

[com.j1803.collectionOfIterator.B@2, com.j1803.collectionOfIterator.A@4554617c]

Process finished with exit code 0

package com.j1803.collectionOfIterator;

import java.util.HashSet;

import java.util.Set;

//类A重写了equals()方法,总是返回true,但没有重写hashCode()方法.

class A{

    @Override

    public boolean equals(Object obj){

        return true;

    }

}

//类B重写了hashCode()方法,总是返回2,但没有重写equals()方法

class B{

    @Override

    public int hashCode(){

        return 2;

    }

}

//类C重写了equals()方法,总是返回true,重写了hashCode()方法,总是返回2

class C{

   /* @Override

    public boolean equals(Object obj){

        return true;

    }*/

   @Override

    public int hashCode(){

        return 2;

    }

}

public class HashSetTest {

    public static void main(String[] args) {

        Set book=new HashSet();

        HashSet books=new HashSet();

        A a=new A();

        B b=new B();

        C c=new C();

        books.add(a);

        books.add(a);

        books.add(b);

        books.add(b);

        books.add(c);

        books.add(c);

        book.add(new A());

        book.add(new A());

        book.add(new B());

        book.add(new B());

        Boolean flag1=book.add(new C());

        System.out.println(flag1);

        Boolean flag2=book.add(new C());

        System.out.println(flag2);

        System.out.println(book);

        System.out.println(books);

    }

}
true
true
[com.j1803.collectionOfIterator.B@2, com.j1803.collectionOfIterator.B@2, com.j1803.collectionOfIterator.C@2, com.j1803.collectionOfIterator.C@2, com.j1803.collectionOfIterator.A@74a14482, com.j1803.collectionOfIterator.A@1540e19d]
[com.j1803.collectionOfIterator.B@2, com.j1803.collectionOfIterator.C@2, com.j1803.collectionOfIterator.A@4554617c]

Process finished with exit code 0

package com.j1803.setTest;

import java.util.HashSet;

class A{

	@Override

	public boolean equals(Object arg0) {

		// TODO Auto-generated method stub

		return true;

	}

}

class B{

	@Override

	public int hashCode() {

		// TODO Auto-generated method stub

		return 2;

	}

}

class C{

	@Override

	public boolean equals(Object obj) {

		// TODO Auto-generated method stub

		return true;

	}

	@Override

	public int hashCode() {

		// TODO Auto-generated method stub

		//注意hashCode()返回为1不是与B类中一样返回为2

		return 1;

	}

}

public class HashSetTest {

	public static void main(String[] args) {

		HashSet books1=new HashSet();

		books1.add(new A());

		books1.add(new A());

		books1.add(new B());

		books1.add(new B());

		books1.add(new C());

		books1.add(new C());

		System.out.println(books1);

	}

[com.j1803.setTest.A@7852e922, com.j1803.setTest.C@1, com.j1803.setTest.B@2, com.j1803.setTest.B@2, com.j1803.setTest.A@4e25154f]

　　　　　注意点：当把一个对象放入HashSet中时，如果需要重写该对象对应类的equals()方法，则也应该重写其hashCode()方法。规则是：如果两个对象通过equals()方法比较返回true,则这两个对象的hashCode()值也应该相同。

　　　　如果两个对象通过equals()方法比较返回true，但这两个对象的hashCode()方法返回值不同，这将导致HashSet会把这两个对象保存在Hash表中不同的位置，从而使两个对象都可以添加成功这就与Set集合的规则相冲突了，

　　　　如果两个对象的hashCode()方法返回的hashCode()值相同，但它们通过equals()方法比较返回false时将更麻烦：因为两个对象的hashCode()值相同，HashSet将试图将它们保存在同一个位置，但又不行（否则只剩下一个对象）所以在实际上会在这个位置用链式结构来保存多个对象；而HashSet访问集合元素时也是根据元素的hashCode值来快速定位的，如果HashSet中两个以上的元素具有相同的hashCode值，将导致性能下降。

　　hashCode()方法对于HashSet的重要性(实际上，对象的hashCode值对于后面的HashMap同样重要)，下面给出重写hashCode()方法的基本原则。

　　在程序运行过程中，同一个对象多次调用hashCode()方法应该返回相同的值。

　　当两个对象通过equals()方法比较返回true时，这两个对象的hashCode()方法也应该返回相等的值。

　　对象中用作equals()方法比较标准的实例变量，都应该用于计算hashCode值。

下面给出重写hashCode()方法的一般几个步骤。

二 LinkedHashSet类

HashSet还有一个子类LinkedHashSet,LinkHashSet集合也是根据元素的hashCode的值来决定元素的存储位置的，但它使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。也就是说，当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按照元素的添加顺序来访问集合里的元素。

　　LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时将有很好的性能，因为它是以链表来维护内部顺序的。

package com.j1803.setTest;

import java.util.LinkedHashSet;

public class LinkedHashSetTest {

    public static void main(String[] args) {

        LinkedHashSet book=new LinkedHashSet();

        book.add("AAAAA");

        book.add("BBBBB");

        book.add("CCCCC");

        book.add("DDDDD");

        System.out.println(book);

    }

}

[AAAAA, BBBBB, CCCCC, DDDDD]

　　输出LinkedHashSet集合的元素时，元素的顺序总是与添加顺序一致。

　　虽然LinkedHashSet使用了链表记录集合元素的添加顺序，但LinkedHashSet依然是HashSet，因此它依然不允许集合元素重复。

三 TreeSet类

　　TresSet是SortedSet接口的实现类，正如SortedSet名字所暗示的，TreeSet可以确保集合元素处于排序状态。与HashSet集合相比，TreeSet还提供了如下几个额外的方法

　　Comparator comparator():如果TreeSet采用了定制排序，则该方法返回定制排序所使用的Comparator;如果TreeSet采用了自然排序，则返回null.

　　Object first():返回集合的第一个元素。

　　Object last():返回集合中的最后一个元素。

　　Object lower(Object e):返回集合中位于指定元素之前的元素(也就是小于指定元素的最大元素，参考元素不需要是TreeSet集合里的元素)。

　　Object higher(Object e):返回集合中位于指定元素之后的元素(也就是大于指定元素的最小元素，参考元素不需要是TreeSet集合里的元素)。

　　Object subSet(Object fromElement,Object toElement):返回此Set的子集合，范围从fromElement(包含)到toElement(不包含)。

　　SortedSet headSet(Object toElement):返回此Set集合的子集，由小于toElement的元素组成。

　　SortedSet tailSet(Object fromElement):返回此Set集合的子集，由大于或等于fromElement的元素组成。

package com.j1803.setTest;

import java.util.TreeSet;

public class TreeSetTest {

    public static void main(String[] args) {

        TreeSet num=new TreeSet();

        num.add(-5);

        num.add(45);

        num.add(78);

        num.add(-13);

        num.add(40);

        num.add(99);

        num.add(0);

        System.out.println(num);

        //输出集合的第一个元素

        System.out.println("输出集合的第一个元素"+num.first());

        //输出集合的最后一个元素

        System.out.println("输出集合的最后一个元素"+num.last());

        //输出小于50最大的元素

        System.out.println("输出小于50的最大的元素"+num.lower(50));

        //输出大于50的最小元素

        System.out.println("输出大于50的最小元素"+num.higher(50));

        //输出50到80之间的元素

        System.out.println("输出10到80之间的元素"+num.subSet(10, 80));

        //输出小于50的元素treeSet集合

        System.out.println("输出小于50的元素"+num.headSet(50));

        //输出大于50的元素的treeSet集合

        System.out.println("输出大于50的元素的treeSet集合"+num.tailSet(50));

    }

}

[-13, -5, 0, 40, 45, 78, 99]
输出集合的第一个元素-13
输出集合的最后一个元素99
输出小于50的最大的元素45
输出大于50的最小元素78
输出10到80之间的元素[40, 45, 78]
输出小于50的元素[-13, -5, 0, 40, 45]
输出大于50的元素的treeSet集合[78, 99]

TreeSet并不是根据元素的插入顺序来排序的，而是根据元素实际值的大小来进行排序的。

与HashSet集合采用hash算法来决定元素的存储位置不同，TreeSet采用红黑树的数据结构来存储集合数据。TreeSet支持两种排序方法：自然排序和定制排序，默认为自然排序。

　　1.自然排序

　　TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系。然后将集合元素按照升序排列，这种方式就是自然排序。

　　Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现该接口的类必须实现该方法，实现了该接口的类的对象就可以比较大小。当一个对象调用该方法与另一个对象进行比较是。例如obj1.compareTo(obj2)，如果改方法返回0，则表明这两个对象相等，如果该方法返回一个正整数，则表明obj1大于obj2;如果该方法返回一个负整数，则表明obj1小于obj2.

　　Java的一些常用类已经实现了Comparable接口，并提供了比较大小的标准。下面是实现了Comparable接口的常用类。

　　BigDecimal,Character,Boolean,String,Date,Time.

　　如果把一个自定义的类的对象添加到treeSet中，则该对象对应的类必须实现Comparable接口，否则程序将会抛出异常ClassCastException.

　　大部分类在实现compareTo(Object obj)方法时，都需要将被比较对象obj强制类型转换成相同类型，因为只有相同类的两个实例才会比较大小。

　　如果向TreeSet中添加的对象是程序员自定义的类的对象，则可以向TreeSet中添加多种类型的对象，前提是用户自定义的类实现了Comparable接口，且实现compareTo(Object obj)方法没有进行强制类型转换。但是当试图取出TreeSet集合元素时，不同类型的元素依然会发生ClassCastException异常。

　　总结：如果希望TreeSet能正常运作，TreeSet只能添加同一种类型的对象。

　　当一个对象加入TreeSet集合中时，TreeSet调用该对象的compareTo(Object obj)方法与容器中的其他对象比较，然后根据红黑树结构找到它的存储位置。如果两个对象通过compareTo(Object obj)方法比较相等，新对象将无法添加到TreeSet集合中。

　　对于TreeSet集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj)方法比较是否返回0，如果返回0，则认为相等，否则就认为它们不相等。

package com.j1803.setTest;

import java.util.TreeSet;

/**

 * @author zhou_oyster

 *

 */

class Person implements Comparable{

    private int age;

    @Override

    public boolean equals(Object obj) {

        return true;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    @Override

    public int compareTo(Object arg0) {

        return 1;

    }

    public Person(int age) {

        super();

        this.age = age;

    }

}

public class TreeSetTest1 {

    public static void main(String[] args) {

    TreeSet book=new TreeSet();

    Person person=new Person(45);

    book.add(person);

    System.out.println(book.add(person));//输出true，添加成功

    System.out.println(book);//显示所有的元素

    //取出book集合中的第一个元素并修改年龄

    ((Person)book.first()).setAge(12);

    //查看第一个元素的年龄和最后一个元素的年龄

    System.out.println(((Person)book.first()).getAge()+"===================="+((Person)book.last()).getAge());

    }

}

true

[com.j1803.setTest.Person@7852e922, com.j1803.setTest.Person@7852e922]

12====================12

　　可以看到虽然修改Comparable的compareTo()方法，误让程序以为person和他本身不相等，从而可以添加成功，集合中保存对象的引用指的是同一个对象，所以修改了第一个age,后面的age也修改了。

　　故：当需要把一个对象放入TreeSet中，重写该对象对应类的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致结果，其规则是：如果两个对象通过equals()方法比较返回true，这两个对象通过compareTo()方法应该返回0.

　　反之如果compareTo(Object obj)返回0而equals()返回false，则会与Set规则产生冲突。

　　如果向TreeSet中添加了可变对象，并且后面的程序修改了该可变对象的实例变量，将导致它与其他对象的大小顺序发生了改变，但TreeSet不会再次调整它们的顺序，甚至可能导致TreeSet中保存的这两个对象通过compareTo(Object obj)方法比较返回0.

package com.j1803.setTest;

import java.util.TreeSet;

public class Book implements Comparable{

    private int price;

    public Book(int price) {

        super();

        this.price = price;

    }

    @Override

    public String toString() {

        return "Book [price=" + price + "]";

    }

    public int getPrice() {

        return price;

    }

    public void setPrice(int price) {

        this.price = price;

    }

        @Override

        public boolean equals(Object obj) {

            if (this == obj)

                return true;

            if (obj == null)

                return false;

            if (getClass() != obj.getClass())

                return false;

            Book other = (Book) obj;

            if (price != other.price)

                return false;

            return true;

        }

        @Override

        public int compareTo(Object obj) {

            Book book=(Book)obj;

            return this.price>book.getPrice()?1:this.price<book.getPrice()?-1:0;

        }

    public static void main(String[] args) {

        TreeSet set=new TreeSet();

        set.add(new Book(12));

        set.add(new Book(10));

        set.add(new Book(-10));

        set.add(new Book(-5));

        set.add(new Book(5));

        set.add(new Book(8));

        //打印set集合

        System.out.println(set);

        //修改第一个元素

        Book book1=(Book)set.first();

        book1.setPrice(13);

        //修改最后一个元素，使其与第二个元素的price相同

        Book book2=(Book)set.last();

        book2.setPrice(-5);

        //打印,可以看到无序且有重复元素

        System.out.println(set);

        //删除实例变量被改变的元素，删除失败。

        System.out.println(set.remove(new Book(13)));

        //打印

        System.out.println(set);

        //删除实例变量没有被改变的元素,删除成功。

        System.out.println(set.remove(new Book(10)));

        //打印

        System.out.println(set);

    }

}

[Book [price=-10], Book [price=-5], Book [price=5], Book [price=8], Book [price=10], Book [price=12]]

[Book [price=13], Book [price=-5], Book [price=5], Book [price=8], Book [price=10], Book [price=-5]]

false

[Book [price=13], Book [price=-5], Book [price=5], Book [price=8], Book [price=10], Book [price=-5]]

true

[Book [price=13], Book [price=-5], Book [price=5], Book [price=8], Book [price=-5]]

　　可以删除没有被修改实例变量，且不与其他修改实例变量的对象重复的对象。

　　当执行了红色代码后TreeSet会对集合中的元素重新索引(不是重新排序），接下来可以删除TreeSet所有元素，推荐不要修改放入HashSet和TreeSet集合中元素的关键实例变量。

    //删除元素

System.out.println(set.remove(new Book(-5)));

System.out.println(set);

[Book [price=13], Book [price=-5], Book [price=5], Book [price=8], Book [price=-5]]

true

[Book [price=13], Book [price=5], Book [price=8], Book [price=-5]]

　　2.定制排序

　　TreeSet的自然排序是根据元素的大小，TreeSet将它们以升序排列。如果需要实现定制排序，例如以降序排列。则可以通过Comparator接口的帮助。，该接口里包含了一个int compare(T o1,T o2)方法。该方法用于比较o1和o2的大小：如果该方法中返回正整数，则表明o1大于o2;如果该方法返回0，则表明o1等于o2;如果该方法返回负整数，则表明o1大于o2.

　　如果需要实现定制排序，则需要在创建TreeSet集合对象时，提供一个Comparator对象与该TreeSet集合关联，由该Comparator对象负责集合元素的排序逻辑。由于Comparator是一个函数式接口，因此可用Lambda表达式来代替Comparator对象。

四 EnumSet类

　　EnumSet是一个专为枚举类设计的集合类，EnumSet中的所有元素都必须是指定枚举类型的枚举值。该枚举类型在创建EnumSet时显示或隐式地指定。EnumSet的集合元素也是有序的，EnumSet以枚举值在Enum类内的定义顺序来决定集合元素的顺序。

　　EnumSet在内部以位向量的形式存储，这种存储方式非常紧凑，高效，因此EnumSet对象占用内存很小，而且运行效率很好。尤其是进行批量操作(如调用containsAll()和remainAll()方法)时，如果其参数也是EnumSet集合，则该批量操作的执行速度也非常快。

　　EnumSet集合不允许加入null元素，如果试图插入null元素，EnumSet将抛出NullPointException异常。如果只是想判断EnumSet是否包含null元素或者试图删除null元素都不会抛出异常，只是删除操作将返回false,因为没有任何null元素被删除。

　　EnumSet类没有暴露任何构造器来创建该类的实例，程序应该通过它提供的类方法来创建EnumSet对象。EnumSet类它提供了如下常用的类方法来创建EnumSet对象。

　　EnumSet allOf(Class elementType):创建一个包含指定枚举类里所有枚举值的EnumSet集合.

　　EnumSet complementOf(Enumset s):创建一个其元素类型与指定EnumSet里元素类型相同的EnumSet集合，新EnumSet集合包含原EnumSet集合所不包含的，此枚举类剩下的枚举值(也就是新EnumSet集　　　　合和原来EnumSet集合的集合元素加起来都是该枚举类的所有枚举值)。

　　EnumSet copyOf(Collection c):使用一个普通集合来创建EnumSet集合。

　　EnumSet copyOf(EnumSet s):创建一个与指定EnumSet具有相同元素类型，相同集合元素的EnumSet集合。

　　EnumSet noneOf(Class elementType):创建一个元素类型为指定枚举类型的空EnumSet.

　　EnumSet of(E first,E...rest):创建一个包含一个或多个枚举值的EnumSet集合，传入的多个枚举值必须属于同一个枚举类。

　　EnumSet range(E from,E to):创建一个包含从from枚举值到to枚举值范围内所有枚举值的EnumSet集合。

package com.j1803.EnumSetTest1;

import java.util.EnumSet;

enum Season{

    SPRING,SUMMER,FALL,WINTER

}

public class EnumSetTest {

    public static void main(String[] args) {

        //创建一个EnumSet集合，集合元素就是Season枚举类的全部枚举值。

        EnumSet esl= EnumSet.allOf(Season.class);

        //输出[SPRING,SUMMER,FALL,WINTER]

        System.out.println(esl);

        //创建一个EnumSet空集合，指定集合元素是Season类的枚举值。

        EnumSet es2=EnumSet.noneOf(Season.class);

        //输出[]

        System.out.println(es2);

        //手动添加元素。

        es2.add(Season.FALL);

        es2.add(Season.SPRING);

        //输出[FALL,SPRING]

        System.out.println(es2);

        //以指定枚举值创建EnumSet集合

        EnumSet es3=EnumSet.of(Season.SUMMER,Season.FALL,Season.WINTER);

        //输出[SUMMER,FALL,WINTER]

        System.out.println(es3);

        EnumSet es4=EnumSet.of(Season.SUMMER,Season.WINTER);

        //新创建的EnumSet集合元素和es4集合元素有相同的类型

        //es5集合元素+es4集合元素=Season枚举类的全部枚举值

        EnumSet es5= EnumSet.complementOf(es4);

        System.out.println(es5);

    }

}

[SPRING, SUMMER, FALL, WINTER]

[]

[SPRING, FALL]

[SUMMER, FALL, WINTER]

[SPRING, FALL]

要求复制另一个Collection集合中的所有元素到新创建的

package com.j1803.EnumSetTest1;

import java.util.Collection;

import java.util.EnumSet;

import java.util.HashSet;

enum Season{

    SPRING,SUMMER,FALL,WINTER

}

public class EnumSetTest {

    public static void main(String[] args) {

        Collection c1=new HashSet();

        c1.add(Season.SUMMER);

        c1.add(Season.SPRING);

        c1.add(Season.FALL);

        //复制Collection集合中的所有元素来创建EnumSet集合

        EnumSet enumSet= EnumSet.copyOf(c1);

        //输出[SUMMER,SPRING,FALL]

        System.out.println(enumSet);

        //运行报ClassCastException错误

        //enumSet.add("PHP");

        //enumSet.add("C++");

        enumSet.add(Season.WINTER);

        System.out.println(enumSet);

    }

}

[SPRING, SUMMER, FALL]

[SPRING, SUMMER, FALL, WINTER]

五各Set实现类的性能分析

　　HashSet与TreeSet：HashSet的性能是比TreeSet要好，因为TreeSet需要额外的红黑树算法来维护集合元素的次序，当需要一个注重保持排序的Set时，才使用TreeSet。

　　EnumSet是所有Set实现类中性能最好的，但它只能保持同一个枚举类的枚举值作为集合元素。

　　HashSet，TreeSet和EnumSet都是线程不安全的。如果有多个线程同时访问一个Set集合，并且有超过一个线程修改了该Set集合，则必须手动保证该Set集合的同步性。通常可以通过Collection工具类的synchronizedSortedSet方法来"包装"该Set集合。在创建时进行，以防止对Set集合的意外非同步访问。

SortedSet sortedSet= Collections.synchronizedSortedSet(new TreeSet());

巴特西

java集合(4)-Set集合

一 HashSet

二 LinkedHashSet类

三 TreeSet类

四 EnumSet类

五各Set实现类的性能分析

最新文章

热门文章

巴特西

java集合(4)-Set集合

一 HashSet

二 LinkedHashSet类

三 TreeSet类

四 EnumSet类

五 各Set实现类的性能分析

最新文章

热门文章

五各Set实现类的性能分析