文章目录
- 1. 求1+2+3+...100 的和,java代码
- 2. 从键盘输入两个数,再输入一个符号(+ - * /),然后根据这个符号,对这两个数字进行运算 用if else 和 switch case 各做一次
- 3. 从键盘输入两个数,为 上 下限,然后10个一行输出上下限间的所有素数
- 4. 计算 1 +(1+2) +(1+2+3) ... (1+2+3+4+...100)
- 5. 若 13 * 7 =103 成立,则该表达式是按 ( ) 进制进算的 //经纬系互联网公司联合校招笔试
- 6. 经典鸡兔同笼问题,头数30,脚数90, 问鸡兔各多少——两种方法
- 7. 判断平年还是闰年
- 8. 计算出某一年中的某个月是多少天?
- 9. 求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。
- 10. 有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
- 11. 判断一年中的第一天是周几
- 12. 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数
- 13. 打印九九乘法表（正倒打印两种）
- 14. 加减乘除计算器（循环执行）
- 15. 计算某个数的阶乘
- 16. 创建一个二维数组,随机生成元素,值在 90 -100 之间,求平均值
- 17. 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共需要多少种跳法
- 18. 公鸡五元钱一只，母鸡三元钱一只，小鸡一元钱三只，现有一百元钱欲买百鸡，共有多少种买法
- 19. `有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组`
- 20. 一个5位数，判断它是不是回文数
1. 求1+2+3+…100 的和,java代码
public class Test {
public static void main(String[] args) {
// `方法1.采用for循环`
int s=0; //变量初始化
for(int i=0;i<=100;i++) {
s+=i;
}
// `方法2.采用while循环`
int n=0,s=0; //变量初始化
while(n<=100) {
s+=n;
n++;
}
System.out.println("和是" +s);
}
}
结果均为：
话说。while循环我之前写错了/(ㄒoㄒ)/~~
我居然傻不拉几的把n++写在了s+=n之前，，导致多加了101，结果算出5151。。。😳( ╯□╰ )
2. 从键盘输入两个数,再输入一个符号(+ - * /),然后根据这个符号,对这两个数字进行运算 用if else 和 switch case 各做一次
方法1.采用 if else
import java.util.*;
public class Test{
public static void main(String []args){
Scanner scan = new Scanner(System.in);
System.out.print("请输入两个运算数：");
int a = scan.nextInt();
int b = scan.nextInt();
System.out.print("请输入运算符：");
String str = scan.next();
if("+".equals(str)){
System.out.println(a+"+"+b+"="+(a+b));
}
else if("-".equals(str)){
System.out.println(a+"-"+b+"="+(a-b));
}
else if("*".equals(str)){
System.out.println(a+"*"+b+"="+(a*b));
}
else if("/".equals(str)){
System.out.println(a+"/"+b+"="+(a/b));
}
else {
System.out.println("输入非法！！");
}
}
}
运行结果：
方法2.采用 switch
import java.util.*;
public class Test{
public static void main(String []args){
Scanner scan = new Scanner(System.in);
System.out.print("请输入两个运算数和一个运算符：");
int a = scan.nextInt();
int b = scan.nextInt();
String str =scan.next();
switch(str){
case "+":
System.out.println(a+"+"+b+"="+(a+b));
break;
case "-":
System.out.println(a+"-"+b+"="+(a-b));
break;
case "*":
System.out.println(a+"*"+b+"="+(a*b));
break;
case "/":
if(b==0){
System.out.println("除数不能为零！");
}
else{
System.out.println(a+"/"+b+"="+(a/b));
}
break;
default:
System.out.println("符号输入非法！");
}
}
}
运行结果：
3. 从键盘输入两个数,为 上 下限,然后10个一行输出上下限间的所有素数
import java.util.Scanner;
public class Sushu{
public static void main(String []args){
int s=0; //要把s当做一个全局变量来监测素数的数量
boolean flag;
System.out.print("请输入上限和下限:");
Scanner scan = new Scanner(System.in);
int m=scan.nextInt();
int n=scan.nextInt();
if(m>0&&m<n) {
// 从m开始一直循环到n
for(int i=m;i<n;i++){
//假设全都是素数
flag=false;
//考虑到上限可能输入1的情况，1既不是素数也不是合数
if(i==1) {
continue; //跳出此次循环，执行下一次循环
}
for(int j=2;j<=Math.sqrt(i);j++){
if(i%j==0){
flag=true; //如果有一个数除得开则这个数就不是素数
break;
}
}
//所有的都除不开后就是素数 所以输出
if(flag==false){
//int s=0; 在这里作为局部变量初始化，是不能实现十个一行输出的
s++;
System.out.print(i+"\t");
if(s%10==0) {
System.out.println();
}
}
}
}
else {
System.out.println("输入非法！");
}
}
}
运行结果：
4. 计算 1 +(1+2) +(1+2+3) … (1+2+3+4+…100)
public class Test{
public static void main(String []args){
int s=0;
for(int i=1;i<=100;i++) {
for(int j=1;j<=i;j++) {
s+=j;
}
}
System.out.println(s);
}
}
运行结果：
5. 若 13 * 7 =103 成立,则该表达式是按 ( ) 进制进算的 //经纬系互联网公司联合校招笔试
若 13 * 7 =103 成立,则该表达式是按 (B) 进制进算的
A 8 B 9 C 11 D 12
计算方法：
设k进制，
13 * 7 = 103
==> (1 * k^1 + 3 * k^0) * (7 * k^0) = 1 * k^2 +0 * k^1 +3 * k^0
==> 7(k+3)=k^2 + 3
==> k=9
6. 经典鸡兔同笼问题,头数30,脚数90, 问鸡兔各多少——两种方法
public class Test{
public static void main(String []args){
//一共有30个头，鸡有1，兔就29，for循环从1到30，一个一个试，满足条件即可
// int x,y;
// for(x=1;x<30;x++){
// y=30-x;
// if(2*x+4*y==90) {
// System.out.println("鸡："+x+"兔:"+y);
// }
// }
//数学方法编程，假设全是兔子
int x,y,m=30,n=90;
x=(4*m-n)/2;
y=m-x;
System.out.println("鸡："+x+"兔:"+y);
}
}
7. 判断平年还是闰年
首先要知道，判断闰年的标准是什么？
闰年:
能被400整除的
或 能被4整除但不能被100整除的
以下是完整代码：
import java.util.*;
public class Test{
public static void main(String []args) {
runnian();
}
//方法1:利用Java库里的Calendar日历类的子类GregorianCalendar公历类里的方法isLeapYear()来判断,返回true或false
// public static void runnian() {
// int year;
// System.out.print("请输入年份：");
// Scanner scan = new Scanner(System.in);
// year= scan.nextInt();
// GregorianCalendar cal = new GregorianCalendar();
// System.out.println(cal.isLeapYear(year));
// }
//方法2:无参函数,和直接写到主函数里没什么区别，换了个地方而已
public static void runnian() {
int year;
System.out.println("请输入年份：");
Scanner scan = new Scanner(System.in);
year= scan.nextInt();
if (year%400==0||year%4==0&&year%100!=0) {
System.out.println(year+"是闰年");
}
else {
System.out.println(year+"是平年");
}
}
//方法2延伸:写一个函数,能接收一个年份做为参数,判断它是平年还是闰年
// public static void main(String []args) {
// System.out.println("请输入年份：");
// int y;
// Scanner scan = new Scanner(System.in);
// y= scan.nextInt();
// boolean result= runnian(y);
// System.out.println(result);
// }
// 这里判断闰年，方法里返回一个boolean型，主函数里对应接收。
// public static boolean runnian(int year) {
// if (year%400==0||year%4==0&&year%100!=0) {
// return true;
// }
// else {
// return false;
// }
// }
运行结果：
一般项目里是要返回一个值，而不是走程序，输出“那年是闰年”语句.
所以写一个函数方法，一般都要传值。主函数要用这个方法返回的值
8. 计算出某一年中的某个月是多少天?
import java.util.*;
public class Test{
// `1.直接在主函数里写`
public static void main(String []args) {
System.out.println("请输入年份和月份:");
Scanner scan = new Scanner(System.in);
int year = scan.nextInt();
int month = scan.nextInt();
int[] intArray={31,28,31,30,31,30,31,31,30,31,30,31};
if((year % 4 == 0 && year % 100 != 0)||(year % 400 == 0)){
intArray[1] = 29;//闰年天数加1
}
System.out.println(year+"年的"+month+"月有"+intArray[month-1]+"天");
//1月的天数对应数组下标为0,所以这里为[month-1]
}
//`2.写一个函数，在主函数调用该方法`
/*
public static void main(String []args) {
System.out.println("请输入年份和月份:");
Scanner scan = new Scanner(System.in);
int year = scan.nextInt();
int month = scan.nextInt();
int t= dayofmonth(year,month); //接收返回的值
System.out.println(t);
}
public static int dayofmonth(int year,int month) {
int[] intArray={31,28,31,30,31,30,31,31,30,31,30,31};
if((year % 4 == 0 && year % 100 != 0)||(year % 400 == 0)){
intArray[1] = 29;//闰年天数加1
}
return intArray[month-1];
//1月的天数对应数组下标为0,所以这里为[month-1]
}
*/
}
运行结果：
9. 求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。
例如2+22+222+2222+22222(此时共有5个数相加)，几个数相,加的数是谁,加由键盘控制。
import java.util.*;
public class Test{
public static void main(String []args) {
Scanner scan = new Scanner(System.in);
System.out.print("几个数相加:");
int a = scan.nextInt();
System.out.print("加的数是谁(1-9):");
int b = scan.nextInt();
int c=b;//先缓存尾数
int s=0;
for(int i=1;i<=a;i++) {
s+=b; //累加 eg:s=1 +11 +111
b=b*10;//前移一位 b=10 b=110
b+=c;//加尾数 b=11 b=111
}
System.out.print(s);
}
}
运行结果：
10. 有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。
这是一道很简单的Java编程题，遇到这样的题，找准规律很重要！
这个分数线序列有什么特别之处内？
就是，每一项的分子 = 前一项的分子 + 前一项的分母
每一项的分母 = 前一项的分子
然后根据规律写出代码。，编译运行。OK~~
public class Test{
public static void main(String []args) {
int x=2,y=1,t=0;
double s=0;
for(int i=0;i<20;i++) {
s+=(double)x/y;
t=x;
x=x+y;
y=t;
}
System.out.print("这个数列的前20项和是"+s);
}
}
运行结果：
11. 判断一年中的第一天是周几
注释里有写计算原理哦~
还是很容易懂的。
import java.util.*;
public class Test{
public static void main(String []args) {
Scanner scan = new Scanner(System.in);
System.out.print("请输入年份：");
int year = scan.nextInt();
int s=0;
//for循环,先计算输入年份距离公元1月1日有多少天
for(int i=1; i<year; i++){
if(i%4==0 && i%100!=0 || i%400==0){
s=s+366; //闰年2月多1天,一共366
}else{
s=s+365;
}
}
int week = (s%7)+1;//公元1月1日是星期日,因此要算每年的1月1日是星期几,对7求余后要加1.
//如果公元1月1日是星期一,总共天数对7求余,结果是几,就是星期几
System.out.println(year+"年第一天是星期"+week);
}
}
运行结果：
12. 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数
//输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数
public static void main(String []args) {
System.out.println("请输入一行字符(英文字母,空格,数字或其他字符):");
Scanner scan = new Scanner(System.in);
String str = scan.nextLine();//next()不能接收空格
int s=0,m=0,n=0,q=0;
for(int i=0;i<str.length();i++) { //遍历字符串
char c=str.charAt(i); //用charAt方法一个个取出字符,再进行判断
if(c>='0'&&c<='9') {
s++;
}
else if(c>='A'&&c<='Z'||c>='a'&&c<='z') {
m++;
}
else if(c==' ') {
n++;
}
else {
q++;
}
}
System.out.println("数字"+s+"个,英文字母"+m+"个,空格"+n+"个,其他字符"+q+"个");
}
运行结果：
13. 打印九九乘法表（正倒打印两种）
public class Jiujiu {
public static void main (String[]args) {
//输出 正的乘法口诀表
for(int i=1;i<10;i++) { //控制行数
for(int j=1;j<=i;j++) { //控制一行输出的，这里每行递增
System.out.print(j+"*"+i+"="+i*j+"\t");
}
System.out.println();
}
System.out.println();
//输出 倒的乘法口诀表
for(int i=9;i>=1;i--) {
for(int j=i;j>=1;j--) {//控制一行输出的，这里每行递减
System.out.print(i+"*"+j+"="+i*j+"\t");
}
System.out.println();
}
}
}
运行结果：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
9*9=81 9*8=72 9*7=63 9*6=54 9*5=45 9*4=36 9*3=27 9*2=18 9*1=9
8*8=64 8*7=56 8*6=48 8*5=40 8*4=32 8*3=24 8*2=16 8*1=8
7*7=49 7*6=42 7*5=35 7*4=28 7*3=21 7*2=14 7*1=7
6*6=36 6*5=30 6*4=24 6*3=18 6*2=12 6*1=6
5*5=25 5*4=20 5*3=15 5*2=10 5*1=5
4*4=16 4*3=12 4*2=8 4*1=4
3*3=9 3*2=6 3*1=3
2*2=4 2*1=2
1*1=1
14. 加减乘除计算器（循环执行）
import java.util.*;
public class Calc{
public static void main(String []args){
boolean flag=false; //初始化变量flag,默认初值是false
while(flag==false) { //注意条件表达式要==
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数：");
int a = scan.nextInt();
System.out.println("请输入第二个数：");
int b = scan.nextInt();
System.out.println("请输入运算符：");
String c =scan.next();
if(b==0&&"/".equals(c)){
System.out.println("除数不能为零，请重新输入");
continue; //跳出本次循环执行下一次循环
}
int result=calc(a,b,c);
System.out.println("运算结果是"+result);
System.out.println("是否继续？ y 是，其他键结束");
String d =scan.next();
if("y".equals(d)) {
flag =false; //把flag标为false,继续执行循环
}
else {
break; //退出循环
}
}
}
public static int calc(int a,int b,String c) {
switch(c){
case "+":
return a+b;
case "-":
return a-b;
case "*":
return a*b;
case "/":
return a/b;
default:
return 0;
}
}
}
运行结果：
请输入第一个数：
1
请输入第二个数：
0
请输入运算符：
/
除数不能为零，请重新输入 //如果除数为0，且运算符为"/",则没有运算结果，直接重新开始循环
请输入第一个数：
1
请输入第二个数：
4
请输入运算符：
+
运算结果是5 //其他情况会输出结果
是否继续？ y 是，其他键结束
y
请输入第一个数：
3
请输入第二个数：
5
请输入运算符：
*
运算结果是15
是否继续？ y 是，其他键结束
q
要实现这段代码的循环运行，中心思想是通过一个 while 循环，当 flag==false 执行循环，调用calc方法就会输出结果，并询问你是否要继续执行，输入y,确定执行，flag=false，把flag标为false,继续执行循环，否则，break 结束循环。
15. 计算某个数的阶乘
一段灰常简单的代码，不熟练的童鞋们也要 注意细节 哦~
import java.util.*;
public class Jiecheng {
public static void main(String[] args) {
System.out.print("请输入一个数：");
Scanner scan = new Scanner(System.in);
int b = scan.nextInt();
int s=1; //阶乘，这里初始化为1
for(int i=1;i<=b;i++) {
s*=i;
}
System.out.println(b+"的阶乘是"+s);
}
}
运行结果：
16. 创建一个二维数组,随机生成元素,值在 90 -100 之间,求平均值
比较难理解的都写在注释里了哦~
应该还是很容易懂的。
多想想，都能自己写出来的。加油💪(ง •_•)ง
import java.util.*;
public class Test{
public static void main(String []args){
System.out.println("请输入要创建的二维数组的行数和列数：");
Scanner scan = new Scanner(System.in);
int a=scan.nextInt();
int b=scan.nextInt();
int [][]x=new int[a][b];
int s=0;
double avg=0;
System.out.println("生成的二维数组为：");
for(int i=0;i<x.length;i++){ //二维数组循环遍历
for(int j=0;j<x[i].length;j++){
x[i][j]=(int)(Math.random()*10+90); //保持随机数在90-100之间，并将其存进数组
System.out.print(x[i][j]+" "); //打印数组
s+=x[i][j]; //求数组所有元素之和
}
System.out.println(); //每打印一行，换行
}
avg=s/(a*b);
System.out.println("平均值是"+avg);
}
}
运行结果：
17. 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共需要多少种跳法
话说这个题，跪了。。
我做得时候没找到规律，，😂，
后来才知道是斐波那契数列。。把我学到的分享给初学地小白们。
递归吧，，小白不好理解，，学得多了就理解了，实在不行，先死记把。。哈哈
//`思路：首先考虑台阶数n等于0、1、2时的特殊情况，f(0) = 0 f(1) = 1 f(2) = 2 其次，当n=3 时，`
// `青蛙的第一跳有两种情况：跳1级台阶或者跳两级台阶，假如跳一级，那么 剩下的两级台阶就是f(2)种跳法；`
// `假如跳两级，那么剩下的一级台阶就是f(1)，因此f(3)=f(2)+f(1) 当n = 4时，f(4) = f(3) +f(2),`
// `因此青蛙跳台阶就是一个斐波那契数列。 `
public class FrogJump{
//递归实现
// public static long f(int n)
// {
// if (n==0){
// return 0;
// }
// if (n==1){
// return 1;
// }
// if (n==2){
// return 2;
// }
// else{
// return f(n - 1) + f(n - 2);
// }
// }
//递推（迭代）实现
public static void main(String [] args)
{
int result=f(9);
System.out.println(result); //34
}
public static int f(int n) {
int a1=1;
int a2=2;
int total=0;
if(n==0) {
return 0;
}
if(n==1) {
return 1;
}
if(n==2) {
return 2;
}
for(int i=3; i<=n; i++) {
total= a1+a2;
a1=a2;
a2=total;
}
return total;
}
} // 递归在性能上,是有一定问题的, 如果可能,可以采用递推
运行结果：
这个青蛙跳台阶题和生兔子的题都是属于 斐波那契数列 的一类题~
18. 公鸡五元钱一只，母鸡三元钱一只，小鸡一元钱三只，现有一百元钱欲买百鸡，共有多少种买法
这个 百元买百鸡 题，其实和鸡兔同笼问题差不多。
这类题按照以下这种基本思路写就可以。
以下是两种写法，都可以。写法很多，可以自己试试看。
public class Maiji {
//法一：
// public static void main(String[] args) {
// int count = 0; //按鸡头数来限制循环最大值没有必要，后面的纯粹浪费时间
// for (int i = 0; i <= 20; i++) { // 100元，假设全买公鸡，最多买20只
// for (int j = 0; j < 34; j++) { // 100元，假设全买母鸡，最多买33.333，即34只
// for (int k = 0; k <= 300; k = k + 3) {// 100元，假设全买小鸡，最多买300只
// if ((5 * i + 3 * j + k / 3 == 100) && (i + j + k == 100)) {
// System.out.println("公鸡：" + i + "母鸡：" + j + "小鸡：" + k);
// count++;
// }
// }
// }
// }
// System.out.println("共有" + count + "买鸡方案");
// }
//法二：
public static void main(String[] args) {
int count = 0;
for (int i = 0; i <= 20; i++) {
for (int j = 0; j < 33-i; j++) {
int k=100-i-j;
if (5 * i + 3 * j + k / 3 == 100&& i + j + k == 100 && k%3==0){
System.out.println("公鸡：" + i + "母鸡：" + j + "小鸡：" + k);
count++;
}
}
}
System.out.println("共有" + count + "买鸡方案");
}
}
运行结果：
19. 有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组
// 法一：比较笨的那种方法
import java.util.*;
public class InsertArray {
public static void main(String [] args){
int [] a = new int[] {88,66,77,2,3,9,7,11,44,33};//写好的数组大小是固定的
int [] c = new int[11]; //因此在原数组插入一个元素可通过 新建一个数组，按插入之后应该的顺序放到新的数组里 来实现
Arrays.sort(a); //由小到大排序
System.out.println("未插入前的数组：");
for(int i=0;i<10;i++){ //遍历数组输出，作结果比对
System.out.print(a[i] + " ");
}
System.out.println();
System.out.print("请输入一个数：");
Scanner scan = new Scanner(System.in);
int b=scan.nextInt();
for(int i=0;i<10;i++){ //一个一个比对，输入的数b小于a[i]时，符合排序规律，把b放到c[i]里
if(b<=a[i]){
c[i]=b;
for(int j=i;j<a.length;j++) { //然后把a[i]以及后面的依照次序放到c[i+1]里
c[i+1]=a[i];
i++;
}
}else{
c[i]=a[i]; //输入的数b大于a[i]时，直接将a[i]的值写到c[i]里
}
}
System.out.println("插入后：");
for(int i=0;i<11;i++){
System.out.print(c[i]+" "); //遍历输出c[i]
}
}
}
//法二：较好的方法
import java.util.*;
public class InsertArray{
public static void main(String[] args) {
int []x= {4,6,7,9,11,33,45,66,77,88};
for(int i=0;i<x.length;i++) {
System.out.print(x[i]+" ");
}
System.out.println();
x=insert(x,100);
for(int i=0;i<x.length;i++) {
System.out.print(x[i]+" ");
}
}
static int [] insert(int [] x,int n){
int [] y=new int [x.length+1];
int index=Arrays.binarySearch(x, n);//用二分查找法，找到要插入的数，应该处于原数组中的哪个位置
if(index<0){//因为利用上面方法查数，如果数组里有，查到了，找到的数就是一个正数，值即为这个数在数组中的位置+1
index= -index-1; //如果数组里没有，会返回一个负值，负号代表数组里没有，值即为如果插入这个数他在数组中应该的位置+1
} //因此这里需要将index变成正的，再减1，返回它在数组中应存放的位置
//复制前半部分
System.arraycopy(x,0,y,0,index); //这个数之前部分的长度就是它在数组中的位置
//把要插入的数存放到它该存放的位置
y[index]=n;
//复制下半部分
System.arraycopy(x, index, y, index+1, x.length-index);
return y;
}
}
运行结果：
20. 一个5位数，判断它是不是回文数
要做这个题，首先得明白什么是回文数呢？
例如，12321就是回文数，个位与万位相同，十位与千位相同，诸如此类。
以下是两段代码，显然。后一种更灵活。不限制输入数的位数。
import java.util.*;
public class HuiWen{
public static void main(String[] args) {
//固定的算法，只能判断5位数的，不是很灵活，
//思想：一位一位对比
// System.out.print("请输入一个五位数的整数: ");
// Scanner scan = new Scanner(System.in);
// int m=scan.nextInt();
// if(m/10000==m%10&&(m/1000)%10==(m/10)%10) {
// System.out.println(m+"是回文数");
// }
// else {
// System.out.println(m+"不是回文数");
// }
//判断n位数的回文数,
//思想：倒着计算这个数和原数相等即是回文数
System.out.println("请输入一个数：");
Scanner scan = new Scanner(System.in);
int m= scan.nextInt();
int number=m;//先缓存输入的这个数，为之后比对做准备
int n=0;//用来缓存倒着计算出的数
while(m>0) {
n=n*10+m%10;
m=m/10;
}
if(n==number) {
System.out.println(number+"是回文数");
}
else {
System.out.println(number+"不是回文数");
}
}
}
运行结果：
注意，这里定义的数是int型的，测试输入超过 int允许存储的最大值2147483647，就会报错：java.util.InputMismatchException,输入不匹配异常。
想要测试更大的数，可以把变量定义为long型
测试下。OK.
java学习ing.jpg 😊o(￣▽￣)ブ
有其他见解，评论区留言或者私信，一起讨论，纠正。
关注我，努力鸭~和我一起学习鸭~
另外，转载文章请记得附上原文链接哦
扫一扫
636
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
