是

否

是

否

是

否

是

否

获取字符串

字符数组

大写?

小写?

数字?

非字母与数字

大写字母

小写字母

数字

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 strMap = new HashMap<>();

第三步 遍历字符串数组放入HashMap，如果key重复则value+1覆盖原有键值对：

// 遍历字符串数组

for (int i =0;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 strMap = new HashMap<>();

for (int i =0;i

if (!strMap.containsKey(str[i])) {

strMap.put(str[i], 1);

}else{

strMap.put(str[i], strMap.get(str[i])+1);

}

}

// 打印结果

Set 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 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 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 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 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 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 cards = new HashMap<>();

// 1-54的整数list，用于打乱顺序取扑克牌，模拟洗牌

List 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 a = new ArrayList<>();

// 玩家b

private static List b = new ArrayList<>();

// 玩家c

private static List c = new ArrayList<>();

// 底牌

private static List 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 cards = new HashMap<>();

private static List order = new ArrayList<>();

private static List a = new ArrayList<>();

private static List b = new ArrayList<>();

private static List c = new ArrayList<>();

private static List 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 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