Java基础实战（三）
文章内容输出来源：拉勾教育大数据开发高薪训练营
源代码：https://gitee.com/tommie523/lagou_bigdata_class/tree/master/task03
Java基础实战（三）
第一题
编程统计字符串"ABCD123!@#$%ab"中大写字母、小写字母、数字、其它字符的个数并打印出来。
编程获取两个指定字符串中的最大相同子串。
是
否
是
否
是
否
是
否
获取字符串
字符数组
大写?
小写?
数字?
非字母与数字
大写字母
小写字母
数字
i<字符数组长度
结束
i=i+1
- 第一步 拆分字符串为字符数组：
static void count(String str) {
// 将字符串拆分为字符数组
char[] charArray = str.toCharArray();
}
- 第二步 定义相关变量记录结果：
// 记录数字字符串
String digit = "";
// 记录统计数字出现的次数
int digitCount = 0;
// 记录大写字母字符串
String upper = "";
// 记录大写字母出现的次数
int upperCount = 0;
// 记录小写字母字符串
String lower = "";
// 记录小写字母出现的次数
int lowerCount = 0;
// 记录非字母与数字的字符串
String other = "";
// 记录非字母与数字出现的次数
int otherCount = 0;
- 第三步 遍历字符数组，依次判断：
// 遍历字符数组依次判断字符类型
for (char ch : charArray) {
// 统计大写字母
if (Character.isUpperCase(ch)) {
upperCount++;
// 字符转字符串
upper += Character.toString(ch);
}
// 统计小写字母
if (Character.isLowerCase(ch)) {
lowerCount++;
lower += Character.toString(ch);
}
// 统计数字
if (Character.isDigit(ch)) {
digitCount++;
digit += Character.toString(ch);
}
// 统计非字母或数字
if (!Character.isLetterOrDigit(ch)) {
otherCount++;
other += Character.toString(ch);
}
}
- 完整代码：
package task03.code0301;
public class CountChar {
public static void main(String[] args) {
String str = "ABCD123!@#$%ab";
count(str);
}
static void count(String str) {
char[] charArray = str.toCharArray();
String digit = "";
int digitCount = 0;
String upper = "";
int upperCount = 0;
String lower = "";
int lowerCount = 0;
String other = "";
int otherCount = 0;
for (char ch : charArray) {
if (Character.isUpperCase(ch)) {
upperCount++;
upper += Character.toString(ch);
}
if (Character.isLowerCase(ch)) {
lowerCount++;
lower += Character.toString(ch);
}
if (Character.isDigit(ch)) {
digitCount++;
digit += Character.toString(ch);
}
if (!Character.isLetterOrDigit(ch)) {
otherCount++;
other += Character.toString(ch);
}
}
System.out.printf("大写字母%d个：\"%s\"；\n小写字母%d个：\"%s\"；\n数字%d个：\"%s\"；\n其他字符%d个：\"%s\"。\n", upperCount, upper,
lowerCount, lower, digitCount, digit, otherCount, other);
}
}
// 大写字母4个："ABCD"；
// 小写字母2个："ab"；
// 数字3个："123"；
// 其他字符5个："!@#$%"。
第二题
如： s1=“asdafghjka”, s2=“aaasdfg” 他们的最大子串为"asd"
提示： 将短的那个串进行长度依次递减的子串与较长的串比较。
思路：
1、判断两个字符串的长度大小；
2、若长的字符串包含短的字符串，则短字符串为两者最大子串；
3、短的字符串长度依次递减，观察长的字符串是否包含，若包含，则此时为两者的最大子串，以"aaasdfg"为例：
当长度=7时，有1子串——（0，7）“aaasdfg”；因前面做了先行判断，可跳过；
当长度=6时，有2子串——（0，6）“aaasdf”；（1，7）“aasdfg”；
当长度=5时，有3子串——（0，5）“aaasd”；（1，6）“aasdf”；（2，7）“asdfg”；
当长度=4时，有4子串——（0，4）“aaas”；（1，5）“aasd”；（2，6）“asdf”；（3，7）“sdfg”；
…
3、规律总结：
第一次：i=0,j=0–>(0,7)=(？，？);不确定;
第二次：i=1,j=0–>(0,6)=(j,7-i); i=1,j=1–>(0,6)=(j,7-i+j);确定下标起点为j，猜想终点位置为7-i+j，继续验证；
第三次：i=2,j=0–>(0,5)=(j,7-i+j); i=2,j=1–>(1,6)=(j,7-i+j); i=2,j=2–>(2,7)=(j,7-i+j);确定终点位置为7-i+j。
- 第一步 判断两个字符串长度大小：
static String getMaxSonStr(String s1, String s2) {
String maxStr = s1.length() > s2.length() ? s1 : s2;
String minStr = s1.length() > s2.length() ? s2 : s1;
}
- 第二步 判断大字符串是否包含小字符串：
// 如果包含，则直接返回
if (maxStr.contains(minStr))
return minStr;
- 第三步 递减小字符串长度，依次判断：
// 初始化最大字符串
String maxSonStr = "";
// 初始化子串
String sonStr = "";
// 递减字符串长度
outer: for (int i = 1; i < minStr.length(); i++) {
// 获取同一长度的所有子串
for (int j = 0; j <= i; j++) {
sonStr = minStr.substring(j, minStr.length() - i + j);
// 如果大字符串包含子串，则赋值给最大子串，跳出外层循环
if (maxStr.contains(sonStr)){
maxSonStr=sonStr;
break outer;
}
}
}
// 如果没有最大子串，返回""
return maxSonStr;
- 完整代码：
package task03.code0302;
public class MaxSonStr {
public static void main(String[] args) {
String maxSonStr = getMaxSonStr("asdafghjka", "aaasdfg");
if ("".equals(maxSonStr)) {
System.out.println("没有最大子串");
} else {
System.out.println("最大子串：" + maxSonStr);
}
}
static String getMaxSonStr(String s1, String s2) {
String maxStr = s1.length() > s2.length() ? s1 : s2;
String minStr = s1.length() > s2.length() ? s2 : s1;
String maxSonStr = "";
String sonStr = "";
if (maxStr.contains(minStr))
return minStr;
outer: for (int i = 1; i < minStr.length(); i++) {
for (int j = 0; j <= i; j++) {
sonStr = minStr.substring(j, minStr.length() - i + j);
if (maxStr.contains(sonStr)) {
maxSonStr = sonStr;
break outer;
}
}
}
return maxSonStr;
}
}
// 最大子串：asd
第三题
准备一个 HashMap 集合，统计字符串"123,456,789,123,456"中每个数字字符串出现的次数并打印出来。
如：
123 出现了 2 次
456 出现了 2 次
789 出现了 1 次
- 第一步 拆分字符串为字符串数组：
String[] str ="123,456,789,123,456".split(",");
- 第二步 定义一个HashMap：
// 将字符串作为key；
// value作为计数；
Map<String,Integer> strMap = new HashMap<>();
- 第三步 遍历字符串数组放入HashMap，如果key重复则value+1覆盖原有键值对：
// 遍历字符串数组
for (int i =0;i<str.length;i++) {
if (!strMap.containsKey(str[i])) {
// 如果不存在key，则放入当前字符串，并value为1，表示该字符串出现了1次
strMap.put(str[i], 1);
}else{
// 如果已经存在当前字符串，获取一存在该字符串key的value，加以后覆盖既有键值对，表示该字符串出现了+1次
strMap.put(str[i], strMap.get(str[i])+1);
}
}
- 完整代码：
package task03.code0303;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class HashMapPractice {
public static void main(String[] args) {
String[] str ="123,456,789,123,456".split(",");
Map<String,Integer> strMap = new HashMap<>();
for (int i =0;i<str.length;i++) {
if (!strMap.containsKey(str[i])) {
strMap.put(str[i], 1);
}else{
strMap.put(str[i], strMap.get(str[i])+1);
}
}
// 打印结果
Set<String> keys = strMap.keySet();
for (String key : keys) {
System.out.printf("%s出现了%d次;\n",key,strMap.get(key));
}
}
}
// 123出现了2次;
// 456出现了2次;
// 789出现了1次;
第四题
使用 List 集合实现简易的学生信息管理系统，要求打印字符界面提示用户选择相应的功 能，根据用户输入的选择去实现增加、删除、修改、查找以及遍历所有学生信息的功能。
其中学生的信息有：学号、姓名、年龄。 要求： 尽量将功能拆分为多个.java 文件。
前提条件：采用LinkedList
- 第一步 定义学生类：
package task03.code0304;
import java.util.Objects;
public class Student {
// 学号、姓名、年龄
private String name;
private int id;
private int age;
// 有参构造
Student(int id,String name,int age){
setId(id);
setName(name);
setAge(age);
}
public void setAge(int age) {
this.age = age;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
// 用学号作为对象的等价标准
@Override
public boolean equals(Object obj) {
if (this==obj) return true;
if(obj==null||this.getClass()!=obj.getClass())return false;
Student b = (Student)obj;
return id==b.id;
}
// 返回学号的哈希码
@Override
public int hashCode() {
return Objects.hash(id);
}
// 打印对象输出格式
@Override
public String toString() {
return "id：" + id + ", name：'" + name + "',age："+age;
}
}
- 第二步 增加学生对象功能：
package task03.code0304;
import java.util.List;
public class Add {
/**
* 添加学生对象
*
* @param id 学号
* @param name 姓名
* @param age 年龄
* @param listStudents 存放学生对象的List
*/
public static void addStudent(int id, String name, int age,List<Student> listStudents) {
Student newStudent = new Student(id, name, age);
boolean flag = listStudents.contains(newStudent);
if (flag) {
System.out.printf("学号%d已经存在，添加失败\n", id);
} else {
listStudents.add(newStudent);
System.out.printf("%s添加成功\n", name);
}
}
}
- 第三步 删除学生对象功能：
package task03.code0304;
import java.util.List;
public class Delete {
/**
* 通过学号删除学生对象
*
* @param id 学号
* @param listStudents
*/
public static void deleteStudent(int id, List<Student> listStudents) {
// 遍历学生对象List
for (Student student : listStudents) {
// 获取当前对象索引
int index = listStudents.indexOf(student);
// 如果当前对象id等于目标id
if (id == student.getId()) {
// 删除
listStudents.remove(index);
System.out.printf("%d删除成功\n", student.getId());
}
}
}
}
- 第四步 查询学生对象：
package task03.code0304;
import java.util.List;
public class Search {
/**
* 查询学生对象
*
* @param id 学号
* @param listStudents
* @return 返回学生对象或者null
*/
public static Student seachStudent(int id, List<Student> listStudents) {
// 遍历List，返回目标
for (Student student : listStudents) {
if (id == student.getId()) {
return student;
}
}
// 如果不存在，则返回null
return null;
}
}
- 第五步 修改学生对象：
package task03.code0304;
public class Change {
/**
* 修改学生对象
*
* @param id 修改后的学号
* @param name 修改后的姓名
* @param age 修改后的年龄
* @param student 修改的对象
*/
public static void changeStudent(int id,String name, int age,Student student) {
student.setId(id);
student.setAge(age);
student.setName(name);
System.out.println("修改成功！");
}
}
- 第六步 打印所有学生信息：
package task03.code0304;
import java.util.List;
public class Print {
/**
* 打印所有学生对象
*
* @param listStudents
*/
public static void printStudents(List<Student> listStudents) {
for (Student student : listStudents) {
System.out.println(student);
}
}
}
- 第七步 系统主菜单：
package task03.code0304;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void getStart() {
// 定一个存放学生对象的list
List<Student> listStudents = new LinkedList<>();
// 获取输入
Scanner sc = new Scanner(System.in);
// 用于接收输入的值
int age;
int id;
String name;
while (true) {
// 打印菜单
System.out.println("1、增加学生信息；\n" + "2、查询学生信息；\n" + "3、删除学生信息；\n" + "4、修改学生信息；\n" + "5、打印所有学生；\n" + "0、退出；");
// 获取输入的菜单选项
int flag = sc.nextInt();
switch (flag) {
// 增加
case 1:
System.out.println("输入id");
id = sc.nextInt();
System.out.println("输入姓名");
name = sc.next();
System.out.println("输入年龄");
age = sc.nextInt();
Add.addStudent(id, name, age, listStudents);
break;
// 查找
case 2:
System.out.println("输入id");
id = sc.nextInt();
Student seachStudent = Search.seachStudent(id, listStudents);
if (null == seachStudent) {
System.out.println("无对象");
} else {
System.out.println("搜索成功" + seachStudent);
}
break;
case 3:
System.out.println("输入需要删除的id");
id = sc.nextInt();
Delete.deleteStudent(id, listStudents);
break;
// 修改-->先查询、再修改
case 4:
System.out.println("输入要修改的id");
id = sc.nextInt();
Student getStudent = Search.seachStudent(id, listStudents);
// 如果查询结果为null，则退出，否则执行下面的修改操作
if (null == getStudent) {
System.out.println("无对象");
break;
}
System.out.println("输入id");
id = sc.nextInt();
System.out.println("输入姓名");
name = sc.next();
System.out.println("输入年龄");
age = sc.nextInt();
Change.changeStudent(id, name, age, getStudent);
break;
// 打印所有对象
case 5:
System.out.println("print");
Print.printStudents(listStudents);
break;
// 打印退出系统
case 0:
System.out.println("正在退出系统...");
break;
default:
System.out.println("请重新选择");
break;
}
// 结束循环，退出系统
if (0 == flag)
break;
}
sc.close();
}
}
- 第八步 测试：
package task03.code0304;
public class MainTest {
public static void main(String[] args) {
Main.getStart();
}
}
// 1、增加学生信息；
// 2、查询学生信息；
// 3、删除学生信息；
// 4、修改学生信息；
// 5、打印所有学生；
// 0、退出；
// 1
// 输入id
// 100
// 输入姓名
// 张三
// 输入年龄
// 22
// 张三添加成功
// 1、增加学生信息；
// 2、查询学生信息；
// 3、删除学生信息；
// 4、修改学生信息；
// 5、打印所有学生；
// 0、退出；
// 2
// 输入id
// 100
// 搜索成功id：100, name：'张三',age：22
// 1、增加学生信息；
// 2、查询学生信息；
// 3、删除学生信息；
// 4、修改学生信息；
// 5、打印所有学生；
// 0、退出；
// 4
// 输入要修改的id
// 100
// 输入id
// 101
// 输入姓名
// 李四
// 输入年龄
// 33
// 修改成功！
// 1、增加学生信息；
// 2、查询学生信息；
// 3、删除学生信息；
// 4、修改学生信息；
// 5、打印所有学生；
// 0、退出；
// 5
// print
// id：101, name：'李四',age：33
// 1、增加学生信息；
// 2、查询学生信息；
// 3、删除学生信息；
// 4、修改学生信息；
// 5、打印所有学生；
// 0、退出；
// 0
// 正在退出系统...
第五题
使用集合实现斗地主游戏的部分功能，要求如下：
（1）首先准备 54 张扑克牌并打乱顺序。
（2）由三个玩家交替摸牌，每人 17 张扑克牌，最后三张留作底牌。
（3）查看三个玩家手中的扑克牌和底牌。
（4）其中玩家手中的扑克牌需要按照大小顺序打印，规则如下：
手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3
- 第一步 生成扑克牌：
// 按大小顺序
String[] value = { "大王", "小王", "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3" };
// 花色
String[] type = { "红桃", "黑桃", "梅花", "方块" };
// 存放生成的扑克牌
Map<Integer, String> cards = new HashMap<>();
// 1-54的整数list，用于打乱顺序取扑克牌，模拟洗牌
List<Integer> order = new ArrayList<>();
// 初始化扑克牌序号
int index = 1;
// 遍历牌面值value
for (int i = 0; i < value.length; i++) {
// 遍历花色type
for (int j = 0; j < type.length; j++) {
// 前两张大小王没有花色
if (i < 2) {
// 添加扑克牌序号与牌面
cards.put(index, value[i]);
// 添加序号
order.add(index);
index++;
// 跳出内循环
break;
} else {
// 大小王外，添加序号与花色+牌面
cards.put(index, type[j] + value[i]);
// 添加序号
order.add(index);
index++;
}
}
}
- 第二步 洗牌：
// 打乱ArrayList顺序
Collections.shuffle(order);
- 第三步 发牌与排序：
// 发牌原理：将order的元素一次分配给其他四个ArrayList对象
// 玩家a
private static List<Integer> a = new ArrayList<>();
// 玩家b
private static List<Integer> b = new ArrayList<>();
// 玩家c
private static List<Integer> c = new ArrayList<>();
// 底牌
private static List<Integer> x = new ArrayList<>();
// 遍历order元素
for (int i = 0; i < order.size(); i++) {
// 获取order元素
int cardId = order.get(i);
// 前三个元素添加进底牌
if(i<3){
x.add(cardId);
}
// a 玩家摸牌
else if (i%3==1) {
a.add(cardId);
}
// b 玩家摸牌
else if(i%3==2){
b.add(cardId);
}
// c 玩家摸牌
else{
c.add(cardId);
}
}
// 元素排序
Collections.sort(a);
Collections.sort(b);
Collections.sort(c);
- 第四步 显示真正牌面：
// 遍历a，从扑克牌中取出牌面
for (Integer integer : a) {
System.out.print(cards.get(integer)+" ");
}
......
- 完整代码：
package task03.code0305;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Landlords {
private static String[] value = { "大王", "小王", "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3" };
private static String[] type = { "红桃", "黑桃", "梅花", "方块" };
private static Map<Integer, String> cards = new HashMap<>();
private static List<Integer> order = new ArrayList<>();
private static List<Integer> a = new ArrayList<>();
private static List<Integer> b = new ArrayList<>();
private static List<Integer> c = new ArrayList<>();
private static List<Integer> x = new ArrayList<>();
public static void getCards() {
int index = 1;
for (int i = 0; i < value.length; i++) {
for (int j = 0; j < type.length; j++) {
if (i < 2) {
cards.put(index, value[i]);
order.add(index);
index++;
break;
} else {
cards.put(index, type[j] + value[i]);
order.add(index);
index++;
}
}
}
}
public static void shuffle(){
Collections.shuffle(order);
}
public static void distribute(){
for (int i = 0; i < order.size(); i++) {
int cardId = order.get(i);
if(i<3){
x.add(cardId);
}
else if (i%3==1) {
a.add(cardId);
}else if(i%3==2){
b.add(cardId);
}else{
c.add(cardId);
}
}
Collections.sort(a);
Collections.sort(b);
Collections.sort(c);
}
public static void showCards(){
System.out.println("a玩家：");
printCards(a);
System.out.println("\nb玩家：");
printCards(b);
System.out.println("\nc玩家：");
printCards(c);
System.out.println("\n底牌：");
printCards(x);
}
private static void printCards(List<Integer> l){
for (Integer integer : l) {
System.out.print(cards.get(integer)+" ");
}
}
}
- 测试：
package task03.code0305;
public class LandlordsTest {
public static void main(String[] args) {
// 获取扑克
Landlords.getCards();
// 洗牌
Landlords.shuffle();
// 发牌
Landlords.distribute();
// 显示牌
Landlords.showCards();
}
}
// a玩家：
// 梅花2 方块2 梅花A 方块K 黑桃Q 方块Q 梅花J 方块J 红桃10 梅花10 红桃7 红桃6 方块6 红桃5 梅花5 梅花3 方块3
// b玩家：
// 大王 黑桃2 黑桃A 方块A 红桃K 红桃Q 红桃J 黑桃9 方块9 黑桃8 梅花8 黑桃7 梅花7 红桃4 黑桃4 方块4 黑桃3
// c玩家：
// 小王 红桃2 红桃A 黑桃K 梅花K 梅花Q 黑桃J 黑桃10 红桃9 梅花9 红桃8 方块8 黑桃6 梅花6 黑桃5 梅花4 红桃3
// 底牌：
// 方块5 方块10 方块7