30道JAVA基础编程练习题
- 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少？（输出第10个月的兔子对数）
程序分析： 兔子的规律为数列1,1,2,3,5,8,13,21…
1.1
2.1
3 .3（T1生了T3）
4.5（T1生了T4，T2生了T5）
5.8（T1生了T6，T2生了T7，T生了T8）
6.13（T4、T5也加入了生兔子大军）
****（运用递归（数列）方法）：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)
public class TextOne {
public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i=1;i<=10;i++){
int num=getNum(i); //调用递归方法
System.out.print("第"+i+"个月，数量为："+num);
}
}
public static int getNum(int i){ //静态方法防止无限循环，非静态方法需实例化才可以用
if(i==1||i==2){
return 1;
}else{
return getNum(i-1)+getNum(i-2);
}
}
}
- 题目：判断101-200之间有多少个素数，并输出所有素数。
程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
public static void main(String[] args) {
int count = 0;
for (int i = 101; i <= 200; i++) {
boolean b = true;
for (int j = 2; j < i; j++) {
// 判断i是否能被整除
if (i % j == 0) {
b = false;
break;
} else {
b = true;
}
}
if (b) {
System.out.print(" " + i);
count++;
}
}
System.out.print(" 101~200的素数为：" + count);
}
}
- 题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。
public static void main(String[] args) {
// TODO Auto-generated method stub
int i,j,n;
for(int x=100;x<999;x++) {
i=x%10;
j=x/10%10;
n=x/100;
if(x==i*i*i+j*j*j+n*n*n) {
System.out.println(x+" ");
}
}
}
}
- 题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
程序分析：(a>b)?a:b这是条件运算符的基本例子。
public static void main(String[] args) {
// TODO Auto-generated method stub
String a = "A",b = "B",c = "C";
System.out.println("enter score:");
//输入成绩
Scanner s=new Scanner(System.in);
//读取成绩
double score=s.nextInt();
//判断成绩等级
if(score>100||score<0) {
System.out.println("输入无效");
}
else {
System.out.println("grade is："+((score>60)?((score>89)?a:b):c));
}
}
}
- 题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
程序分析：利用定义法。
辗转相除定理：两个整数m和n（m>n)他们的最大公约数等于m除以n的余数c和较小数n之间的最大公约数
两个数相除得出余数——>若余数不为0，则拿较小的数与余数继续相除，判断新的余数是否为0；
若余数为0，则最大公约数即本次相除中较小的数
方法一：
import java.util.Scanner;
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 0;
int c[] = new int[2];
int m = c[0];
int n = c[1];
Scanner s = new Scanner(System.in);
System.out.println("enter:");
for (int i = 0; i < 2; i++) {
c[i] = s.nextInt();
}
if (m > n) {
for (int i = 0; i < 2; i++) {
a = m % n;
while (a != 0) {
a = m % n;
}
if (a == 0) {
a = n;
break;
}
}
} else {
m = c[1];
n = c[0];
for (int i = 0; i < 2; i++) {
a = m % n;
if (a != 0) {
a = m % n;
}
if (a == 0) {
a = n;
break;
}
}
}
System.out.println("最大公约数为：" + a);
System.out.println("最小公倍数为：" + m * n / a);
}
}
方法二：
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("输入两个整数m和n：");
Scanner scan =new Scanner(System.in);
int m=scan.nextInt();
int n=scan.nextInt();
int max=(m>n?m:n);
int min=(m<n?m:n);
// 先求最大公约数
int i=min;
//大到小，有一个条件不满足，则继续向下找
while((min%i!=0)||(max%i!=0)){
i--;
}
System.out.println("最大公约数:"+i);
System.out.println("最小公倍数:"+(m*n)/i);
}
}
报错：Syntax error on token ".", @ expected after this token
要把代码写在主方法体里面，否则报错
- 题目：求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。
程序分析：关键是计算出每一项的值。
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int a = s.nextInt();
Scanner c = new Scanner(System.in);
int n = c.nextInt();
System.out.println(expressed(a, n) + add(a, n));
}
// 列出字符串表达式a+aa+aaa+aaaa+aa...a
public static String expressed(int a, int n) {
// 字符串常量一旦声明则不可改变，而字符串对象可以改变，但是改变的是其内存地址的指向
/*StringBuffer类方便用户进行内容的修改。在String类中使用“+”作为数据库的连接操作，
而在StringBuffer类中使用append()方法（方法定义：public StringBuffer append(数据类型 变量））进行数据的连接。 */
StringBuffer sb = new StringBuffer();
StringBuffer subSB = new StringBuffer();
for (int i = 1; i < n + 1; i++) {
subSB = subSB.append(a); //子项
sb = sb.append(subSB); //总项
if (i < n) //不要最后的+
sb = sb.append("+");
}
sb.append("=");
return sb.toString();
} // 求和
public static long add(int a, int n) { // a为数字，n为每一项的位数
long sum = 0; //总项
long subSUM = 0; //每一项
for (int i = 1; i < n + 1; i++) {
subSUM = subSUM * 10 + a; //整体进位，低位补a
sum = sum + subSUM; //加到整体中
}
return sum;
}
- 题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？并分别打印出这些数
程序分析：可填在百位、十位、个位的数字都是1、2、3、4，组成所有的排列后再去掉不满足条件的排列。
public static void main(String[] args) {
// TODO Auto-generated method stub
int i, j, k, sum = 0;
int count = 0; // 逐为增加，各位相等就继续循环加一直到各位不相等
for (i = 1; i <= 4; i++) {
for (j = 1; j <= 4; j++) {
if (i == j) {
continue;
}
for (k = 1; k <= 4; k++) {
if (k == i || k == j) {
continue;
}
int n = j * 10; // 算出十位的数
int m = k * 100; // 算出百位的数
sum = i + n + m; // 应先输出再换行才能输出够十个才会换行
System.out.print(sum); // 否则变成第一行九个但实际一算出10个就换行才输出
System.out.print(" "); // 错误： if((++count)%10==0) {
if ((++count) % 10 == 0) { // System.out.print("\n");
System.out.print("\n"); // }
} // System.out.print(sum);
} // System.out.print(" ");
}
}
System.out.print("可以组成" + count + "个 ");
}
- 题目：输入某年某月某日，判断这一天是这一年的第几天？
程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于3时需考虑多加一天。
方法一：
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sca = new Scanner(System.in);
int year = sca.nextInt();
int month = sca.nextInt();
int day = sca.nextInt();
System.out.println(year + "年的第" + getDay(year, month, day) + "天");
}
public static int getDay(int year, int month, int day) {
// 闰年
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
// 第一个月
if (month == 1) {
day = day;
}
// 第二个月
if (month == 2) {
// 闰年第二个月最多只有29天
if (day > 29) {
System.out.print("不存在");
return 0;
} else {
day = day + 31;
}
}
// 超过七月时变成双数有31天
if (month < 8 && month > 2) {
if (month % 2 == 1) {
day = ((month - 1) / 2) * 31 + ((month - 1) / 2) * 30 - 1 + day;
} else {
day = (month / 2) * 31 + ((month / 2) - 1) * 30 - 1 + day;
}
if (month >= 8) {
if (month % 2 == 1) {
day = (((month - 3) / 2) * 30 - 1) + ((month + 1) / 2) * 31 + day;
} else {
day = (((month / 2) * 31) + ((month - 2) / 2) * 30 - 1) + day;
}
}
}
} else {
if (month == 1) {
day = day;
}
if (month == 2) {
if (day > 28) {
System.out.print("不存在");
} else {
day = day + 30;
}
}
if (month < 8 && month > 2) {
if (month % 2 == 1) {
day = ((month - 1) / 2) * 31 + ((month - 1) / 2) * 30 - 2 + day;
} else {
day = (month / 2) * 31 + ((month / 2) - 1) * 30 + day;
}
}
if (month >= 8) {
if (month % 2 == 1) {
day = (((month - 3) / 2) * 30 - 2) + ((month + 1) / 2) * 31 + day;
} else {
day = (((month / 2) * 31) + ((month - 2) / 2) * 30 - 2) + day;
}
}
}
return day;
}
方法二：
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sca = new Scanner(System.in).useDelimiter("\\D");
System.out.println("请输入当前日期(年-月-日)");
int year = sca.nextInt();
int month = sca.nextInt();
int day = sca.nextInt();
System.out.println(year + "年的第" + getDay(year, month, day) + "天");
}
public static int getDay(int year, int month, int day) {
int n = 0;
// 要加的前一个月
int month_data[] = new int[] { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30 };
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
month_data[2] = 29;
}
for (int i = 0; i < month; i++) {
n += month_data[i];
}
return n + day;
}
}
方法三：
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sca = new Scanner(System.in);
int year = sca.nextInt();
int month = sca.nextInt();
int day = sca.nextInt();
System.out.println(year + "年的第" + getDay(year, month, day) + "天");
}
public static int getDay(int year, int month, int day) {
int sum = 0;
/* 先计算某月以前月份的总天数 */
switch (month) {
case 1:
sum = 0;
break;
case 2:
sum = 31;
break;
case 3:
sum = 59;
break;
case 4:
sum = 90;
break;
case 5:
sum = 120;
break;
case 6:
sum = 151;
break;
case 7:
sum = 181;
break;
case 8:
sum = 212;
break;
case 9:
sum = 243;
break;
case 10:
sum = 273;
break;
case 11:
sum = 304;
break;
case 12:
sum = 334;
break;
default:
System.out.println("输入错误");
break;
}
sum = sum + day; /*再加上某月的天数*/
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
if (month > 2) {
sum++; /*如果是闰年且月份大于2,总天数应该加一天*/
}
}
return sum;
}
}
- 题目：输出9*9口诀。
程序分析：分行与列考虑，共9行9列，i控制行，j控制列。
public static void main(String[] args) {
// TODO Auto-generated method stub
int i, j;
// 从左到右输出，每一行只有i个式子
for (i = 1; i <= 9; i++) {
for (j = 1; j <= i; j++) {
System.out.print(j + "×" + i + "=" + i * j + "\t");“ ”换成“\t”，现在来说明空格和“\t”的区别！
}
System.out.println();
\t是补全当前字符串长度到8的整数倍，最少1个最多8个空格
} 补多少要看你\t前字符串长度
} 比如当前字符串长度10，那么\t后长度是16，也就是补6个空格
} 如果当前字符串长度12，此时\t后长度是16，补4个空格
- 题目：打印出如下图案（菱形）
程序分析：先把图形分成两部分来看待，前五行一个规律，后四行一个规律，利用双重for循环，第一层控制行，第二层控制列。
（最多一行九个星星）
上半部分
* 第一行：四个空格一个星星
*** 第二行：三个空格三个星星
***** 第三行：二个空格五个星星
******* 第四行：一个空格七个星星
********* 第五行：零个空格九个星星
******* 空格数：总行数-行号 星星数：2*行号-1
***** 行：外层for循环 内层for循环 内层for循环
***
*
方法一：
public static void main(String[] args) {
// TODO Auto-generated method stub
int i, j, k, n = 5;
for (i = 1; i <= n; i++) { // 控制行数
// 只需要打印左边的空格，右边会自动生成，每一行星星前面有n-i个星星
for (j = 1; j <= n - i; j++) {
System.out.print(" ");
}
// 打印完空格打印2*i-1个星星，每一行有2*i-1个星星
for (k = 1; k <= 2 * i - 1; k++) {
System.out.print("*");
}
System.out.println();
}
// 控制下半部分行数
// 把上面的倒过来输出，第六行相当于第四行
for (i = n - 1; i >= 1; i--) {
// 只需要打印左边的空格，右边会自动生成
for (j = 1; j <= n - i; j++) {
System.out.print(" ");
}
// 打印完空格打印2*i-1个星星
for (k = 1; k <= 2 * i - 1; k++) {
System.out.print("*");
}
System.out.println();
}
}
方法二：
public static void main(String[] args) {
// TODO Auto-generated method stub
int n = 5;
printStar(n);
}
public static void printStar(int n) {
// 打印上半部分
for (int i = 0; i < n; i++) {
// 每一行有十个位置
for (int j = 0; j < 2 * n; j++) {
// n-i为空格数
if (j < (n - i)) {
System.out.print(" ");
}
// n+i为最后一个星星数
if (j >= n - i && j <= n + i) {
System.out.print("*");
}
}
System.out.println();
}
// 打印下半部分
for (int i = 1; i < n; i++) {
System.out.print(" ");
// 2*n-i为星星数
for (int j = 0; j < 2 * n - i; j++) {
// i为每行空格数
if (j < i) {
System.out.print(" ");
}
// 2*n-i-1为最后一个星星位置
if (j >= i && j < 2 * n - i - 1) {
System.out.print("*");
}
}
System.out.println();
}
}
- 题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。
程序分析：请抓住分子与分母的变化规律。
a=a+b;与a+=b;的区别：
不同类型的两个变量在进行运算的时候，我们经常说到的是类型的转换问题。
这里，记住两点：
*一、运算过程中，低精度的类型向高精度类型转换。
*二、如果将高精度的数值赋值给低精度类型变量，则必须要进行显性的强制转换。
对于a+=b;这个式子，要明确的一点是，+=运算中，结合了强制类型转换的功能，因此，不会出现编译错误
而对于a=a+b;这个式子，因为是简单的运算，没有类型转换，在编译过程中会报错
方法一：
public static void main(String[] args) {
// TODO Auto-generated method stub
// 从第二个数开始
// 分子=前一个数的分子+分母
// 分母=前一个数的分子
double n1 = 1, n2 = 1, n, sum = 0;
for (int i = 1; i <= 20; i++) {
double t1 = n1;
double t2 = n2;
n1 = t1 + t2;
n2 = t1;
n = n1 / n2;
sum += n;
}
System.out.print("sum=" + sum);
}
方法二：
public static void main(String[] args) {
// TODO Auto-generated method stub
int i,zi=2,mu=1;
double sum=0;
//循环20次算前20项之和
for(i=0;i<20;i++) {
//将分子转换为double型，否则两个int相除结果还是int，会舍弃小数点后的数
//(double）(zi/mu)将先是int型才是double型,(double)zi/mu将zi转为double型再计算结果仍是double型
sum+=(double)zi/mu;
//后一个数的分子是前一个数的分子和分母之和
zi=zi+mu;
//此时新分子已经是原分子分母的和了，只需要再减去原分母。即可将原分子赋给新分母。
mu=zi-mu;
}
System.out.print("sum="+sum);
}
- 题目：求1+2!+3!+…+20!的和
程序分析：此程序只是把累加变成了累乘。
方法一：
//外层循环控制累加，内层循环控制累乘
public static void main(String[] args) {
// TODO Auto-generated method stub
int i = 0, j = 0;
System.out.print("sum=" + getMul(i, j));
}
public static long getMul(int i, int j) {
long sum = 0; //单层循环：long sum = 0;
for (i = 1; i <= 20; i++) { // long n=1;
long n = 1; // for(i=1;i<=20;i++) {
for (j = 1; j <= i; j++) { // sum+=n;
n *= j; // n*=i;
} // }
sum += n; // return sum;
}
return sum;
}
}
方法二：
public static void main(String[] args) {
long sum = 0;
for (int i = 0; i < 20; i++){
sum += factorial(i + 1); //即sum=sum+mult，将i+1传递给n
}
System.out.println(sum);
}
// 阶乘
private static long factorial(int n) { //当i=1，n=2,加到2!，i=1即第二项为二阶乘
long mult = 1; //此处mult不能用int，否则到后面会损失精度
for (int i = 1; i < n + 1; i++){ //当主方法的i=1，这里n=3循环2次
mult *= i;
}
return mult;
}
- 题目：利用递归方法求5!。
程序分析：递归公式：fn=fn_1*4!
public static void main(String[] args) {
// TODO Auto-generated method stub
int n = 5;
System.out.print("5!=" + fn(n)); //1~5累乘
}
//传入一个数据累乘操作的最大值，而后每次进行数据的递减，一直累乘到计算数据为1
private static int fn(int n) { //最大的内容
if (n == 1) { //递归的结束调用
return 1; //最终的结果返回了1
}
//递归调用：5*fn(4);——>5*4*fn(3)——>5*4*3*fn(2)——>5*4*3*2*fn(1)==5*4*3*2*1
return n * (fn(n - 1));
}
- 题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
java中并不支持多维数组，但它允许一维数组作为另一个一维数组的元素，以此来达成多维数组的功能
a.length指二维数组a的行数，a[0].length指第一行中元素的个数
s.length是针对java中数组的，length是数组的一个属性，用来表示数组的长度
s.length()则是字符串的一个方法，用来返回字符串的长度的
字符串是没有length属性的，只有length()方法
数组有length属性，而没有length()方法
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sca = new Scanner(System.in);
String a = sca.next();
if (a.length() > 5) { // s.length()则是字符串的一个方法，用来返回字符串的长度的
System.out.print("输入错误");
} else {
System.out.println(a + "是" + a.length() + "位数");
System.out.println("逆序输出为：");
for (int i = a.length() - 1; i >= 0; i--) {
System.out.print(a.charAt(i) + " ");
}
}
}
- 题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int hui = sc.nextInt();
if (hui < 10000 || hui > 99999) {
System.out.print("输入错误");
} else {
if ((hui % 10 == hui / 10000) && (hui / 10 % 10 == hui / 1000 % 10)) {
System.out.print(hui + "是回文数");
} else {
System.out.print(hui + "不是回文数");
}
}
}
- 题目：对10个数进行排序
程序分析：利用冒泡法，通过邻位的交换，把当前剩余最大数赶到右边，然后依次从右到左，确定各位的数。输入：31, 42, 21, 50, 12, 60, 81, 74, 101, 93
先第一个跟第二个比较交换，第二个跟第三个比较交换......
然后遍历完后又返回重新第一个与第二个比较交换，第二个与第三个比较交换，以此类推
public static void main(String[] args) {
// TODO Auto-generated method stub
//利用键盘输入读取数组的方法，也可自定义一个数组即：
int[] a=new int[]{31,42,21,50,12,60,81,74,101,93}
int[] a = new int[10];
int m = 0;
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 10; i++) {
a[i] = sc.nextInt();
}
for (int i = 0; i < 10; i++) { // 外层循环控制比较次数
/*j<a.length-1是因为循环了一遍后最后一个已经是最大值，不需要再比较被推到最后的数，
循环一遍最后面有一个最大，两遍有两个最大 */
for (int j = 0; j < a.length - i - 1; j++) { // 内层循环控制相邻
if (a[j] > a[j + 1]) {
m = a[j];
a[j] = a[j + 1];
a[j + 1] = m;
}
}
}
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
}
- 题目：求一个3*3矩阵对角线元素之和
程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。
public static void main(String[] args) {
// TODO Auto-generated method stub
int[][] a = new int[][] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
for (int i = 0; i < a.length; i++) { // 外层循环控制数组的行内容
for (int j = 0; j < a[i].length; j++) { // 内层循环控制数组的列内容
System.out.print(a[i][j] + "\t");
}
System.out.println();
}
int sum1 = 0, sum2 = 0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if (i == j) {
sum1 += a[i][j];
}
if (i == a.length - i - 1) {
sum2 += a[i][j];
}
}
}
System.out.print("矩阵对角线为：" + sum1 + "和" + sum2);
}
- 题目：打印出杨辉三角形（要求打印出10行如下图）
程序分析：用10×21列二维数组存储。
方法一：（利用递归方法）
public static void main(String[] args) {
// TODO Auto-generated method stub
int a[][] = new int[10][21];
for (int i = 1; i <= 10; i++) {
for (int k = 1; k < (10 - i) + 1; k++) { // 在数字之前打印空格
System.out.print(" "); //此处为两个空格
}
for (int j = 1; j <= i; j++) {
System.out.print(fun(i, j) + " "); //此处三个空格
}
System.out.println();
}
}
public static int fun(int n, int k) {
if (k == 1 || n == k) { // 每行第一个或者最后一个为1
return 1;
} else {
return fun(n - 1, k - 1) + fun(n - 1, k); // 调用递归方法计算
}
}
方法二：
int[][] a=new int[10][21]; //创建一个二维数组
//赋值
for(int i=0;i<10;i++) {
a[i][0]=1; //每一行第一个为1
a[i][i]=1; //每一行最后一个为1
}
for(int j=2;j<10;j++) { //第二行开始计算
for(int n=1;n<j;n++) { //第j行只有j个数
a[j][n]=a[j-1][n-1]+a[j-1][n]; //每个数等于它上方两数之和。
}
}
//打印
for(int i=0;i<10;i++) { //控制行
for(int j=0;j<2*(10-i)-1;j++) {
System.out.print(" "); //此处为两个空格
}
for(int k=0;k<=i;k++){
System.out.print(a[i][k]+" "); //此处三个空格
}
System.out.println();
}
}
方法三：
public static void main(String[] args) {
// TODO Auto-generated method stub
/**** 1 要理解下面的实现，首先要明白int数组中元素默认值为 0
* 2 然后每一次迭代打印新的一行的元素的时候：
* 新的特定位置的元素 = 该位置原来的元素 + 该位置的前一个位置的值
*****/
int a[][] = new int[10][21];
int b[] = new int[10 + 1]; // 临时存储数据用
int previous = 1; // 默认第一个数
for (int i = 1; i <= 10; i++) { // i 用来控制行数
for (int j = 1; j <= 10 - i; j++) { // 输出空格
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
int current = b[j]; // 先获得后一个数
b[j] = previous + current;
previous = current;
System.out.print(b[j] + " ");
}
System.out.println();
}
}
- 题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
索引：数组中的元素在内存是连续排列的，有时我们我处理里面的数据并不是从头取到尾，
有时从中间取，所以这里就需要一个下标，标记是在哪个位置，这个下标就就是索引，
比如中药铺里面的药柜，要写明药名是不，这个名就是索引．而数组下标是从0开始的．
比如a[0],a[1],a[2],a[3],a[4],a[5] 这0,1,2,3,4,5,就是索引
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
System.out.println("输入人数：");
int n = sc.nextInt();
/**** 初始化人员 ****/
boolean a[] = new boolean[n]; // boolean数组表示站成一圈的人，false表示退出
// 初始化使每个人都是true，都在圈内
for (int i = 0; i < a.length; i++) {
a[i] = true;
}
/**** 报号 ****/
int incount = n; // 还在圈内人数
int inNumber = 0; // 本轮报数
int inDex = 0; // 数组n中的标记索引
// 圈内有9个人，此时a[0]==true,还没开始报数，先判断是否是真，是真则报数
while (incount > 1) { // 只要圈内多于一人就可以继续
// 是true才报数，inNumber才加一
if (a[inDex] == true) {
inNumber++; // 本轮报数加一
if (inNumber == 3) { // 如果本轮报数为3
inNumber = 0; // 本轮结束，本轮报数归零
a[inDex] = false; // 置false，表示退出
incount--; // 圈内人数减一
}
}
inDex++; // 对下一个人进行判断
if (inDex == n) { // 得一圈后重新开始
inDex = 0;
}
}
// 如果i=1则指向第二个，此处索引应从0开始
for (int i = 0; i < n; i++) {
if (a[i] == true) {
System.out.print(i + 1); // 第i个人的下标为i-1
}
}
}
- 题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5，然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。请编写程序，从键盘输入4位整数，然后进行加密输出。
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入四个整数：");
Scanner sc = new Scanner(System.in);
// 把输入的数分别取出来放在数组而不是输入数组
int n = sc.nextInt();
// 输入数组长度为四的数
int a[] = new int[4];
int temp2 = 0, temp1 = 0;
// 输入1234默认a[0]为1234，如需a[0]=1,a[1]=2......应输入1空格2空格......
// 从左到右取存
for (int i = 3; i >= 0; i--) {
a[i] = n % 10;
n /= 10;
}
// 注意：要一边循环一边输出换好的值，不能运算后输出一个再回去循环再输出一个
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]);
}
for (int i = 0; i < a.length; i++) {
a[i] += 5;
a[i] %= 10;
}
System.out.println();
// 此处只要交换一次，不需要用循环，如果在循环里交换就会循环几次导致交换多次变回原来的样子
temp1 = a[0];
a[0] = a[3];
a[3] = temp1;
temp2 = a[1];
a[1] = a[2];
a[2] = temp2;
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]);
}
}
- 题目：有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），计算出平均成绩，将原有的数据和计算出的平均分数存放在磁盘文件"test21.txt"中。
public class TextFifty {
// 定义学生模型
String name[] = new String[5]; // 定义名字长度为5的数组
String number[] = new String[12]; // 定义学号
double grade[][] = new double[5][3]; // 定义五个学生三门课成绩
double sum[] = new double[5]; // 定义五个学生的总成绩
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
TextFifty stud = new TextFifty();
qw.input();
qw.output();
}
// 输入学号、姓名、成绩
public void input() {
Scanner sc = new Scanner(System.in);
// 控制行内容
for (int i = 0; i < 5; i++) {
System.out.println("请输入学号：");
// 每循环一次存一个到数组
number[i] = sc.next();
System.out.println("请输入名字：");
name[i] = sc.next();
// 控制列内容
for (int j = 0; j < 3; j++) {
System.out.println("请输入第" + (j + 1) + "门课成绩"); // 分别输入三科成绩
grade[i][j] = sc.nextInt(); // 将成绩一个一个存到数据
}
System.out.println();
sum[i] = grade[i][0] + grade[i][1] + grade[i][2]; // 计算每个人总成绩
}
}
// 输出/写入文件
public void output() throws IOException {
// 创建文件输出流对象，“//”为分隔符，文件放在F盘的这个文件中
FileWriter fw = new FileWriter("F://text21.txt");
// 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
BufferedWriter bw = new BufferedWriter(fw);
bw.write("No. " + "Name " + "grade1" + " grade2 " + " grade3 " + "average"); // 输出标题
// newLine():写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义，并且不一定是单个新行 ('\n') 符
bw.newLine();
for (int i = 0; i < 5; i++) {
bw.write(number[i]);
bw.write(" " + name[i]);
for (int j = 0; j < 3; j++) {
bw.write(" " + grade[i][j]);
}
bw.write(" " + sum[i] / 3);
bw.newLine();
}
bw.close();
}
}
22.（1） 编写一个抽象类Shape，声明计算图形面积的抽象方法getArea。（2）分别定义Shape的子类Circle（圆）和Rectangle（矩形），子类Circle（圆）增加半径属性r，子类Rectangle（矩形）增加宽、高属性w和h，在两个子类中按照不同图形的面积计算公式，实现Shape类中计算面积的方法。（3）编写主类MainClass，在main()方法中分别创建子类Circle（圆）和Rectangle（矩形），数据自定，并输出这两个图形的面积。
方法一：
public static void main(String[] args) {
// TODO Auto-generated method stub
Circle c=new Circle(2);
Rectangle re=new Rectangle(2,4);
System.out.println(c.getArea());
System.out.println(re.getArea());
}
}
abstract class Shape{
public abstract double getArea() ;
}
class Circle extends Shape{
double r;
double S;
//实现父类抽象方法
public Circle(double r) {
this.r=r;
}
public double getArea() {
// TODO Auto-generated method stub
return S=3.14*r*r;
}
}
class Rectangle extends Shape{
double w,h,s;
//实现父类抽象方法
public Rectangle(double w,double h) {
this.w=w;
this.h=h;
}
public double getArea() {
// TODO Auto-generated method stub
return s=w*h;
}
方法二：
abstract class Shape{
abstract double getArea();
}
class Circle extends Shape{
private double r=10;
double getArea(){
return 3.14*r*r;
}
}
class Rectangle extends Shape{
private double w=10;
private double h=20;
double getArea(){
return w*h;
}
}
public class MainClass {
public static void main(String args[]) {
Circle cir =new Circle();
Rectangle rec =new Rectangle();
System.out.println("The area of Circle is:" + cir.getArea());
System.out.println("The area of Rectangle is:" + rec.getArea());
}
}
转载：https://blog.csdn.net/jiangchengchenga/article/details/105282319
查看评论