1. Set里的元素是不能重复的，那么用什么方法来区分重复与否呢?
基本数据类型是判断他的哈希值，引用数据类型需要重写equals()和hashCode()来判断。
2. List和Set的区别？
List是有序，是元素可重复的集合，有索引可用普通for循环；
Set是无序的，是元素不可重复的集合，没索引不可用普通for循环；
3. 创建Set接口的实现类，添加10个以上的元素，通过Iterator遍历此集合元素。 创建Set接口的实现类，添加10个以上的元素，通过foreach遍历此集合元素。 创建Set接口的实现类，添加10个以上的元素，要求能够排序。public class Work7_Set_1_3 {
public static void main(String[] args) {
//创建Set接口的实现类
Set set1 = new HashSet();
//添加10个以上的元素
set1.add(22);
set1.add(2);
set1.add(55);
set1.add(78);
set1.add(5);
set1.add(15);
set1.add(7);
set1.add(30);
set1.add(9);
set1.add(70);
set1.add(11);
//通过Iterator遍历此集合元素
Iterator iterator = set1.iterator();
while(iterator.hasNext()){
int i = iterator.next();
System.out.print(i + " ");
}
System.out.println("n--------------------------------");
//创建Set接口的实现类
Set set2 = new LinkedHashSet<>();
//添加10个以上的元素
set2.add("three");
set2.add("one");
set2.add("two");
set2.add("four");
set2.add("six");
set2.add("five");
set2.add("seven");
set2.add("ten");
set2.add("nine");
set2.add("eleven");
//通过foreach遍历此集合元素
set2.forEach(s2 ->{
System.out.print(s2 + " ");
});
System.out.println("n--------------------------------");
//创建Set接口的实现类
Set set3 = new TreeSet();
//添加10个以上的元素
set3.add("aaa");
set3.add("ccc");
set3.add("lll");
set3.add("bbb");
set3.add("eee");
set3.add("ddd");
set3.add("nnn");
set3.add("ooo");
set3.add("ppp");
set3.add("ttt");
set3.add("yyy");
set3.add("zzz");
//要求能够排序
for (String s : set3){
System.out.print(s + " ");
}
}
}
输出结果：
2 5 22 70 55 7 9 11 78 30 15
three one two four six five seven ten nine eleven
aaa bbb ccc ddd eee lll nnn ooo ppp ttt yyy zzz
4. 定义一个Collection接口类型的变量，引用一个Set集合的实现类，实现添加单个元素，添加另一个集合，删除元素，判断集合中是否包含一个元素，判断是否为空，清除集合，返回集合里元素的个数等常用操作。public class Work7_Set_1_4 {
public static void main(String[] args) {
//引用一个Set集合的实现类
Set set = new TreeSet();
//实现添加单个元素
set.add(1);
set.add(2);
set.add(8);
//添加另一个集合
Set set1 = new HashSet();
set1.addAll(set);
//删除元素
set1.remove(2);
System.out.println("删除2元素的集合："+set1);
//判断集合中是否包含一个元素
System.out.println("是否包含8:"+set1.contains(8));
//判断是否为空
System.out.println("集合是否为空:"+set1.isEmpty());
//清除集合
set1.clear();
//返回集合里元素的个数
System.out.println("清空后元素个数："+set1.size());
}
}
输出结果：
删除2元素的集合：[1, 8]
是否包含8:true
集合是否为空:false
清空后元素个数：0
Car实体类：
public class Car {
//创建Car类，包含name，price属性，构造器等方法
private String name;
private int price;
public Car() {
}
public Car(String name, int price) {
this.name = name;
this.price = price;
}
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;
}
@Override
public String toString() {
return "name=" + name +
" price=" + price;
}
}
测试类：
public class Work7_Set_1_5 {
public static void main(String[] args) {
//创建测试类，在main方法中创建Set接口的实现类
Set set = new TreeSet<>(new Comparator() {
@Override
public int compare(Car o1, Car o2) {
int num = o1.getName().compareTo(o2.getName());
int num1 = num == 0 ? o1.getPrice() - o2.getPrice() : num;
return num1;
}
});
//添加5个以上的Car对象
set.add(new Car("沃尔沃",250000));
set.add(new Car("大众",150000));
set.add(new Car("凯迪拉克",350000));
set.add(new Car("奥迪",550000));
set.add(new Car("雷克萨斯",950000));
set.add(new Car("雷克萨斯",950000));
//遍历集合元素，验证重复元素是否过滤了，如果没有过滤，实现过滤功能
for (Car car : set){
System.out.println(car);
}
System.out.println("------------------------------");
//把每个小车的price降10000元,再遍历，查看price是否已改变
for (Car car : set){
car.setPrice(car.getPrice()-10000);
System.out.println(car);
}
}
}
输出结果：
name=凯迪拉克 price=350000
name=大众 price=150000
name=奥迪 price=550000
name=沃尔沃 price=250000
name=雷克萨斯 price=950000
name=凯迪拉克 price=340000
name=大众 price=140000
name=奥迪 price=540000
name=沃尔沃 price=240000
name=雷克萨斯 price=940000
新闻一：中国多地遭雾霾笼罩空气质量再成热议话题
新闻二：民进党台北举行“火大游行”
新闻三：春节临近北京“卖房热”
新闻四：春节临近北京“卖房热”
完成如下要求：
1）完成对新闻类的设计，要求在初始化新闻类对象时 ，通过构造传参的形式对新闻标题赋值，并要求实例化四个对象，标题内容如题。
2）要求打印新闻对象时，直接打印新闻标题；
3）要求使用equals方法比较新闻时，只要标题相同，就认为是同一新闻，请输出新闻一与新闻二的比较结果，新闻三与新闻四的比较结果。
4）将新闻对象存入HashSet集合中，并且遍历集合，打印新闻类对象；
5）打印集合中新闻数量。
新闻实体类：
public class Journalism {
//封装一个新闻类，包含标题、作者、新闻内容和发布时间，
private String title;
private String author;
private String details;
private Date date;
public Journalism() {
}
public Journalism(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getDetails() {
return details;
}
public void setDetails(String details) {
this.details = details;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
@Override
public String toString() {
return "标题：" + title +
"n作者：" + author +
"n内容：" + details +
"n发布时间：" + date ;
}
//要求使用equals方法比较新闻时，只要标题相同，就认为是同一新闻
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Journalism that = (Journalism) o;
return title != null ? title.equals(that.title) : that.title == null;
}
@Override
public int hashCode() {
return title != null ? title.hashCode() : 0;
}
}
测试类:
public class Work7_Set_1_6 {
public static void main(String[] args) {
//创建HashSet集合对象
Set set = new HashSet();
//要求在初始化新闻类对象时 ，通过构造传参的形式对新闻标题赋值，并要求实例化四个对象，标题内容如题。
Journalism journalism1 = new Journalism("中国多地遭雾霾笼罩空气质量再成热议话题");
Journalism journalism2 = new Journalism("民进党台北举行“火大游行“");
Journalism journalism3 = new Journalism("春节临近北京“卖房热”");
Journalism journalism4 = new Journalism("春节临近北京“卖房热”");
//将新闻对象存入HashSet集合中
set.add(journalism1);
set.add(journalism2);
set.add(journalism3);
set.add(journalism4);
//要求打印新闻对象时，直接打印新闻标题；
for (Journalism journalism : set){
System.out.println(journalism);
System.out.println("------------------------");
}
//只要标题相同，就认为是同一新闻，请输出新闻一与新闻二的比较结果，新闻三与新闻四的比较结果
System.out.println("新闻一与新闻二的比较结果:"+journalism1.equals(journalism2));
System.out.println("新闻三与新闻四的比较结果:"+journalism3.equals(journalism4));
//打印集合中新闻数量
System.out.println("集合中新闻数量:"+set.size());
}
}
输出结果：
标题：春节临近北京“卖房热”
作者：null
内容：null
发布时间：null
标题：民进党台北举行“火大游行“
作者：null
内容：null
发布时间：null
标题：中国多地遭雾霾笼罩空气质量再成热议话题
作者：null
内容：null
发布时间：null
新闻一与新闻二的比较结果:false
新闻三与新闻四的比较结果:true
集合中新闻数量:3
- 生成10个随机数，值在100到200之间；
- 将这十个数存入HashSet集合中（有可能集合的长度小于10）。
- 将这个HashSet集合转换成ArrayList集合
- 重新为ArrayList集合排序，按照从小到大的顺序；
- 使用foreach遍历集合；
public class Work7_Set_1_7 {
public static void main(String[] args) {
//创建HashSet集合对象
Set hashSet = new HashSet();
//创建随机对象
Random random = new Random();
//（有可能集合的长度小于10）
for (int j = 0;j < 10;j++){
//生成10个随机数，值在100到200之间；
int i = random.nextInt(100)+101;
//将这十个数存入HashSet集合中
hashSet.add(i);
}
System.out.print(hashSet + " n");
//将这个HashSet集合转换成ArrayList集合
ArrayList arrayList = new ArrayList(hashSet);
//重新为ArrayList集合排序，按照从小到大的顺序
arrayList.sort(Comparator.naturalOrder());
//使用foreach遍历集合
arrayList.forEach(i ->{
System.out.print(i + " ");
});
}
}
输出结果：
[178, 182, 118, 166, 185, 173, 125, 142, 175]
118 125 142 166 173 175 178 182 185
**注：**arraylist 是 ArrayList 类的一个对象。
java arraylist.sort(Comparator c);
参数说明：comparator - 顺序方式 返回值：sort() 方法不返回任何值，它只是更改动态数组列表中元素的顺序。 Comparator 接口的 naturalOrder() 方法指定元素以自然顺序（升序）排序。 Comparator 接口的 reverseOrder() 方法指定以相反的顺序（降序）对元素进行排序。
测试类：
public class Work7_Set_1_8 {
public static void main(String[] args) {
//2）创建键盘录入对象,需要导入Scanner类
Scanner scanner = new Scanner(System.in);
//3）创建TreeSet集合对象，传入参数是比较器，总分比较
Set studentTreeSet = new TreeSet(new Comparator() {
@Override
public int compare(Student o1, Student o2) {
//总成绩降序
int num = o2.getSumScore()-o1.getSumScore() ;
return num == 0 ? 1 : num ;
}
});
int i = 1;
while (studentTreeSet.size() < 5) {
//4）录入5个学生信息，集合的size就是等于5，超过不继续存储
System.out.println("请输入第"+ i++ + "个学生姓名，语文成绩，数学成绩，英语成绩：");
//5）录入字符串切割
String line = scanner.nextLine();
// 逗号切割，返回是一个字符串数组，
String[] arr = line.split(",");
// 需要把成绩字符串转成Int类型
int languageScore = Integer.parseInt(arr[1]);
int mathScore = Integer.parseInt(arr[2]);
int englishScore = Integer.parseInt(arr[3]);
//6）转换后结果封装到学生类对象里，然把学生类对象添加到TreeSet集合中
Student student = new Student(arr[0],languageScore,mathScore,englishScore);
student.setSumScore(student.getSumScore());
studentTreeSet.add(student);
}
//7）遍历TreeSet集合，打印学生信息
for (Student student : studentTreeSet){
System.out.println(student);
}
}
}
输出结果：
请输入第1个学生姓名，语文成绩，数学成绩，英语成绩：
Jake,77,76,70
请输入第2个学生姓名，语文成绩，数学成绩，英语成绩：
Pamela,88,90,99
请输入第3个学生姓名，语文成绩，数学成绩，英语成绩：
Stark,99,99,100
请输入第4个学生姓名，语文成绩，数学成绩，英语成绩：
Jennie,77,65,88
请输入第5个学生姓名，语文成绩，数学成绩，英语成绩：
Lisa,80,77,65
姓名：Stark 语文成绩：99 数学成绩：99 英语成绩：100 总成绩：298
姓名：Pamela 语文成绩：88 数学成绩：90 英语成绩：99 总成绩：277
姓名：Jennie 语文成绩：77 数学成绩：65 英语成绩：88 总成绩：230
姓名：Jake 语文成绩：77 数学成绩：76 英语成绩：70 总成绩：223
姓名：Lisa 语文成绩：80 数学成绩：77 英语成绩：65 总成绩：222
