javaSE_集合与队列（set）

红太狼 2022-05-25 03:08 270阅读 0赞

Set是个接口类，有很多派生类：

在插入数据时，它通过数据的hashCode方法获取一个值，可以理解为其内部有一个map，hashCode为键，值为值。因此添加两个一样的数据时，第二个会失败。

HashSet类按照哈希算法来存取集合中的对象，存取速度比较快

TreeSet类实现了SortedSet接口，能够对集合中的对象进行排序。

1) HashSet

**public** **static** **void** set\_Integer()\{

Set<Integer> nums = **new** HashSet<>();

**boolean** bR1 = nums.add(10);

**boolean** bR2 = nums.add(30);

**boolean** bR3 = nums.add(20);

**boolean** bR4 = nums.add(40);

**boolean** bR5 = nums.add(30);

System.***out***.println(bR1);

System.***out***.println(bR2);

System.***out***.println(bR3);

System.***out***.println(bR4);

System.***out***.println(bR5);

**for** (Integer num : nums)\{

System.***out***.println(num);

输出：

true

false

可见两点：

1.set内存储的内容是无序的，并不是插入时的顺序；

2.相同的值不能插入，add方法返回的是false。

如果是类对象，判断两个对象是否一样时，通过类的hashCode和equals方法共同来判断。

如：定义一个Student类，重写其hashCode和equals方法，都只使用name成员变量来判断。

**public** **class** Student \{

**private** Integer age;

**private** String name;

**public** Integer getAge() \{

**return** age;

**public** **void** setAge(Integer age) \{

**this**.age = age;

**public** String getName() \{

**return** name;

**public** **void** setName(String name) \{

**this**.name = name;

**public** Student(Integer age, String name) \{

**super**();

**this**.age = age;

**this**.name = name;

**public** Student() \{

**super**();

@Override

**public** **int** hashCode() \{

**final** **int** prime = 31;

**int** result = 1;

//result = prime \* result + ((age == null) ? 0 : age.hashCode());

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 (age == null) \{

//if (other.age != null)

//return false;

//\} else if (!age.equals(other.age))

//return false;

**if** (name == **null**) \{

**if** (other.name != **null**)

**return** **false**;

\} **else** **if** (!name.equals(other.name))

**return** **false**;

**return** **true**;

**public** **static** **void** set\_Student()\{

Set<Student> students = **new** HashSet<>();

Student stud1 = **new** Student(20, "张三");

Student stud2 = **new** Student(22, "李四");

Student stud3 = **new** Student(21, "王五");

Student stud4 = **new** Student(20, "李四");

students.add(stud1);

students.add(stud2);

students.add(stud3);

students.add(stud4);

**for** (Student stdu : students)\{

System.***out***.println(stdu.getName() + " -- " + stdu.getAge());

输出：

王五 \-- 21

李四 \-- 22

张三 \-- 20

可见，姓名相同的对象没有添加成功。

2) LinkedHashSet

LinkedHashSet是HashSet的派生类，主要的区别在于：

HashSet中的数据是无序的（和插入时顺序无关）

LinkedHashSet中的数据是按插入时的顺序存储的。

如：

Set<Integer> nums = **new** HashSet<>();

**for** (**int** i = 10; i < 100000; i\++)\{

nums.add(i);

nums.add(6 );

nums.add(5);

**for** (Integer num : nums)\{

System.***out***.println(num);

输出的值不是连续的：

![20180507115903202][]

Set<Integer> nums = **new** LinkedHashSet<>();

**for** (**int** i = 10; i < 100000; i\++)\{

nums.add(i);

nums.add(6 );

nums.add(5);

**for** (Integer num : nums)\{

System.***out***.println(num);

输出插入时的顺序：

![20180507115948474][]

3) TreeSet

其内部使用一个红黑树算法来维护元素的顺序。

即：其内部数据是排序的。

l 方法

TreeSet<Integer> nums = **new** TreeSet<>(**new** IntComparator());

nums.add(6);

nums.add(5);

nums.add(3);

nums.add(7);

nums.add(1);

nums.add(2);

**for** (Integer num : nums)\{

System.***out***.print("\\t" + num);

System.***out***.println("");

System.***out***.println(nums.toString());// \[7, 6, 5, 3, 2, 1\]

System.***out***.println(nums.first());// 第一个元素

System.***out***.println(nums.last());// 最后一个元素

System.***out***.println(nums.lower(2));// 元素2前面的元素值“3”

System.***out***.println(nums.higher(2));// 元素2后面的元素值“1”

TreeSet<Integer> subSet=(TreeSet<Integer>) nums.subSet(5, 2);// 值在［5，2）间的值（包含5，不包含2）

System.***out***.println(subSet.toString());// \[5, 3\]

TreeSet<Integer> headSet = (TreeSet<Integer>) nums.headSet(3);// 值在3前面的值（不包含3）

System.***out***.println(headSet.toString());// \[7, 6, 5\]

TreeSet<Integer> tailSet = (TreeSet<Integer>) nums.tailSet(3);// 值在3后面的值（包含3）

System.***out***.println(tailSet.toString());// \[3, 2, 1\]

l Int

Set<Integer> nums = **new** TreeSet<>();

nums.add(6);

nums.add(5);

nums.add(3);

nums.add(7);

**for** (Integer num : nums)\{

System.***out***.print(num + "\\t");

输出： 3567

默认增序排序，也可以自定义排序规则：

定义一个类，创建TreeSet时由构造函数将排序类传入：

**public** **class** IntComparator **implements** Comparator<Integer>\{

@Override

**public** **int** compare(Integer arg0, Integer arg1) \{

**return** arg1\-arg0;

使用时如下：

Set<Integer> nums = **new** TreeSet<>(**new** IntComparator());

输出： 7653

l String

上面是数字，如果是字串，则是使用的hashcode进行的比较，修改为降序如下：

**public** **class** StringComparator **implements** Comparator<String>\{

@Override

**public** **int** compare(String o1, String o2) \{

**return** o2.hashCode() - o1.hashCode();

使用时如下：

Set<String> strs = **new** TreeSet<>(**new** StringComparator());

strs.add("李四");

strs.add("张三");

strs.add("王五");

strs.add("a");

strs.add("d");

strs.add("b");

**for** (String str : strs)\{

System.***out***.print("\\t" + str);

输出： 王五 李四 张三 d b a

l Date

Set<Date> dates = **new** TreeSet<>();

**try** \{

String format = "yyyy-MM-dd HH:mm:ss";

Date date1 = *stringToDate*("2016-5-1 13:24:5", format);

Date date2 = *stringToDate*("2016-5-3 13:24:5", format);

Date date3 = *stringToDate*("2016-5-2 13:24:5", format);

dates.add(date1);

dates.add(date2);

dates.add(date3);

**for** (Date date : dates)\{

System.***out***.println(*dateToString*(date, format));

\} **catch** (ParseException e) \{

e.printStackTrace();

输出：

2016-05-01 13:24:05

2016-05-02 13:24:05

2016-05-03 13:24:05

降序：

**public** **class** DateComparator **implements** Comparator<Date>\{

@Override

**public** **int** compare(Date o1, Date o2) \{

**if** (o2.before(o1))\{

**return** -1;

**return** 1;

Set<Date> dates = **new** TreeSet<>(**new** DateComparator());

**try** \{

String format = "yyyy-MM-dd HH:mm:ss";

Date date1 = *stringToDate*("2016-5-1 13:24:5", format);

Date date2 = *stringToDate*("2016-5-3 13:24:5", format);

Date date3 = *stringToDate*("2016-5-2 13:24:5", format);

dates.add(date1);

dates.add(date2);

dates.add(date3);

**for** (Date date : dates)\{

System.***out***.println(*dateToString*(date, format));

\} **catch** (ParseException e) \{

e.printStackTrace();

输出：

2016-05-03 13:24:05

2016-05-02 13:24:05

2016-05-01 13:24:05

4) EunmSet

枚举set，暂时没找到使用场景，在网上找了一段说明，如下：

1、EnumSet中所有值都必须是指定枚举类型的值，它的元素也是有序的，以枚举值在枚举类的定义顺序来决定集合元素的顺序。

2、EnumSet集合不允许加入null元素，否则会抛出NullPointerException异常。

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

static EnumSet allOf（Class elementType）：创建一个包含指定枚举类里所有枚举值的EnumSet集合。

static EnumSet complementOf（EnumSet s）：创建一个其元素类型与指定EnumSet里元素类型相同的EnumSet，新的EnumSet集合包含原EnumSet集合所不包含的、此枚举类剩下的枚举值。

static EnumSet copyOf（collection c）：使用一个普通集合来创建EnumSet集合。

static EnumSet copyOf（EnumSet e）:创建一个与指定EnumSet具有相同元素类型、相同集合元素的EnumSet。

static EnumSet noneOf（Class elementType）：创建一个元素类型为指定枚举类型的空EnumSet.

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

static EnumSet range（E from，E to）：创建包含从from枚举值，到to枚举值范围内所有枚举值的EnumSet集合。

public static void main(String\[\] args) \{

EnumSet e1=EnumSet.allOf(Season1.class);//创建一个EnumSet集合，集合元素就是Season里的全部枚举值

System.out.println(e1);//输出\[SPRING, SUMMER, FALL, WINTER\]

EnumSet e2=EnumSet.noneOf(Season1.class);//创建一个EnumSet空集合，指定其集合元素是season1的枚举值

e2.add(Season1.WINTER);

e2.add(Season1.SPRING);

System.out.println(e2);//输出\[SPRING, WINTER\]

EnumSet e3=EnumSet.of(Season1.SUMMER, Season1.WINTER);//以指定枚举值创建EnumSet集合

System.out.println(e3);//输出\[SUMMER, WINTER\]

EnumSet e4=EnumSet.range(Season1.SUMMER, Season1.WINTER);

System.out.println(e4);//输出\[SUMMER, FALL, WINTER\]

EnumSet e5=EnumSet.complementOf(e4);

System.out.println(e5);//输出\[SPRING\]

**遍历集合**

主要有两种方式，for，以及迭代器：

如：

Set<Integer> nums = **new** HashSet<>();

nums.add(10);

nums.add(30);

**for** (Integer num : nums)\{

System.***out***.print(num + "\\t");

Iterator<Integer> iter = nums.iterator();

**while** (iter.hasNext())\{

Integer num = iter.next();

System.***out***.print(num + "\\t");

[20180507115903202]: /images/20220525/0f8a9a4c15f143448c21747ef41d6f8f.png
[20180507115948474]: /images/20220525/40f1173e0f334270a4b6b151e1763e3f.png

javaSE_集合与队列（set）

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 JavaSE——集合、集合继承结构图

相关 JavaSE 集合框架（2）- Set集合

相关 JAVASE之集合

相关 javaSE_集合与队列（queue)

相关 javaSE_集合与队列(map)

相关 javaSE_集合与队列（list）

相关 javaSE_集合与队列（set）

相关集合之list（数组，队列），set

相关 Javase之集合体系（3）之Set及其子类知识

相关 JavaSE 集合