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串符字
要求：
提示：
实现： 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
要求
键盘录入一个大字符串，再录入一个小字符串。 统计小字符串在大字符串中出现的次数。 提示：
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次
要求
键盘录入一个srcStr字符串，再录入一个delStr字符串。 删除该字srcStr符串中的所有delStr字符串。 提示：
实现： 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
实现： 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
要求：
定义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, 你好啊, 别跑啊]
实现： 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
要求：
接收三个参数，一个整数，一个运算符，另一个整数。 计算出运算结果。 无法运算时，返回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
要求：
必须至少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
要求：
定义用户类，属性为用户名和密码。 使用集合存储多个用户对象。 录入用户和密码，对比用户信息，匹配成功登录成功，否则登录失败。 登录失败时，当用户名错误，提示没有该用户。 登录失败时，当密码错误时，提示密码有误。 实现： //定义一个用户类：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==
登录结果：用户名不存在
简述：String类中的equals方法与Object类中的equals方法的不同点 解答：
String类 中的equals方法是用来判断两个对象的内容是否相同 ，而Object 类 中的equals方法是用来判断两个对象是否是同一个对象，所谓同一个对象指的是内存中的同一块存储空间 。 简述：
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方法的时候会被自动调用，不用显示的写出来。 简述：
看下列程序，不运行说结果，写出答案后，并在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函数没有重载，则和" "比较规则一样== 简述：StringBuilder类与String类的区别 解答：
String类的对象内容不可改变 ，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象，所以经常改变内容的字符串最好不要用String，因为每次生成对象都会对系统性能产生影响。StringBuilder又称为可变字符序列 ，是JDK5.0 中新增加的一个类，它是一个类似于String的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。即它是一个容器，容器中可以装很多字符串，并且能够对其中的字符串进行各种操作。它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容，StringBuilder会自动维护数组的扩容。 简述：
请用代码实现:获取当前的日期,并把这个日期转换为指定格式的字符串,如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
简述：
使用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日
简述：
注意：
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日是星期三
要求：
随机生成十组六位字符组成的验证码。 验证码由大小写字母、数字字符组成。 实现： 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
要求：
循环录入的方式，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
要求：
定义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]
要求：
定义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次
要求：
定义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人
开发提示：
使用集合保存所有的扑克牌对象。 从所有牌中，随机移除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张牌:
超越范围,无法获取
要求：
定义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]
要求：
已知有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
要求：
使用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
问题:
简述单列集合、双列集合、数组分别如何获取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);
}
问题:
有如下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));
}
}
//结果：
[郭靖, 郭芙, 郭襄, 郭破虏]
问题:
已知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);
}
}
//结果：
陈玄风
梅超风
冯默风
罗玉风
问题:
实现： 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
问题:
已知数组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);
}
}
//结果：
[郭靖, 杨康, 黄蓉, 穆念慈]
问题:
提示：
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();
}
}
本博客提供了一系列Java编程的实战案例，涵盖了字符串操作、数学运算、日期处理、集合操作及流处理等多个方面，通过具体示例讲解了常见问题的解决方法。
扫一扫
434
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
