文章目录
-
目录
文章目录
1.集合的概念
2.Set集合
1.HashSet类
2.LinkedHashSet类
3.TreeSet类
4.EnumSet类
一、Java集合
1.集合的概念
Java集合类是一种特别有用的工具类 , 可用于存贮数量不等的对象 , 并可以实现经常用的数据结构 , 同时集合还可用于保存具有映射关系的关联数组.
Java集合大致可分为Set List Queue Map四种体系
- Set ( 无序 不可重复的集合 )
- List ( 代表有序 , 重复的集合 )
- Map ( 代表具有映射关系的集合 )
- Queue ( 队列集合 )
Java 集合就像一种容器 , 可以把多个对象 ( 实际上是对象的引用 , 但习惯上都成对象 ) " 丢进 "该容器中 .
Java集合类的作用 :
- 保存数量不确定的数据
- 保存具有映射关系的数据 ( 也被称为关联数组 )
集合类主要负责保存 , 盛装其他数据 , 因此集合类也被称为容器类 .
集合里只能保存对象 ( 实际上只是保存对象的引用变量 , 但通常习惯上认为集合里保存的是对象 )
Java的集合类主要有两个接口派生而出 : Collection 和 Map
牢记:
集合类就像容器 , 现实生活中容器的功能 , 无非就是添加对象 , 删除对象, 清空容器 , 判断容器是否为空等 , 集合类就为这些功能提供了对应的方法.
package name;
import java.util.ArrayList;
import java.util.HashSet;
public class CollectionTest {
public static void main(String[] args)
{
ArrayList a = new ArrayList();
a.add("孙悟空");
a.add(6);
System.out.println("a集合里面的元素个数为: " + a.size());
System.out.println("a集合是否包含\"孙悟空\"字符串: " + a.contains("孙悟空"));
a.add("轻量级Java EE企业应用实战.");
System.out.println("a集合的元素: " + a);
HashSet books = new HashSet();
books.add("轻量级Java EE企业应用实战.");
books.add("疯狂Java讲义");
System.out.println("a的集合里面是否完全包含books集合?" + a.containsAll(books));
a.removeAll(books);
System.out.println("a集合里面的元素: " + a);
a.clear();
System.out.println("a集合里面的元素: " + a);
books.retainAll(a);
System.out.println("books集合的元素: " + books);
}
}
a集合里面的元素个数为: 2
a集合是否包含"孙悟空"字符串: true
a集合的元素: [孙悟空, 6, 轻量级Java EE企业应用实战.]
a的集合里面是否完全包含books集合?false
a集合里面的元素: [孙悟空, 6]
a集合里面的元素: []
books集合的元素: []2.Set集合
Set 集合类似一个管子 , 程序可以一次把多个对象"丢进" Set集合 , 而Set集合通常不能记住元素的添加顺序 .
Set集合不允许包含相同的元素 , 如果试图把两个相同的元素加入同一个 Set集合中 , 添加操作会失败 , 新元素不会被加入 .
1.HashSet类
HashSet的特点
- 不能保证元素的排列顺序 , 顺序可能与添加顺序不同 , 顺序也有可能发生变化
- HashSet不是同步的
- 集合元素值可以是null
HashSet存储是通过调用对象的HashCode()方法来得到对象的 hashCode 值 , 然后根据 hashCode 值来决定对象在 HashSet 中的存储位置
package name;
import java.util.HashSet;
public class HashSetTest {
public static void main(String [] args)
{
HashSet books = new HashSet();
books.add(new A());
books.add(new A());
books.add(new B());
books.add(new C());
books.add(new C());
System.out.println(books);
}
}
class A
{
public boolean equals(Object obj)
{
return true;
}
}
class B
{
public int hashCode()
{
return 1;
}
}
class C
{
public int hashCode()
{
return 2;
}
public boolean equals(Object obj)
{
return true;
}
}
//输出:
//[name.B@1, name.C@2, name.A@7d4991ad, name.A@4aa298b7]由上面的两个A对象通过equals方法和地址可见 , 尽管两个A对象返回的都是true
但是Hashset依旧把两个当做不同的对象
由两个 B 对象的返回值都是 1 但地址不同可见 , HashSet依旧是把两个 B 对象
当成不同的对象
这个现象是违背了 Set 的集合的规则的
所以 , 把一个对象放进 HashSet 中, 如果要重写该对象的对应类的 equals()方法,
也应该重写 hashCode()方法
规则是:
如果两个对象通过 equals()都返回true, 则这两个对象的 hashCode也应该要一致HashCode() 方法规则:
- 同一个对象多次调用 hashCode() 应该返回相同的值
- 当两个对象通过equals() 方法比较返回 true 时 , 这两个对象的 hashCode() 方法应该返回相等的值
- 对象中用作equals()方法比较标准的实例变量 , 都应该用于计算 hashCode值
当向HashSet添加可变对象时 , 必须十分小心 .如果修改HashSet集合中的对象 , 有可能导致该对象与集合中的其他对象相等 , 从而导致 HashSet 无法准确访问该对象
2.LinkedHashSet类
LinkedHashSet 集合也是根据元素的 hashCode值来决定元素的存储位置 , 但它同时使用链表维护元素的次序 , 也就是说 , LinkedHashSet 将会按照元素的添加顺序来访问集合里的元素.
注意: LinkedHashSet 虽然使用了链表记录集合元素的添加顺序 , 但 LinkedHashSet 依然是 HashSet , 因此他依然不允许集合元素重复
3.TreeSet类
TreeSet 是SortedSet接口的实现类 , TreeSet可以确保集合元素处于排序状态
TreeSet提供很多方法的原因: TreeSet里面的元素是有序的 , 所以增加了访问第一个 , 前一个,后一个 , 最后一个元素的方法 , 并且提供了三个从 TreeSet 中截取子 TreeSet的方法
package name;
import java.util.TreeSet;
public class TreeSetTest {
public static void main(String [] args)
{
TreeSet nums = new TreeSet();
nums.add(5);
nums.add(2);
nums.add(10);
nums.add(-9);
System.out.println(nums);
System.out.println(nums.first());
System.out.println(nums.last());
System.out.println(nums.headSet(4));
System.out.println(nums.tailSet(4));
System.out.println(nums.subSet(-3,4));
}
}
/*
输出:
[-9, 2, 5, 10]
-9
10
[-9, 2]
[5, 10]
[2]
*/
- TreeSet 不是根据元素的插入顺序排序的 , 而是根据元素实际值的大小来进行排序的
- TreeSet采用红黑树的数据结构来存储集合元素
- TreeSet 支持两种排序方式 : 自然排序和定制排序 , 默认情况下 , TreeSet采用自然排序
TreeSet两种功能排序模式: 自然排序和定制排序
自然排序:TreeSet调用集合的compareTo(Object obj)方法比较元素大小 , 然后将元素升序排列
Comparable接口:
Java提供了一个Comparable接口 , 该接口里定义了一个 compareTo(Object obj)方法 , 该方法返回一个整数值:
- 如果两个对象相等 , 则返回0
- 如果返回一个正整数 , 则 obj1>obj2
- 如果返回一个负整数 , 则 obj1<obj2
package name;
import java.util.TreeSet;
public class TreeSetTest3 {
public static void main(String [] args)
{
TreeSet ts= new TreeSet();
ts.add(new R(5));
ts.add(new R(-3));
ts.add(new R(9));
ts.add(new R(-2));
System.out.println(ts);
R first = (R) ts.first();
first.count = 20;
R last = (R) ts.last();
last.count = -2;
System.out.println(ts);
System.out.println(ts.remove(new R(-2)));
System.out.println(ts);
System.out.println(ts.remove(new R(5)));
System.out.println(ts);
}
}
class R implements Comparable
{
int count;
public R(int count)
{
this.count = count;
}
public String toString()
{
return "R[count: " + count + "]";
}
public boolean equals(Object obj)
{
if(this==obj)
{
return true;
}
if(obj!=null&&obj.getClass()==R.class)
{
R r = (R) obj;
return r.count ==this.count;
}
return false;
}
public int compareTo(Object obj)
{
R r = (R) obj;
return count > r.count?1 : count < r.count ? -1:0;
}
}
/*
输出:
[R[count: -3], R[count: -2], R[count: 5], R[count: 9]]
[R[count: 20], R[count: -2], R[count: 5], R[count: -2]]
false
[R[count: 20], R[count: -2], R[count: 5], R[count: -2]]
true
[R[count: 20], R[count: -2], R[count: -2]]
*/
- 如果试图把一个对象添加到TreeSet , 则该对象必须实现 Comparable 接口 ,否则程序会发生 ClassCastException异常
- 同时 , 将一个元素添加到TreeSet树中 , 要求集合中的其他元素与该元素使用一个类的实例 , 否则也会引发 ClassCastException异常 . 也就是说: 如果希望TreeSet能正常运作 , TreeSet只能添加同一种类型.
如果向TreeSet 添加一个可变对象 , 并且后面程序修改了该可变对象的实例变量,这将导致它与其他对象的大小顺序发生了改变 , 但是TreeSet 不会再一次调整它们的顺序 , 甚至可能导致TreeSet中保存的这两个对象通过compareTo(Object obj)方法比较返回 0
为了让程序更加健壮 , 最好不要再次修改 HashSet 和 TreeSet 集合中元素的关键实例变量!!
定制排序: 如果要实现定制排序 , 例如降序排序 , 则需要通过 Comparator接口的帮助
Comparator接口:
Java提供了一个Comparable接口 , 该接口里定义了一个int compareTo(T o1, T o2)方法 , 该方法返回一个整数值:
- 如果两个对象相等 , 则返回0
- 如果返回一个正整数 , 则 obj1>obj2
- 如果返回一个负整数 , 则 obj1<obj2
Comparator是一个函数式接口 , 因此可使用Lambda表达式来代替Comparator 对象
package name;
import java.util.TreeSet;
public class TreeSetTest4 {
public static void main(String [] args)
{
TreeSet ts = new TreeSet((o1,o2)->
{
M m1 = (M) o1;
M m2 = (M) o2;
return m1.age > m2.age ? -1 : m1.age < m2.age ? 1 : 0;
});
ts.add(new M(5));
ts.add(new M(-3));
ts.add(new M(9));
System.out.println(ts);
}
}
class M
{
int age;
public M(int age)
{
this.age = age;
}
public String toString()
{
return "M[age: " + age + "]";
}
}
/*
输出:
[M[age: 9], M[age: 5], M[age: -3]]
*/
- 通过Comparator对象来时先TreeSet的定制排序 , 依旧不能像 TreeSet 种添加类型不同的对象 , 否测会引发 ClassCastException异常 ;
- 定制排序的时候 , TreeSet对集合元素排序不管集合元素本身的大小 , 而是由 Comparator 对象负责集合元素的排序规则;
- TreeSet判断两个集合相等的标准 : 通过比较两个元素返回了0
4.EnumSet类
- EnumSet是专门为枚举类设计的集合类
- EnumSet里面的所有元素都必须指定枚举类型的枚举值 ,并且该枚举类型在创建EnumSet时显式或隐式地指定
- EnumSet的集合元素也是有序的
- EnumSet通过枚举值在Enum类的定义顺序来决定集合元素的顺序
- EnumSet集合不允许加入null元素 , 如故如果试图插入null 元素 , EnumSet将抛出NullPointerException异常
package name;
import java.util.EnumSet;
enum Season
{
SPRING,SUMMER,FALL,WINTER
}
public class EnumSetTest {
public static void main(String [] args)
{
EnumSet a = EnumSet.allOf(Season.class);
System.out.println(a);
EnumSet b= EnumSet.noneOf(Season.class);
System.out.println(b);
b.add(Season.WINTER);
b.add(Season.SPRING);
System.out.println(b);
EnumSet c = EnumSet.of(Season.SUMMER,Season.WINTER);
System.out.println(c);
EnumSet d = EnumSet.range(Season.SUMMER,Season.WINTER);
System.out.println(d);
EnumSet e = EnumSet.complementOf(d);
System.out.println(e);
}
}
/*
输出:
[SPRING, SUMMER, FALL, WINTER]
[]
[SPRING, WINTER]
[SUMMER, WINTER]
[SUMMER, FALL, WINTER]
[SPRING]
*/
