第一部分 Math类
1.1 反转键盘录入的字符串。
- 提示:
- String中toCharArray方法
- 参考答案:
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String next = sc.next();
System.out.println("录入的字符串:" + next);
String s = reverseStr(next);
System.out.println("反转的字符串:" + s);
}
public static String reverseStr(String str){
String s = "";
char[] chars = str.toCharArray();
for(int i = chars.length - 1; i >= 0; i--){
s += chars[i];
}
return s;
}
}
//结果:
==字符串123反转==
录入的字符串:字符串123反转
反转的字符串:转反321串符字
1.2 键盘录入QQ号码,验证格式的正确性。
- 要求:
- 必须是5—12位数字。
- 0不能开头。
- 提示:
- String中charAt方法
- 实现:
public class Test2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String qq = sc.next();
boolean isOK = checkQQ(qq);
System.out.println("这个QQ号码是否正确:" + isOK);
}
/*
* 定义方法:checkQQ (String qq)方法内实现验证
* 指定方法的名称:checkQQ
* 指定方法的参数:String qq
* 指定方法的返回值:boolean
*/
public static boolean checkQQ(String qq){
if(qq.length() < 5 || qq.length() > 12){
return false;
}
if(qq.charAt(0) == '0'){
return false;
}
for(int i = 0; i < qq.length(); i++){
char ch = qq.charAt(i);
if(ch < '0' || ch > '9'){
return false;
}
}
return true;
}
}
//结果:
==034235235==
这个QQ号码是否正确:false
1.3 字符串查找。
- 要求
- 键盘录入一个大字符串,再录入一个小字符串。
- 统计小字符串在大字符串中出现的次数。
- 提示:
- indexOf(String str, int fromIndex)
- 该方法作用:从fromIndex位置开始查找,字符串str第一次出现的位置;若没找到,放回-1
- 实现:
/*
* 分析以下需求,并用代码实现
1.键盘录入一个大字符串,再录入一个小字符串
2.统计小字符串在大字符串中出现的次数
3.代码运行打印格式:
请输入大字符串:woaiheima,heimabutongyubaima,wulunheimahaishibaima,zhaodaogongzuojiushihaoma
请输入小字符串:heima
控制台输出:小字符串heima,在大字符串woaiheima,heimabutongyubaima,wulunheimahaishibaima,zhaodaogongzuojiushihaoma中共出现3次
*/
public class Test3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输大字符串:");
String big = sc.nextLine();
System.out.println("请输小字符串:");
String small = sc.nextLine();
int count = getCount(big, small);
System.out.println("小字符串" + small + ",在大字符串中共出现" + count + "次");
}
/*
* 方法功能:统计小字符串在大字符串中出现的次数
* 参数:big 代表大字符串
* 参数:small 代表小字符串
* 返回值:小字符串在大字符串中出现的次数
*/
public static int getCount(String big, String small){
int index = 0;
int count = 0;
/*
* indexOf(String str, int fromIndex)
* 该方法作用:从fromIndex位置开始查找,字符串str第一次出现的位置;若没找到,放回-1
*/
while((index = big.indexOf(small, index)) != -1){
index++;
count++;
}
return count;
}
}
//结果:
请输大字符串:
==woaiheima,heimabutongyubaima,wulunheimahaishibaima,zhaodaogongzuojiushihaoma==
请输小字符串:
==heima==
小字符串heima,在大字符串中共出现3次
1.4 替换某字符串中的某字符串。
- 要求
- 键盘录入一个srcStr字符串,再录入一个delStr字符串。
- 删除该字srcStr符串中的所有delStr字符串。
- 提示:
- String中的replace方法
- 实现:
public class Test4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入源字符串:");
String srcStr = sc.nextLine();
System.out.println("请输入要删除的字符串:");
String delStr = sc.nextLine();
printCount(srcStr, delStr);
}
//删除该字scrStr符串中的所有delStr字符串
// (最终的字符串中不能包含delStr),
// 要求打印删除后的结果以及删除了几个delStr字符串
public static void printCount(String srcStr, String delStr){
String resultStr = srcStr.replace(delStr, "");
int count = (srcStr.length() - resultStr.length()) / delStr.length();
System.out.println("源字符串中总共包含:"+ count +" 个 "+ delStr +" ,\r\n删除"+ delStr +"后的字符串为: "+ resultStr);
}
}
//结果:
请输入源字符串:
javadjfajejfjegjiaojavafjlejfiajfajava
请输入要删除的字符串:
java
源字符串中总共包含:3 个 java ,
删除java后的字符串为: djfajejfjegjiaofjlejfiajfa
1.5 生成一个随机100内小数,转换为保留两位小数的字符串,不考虑四舍五入的问题。
- 实现:
public class Test5 {
public static void main(String[] args) {
double random = Math.random() * 100;
System.out.println("随机数为:");
System.out.println(random);
String str = random + "";
int index = str.indexOf(".");
//System.out.println(index);
String substring = str.substring(0, index + 3); //右侧不包括
System.out.println("转换为:");
System.out.println(substring);
}
}
//结果:
随机数为:
27.58793062920516
转换为:
27.58
1.6 筛选字符串。
- 要求:
- 定义ArrayList集合,存入多个字符串。
- 长度大于5的字符串,打印删除后的集合。
- 实现:
public class Test6 {
public static void main(String[] args) {
ArrayList<String> list = getArrayList();
System.out.println("源字符串:");
System.out.println(list);
//删除集合中长度大于5的元素
delStrsFromList01(list);
System.out.println("删除后:");
System.out.println(list);
}
//返回存储多个字符串的ArrayList集合
private static ArrayList<String> getArrayList(){
ArrayList<String> list = new ArrayList<>();
list.add("bca");
list.add("dadfa");
list.add("dddaaa");
list.add("你好啊");
list.add("我来啦,你干嘛呢");
list.add("别跑啊");
return list;
}
//删除list集合中所有长度>5的字符串
private static void delStrsFromList01(ArrayList<String> list){
ArrayList<String> newList = new ArrayList<>();
//遍历原集合对象
for(int i = 0; i < list.size(); i++){
//获取当前元素
String str = list.get(i);
//如果str的长度大于5
if(str.length() > 5){
newList.add(str);//将str添加到新集合中
}
}
//遍历新集合
for (String str : newList) {
//因为新集合中的元素就是要删除的元素
list.remove(str);
}
}
}
//结果:
源字符串:
[bca, dadfa, dddaaa, 你好啊, 我来啦,你干嘛呢, 别跑啊]
删除后:
[bca, dadfa, 你好啊, 别跑啊]
1.7 判断回文字符串。如果一个字符串,从前向后读和从后向前读,都是一个字符串,称为回文串,比如mom,dad,noon。
- 实现:
public class Test7 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String next = sc.next();
boolean p = isP(next);
System.out.println("回文数:" + p);
}
public static boolean isP(String str){
int start = 0;
int end = str.length() - 1;
while (start < end){
if(str.charAt(start) != str.charAt(end)){
return false;
}
start++;
end--;
}
return true;
}
}
//结果:
==hah==
回文数:true
1.8 模拟简单计算器,可以运算+,—,*,/,%
- 要求:
- 接收三个参数,一个整数,一个运算符,另一个整数。
- 计算出运算结果。
- 无法运算时,返回null。
- 实现:
public class Test8 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
String next = sc.next();
int b = sc.nextInt();
String count = count(a, next, b);
System.out.println(a + next + b + "=" + count);
}
public static String count(int a, String op, int b){
int r = 0;
if("+".equals(op)){
r = a + b;
}else if("-".equals(op)){
r = a - b;
}else if("*".equals(op)){
r = a * b;
}else if("/".equals(op)){
r = a / b;
}else if("%".equals(op)){
r = a % b;
}else {
return null;
}
return r + ""; //变成字符串
}
}
//结果:
==5 * 6==
5*6=30
1.9 校验密码是否合法。
- 要求:
- 必须至少8个字符。
- 必须至少2个大写字符。
- 必须只有字母和数字。
- 实现:
public class Test9 {
public static void main(String[] args) {
String s = "qweRY123";
System.out.println(s + "密码是否合法:" + isV(s));
}
public static boolean isV(String pwd){
if(pwd.length() < 8){
return false;
}
int countA = 0;
char[] chars = pwd.toCharArray();
for(int i = 0; i < chars.length; i++){
char ch = chars[i];
//2个大写字符
if(ch >= 'A' && ch <= 'Z'){
countA++;
}
//字母数字
if((ch < '0' || ch > '9') && (ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')){
return false;
}
}
if(countA < 2){
return false;
}
return true;
}
}
//结果:
qweRY123密码是否合法:true
1.10 模拟用户登录。
- 要求:
- 定义用户类,属性为用户名和密码。
- 使用集合存储多个用户对象。
- 录入用户和密码,对比用户信息,匹配成功登录成功,否则登录失败。
- 登录失败时,当用户名错误,提示没有该用户。
- 登录失败时,当密码错误时,提示密码有误。
- 实现:
//定义一个用户类:User.java
public class User {
private String username;
private String pwd;
public User() {
}
public User(String username, String pwd) {
this.username = username;
this.pwd = pwd;
}
public void show(){
System.out.println(username + "-" + pwd);
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
}
//主方法:Test10.java
public class Test10 {
static ArrayList<User> list = new ArrayList<>();
static {
list.add(new User("jack", "1234"));
list.add(new User("rose", "5678"));
list.add(new User("tom", "0000"));
for (int i = 0; i < list.size(); i++) {
list.get(i).show();
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String username = sc.nextLine();
System.out.println("请输入密码");
String password = sc.nextLine();
User u = new User(username, password);
String login = login(u);
System.out.println("登录结果:" + login);
}
public static String login(User user){
String msg = "";
String n = user.getUsername();
String p = user.getPwd();
for(int i = 0; i < list.size(); i++){
User u = list.get(i);
String name = u.getUsername();
String pwd = u.getPwd();
if(name.equals(n)){
if(pwd.equals(p)){
return "登录成功";
}else {
return "密码错误";
}
}else {
msg = "用户名不存在";
continue;
}
}
return msg;
}
}
//结果:(成功的)
jack-1234
rose-5678
tom-0000
请输入用户名
==jack==
请输入密码
==1234==
登录结果:登录成功
//结果:(密码错误)
jack-1234
rose-5678
tom-0000
请输入用户名
==jack==
请输入密码
==123==
登录结果:密码错误
//结果:(用户名不对)
jack-1234
rose-5678
tom-0000
请输入用户名
==jac==
请输入密码
==1234==
登录结果:用户名不存在
第二部分 Object类&Date类&Calender类&StringBuilder类
2.1 Object类equals方法
- 简述:String类中的equals方法与Object类中的equals方法的不同点
- 解答:
- String类中的equals方法是用来判断两个对象的内容是否相同,而Object 类中的equals方法是用来判断两个对象是否是同一个对象,所谓同一个对象指的是内存中的同一块存储空间。
2.2 Object类的toString方法*
- 简述:
- 不运行代码,直接说出打印结果,并解释原因
public class ToStringTest{
static int i = 1;
public static void main(String args[]){
System.out.println("love " + new ToStringTest());//love java
ToStringTest a = new ToStringTest();
a.i++;
System.out.println("me " + a.i);//me 2
}
public String toString(){
System.out.print("I ");//I
return "java ";
}
}
- 解答:
- 结果:I love java me 2
- 原因:
- 当执行代码的时候,首先加载静态变量,然后执行main方法,由于main方法内部第一行代码为输出语句,里面new了此类对象,当执行此行代码时会先创建了本类的对象,由于此类重写了toString方法,会先执行toString方法的打印输出,然后返回“java ”,再执行main方法第一行打印输出。在Java中“System.out.println(类对象名);”实际输出的是该对象的toString()方法返回的字符串,即括号中的内容等价于类对象名.toString(),toString方法的好处是在碰到println方法的时候会被自动调用,不用显示的写出来。
2.3 Object类equals方法
- 简述:
- 看下列程序,不运行说结果,写出答案后,并在IntelliJ IDEA中运行看看自己给的答案与运行结果是否正确,并分析原因
//一
String s1 = new String("abc");
String s2 = "abc";
System.out.println(s1 == s2); //false
System.out.println(s1.equals(s2)); //true
//二
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); //true
System.out.println(s1.equals(s2)); //true
//三
String s1 = "a" + "b" + "c";
String s2 = "abc";
System.out.println(s1 == s2); //true
System.out.println(s1.equals(s2)); //true
//四
String s1 = "ab";
String s2 = "abc";
String s3 = s1 + "c";
System.out.println(s3 == s2); //false
System.out.println(s3.equals(s2)); //true
- 解答:
- :在比较对象的时候,是比较他们是不是引用的同一个==对象
- equals比较对象的值是否相等
- 注:有些对象equals函数没有重载,则和""比较规则一样==
2.4 StringBuilder类与String类的区别
- 简述:StringBuilder类与String类的区别
- 解答:
- String类的对象内容不可改变,所以每当进行字符串拼接时,总是会在内存中创建一个新的对象,所以经常改变内容的字符串最好不要用String,因为每次生成对象都会对系统性能产生影响。
- StringBuilder又称为可变字符序列,是JDK5.0中新增加的一个类,它是一个类似于String的字符串缓冲区,通过某些方法调用可以改变该序列的长度和内容。即它是一个容器,容器中可以装很多字符串,并且能够对其中的字符串进行各种操作。它的内部拥有一个数组用来存放字符串内容,进行字符串拼接时,直接在数组中加入新内容,StringBuilder会自动维护数组的扩容。
2.5 Date类的使用
- 简述:
- 请用代码实现:获取当前的日期,并把这个日期转换为指定格式的字符串,如2088-08-08 08:08:08
- 解答:
public class DateTest {
public static void main(String[] args) {
//获取当前日期对象 now;
Date now = new Date();
//创建SimpleDateFormat对象 df,并制定日期格式
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//调用df的format(Date date) 方法,传入now; 接收返回的字符串
String datestr = df.format(now);
//打印这个字符串
System.out.println(datestr);
}
}
//结果:
2020-03-10 18:15:17
2.6 DateFormat类方法的使用
- 简述:
- 使用SimpleDateFormat类,把2018-03-04转换为2018年03月04日
- 注:
- parse方法 //throws ParseException
- 解答:
public class DateFormatTest {
public static void main(String[] args) throws ParseException {
//创建SimpleDateFormat对象df1,指定日期模式为yyyy-MM-dd
SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd");
//调用df1的parse(String str)方法传入2018-03-04
Date date = df1.parse("2018-03-04"); //throws ParseException
//将符合模式的字符串,解析为Date日期
System.out.println(date); //Sun Mar 04 00:00:00 CST 2018
//创建日期格式化对象df2,在获取格式化对象时可以指定风格
SimpleDateFormat df2 = new SimpleDateFormat("yyyy年MM月dd日");
//调用df2的format(Date date) 传入刚才转换的日期
String str = df2.format(date);
System.out.println(str);
}
}
//结果:
Sun Mar 04 00:00:00 CST 2018
2018年03月04日
2.7 Calendar类方法的使用
- 简述:
- 用程序判断2018年2月14日是星期几
- 注意:
- Calendar.getInstance(); //Calendar的特有创建对象
- get方法获取月的时候从0开始,所以要加1
- 解答:
public class CalendarTest01 {
public static void main(String[] args) {
//创建Calendar对象
Calendar c = Calendar.getInstance();
//将给定的日历字段设置到Calendar对象中
c.set(Calendar.YEAR, 2018);
c.set(Calendar.MONTH, 2);
c.set(Calendar.DATE, 14);
//设置年
int year = c.get(Calendar.YEAR);
//设置月
int month = c.get(Calendar.MONTH)+1;
//设置日
int date = c.get(Calendar.DATE);
//设置星期
char week = getWeek(c.get(Calendar.DAY_OF_WEEK));
//输出结果:
System.out.println(year+"年"+month+"月"+date+"日是星期"+week);
}
//定义方法,获取星期汉字
public static char getWeek(int a){
char[] c = {' ','日','一','二','三','四','五','六'};
return c[a];
}
}
//结果:
2018年3月14日是星期三
第三部分 Random类&ArrayList集合
3.1 随机验证码。
- 要求:
- 随机生成十组六位字符组成的验证码。
- 验证码由大小写字母、数字字符组成。
- 实现:
public class Test1 {
public static void main(String[] args) {
for(int i = 0; i < 10; i ++){
String s = verifyCode();
System.out.println("随机验证码:" + s);
}
}
public static String verifyCode(){
char[] arr = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
Random random = new Random();
String code = "";
for(int i = 0; i < 6; i++){
int index = random.nextInt(arr.length);
code += arr[index];
}
return code;
}
}
//结果:
随机验证码:l04umf
随机验证码:iDocZN
随机验证码:aJQ0JD
随机验证码:uXVCcf
随机验证码:4Y8r0A
3.2 键盘录入学生信息,保存到集合中。
- 要求:
- 循环录入的方式,1:表示继续录入,0:表示结束录入。
- 定义学生类,属性为姓名,年龄,使用学生对象保存录入数据。
- 使用ArrayList集合,保存学生对象,录入结束后,遍历集合。
- 实现:
//定义一个Student类
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void show(){
System.out.println( "学生姓名=" + name + ", 年龄=" + age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//主方法:Test2.java
public class Test2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArrayList<Student> list = new ArrayList<>();
while (true){
System.out.println("1.录入信息 0.退出");
int i = sc.nextInt();
switch (i){
case 1:
inputStu(list, sc);
break;
case 0:
System.out.println("录入完毕");
}
if(i == 0){
break;
}
}
for(int i = 0; i < list.size(); i++){
Student student = list.get(i);
student.show();
}
}
public static void inputStu(ArrayList<Student> list, Scanner sc){
System.out.println("请输入姓名:");
String name = sc.next();
System.out.println("请输入年龄:");
int age = sc.nextInt();
Student student = new Student(name, age);
list.add(student);
}
}
//结果:
1.录入信息 0.退出
==1==
请输入姓名:
==葛晓伟==
请输入年龄:
==22==
1.录入信息 0.退出
==1==
请输入姓名:
==张子玄==
请输入年龄:
==18==
1.录入信息 0.退出
==0==
录入完毕
学生姓名=葛晓伟, 年龄=22
学生姓名=张子玄, 年龄=18
3.3 集合工具类。
- 要求:
- 定义findIndex方法,在某集合中,查找某元素,返回第一次出现的索引。
- 定义replace方法,将某集合中的某元素,全部替换为新元素。
- 实现:
public class Test3 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(3);
list.add(4);
list.add(55);
list.add(67);
list.add(89);
int index = findIndex(list, 55);
System.out.println("55在索引" + index);
//替换前
System.out.println("替换前:");
System.out.println(list);
//替换后
replace(list, 67, 76);
System.out.println("替换后:");
System.out.println(list);
}
//定义findIndex方法,在某集合中,查找某元素,返回第一次出现的索引。
public static int findIndex(List<Integer> list, int i){
int index = -1;
for(int j = 0; j < list.size(); j++){
if(list.get(j) == i){
index = j;
break;
}
}
return index;
}
//定义replace方法,将某集合中的某元素,全部替换为新元素。
public static void replace(List<Integer> list, Integer oldValue, Integer newValue){
for(int i = 0; i < list.size(); i++){
if(list.get(i) == oldValue){
list.set(i, newValue);
}
}
}
}
//结果:
55在索引2
替换前:
[3, 4, 55, 67, 89]
替换后:
[3, 4, 55, 76, 89]
3.4 统计数字出现次数。
- 要求:
- 定义getNumList方法,随机生成100个数字,数字范围从1到10。
- 定义printCount方法,统计每个数字出现的次数并打印到控制台。
- 实现:
public class Test4 {
public static void main(String[] args) {
ArrayList<Integer> numList = getNumList();
// 统计字符数组中字母出现次数
printCount(numList);
}
//定义printCount方法,统计每个数字出现的次数并打印到控制台。
public static void printCount(ArrayList<Integer> list){
int[] count = new int[10];
// 对应保存数字出现的次数
for(int i = 0; i < list.size(); i++){
int c = list.get(i);
count[c - 1]++;
}
// 打印数字和次数
for(int i = 0; i < count.length; i++){
System.out.println("数字:"+(i+1) + "--" + count[i]+"次");
}
}
//定义getNumList方法,随机生成100个数字,数字范围从1到10。
public static ArrayList<Integer> getNumList(){
ArrayList<Integer> list = new ArrayList<>();
Random r = new Random();
for(int i = 0; i < 100; i++){
int x = r.nextInt(10) + 1; //1-10,随机从0开始的所以加1
list.add(x);
}
return list;
}
}
//结果:
数字:1--7次
数字:2--7次
数字:3--7次
数字:4--13次
数字:5--12次
数字:6--13次
数字:7--10次
数字:8--11次
数字:9--12次
数字:10--8次
3.5 模拟统计班级考试分数分布情况,分别统计100-80,79-60,59-40,39-0各个阶段的人数。
- 要求:
- 定义getScoreList方法,随机生成50个数字,数字范围从0到100。
- 定义countScore方法,统计各个阶段的分数个数。
- 定义printCount方法,打印各个阶段的统计结果。
- 实现:
//模拟统计班级考试分数分布情况,分别统计100-80,79-60,59-40,39-0各个阶段的人数。
public class Test5 {
public static void main(String[] args) {
// 获取随机分数
ArrayList<Integer> scoreList = getScoreList();
// 定义计数的变量
ArrayList<Integer> countlist = countScore(scoreList);
// 打印统计结果
printCount(countlist);
}
//定义printCount方法,打印各个阶段的统计结果。
public static void printCount(ArrayList<Integer> countList){
int start = 100;
int end = 80;
for(int i = 0; i < countList.size(); i++){
Integer integer = countList.get(i);
System.out.println(start + "\t分 --" + end + " \t分:" + integer+"人");
if (i == 0){
start-=21;
end -=20;
}else if (i == countList.size()-2){
start-=20;
end-=40;
}else {
start -= 20;
end -= 20;
}
}
}
//定义countScore方法,统计各个阶段的分数个数
private static ArrayList<Integer> countScore(ArrayList<Integer> scoreList){
ArrayList<Integer> countList = new ArrayList<>();
int count100 = 0;
int count79 = 0;
int count59 = 0;
int count39 = 0;
for(int i = 0; i < scoreList.size(); i++){
Integer score = scoreList.get(i);
if(score <= 100 && score >= 80){
count100++;
}else if(score <= 79 && score >= 60){
count79++;
}else if(score <= 59 && score >= 40){
count59++;
}else {
count39++;
}
}
countList.add(count100);
countList.add(count79);
countList.add(count59);
countList.add(count39);
return countList;
}
//定义getScoreList方法,随机生成50个数字,数字范围从0到100。
public static ArrayList<Integer> getScoreList(){
ArrayList<Integer> list = new ArrayList<>();
Random r = new Random();
for(int i = 0; i < 50; i++){
int x = r.nextInt(100); //0到100。
list.add(x);
}
return list;
}
}
//结果:
100 分 --80 分:12人
79 分 --60 分:9人
59 分 --40 分:10人
39 分 --0 分:19人
3.6 随机生成n张扑克牌。
- 开发提示:
- 使用集合保存所有的扑克牌对象。
- 从所有牌中,随机移除n张牌,保存到新集合。
- 判断n的值,不能超越一副扑克牌的范围。
- 实现:
//定义一个Card类
public class Card {
private String ds; //点数
private String hs; //花色
public Card(String ds, String hs) {
this.ds = ds;
this.hs = hs;
}
public void show(){
System.out.print(ds + hs+" ");
}
}
//主方法:Test6.java
public class Test6 {
public static void main(String[] args) {
int n = 5;
ArrayList<Card> cards = randomCard(n);
if(cards != null){
System.out.println("随机"+ n +"张牌:" );
for(int i = 0; i < cards.size(); i++){
Card card = cards.get(i);
card.show();
}
}else {
System.out.println(n+"超越范围,无法获取牌" );
}
System.out.println();
System.out.println();
int n2 = 55;
ArrayList<Card> cards2 = randomCard(n2);
if (cards2 != null) {
System.out.println("随机"+ n2 +"张牌:" );
for (int i = 0; i < cards.size(); i++) {
Card card = cards.get(i);
card.show();
}
}else {
System.out.println("随机"+ n2 +"张牌:\r\n超越范围,无法获取" );
}
}
//从所有牌中,随机移除n张牌,保存到新集合。
public static ArrayList<Card> randomCard(int n){
if(n > 54 || n < 0){
return null;
}
ArrayList<Card> rList = new ArrayList<>();
ArrayList<Card> cards = allCard();
Random r = new Random();
for(int i = 0; i < n; i++){
int index = r.nextInt(cards.size());
Card rCard = cards.remove(index);
rList.add(rCard);
}
return rList;
}
//使用集合保存所有的扑克牌对象。
public static ArrayList<Card> allCard(){
ArrayList<Card> allList = new ArrayList<>();
// 花色数组
String[] hs = {"黑桃", "红桃", "梅花", "方片"};
// 点数数组
String[] ds = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
for(int H = 0; H < hs.length; H++){
for(int d = 0; d < hs.length; d++){
Card card = new Card(hs[H], ds[d]);
// 添加到集合
allList.add(card);
}
}
return allList;
}
}
//结果:
随机5张牌:
方片3 梅花3 红桃4 梅花2 红桃A
随机55张牌:
超越范围,无法获取
3.7 自定义MyList类,实现存取元素的功能。
- 要求:
- 定义add方法,可以保存元素,添加MyList尾部。
- 定义remove方法,可以获取到最后添加的元素,并从MyList中移除该元素。
- 定义show方法,可以展示MyList中的元素。
- 实现:
//定义MyList类
public class MyList {
ArrayList<Integer> ml = new ArrayList<>();
public void add(Integer i){
ml.add(i);
}
public Integer remove(){
Integer remove = ml.remove(ml.size() - 1);
return remove;
}
public void show(){
System.out.println(ml);
}
}
//主方法:Tset7
public class Tset7 {
public static void main(String[] args) {
MyList myList = new MyList();
for(int i = 0; i < 3; i++){
myList.add(i);
}
System.out.println("添加元素后:");
myList.show();
Integer remove = myList.remove();
System.out.println("删除元素:");
System.out.println(remove);
System.out.println("删除元素后:");
myList.show();
}
}
//结果:
添加元素后:
[0, 1, 2]
删除元素:
2
删除元素后:
[0, 1]
第四部分 Stream流
4.1 Predicate接口使用
- 要求:
- 已知有Integer[] arr = {-12345, 9999, 520, 0,-38,-7758520,941213}
- 使用lambda表达式创建Predicate对象p1,p1能判断整数是否是自然数(大于等于0)
- 使用lambda表达式创建Predicate对象p2,p2能判断整数的绝对值是否大于100
- 使用lambda表达式创建Predicate对象p3,p3能判断整数是否是偶数
- 遍历arr,仅利用已创建的Predicate对象(不使用任何逻辑运算符),完成以下需求
- 打印自然数的个数
- 打印负整数的个数
- 打印绝对值大于100的偶数的个数
- 打印是负整数或偶数的数的个数
- 实现:
public class Test03 {
public static void main(String[] args) {
Integer[] arr = {-12345, 9999, 520, 0,-38,-7758520,941213};
//a) 使用lambda表达式创建Predicate对象p1,p1能判断整数是否是自然数
Predicate<Integer> p1 = s -> s >= 0;
//b) 使用lambda表达式创建Predicate对象p2,p2能判断整数的绝对值是否大于100
Predicate<Integer> p2 = s -> Math.abs(s) > 100;
//c) 使用lambda表达式创建Predicate对象p3,p3能判断整数是否是偶数
Predicate<Integer> p3 = s -> s % 2 == 0;
//e) 遍历arr,仅利用已创建的Predicate对象(不使用任何逻辑运算符),完成以下需求
int count1 = 0;
int count2 = 0;
int count3 = 0;
int count4 = 0;
for (Integer i : arr) {
//统计自然数个数
if(p1.test(i)){
count1++;
}
//负整数的个数为
if(p1.negate().test(i)){
count2++;
}
//统计绝对值大于100的偶数个数
if(p2.and(p3).test(i)){
count3++;
}
//统计是负整数或偶数的数的个数
if(p1.negate().or(p3).test(i)){
count4++;
}
}
//分别打印结果
System.out.println("自然数的个数为:"+count1);
System.out.println("负整数的个数为:"+count2);
System.out.println("绝对值大于100的偶数的个数为:"+count3);
System.out.println("是负整数或偶数的数的个数为:"+count4);
}
}
//结果:
自然数的个数为:4
负整数的个数为:3
绝对值大于100的偶数的个数为:2
是负整数或偶数的数的个数为:5
4.2 Function接口使用
- 要求:
- 使用lambda表达式分别将以下功能封装到Function对象中
- 求Integer类型ArrayList中所有元素的平均数
- 将Map<String,Integer>中value存到ArrayList中
- 已知学生成绩如下
姓名 成绩
岑小村 59
谷天洛 82
渣渣辉 98
蓝小月 65
皮几万 70
- 以学生姓名为key成绩为value创建集合并存储数据,使用刚刚创建的Function对象求学生的平均成绩
- 实现:
public class Test04 {
public static void main(String[] args) {
//1. 使用lambda表达式分别将以下功能封装到Function对象中
//a) 求Integer类型ArrayList中所有元素的平均数
Function<ArrayList<Integer>, Integer> f1 = list -> {
Integer sum = 0;
for (Integer i : list) {
sum += i;
}
return sum / list.size();
};
//b) 将Map<String,Integer>中value存到ArrayList<Integer>中
Function<Map<String, Integer>, ArrayList<Integer>> f2 = (map) -> {
/*ArrayList<Integer> list = new ArrayList<>();
for (String s : map.keySet()) {
Integer value = map.get(s);
list.add(value);
}*/
Collection<Integer> values = map.values();
ArrayList<Integer> list = new ArrayList<>();
list.addAll(values);
return list;
};
//2 将学生姓名和成绩封装到map中
Map<String, Integer> map = new HashMap<>();
map.put("岑小村", 59);
map.put("谷天洛", 82);
map.put("渣渣辉", 98);
map.put("蓝小月", 65);
map.put("皮几万", 70);
//利用Function求平均成绩
Integer avg = f2.andThen(f1).apply(map);
System.out.println("学生平均成绩为:"+avg);
}
}
//结果:
学生平均成绩为:74
4.3 如何获取流
- 问题:
- 简述单列集合、双列集合、数组分别如何获取Stream流对象,并进行演示
- 解答:
- java.util.Collection接口中加入了default方法stream()获取流对象,因此其所有实现类均可通过此方式获取流。
- java.util.Map接口想要获取流,先通过keySet()、values()或entrySet()方法获取键、值或键值对的单列集合,再通过stream()获取流对象。
- 数组获取流,使用Stream接口中的的静态方法of(T…values)获取流。
- 注:1.2调用时候小写stream,3是大写Stream
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
Map<String, String> map = new HashMap<>();
Stream<String> keyStream = map.keySet().stream();
Stream<String> valueStream = map.values().stream();
Stream<Map.Entry<String,String>>entryStream = map.entrySet().stream();
String[] array = {"东邪", "西毒", "南帝", "北丐", "中神通"};
Stream<String> stream = Stream.of(array);
}
4.4 过滤:filter、结果收集(数组)
- 问题:
- 有如下7个元素黄药师,冯蘅,郭靖,黄蓉,郭芙,郭襄,郭破虏,使用Stream将以郭字开头的元素存入新数组
- 实现:
public class Test {
public static void main(String[] args) {
Stream<String> stream = Stream.of("黄药师", "冯蘅", "郭靖", "黄蓉", "郭芙", "郭襄", "郭破虏");
String[] guos = stream.filter((s) -> s.startsWith("郭")).toArray(String[]::new); //方法引用
System.out.println(Arrays.toString(guos));
}
}
//结果:
[郭靖, 郭芙, 郭襄, 郭破虏]
4.5 取用前几个:limit、跳过前几个:skip
- 问题:
- 已知ArrayList集合中有如下元素{陈玄风、梅超风、陆乘风、曲灵风、武眠风、冯默风、罗玉风},使用Stream
- 取出前2个元素并在控制台打印输出。
- 取出后2个元素并在控制台打印输出。
- 实现:
public class Test02 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("陈玄风");
list.add("梅超风");
list.add("陆乘风");
list.add("曲灵风");
list.add("武眠风");
list.add("冯默风");
list.add("罗玉风");
list.stream().limit(2).forEach(System.out::println);
list.stream().skip(list.size() - 2).forEach(System.out::println);
}
}
//结果:
陈玄风
梅超风
冯默风
罗玉风
4.6 映射:map、逐一消费:forEach
- 问题:
- 有如下整数1,-2,-3,4,-5
- 使用Stream取元素绝对值并打印
- 实现:
public class Test05 {
public static void main(String[] args) {
Stream<Integer> stream = Stream.of(1, -2, -3, 4, -5);
stream.map(Math::abs).forEach(System.out::println);
}
}
//结果:
1
2
3
4
5
4.7 组合:concat、结果收集(list->collect(Collectors.toList()))
- 问题:
- 已知数组arr1中有如下元素{郭靖,杨康},arr2中有如下元素{黄蓉,穆念慈},使用Stream将二者合并到List集合
- 注:Collectors():类实现了很多归约操作,例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串:
- 实现:
public class Test6 {
public static void main(String[] args) {
Stream<String> arr1 = Stream.of("郭靖", "杨康");
Stream<String> arr2 = Stream.of("黄蓉", "穆念慈");
List<String> strList = Stream.concat(arr1, arr2).collect(Collectors.toList());
System.out.println(strList);
}
}
//结果:
[郭靖, 杨康, 黄蓉, 穆念慈]
4.8 获取并发流
- 问题:
- 请分别写出获取并发流的两种方式。
- 提示:
- coll.parallelStream();
- Stream.of(100, 200, 300, 400).parallel();
- 实现:
public class Test08 {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<>();
Stream<String> parallelStream1 = coll.parallelStream();
Stream<Integer> parallelStream2 = Stream.of(100, 200, 300, 400).parallel();
}
}