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<10){
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<String> 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接口中的compareTo方法进行比较
要进行自然排序，元素对应的类必须实现自然排序接口
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<Tea> ts = new TreeSet<>(new Comparator<Tea>() { @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<Tea> 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随机数，要求不能重复
-键盘输入几个学生信息(科目成绩)，按照总成绩从高到低排序
