目录
2.自然排序：实现java.lang.Comparable接口
3.比较器排序：实现java.util.Comparator的匿名内部类
1.first()和last()方法分别获取了集合中的最小值和最大值。
一.set简介
在Java中，Set是一个接口，用于存储一组不重复的元素。Set接口继承自Collection接口，因此它具有Collection接口定义的所有方法，例如添加、删除和迭代等。
二.set集合的特点
1.Set不存储重复的元素
2.Set中的元素通常是无序的
package com.ctb.set;
import java.util.HashSet;
import java.util.Set;
/**
* set集合的特点
* 1.无序-没有下标--所以无法修改
* 2.元素无重复
*
* @author biao
*
*/
public class Demo1 {
public static void main(String[] args) {
//定义set集合
Set set=new HashSet<>();
//增加
set.add("ha");
set.add("ds");
set.add("dh");
set.add("es");
set.add("di");
//删除
set.remove("di");
System.out.println(set.size()); //输出：4
//查询
System.out.println(set);//输出[dh, ha, es, ds]
}
}
三.set集合的遍历方式
1.foreach遍历
2.iterator迭代器遍历
package com.ctb.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* set集合的遍历方式
* 1.foreach遍历
* 2.iterator迭代器遍历
* @author biao
*
*/
public class Demo2 {
public static void main(String[] args) {
//定义set集合
Set set=new HashSet<>();
//增加
set.add("花花");
set.add("曹操");
set.add("苹果");
//foreach遍历
for (Object object : set) {
System.out.println(object);//输出：花花 苹果 曹操
}
System.out.println("------------------------------------");
//iterator迭代器遍历
Iterator it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());//输出：花花 苹果 曹操
}
}
}
四.HashSet哈希表存储，重复元素存储底层原理
Set集合中元素是不重复的，但在我们存储对象过程中，对象是可以重复添加的，那么，我们 需要重写存储对象中的hashcode方法和equals方法，它会在hashCode方法中进行筛选，再到equals方法进行判断
注：若只重写一个方法，则无法避免存储对象重复的添加
package com.ctb.set;
import java.util.HashSet;
import java.util.Set;
/**
* set集合对象去重底层原理
* 先进入hashcode方法进行筛选，后进入equlas方法判断
* @author biao
*
*/
public class Demo3 {
public static void main(String[] args) {
Set set = new HashSet<>();
set.add(new Cat(1, "土猫"));
set.add(new Cat(2, "哈士奇"));
set.add(new Cat(3, "翔子猫"));
set.add(new Cat(4, "毛猫"));
// System.out.println(set.contains(new Cat(2, "哈士奇")));//false
set.add(new Cat(2, "哈士奇"));
for (Object object : set) {
System.out.println(object); //输出结果：Cat [id=4, name=毛猫]
// Cat [id=3, name=翔子猫]
// Cat [id=1, name=土猫]
// Cat [id=2, name=哈士奇]
}
}
}
class Cat {
private int id;
private String name;
public Cat() {
// TODO Auto-generated constructor stub
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Cat [id=" + id + ", name=" + name + "]";
}
public Cat(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
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;
Cat other = (Cat) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
五.LinkedHashSet保留元素插入顺序
LinkedHashSet是基于链表和哈希表的实现，它保留了元素插入的顺序，通过哈希表来实现元素的快速查找。
package com.ctb.set;
import java.util.LinkedHashSet;
import java.util.Set;
/**
* LinkedHashSet
* 元素插入排序
* @author biao
*
*/
public class Demo5 {
public static void main(String[] args) {
Set set = new LinkedHashSet<>();
set.add("花花");
set.add("鸟鸟");
set.add("猫猫");
set.add("哈哈");
for (Object object : set) {
System.out.println(object);// 输出：花花 鸟鸟 猫猫 哈哈
}
}
}
六.TreeSet(自然排序，比较器排序)
1.默认排序：set集合中的默认的排序
2.自然排序：实现java.lang.Comparable接口
3.比较器排序：实现java.util.Comparator的匿名内部类
package com.ctb.set;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
/**
* set集合排序
* @author biao
*
*/
public class Demo4 {
public static void main(String[] args) {
Set set =new TreeSet<>();
set.add(new Cart(1, "麻辣", 19));
set.add(new Cart(2, "香甜", 32));
set.add(new Cart(3, "可口", 23));
set.add(new Cart(4, "酸辣", 45));
set.add(new Cart(5, "苦逼", 23));
set.add(new Cart(6, "咸蛋", 23));
System.out.println("-------set集合默认排序---------");
//默认排序
for (Object object : set) {
System.out.println(object);
}
//自然排序
Set ts=new TreeSet<>();
//添加数据
for (Object object : set) {
ts.add(object);
}
System.out.println("------java.lang.Comparable自然排序-------");
for (Object object : ts) {
System.out.println(object);
}
//比较排序--根据价格排序
Set s=new TreeSet<>(new Comparator<Cart>() {
@Override
public int compare(Cart o1, Cart o2) {
// TODO Auto-generated method stub
return o2.getPrice()-o1.getPrice();
}
});
//添加数据
for (Object object : set) {
s.add(object);
}
System.out.println("---------java.util.Comparator的匿名内部类-按价格排序--------");
for (Object object : s) {
System.out.println(object);
}
//比较排序--先根据价格排序--价格相同则按id排序
Set ss=new TreeSet<>(new Comparator<Cart>() {
@Override
public int compare(Cart o1, Cart o2) {
// TODO Auto-generated method stub
int n=o2.getPrice()-o1.getPrice();
if (n==0) {
return o1.getId()-o2.getId();
}
return n;
}
});
//添加数据
for (Object object : set) {
ss.add(object);
}
System.out.println("---------java.util.Comparator的匿名内部类-先价格，再id排序--------");
for (Object object : ss) {
System.out.println(object);
}
}
}
class Cart implements Comparable<Cart>{
private int id;
private String name;
private int price;
public Cart() {
// TODO Auto-generated constructor stub
}
@Override
public String toString() {
return "Cart [id=" + id + ", name=" + name + ", price=" + price + "]";
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public Cart(int id, String name, int price) {
super();
this.id = id;
this.name = name;
this.price = price;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + price;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Cart other = (Cart) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (price != other.price)
return false;
return true;
}
@Override
public int compareTo(Cart o) {
return this.id-o.id;
}
}输出：
七.SortedSet
1.first()和last()方法分别获取了集合中的最小值和最大值。
2.subSet()方法获取了子集合
subSet()方法的第一个参数inclusive，第二个参数exclusive，即包含起始元素但不包含结束元素
3.tailSet()方法尾部子集合
package com.ctb.set;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
/**
* SortedSet
* @author biao
*
*/
public class Demo5 {
public static void main(String[] args) {
SortedSet<Integer> set = new TreeSet<>();
set.add(1);
set.add(2);
set.add(3);
set.add(4);
set.add(5);
System.out.println( set.first()); // 1
System.out.println( set.last()); // 5
SortedSet<Integer> subSet = set.subSet(2, 4);
System.out.println(subSet); // [2, 3]
SortedSet<Integer> tailSet = set.tailSet(3);
System.out.println( tailSet); // [3, 4, 5]
}
}
祝大家在梦想之路披荆斩棘！！
207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
