Set集合

import java.util.ArrayList;

import java.util.Random;

public class Main {

public static void main(String[] args) {

ArrayList list = new ArrayList();

Random r = new Random();

int count = 0;

while (count

int num = r.nextInt(50)+1;

if(!list.contains(num)){

list.add(num);

count++;

}

}

System.out.println(list);

}

}

package com.momo.demo;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Scanner;

public class Demo1 {

public static void main(String[] args) {

ArrayList list = new ArrayList();

Scanner sc = new Scanner(System.in);

while (true){ System.out.println(“请输入：”);
int i = sc.nextInt();
if(i==0){
break;
}else{
list.add(i);
}
}

Integer[] array = list.toArray(new Integer[1]);
System.out.println(Arrays.toString(array));
Arrays.sort(array);
System.out.println(Arrays.toString(array));
System.out.println(array[array.length-1]);
}

}

集合版模拟用户注册登录案例

package com.momo.demo;

import com.momo.po.User;

import com.momo.service.UserService;

import com.momo.service.imp.UserServiceImp;

import com.momo.util.Game;

import java.util.Scanner;

/*

• 模拟用户注册登录，登录成功之后实现增删改查
• 分析：面向对象思想
• 有哪些类？
• 用户类
• 用户信息：id，name，gender，bir，account，password,… 构造方法，get和set，toString， eat，sleep…
• 登录功能
• 注册功能
• …..
• 如果用户类的内容很多，将来维护的时候就比较麻烦了，所以为了更加清晰的分析，我们可以把用户类分成2个类
• 用户基本类
• 成员变量，构造方法，成员方法
• 用户操作类
• 登录功能

• 注册功能
• …..

• 测试类
• main
• 每个类中有什么内容？
• 类和类之间的关系是什么？
• */

public class Demo2 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println(“欢迎你访问xxxxxx系统”);

System.out.println(“——————————–“);

UserService us = new UserServiceImp();

while (true) {

System.out.println(“请选择：1–注册 2–登录 3–退出”);

String i = sc.nextLine(); switch (i) {
case “1”: {
System.out.println(“注册页面”);
System.out.println(“编号：”);
int id = Integer.parseInt(sc.nextLine());
System.out.println(“姓名：”);
String name = sc.nextLine();
System.out.println(“账号：”);
String account = sc.nextLine();
System.out.println(“密码：”);
String password = sc.nextLine();

boolean boo = us.regist(new User(id, name, account, password));
if (boo) {
System.out.println(“注册成功。。。。”);
} else {
System.out.println(“注册失败。。。。”);
}
break;
}
case “2”: {
System.out.println(“登录页面”);
System.out.println(“账号：”);
String account = sc.nextLine();
System.out.println(“密码：”);
String password = sc.nextLine();

boolean boo = us.login(account, password);
if (boo) {
System.out.println(“登录成功。。。。欢迎你：”+account);
System.out.println(“—————————“);
while (true) {
System.out.println(“要开始游戏吗？y/n”);
String s = sc.nextLine();
if(s.equals(“y”)){
System.out.println(“游戏开始！”);
//玩游戏
Game.start();
} else if (s.equals(“n”)) {
break;
}else{
System.out.println(“输入有误。。。”);
}
// System.out.println(“1–查询 2–新增 3–修改 4–删除 5–退出”);
}
} else {
System.out.println(“登录失败。。。。”);
}
break;
}
case “3”:
System.out.println(“欢迎下次再来，请慢走。。。”);
System.exit(0);
break;
default:
System.out.println(“没有该选项！”);
break;
}
}

}

}

package com.momo.service;

import com.momo.po.User;

//用户操作类接口

public interface UserService {

//注册

public abstract boolean regist(User u);

//登录

public abstract boolean login(String account,String password);

}

package com.momo.service.imp;

import com.momo.po.User;

import com.momo.service.UserService;

import java.util.ArrayList;

//用户操作类

public class UserServiceImp implements UserService {

private ArrayList list = new ArrayList();

//private static ArrayList list = new ArrayList();

//注册

public boolean regist(User u){

// ArrayList list = new ArrayList();

// return list.add(u);

boolean boo = list.add(u);

System.out.println(list);

return boo;

}

//登录 public boolean login(String account,String password){
boolean boo = true;
for (User user : list) {
if(user.getAccount().equals(account)&&user.getPassword().equals(password)){
boo = true;
break;
}else{
boo = false;
}
}
return boo;
}

}

package com.momo.po;

import java.util.Objects;

//用户基本类

public class User {

private int id;

private String name;

private String account;

private String password;

public User() {}

public User(int id, String name, String account, String password) {
this.id = id;
this.name = name;
this.account = account;
this.password = password;
}

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 String getAccount() {
return account;
}

public void setAccount(String account) {
this.account = account;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

@Override
public String toString() {
return “User{” +
“id=” + id +
“, name='” + name + ”’ +
“, account='” + account + ”’ +
“, password='” + password + ”’ +
‘}’;
}

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return id == user.id && Objects.equals(name, user.name) && Objects.equals(account, user.account) && Objects.equals(password, user.password);
}

@Override
public int hashCode() {
return Objects.hash(id, name, account, password);
}

}

package com.momo.util;

import java.util.Random;

import java.util.Scanner;

public class Game {

private Game(){}

public static void start(){

Scanner sc = new Scanner(System.in);

Random r = new Random();

int i = r.nextInt(100)+1;

while (true) {

System.out.println(“请输入：(1-100)”);

int j = sc.nextInt();

if (i == j) {

System.out.println(“猜对了，请去前台领取奖品”);

break;

} else if (i > j) {

System.out.println(“小了”);

} else {

System.out.println(“大了”);

}

}

}

}

一，Set

1，概述

不包含重复元素的集合，并且最多一个空元素。

2，特点

-无序，唯一

3，成员方法

-都是讲过的

package com.momo.demo;

import java.util.HashSet;

import java.util.Set;

public class Demo3 {

public static void main(String[] args) {

/* Set s = new HashSet();

s.add(“aaa”);

s.add(“bbb”);

s.add(“ccc”);

s.add(null);*/

/s.add(“bbb”);s.add(“ccc”);s.add(null);/

/* for (Object o : s) { System.out.println(o);
}*/

Set s = new HashSet();
s.add(“aaa”);
s.add(“bbb”);
s.add(“ccc”);

for (String ss : s) {
System.out.println(ss);
}
}

}

4，练习

-存储字符串遍历

-存储自定义对象遍历

package com.momo.demo;

import com.momo.po.Stu;

import java.util.HashSet;

import java.util.Set;

/*

• 我们按照和字符串一样的思路，存储了自定义对象，但是这次并没有去掉重复内容
• 为什么？
• 我们简单的查看了一下原码，发现原码中使用了equals方法进行对比，字符串重写过equals方法，比较的是内容
• 而自定义对象我们没有重写，默认使用Object的(用的是==) ，== 引用类型比较的是地址值，对象都是new的
• 地址值肯定不一样，所以，使用Set集合存储自定义对象时，一定记住要重写equals方法
• */

public class Demo4 {

public static void main(String[] args) {

Set s = new HashSet();

s.add(new Stu(“默默”,18));

s.add(new Stu(“三藏”,26));

s.add(new Stu(“悟空”,800));

s.add(new Stu(“八戒”,1000));

s.add(new Stu(“悟净”,1500));

s.add(new Stu(“默默”,18));

s.add(new Stu(“悟空”,800));

for (Stu stu : s) { System.out.println(stu.getName()+”—“+stu.getAge());
}

}

}

二，HashSet

1，概述

-此类实现Set接口，由哈希表（实际为HashMap实例）支持。

-对集合的迭代次序不作任何保证; 特别是，它不能保证元素

在一段时间内保持不变。 这个类允许null元素。

2，特点

-底层数据结构是 哈希表(元素是链表的数组，结合了数组和链表的优势)

哈希表依赖哈希值，添加功能依赖 hashCode和equals方法

-无序，唯一，允许为空(只能有一个)

-此实现不同步，线程不安全，效率高

3，构造方法

HashSet()

构造一个新的空集合

HashSet(Collection c)

构造一个包含指定集合中的元素的新集合。

HashSet(int initialCapacity)

构造一个新的空集合; 背景HashMap实例具有指定的初始容量

4，成员方法

-常用的都是讲过的

5，练习

-使用HashSet集合存储字符串，自定义对象遍历(加泛型)

三，LinkedHashSet

1，概述

-哈希表和链表实现了Set接口，具有可预测的迭代次序。

-此实现不同步。

2，特点

-有序(存储顺序)，唯一

3，构造方法

LinkedHashSet()

构造一个具有默认初始容量（16）和负载因子（0.75）的新的，空的链接散列集。

LinkedHashSet(Collection c)

构造与指定集合相同的元素的新的链接散列集。

LinkedHashSet(int initialCapacity)

构造一个具有指定初始容量和默认负载因子（0.75）的新的，空的链接散列集。

4，成员方法

–常用的都是讲过的

5，练习

-使用LinkedHashSet集合存储字符串，自定义对象遍历(加泛型)

package com.momo.demo;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.Set;

public class Demo5 {

public static void main(String[] args) {

LinkedHashSet s = new LinkedHashSet();

// s.add(“bbb”);

s.add(“ccc”);

s.add(“bbb”);

s.add(“aaa”);

for (String ss : s) {

System.out.println(ss);

}

}

}

四，TreeSet

1，概述

-一个可以排序的集合，排序有2种方式：

自然排序

比较器排序

取决于创建对象时采用的构造方法

2，特点

-唯一，排序，不能为空

-此实现不同步。

3，构造方法

TreeSet()

构造一个新的，空的树组，根据其元素的自然排序进行排序。

TreeSet(Collection c)

构造一个包含指定集合中的元素的新树集，根据其元素的 自然排序进行排序 。

TreeSet(Comparator comparator)

构造一个新的，空的树集，根据指定的比较器进行排序。

package com.momo.demo;

import java.util.ArrayList;

import java.util.TreeSet;

public class Demo6 {

public static void main(String[] args) {

//无参构造，表示使用自然排序对元素进行排序

// TreeSet ts = new TreeSet();

ArrayList ts = new ArrayList();

ts.add(54);

ts.add(23);

ts.add(345);

ts.add(1);

ts.add(23);

ts.add(54);

ts.add(11);

// ts.add(null);

//ts.add(null);

// System.out.println(ts);

for (Integer t : ts) {

System.out.println(t);

}

System.out.println(“————“);

TreeSet tt = new TreeSet(ts);

for (Integer it : tt) {

System.out.println(it);

}

}

}

4,TreeSet是如何保证排序和唯一的

-底层数据结构是 二叉树

当我们添加的时候，拿第一个元素放到根节点

从第二个元素开始，都要和之前的元素进行比较，小的放左边，大的放右边

一样的进行替换，这样就可以保证唯一

我们在获取元素的时候，是按照左中右的顺序的获取元素，保证排序

-通过简单查看源码，我们发现TreeSet的add方法实际上调用的是

TreeMap中的put方法做的添加，在这个方法中，有2中比较方式。

一：通过传递的比较器排序， Comparator接口中的compare方法进行比较

二：使用自然排序，会使用Comparable接口中的c服务器托管网ompareTo方法进行比较

要进行自然排序，元素对应的类必须实现自然排序接口

Comparable，重写compareTo方法，会把元素强转成Comparable类型

-第一个案例存储的是Integer类型数据，Integer类已经实现了Comparable接口，

也重写了compareTo方法。所以可以直接进行自然排序

-第二个案例存储的是自定义对象，刚开始并没有实现Comparable接口，

所以在源码中转换的时候就报错了 ClassCastException 类型转换异常

注意：存储自定义对象时，要进行自然排序，必须实现该接口，重写该方法

方法中要如何进行比较，是我们自定义的。

package com.momo.demo;

import java.util.ArrayList;

import java.util.TreeMap;

import java.util.TreeSet;

public class Demo6 {

public static void main(String[] args) {

//无参构造，表示使用自然排序对元素进行排序

TreeSet ts = new TreeSet();

// ArrayList ts = new ArrayList();

ts.add(54);

ts.add(23);

ts.add(345);

ts.add(1);

ts.add(23);

ts.add(54);

ts.add(11);

// ts.add(null);

//ts.add(null);

// System.out.println(ts);

for (Integer t : ts) {

System.out.println(t);

}

/*System.out.println(“————“);

TreeSet tt = new TreeSet(ts);

for (Integer it : tt) {

System.out.println(it);

}

*/

}

}

package com.momo.demo;

import com.momo.po.Stu;

import java.util.TreeSet;

/*

• 按照和刚才一样的方式，存储了自定义对象，但是这次报错了
• ClassCastException 类型转换异常
• com.momo.po.Stu cannot be cast to class java.lang.Comparable
• 说明了，自定义对象要进行自然排序，必须实现自然排序接口，重写compareTo 方法
• Comparable：接口，自然排序接口
• int compareTo(T o) 将此对象与指定的对象进行比较以进行排序。
• */

public class Demo7 {

public static void main(String[] args) {

// //无参构造，表示使用自然排序对元素进行排序

TreeSet ts = new TreeSet();

ts.add(new Stu(“默默”,18));

ts.add(new Stu(“三藏”,26));

ts.add(new Stu(“悟空”,800));

ts.add(new Stu(“八戒”,1000));

ts.add(new Stu(“悟净”,1500));

ts.add(new Stu(“默默”,18));

ts.add(new Stu(“悟空”,800));

for (Stu t : ts) { System.out.println(t);
}

}

}

package com.momo.po;

import java.util.Objects;

public class Stu implements Comparable{

private String name;

private Integer age;

public Stu() {}

public Stu(String name, Integer age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;

Stu stu = (Stu) o;

if (!Objects.equals(name, stu.name)) return false;
return Objects.equals(age, stu.age);
}

@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + (age != null ? age.hashCode() : 0);
return result;
}

@Override
public String toString() {
return “Stu{” +
“name='” + name + ”’ +
“, age=” + age +
‘}’;
}

//比什么？怎么比？这是由我们自己定义的
@Override
public int compareTo(Stu 服务器托管网o) {
//先比哪个？后比哪个？
//以年龄为主要条件
int i = this.age-o.age;
//年龄一样，还要比较姓名
int ii = i==0?this.name.compareTo(o.name):i;
return ii;
}

}

package com.momo.demo;

import com.momo.po.Stu;

import java.util.TreeSet;

/*

• 存储自定义对象，按照姓名长度进行排序
• */

public class Demo8 {

public static void main(String[] args) {

TreeSet ts = new TreeSet();

ts.add(new Stu(“momo”,18));

ts.add(new Stu(“xiaobao”,20));

ts.add(new Stu(“xiaolong”,30));

ts.add(new Stu(“dilireba”,28));

ts.add(new Stu(“hani”,26));

for (Stu t : ts) { System.out.println(t);
}

}

}

package com.momo.po;

import java.util.Objects;

public class Stu implements Comparable{

private String name;

private Integer age;

public Stu() {}

public Stu(String name, Integer age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;

Stu stu = (Stu) o;

if (!Objects.equals(name, stu.name)) return false;
return Objects.equals(age, stu.age);
}

@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + (age != null ? age.hashCode() : 0);
return result;
}

@Override
public String toString() {
return “Stu{” +
“name='” + name + ”’ +
“, age=” + age +
‘}’;
}

//姓名长度， 主要条件
@Override
public int compareTo(Stu o) {
//姓名长度
int i = this.name.length()-o.name.length();
//姓名内容
int ii=i==0?this.name.compareTo(o.name):i;
//年龄
int iii=ii==0?this.age-o.age:ii;
return iii;
}

/*//比什么？怎么比？这是由我们自己定义的
@Override
public int compareTo(Stu o) {
//先比哪个？后比哪个？
//以年龄为主要条件
int i = this.age-o.age;
//年龄一样，还要比较姓名
int ii = i==0?this.name.compareTo(o.name):i;
return ii;
}*/
}

package com.momo.demo;

import com.momo.po.MyComparator;

import com.momo.po.Stu;

import com.momo.po.Tea;

import java.text.ParseException;

import java.text.RuleBasedCollator;

import java.util.Comparator;

import java.util.TreeSet;

/*

• 存储自定义对象，进行比较器排序
• Comparator 比较器 接口
• int compare(T o1, T o2) 比较其两个参数的顺序。

应该传递该接口的具体实现类对象，比较规则是我们自定义的,所以我们要自己编写实现类，

• 重写compare方法，自己定义我们的比较规则

• /

public class Demo9 {public static void main(String[] args) throws ParseException {//传递比较器，通过比较器排序，按照姓名长度排序(按照年龄排序,…)/ TreeSet ts = new TreeSet(new MyComparator());

ts.add(new Tea(“momo”,18));

ts.add(new Tea(“xiaobao”,20));

ts.add(new Tea(“xiaolong”,30));

ts.add(new Tea(“dilireba”,28));

ts.add(new Tea(“hani”,26));*/

//匿名内部类来改进代码 /*TreeSet ts = new TreeSet(new Comparator() {
@Override
public int compare(Tea o1, Tea o2) {
int i = o2.getName().length()-o1.getName().length();
int i2 = i==0?o1.getName().compareTo(o2.getName()):i;
int i3 = i2==0?o2.getAge()-o1.getAge():i2;
return i3;
}
});*/

//使用lamada表达式改进
TreeSet ts = new TreeSet((o1, o2) -> {
int i = o2.getName().length()-o1.getName().length();
int i2 = i==0?o1.getName().compareTo(o2.getName()):i;
int i3 = i2==0?o2.getAge()-o1.getAge():i2;
return i3;
});

ts.add(new Tea(“momo”,18));
ts.add(new Tea(“xiaobao”,20));
ts.add(new Tea(“xiaolong”,30));
ts.add(new Tea(“dilireba”,28));
ts.add(new Tea(“hani”,26));

for (Tea t : ts) {
System.out.println(t);
}

}

}

package com.momo.po;

import java.util.Comparator;

//自定义类，实现比较器排序接口，重写方法。

public class MyComparator implements Comparator {

@Override

public int compare(Tea o1, Tea o2) {

int i = o2.getName().length()-o1.getName().length();

int i2 = i==0?o1.getName().compareTo(o2.getName()):i;

int i3 = i2==0?o2.getAge()-o1.getAge():i2;

return i3;

}

}

package com.momo.po;

import java.util.Objects;

public class Tea{

private String name;

private Integer age;

public Tea() {}

public Tea(String name, Integer age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}

@Override
public String toString() {
return “Tea{” +
“name='” + name + ”’ +
“, age=” + age +
‘}’;
}

}

5，函数式接口

-接口上有这个注解(@FunctionalInterface)的接口就叫做函数式接口

-特点：

可以使用lambda表达式来简化

只有一个抽象方法

@FunctionalInterface

public interface Comparator

package com.momo.service;

@FunctionalInterface

public interface Inter {

void show();

// void fun();

}

package com.momo.demo;

import com.momo.service.Inter;

public class Demo10 {

public static void main(String[] args) {

/* new Inter(){

@Override

public void show() {

System.out.println(“aaa”);

}

}.show();

((Inter)()-> System.out.println(“bbb”)).show();}*/
}

}

6，练习

-获取10个1-50随机数，要求不能重复

-键盘输入几个学生信息(科目成绩)，按照总成绩从高到低排序

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
机房租用，北京机房租用，IDC机房托管， http://www.fwqtg.net

相关推荐: 基于智能远程监考方案，云上组考打造考试新范式

热潮兴起，「云上组考」是怎样炼成的？ 疫情以来，改变了很多场景形态，“考试”是其中之一。 越来越多的学校开始采用云上组考模式，提高考试效率，节省人力、物力成本，规范考试管理，引发一阵考试与测评领域的热潮，也是教育数智化创新的一面。 承载云上的音视频技术与AI融…