目录
7.BMI 指数测试 BMI = 体重 (kg) / 身高² (m)
8.李华想买一个价值9899元的新手机，他的旧手机在二手市场能卖2000元，而手机专卖店推出以旧换新的优惠，把他的旧手机交给店家，新手机就能够打7.5折优惠。为了更省钱，李华要不要以旧换新？
13.手机选号:根据用户输入的手机号来确认用户实际支付的价格
15.写一个死循环(for循环/While循环/do-While循环分别写一个)
19.多次生成随机数,并打印第一次出现大于0.999 时的次数与生成的随机数
25.体彩中有一项是双色球，要求在1-33号共33个红色球里选出6个，1-16号共16个蓝色球中选出一个作为中奖号码
29. 随机数组的归并:生成两个任意的随机数组，并将这两个数组按照数字大小按顺序归并到一个新数组中
30.15个猴子围成一圈选大王,依次1-7循环报数,报到7的猴子被淘汰,直到最后一只猴子称为大王,问:哪只猴子会成为大王?
35.给20块钱买饮料，每瓶饮料3块钱，喝完之后退瓶子可以换回1块钱。问最多可以喝到多少瓶饮料？
36.打印出1-100之间所有不是7的倍数和不包含7的数字， 并求和
37.输入年份和月份，输出这个月应该有多少天（使用switch结构，考虑平年和闰年)
38.随机给十个数字，对它们进行排序。（可以给一个有10个整数元素的数组，然后对数组排序）
39.有一个已经排好序的int数组{1, 2, 3, 4, 5, 6, 7, 8} 。现输入一个数（要求该数在1-8之间），按原来的规律将它插入数组中。
40.给出一个int数组，把它最大的元素与第一个元素交换，最小的元素与最后一个元素交换，输出交换后的数组。
42.创建一个长度为6的整数数组，数组中有六个整数(直接赋值即可)。遍历数组中的每个元素，元素之间用空格隔开
43.现有一个小数数组{12.9,53.54,75.0,99.1,3.14};找出数组中的最小值并打印
44.创建一个长度为6的整数数组,随机生成六个0-100之间的整数存放到数组中，然后再计算出数组中元素的和并打印
45.有一个整数数组，让数组的最后一个元素代表个位，倒数第二个元素代表十位，以此类推。最终得到一个大的整数。
46.定义一个数组来存储10个学生的成绩{72,89,65,87,91,82,71,93,76,68}，计算并输出学生的平均成绩
49.定义一个数组其中包含多个数字，奇数放在数组的左边，偶数放在数组的右边。
55.定义一个数组{1,3,4,2,6,2,6,2,8,2,6},要求输出结果是不重复的数
56.输入数组(数组的长度和数组各个位上的值都在控制台输入)，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组
57.给定一个数组，大小为10，输入十个同学的成绩，求这些成绩的总分数；某一天转入2个新同学，请再次求12个同学的平均成绩（使用扩容做）
60.由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出
1.预测身高案例
假定父母与子女的身高遗传关系如下：
儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2
女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2
那已知：现有父亲身高175CM,母亲身高160CM。将预测的子女身高打印输出
public class Test {
public static void main(String[] args) {
//1.定义变量保存父亲的身高
double fatherHeight = 175;
//2.定义变量保存母亲的身高
double motherHeight = 160;
//3.计算儿子身高
double sonHeight = (fatherHeight + motherHeight) * 1.08 / 2;
//4.计算女儿身高
double daughterHeight = (fatherHeight * 0.923 + motherHeight) / 2;
//5.打印输出最终计算的结果
System.out.println("儿子预计身高" + sonHeight + "厘米");
System.out.println("女儿预计身高" + daughterHeight + "厘米");
}
}2.已知小红同学有25元，她攒了几天钱之后发现自己的现在的钱比原来的2倍还多出10块。而小蓝同学有30元，他攒了几天钱之后发现自己的钱正好是原来的2倍。于是小胖说：小红和小蓝现在的钱一样多，请问，他说的对吗？
public class Test {
public static void main(String[] args) {
//1.定义变量保存小红原来的钱数
int red = 25;
//2.定义变量保存小蓝原来的钱数
int blue = 30;
//3.求小红同学现在的钱数
red = red * 2 + 10;
//4.求小蓝同学现在的钱数
blue *= 2; //这是一种简写形式，等同于blue = blue *2;
//5.判断并输出两个人的钱是否相等
System.out.println(red == blue);
}
}3.想定一份外卖，商家的优惠方式如下：鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？
public class Eat{
public static void main(String[] args) {
//1.求不使用优惠时的总价
double money1 = 24 + 8 + 3;
//2.判断折后总价
money1 = (money1 <= 30 ? money1 : money1 * 0.8);
//3.求使用优惠时的总价
double money2 = 16 + 8 + 3;
//4.判断两种花费哪个更少
double money = money1 < money2 ? money1 : money2;
//5.打印最终花费
System.out.println(money);
}
}4.接收用户输入的3个整数,并将它们的最大值作为结果输出
import java.util.Scanner;
public class GetMaxNumber {
public static void main(String[] args) {
//1.提示并接收用户输入的三个整数,并交由变量a b c来保存
System.out.println("请输入第一个整数:");
int a = new Scanner(System.in).nextInt();
System.out.println("请输入第二个整数:");
int b = new Scanner(System.in).nextInt();
System.out.println("请输入第三个整数:");
int c = new Scanner(System.in).nextInt();
//2.对接收到的三个值进行比较
/**三元运算符 1 ? 2 : 3
* 如果1号位置的表达式结果为true,结果就取2号位置的值,反之,就取3号位置的值*/
//2.1定义变量max来保存a和b中的最大值
int max = a>b ? a : b;
//2.2比较max与c谁最大,并将最大值交由max来保存
max = max>c ? max : c;
/**解决方案二:*/
//int max = a>b?(a>c?a:c):(b>c?b:c);
//3.输出结果
System.out.println("三个数的最大值是:"+max);
}
}5.接收用户输入的数据，判断是奇数还是偶数
import java.util.Scanner;
public class TestNum {
public static void main(String[] args) {
//1.提示并接收用户输入的数据
System.out.println("请输入您要判断的数据");
int input = new Scanner(System.in).nextInt();
//2.判断用户输入的数据
if(input % 2 == 0) {
System.out.println(input+"是偶数");
}else {
System.out.println(input+"是奇数");
}
}
}6.输入数字1~7，输出对应星期几
import java.util.Scanner;
public class TestDay {
public static void main(String[] args) {
//1.提示并接收用户输入的数据
System.out.println("请输入数据：");
int input = new Scanner(System.in).nextInt();
//2.判断用户输入的数据
if(input == 1) {
System.out.println("星期一");
}else if(input == 2){
System.out.println("星期二");
}else if(input == 3){
System.out.println("星期三");
}else if(input == 4){
System.out.println("星期四");
}else if(input == 5){
System.out.println("星期五");
}else if(input == 6){
System.out.println("星期六");
}else if(input == 7){
System.out.println("星期日");
}
}
}7.BMI 指数测试 BMI = 体重 (kg) / 身高² (m)
接收用户输入身高体重，输出结果
过轻：低于18.5
正常：18.5 ~ 22.9
偏胖：23 ~ 24.9
肥胖：25 ~ 29.9
重度肥胖：高于30
极度肥胖：高于40
import java.util.Scanner;
public class TestBMI {
public static void main(String[] args) {
//1.提示并接收用户输入的身高与体重信息
System.out.print("请输入您的身高(单位为m)：");
double height = new Scanner(System.in).nextDouble();
System.out.print("请输入您的体重(单位为kg)：");
double weight = new Scanner(System.in).nextDouble();
//2.调用getBMI()方法，根据身高和体重信息,输出结果
getBMI(height, weight);
}
public static void getBMI(double h, double w) {
//求出BMI指数
double bmi = w / (h * h);
//定义一个变量r来保存最终结果
String r = "";
//根据 bmi 指数范围，来给r重新赋值
if (bmi < 18.5) {
r = "过轻";
} else if (bmi <= 22.9) {
r = "正常";
} else if (bmi <= 24.9) {
r = "偏胖";
} else if (bmi <= 29.9) {
r = "肥胖";
} else if (bmi <= 40) {
r = "重度肥胖";
} else {
r = "极度肥胖";
}
//打印最终结果
System.out.println("您的BMI指数：" + bmi);
System.out.println("您的体重属于：" + r);
}
}8.李华想买一个价值9899元的新手机，他的旧手机在二手市场能卖2000元，而手机专卖店推出以旧换新的优惠，把他的旧手机交给店家，新手机就能够打7.5折优惠。为了更省钱，李华要不要以旧换新？
public class Choice {
public static void main(String[] args) {
//1.计算不使用以旧换新的花费
int plan1 = 9899 - 2000;
//2.计算以旧换新的花费
double plan2 = 9899 * 0.75;
//3.判断两种方式
if(plan1 > plan2){
System.out.println("使用以旧换新更省钱");
}else{
System.out.println("不使用以旧换新更省钱");
}
}
}9.求数字的绝对值
绝对值是指一个数在数轴上所对应点到原点的距离，用“| |”来表示。负数的绝对值是他去掉负号以后的值，而非负数（0和正数）的绝对值是他本身。请定义一个方法，接收用户输入的数字，输出绝对值结果。
import java.util.Scanner;
public class TestNum {
public static void main(String[] args) {
//1.接收用户输入的要测试的数字
System.out.println("请输入你要判断的数字：");
double input = new Scanner(System.in).nextDouble();
//2.调用求绝对值的方法并拿到方法执行后的结果（返回值）
double result = getAbsNum(input);
//3.打印求出的结果
System.out.println(input+"的绝对值是："+result);
}
private static double getAbsNum(double input) {
if(input >=0){//如果是非负数
return input;//返回本身的值
}else{//如果是负数
return -input;//则值取反
}
}
}10.求指定两个数的最大公约数和最小公倍数
import java.util.Scanner;
public class NumTest {
public static void main(String[] args) {
System.out.println("输入两个整数：");
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
int d = zdgys(a,b);//调用求最大公约数的方法
long x = zxgbs(a,b);//调用求最小公倍数的方法
System.out.println("最大公约数："+d);
System.out.println("最小公倍数："+x);
}
private static int zdgys(int a, int b) {
int min = a<b ? a : b;
for(int i=min; i>=1; i--) {
//i能把a和b同时整除
if(a%i==0 && b%i==0) {
return i;
}
}
//这句代码根本不会执行，
//让编译可以通过
return 0;
}
private static long zxgbs(int a, int b) {
int max = a>b? a : b;
for(long i=max; ;i+=max) {
//i能同时被a和b整除
if(i%a==0 && i%b==0) {
return i;
}
}
}
}11.银行收入计算
某银行推出了整存整取定期储蓄业务，其存期分为一年、两年、三年、五年，到期凭存单支取本息。存款年利率表如下： 存期 年利率（%） 一年 2.25 两年 2.7 三年 3.25 五年 3.6
请存入一定金额（1000起存），存一定年限（四选一），计算到期后得到的本息总额。
提示：
存入金额和存入年限均由键盘录入
本息计算方式：本金+本金×年利率×年限
import java.util.Scanner;
public class BankDemo {
public static void main(String[] args) {
//1.提示并接收用户输入的存款金额
System.out.println("请输入存款金额：");
int money = new Scanner(System.in).nextInt();
//2.提示并接收用户输入的存款年限
System.out.println("请输入存款年限：");
int year = new Scanner(System.in).nextInt();
//3.定义变量用来保存本金和利息之和
double outMoney = 0;
//4.根据利率和年限计算本息和
if (year == 1) {
outMoney = money + money * 2.25 / 100 * 1;
} else if (year == 2) {
outMoney = money + money * 2.7 / 100 * 2;
} else if (year == 3) {
outMoney = money + money * 3.25 / 100 * 3;
} else if (year == 5) {
outMoney = money + money * 3.6 / 100 * 5;
} else {
System.out.println("输入的年限有误");
}
//5.打印输出
System.out.println("存款" + year + "年后的本息是：" + outMoney);
}
}12.求税后工资问题
国家推出新的个人所得税政策，起征点上调值5000元。也就是说税前工资扣除三险一金（三险一金数额假设是税前工资的10%）后如果不足5000元，则不交税。如果大于5000元，那么大于5000元的部分按梯度交税，具体梯度比例如下：
0 ~ 3000元的部分，交税3%
3000 ~ 12000元的部分，交税10%
12000 ~ 25000的部分 ， 交税20%
25000 ~ 35000的部分，交税25%
35000 ~ 55000的部分，交税30%
55000 ~ 80000的部分，交税35%
超过80000的部分，交税45%
例如：李华入职一家企业后，税前工资是18000，则他每月该交个税的部分是18000-1800-5000=11200元，个税缴纳数额是3000×3%+8200×10%=910元。税后工资15290元。
请完成一个个税计算程序，在用户输入税前工资后，计算出他对应的纳税数额，以及税后工资为多少？
import java.util.Scanner;
public class Demo5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的税前工资：");
//2.键盘录入税前工资
int money = sc.nextInt();
//3.计算应纳税部分的工资
double before = money - (money*0.1) - 5000;
//4.定义个税变量
double shui = 0;
//5.按照梯度范围计算个税数值
if(before > 0 && before <=3000){
shui = before * 0.03;
}else if(before > 3000 && before <=12000){
shui = 3000*0.03 + (before-3000) * 0.1;
}else if(before > 12000 && before <=25000){
shui = 3000*0.03 + 9000*0.1 + (before-12000)*0.2;
}else if(before > 25000 && before <=35000){
shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + (before-25000)*0.25;
}else if(before > 35000 && before <=55000){
shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + (before-35000)*0.3;
}else if(before > 55000 && before <=80000){
shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + 20000*0.3 + (before-55000)*0.35;
}else if(before > 80000){
shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + 20000*0.3 + 25000*0.35 + (before-80000)*0.45;
}
//6.计算税后工资
double after = money - (money*0.1) - shui;
//7.打印个税和税后工资
System.out.println("个人所得税" + shui + "元");
System.out.println("税后工资" + after + "元");
}
}13.手机选号:根据用户输入的手机号来确认用户实际支付的价格
尾数为8，需支付办卡费50元；尾数为4，不需要支付费用；如果是其他尾号,需支付办卡费用20元
import java.util.Scanner;
public class Phone{
public static void main(String[] args) {
//1.提示并接收用户输入的手机号
System.out.println("请输入您预选的手机号：");
String tel = new Scanner(System.in).nextLine();//注意String类型数据一般用nextLine()
//2.调用getPrice()方法，来计算价格,注意需要把手机号tel作为参数传入方法中
getPrice(tel);
}
//3.创建getPrice()
public static void getPrice(String tel) {
//3.1 手机号tel的长度，必须是11位的正确手机号--提前校验,提高程序健壮性
if(tel.length() != 11) {
System.out.println("号码格式错误");
return;//结束方法，返回到调用位置再继续执行
}
/*比如我们拿到的手机号是tel="2313123123",想要拿到尾数,也就是最后一个字符
* 需要用到 char c = tel.charAt(10)
* 注意:由于下标也是从0开始,所以取第11个字符，它的下标位置是10
*/
//3.2获取手机号的尾数
char c = tel.charAt(10);
//3.2定义用来保存最终结果的变量price,初始值为0
int price = 0;
//3.3根据c字符的值，来为price重新赋值
switch(c) {
case '8': price=50; break;//尾数为8支付50
case '4': price=0; break;//尾数为4免费
default: price=20;//其他情况需支付20
}
//3.4显示结果
System.out.println("您实际应支付的价格为："+price);
}
}14.接收用户输入的邮箱名，获取邮箱的名字
import java.util.Scanner;
public class GetEmailName {
public static void main(String[] args) {
System.out.println("输入email:");
String e = new Scanner(System.in).nextLine();
//email地址e，传递到该方法，
//并得到方法返回的名字，保存到变量n
String n = getName(e);
System.out.println(n);
}
static String getName(String email) {
/*
* "terita@rewerwe.com"
* |
* index
*
* 1. 定位 "@" 的下标位置 index
* 2. 截取 [0, index)，直接返回
* email.indexOf("@")
* 查找指定子串的位置
* 找不到，得到特殊值 -1
* email.substring(0, index)
* 截取 [0, index)
*/
//找@的位置
int index = email.indexOf("@");
if(index == -1) {//找不到
return "邮箱格式错误";
}
//截取，直接返回截取的结果
return email.substring(0, index);
}
}15.写一个死循环(for循环/While循环/do-While循环分别写一个)
public class DeadCycle {
public static void main(String[] args) {
//for循环的死循环
// for (int i = 1; ; i++){
// System.out.println("欢迎学习泡泡的分享,继续加油哦~");
// }
//while循环的死循环
// while(true){
// System.out.println("都到这里啦?奥利给~");
// }
//do-while循环的死循环
do{
System.out.println("相信我们可以的~");
}while(true);
}
}16.鸡兔同笼(穷举法)
鸡兔共35只,共94只脚,那么鸡和兔各几只?
//穷举法
//鸡 兔
//0 35
//1 34
//2 33
//3 32
//...
//23 12
//...
//35 0
public class ChicRa {
public static void main(String[] args) {
//循环变量j,控制小鸡的个数: 0到35递增
//循环变量t,控制兔子的个数: 35到0递减
for(int j=0,t=35; j<=35; j++,t--) {//如果有多个小条件,用逗号隔开
//保证脚的数量是94
if(j*2 + t*4 == 94) {
System.out.println("鸡："+j+"， 兔："+t);
}
}
}
}17.商品录入系统
功能：菜单显示、商品信息展示、商品信息录入、商品信息查询、退出
import java.util.Scanner;
public class Product {
//成员变量
static String[] names = {"iPhoneXS","华为 Mate 20 pro","小米X","vivo NEX","oppo Find"};
static double[] price = {8999,5399,2399,4399,3999};
static int[] numbers = {50,20,80,120,90};
public static void main(String[] args) {
/*
* ----------------------
* 1. 商品列表
* 2. 商品录入
* 3. 商品查询
* 4. 统计信息
* 5. 退出
* ----------------------
* 选择：> 1
* ....
*/
//死循环显示菜单
outer:
while(true) {
//显示菜单，并获得选择的值
int c = menu();
//判断c的值
switch(c) {
case 1: f1(); break;
case 2: f2(); break;
case 3: f3(); break;
case 4: f4(); break;
case 5: break outer;
}
}
}
private static int menu() {
System.out.println("----------------------");
System.out.println("1. 商品列表");
System.out.println("2. 商品录入");
System.out.println("3. 商品查询");
System.out.println("4. 统计信息");
System.out.println("5. 退出");
System.out.println("----------------------");
System.out.print("选择：> ");
return new Scanner(System.in).nextInt();
}
private static void f1() {
/*
names
["A", "B", "C"]
price
[2, 8, 3]
numbers
[200, 300, 180]
0 1 2
1. 名称：xx，价格：xx，数量：xx
*/
for(int i=0;i<names.length;i++) {
String n = names[i];
double p = price[i];
int b = numbers[i];
System.out.println(
(i+1)+". 名称："+n+"，价格："+p+"，数量："+b);
}
}
private static void f2() {
/*
names
["A", "B", "C"]
price
[2, 8, 3]
numbers
[200, 300, 180]
0 1 2
*/
//遍历数组
for (int i = 0; i < names.length; i++) {
System.out.println("录入第"+(i+1)+"件商品：");
System.out.print("名称：");
String n = new Scanner(System.in).nextLine();
System.out.print("价格：");
double p = new Scanner(System.in).nextDouble();
System.out.print("数量：");
int b = new Scanner(System.in).nextInt();
names[i] = n;
price[i] = p;
numbers[i] = b;
}
//重新显示商品列表
f1();
}
private static void f3() {
/*
names
["A", "B", "C"]
price
[2, 8, 3]
numbers
[200, 300, 180]
0 1 2
字符串，比价是否相等，要用equals()方法
a = "aaa"
b = "aaa"
a.equals(b)
*/
System.out.print("输入查询的商品名：");
String n = new Scanner(System.in).nextLine();
//遍历数组
for (int i = 0; i < names.length; i++) {
// n 和 names[i] 相等
if(n.equals(names[i])) {
String name = names[i];
double p = price[i];
int b = numbers[i];
System.out.println(
(i+1)+". 名称："+name+"，价格："+p+"，数量："+b);
return;
}
}
//循环结束，所有商品都比较完，没有找到
System.out.println("找不到商品");
}
private static void f4() {
/*
names
["A", "B", "C"]
price
[2, 8, 3]
numbers
[200, 300, 180]
0 1 2
*/
//商品总价，单价均价，最高单价，最高总价
double spzj = 0;//商品总价
double djzj = 0;//单价总价
double zgdj = 0;//最高单价
double zgzj = 0;//最高总价
//遍历数组
for (int i = 0; i < names.length; i++) {
spzj += price[i] * numbers[i];
djzj += price[i];
//数组中，找到更大的值
if(price[i] > zgdj) {
zgdj = price[i];//更大值存到这个变量
}
if(price[i]*numbers[i] > zgzj) {
zgzj = price[i]*numbers[i];
}
}
System.out.println("商品总价："+spzj);
System.out.println("单价均价："+(djzj/names.length));
System.out.println("最高单价："+zgdj);
System.out.println("最高总价："+zgzj);
}
}18.阶乘(for循环)
需求:接收用户输入的数字,打印输出该数字的阶乘结果
提示：负数不可以有阶乘,0的阶乘结果是1, 5 ! = 5 x 4 x 3 x 2 x 1
import java.util.Scanner;
public class Factorial {
public static void main(String[] args) {
System.out.print("输入整数，求阶乘：");
int n = new Scanner(System.in).nextInt();
//调用f()方法，把n的值传递到f()方法，求阶乘
f(n);
}
public static void f(int n) {
if(n<0) {
System.out.println("负数不可以求阶乘");
return;//方法结束，返回到调用位置继续执行
}
if(n == 0) {
System.out.println("0的阶乘是1");
return;
}
/*
* r = 5
* i
* 4, r=r*i
* 3, r=r*i
* 2, r=r*i
* 1, r=r*i
*/
long r = n;
for(int i=n-1; i>=1; i--) {
r *= i;
}
System.out.println(n+"的阶乘："+r);
}
}19.多次生成随机数,并打印第一次出现大于0.999 时的次数与生成的随机数
public class MathRan {
public static void main(String[] args) {
// Math.random()可以产生[0,1)的随机浮点数
// >0.999
//写一个死循环, i变量用来计次
for(int i=1; ;i++) {
double d = Math.random();
if(d>0.999) {
System.out.println("第"+i+"次产生了目标值,值为:"+d);
break;
}
}
}
}20.打印100以内除了尾数为3,5,7的所有数
public class ForContinue {
public static void main(String[] args) {
for(int i=1;i<=100;i++) {
int y = i%10;//100以内的数,通过取余求出尾数
if(y==3 || y==5 || y==7) {
continue;//如果尾数为3 5 7 ,则跳过后面的打印,进行下一轮循环
}
System.out.println(i);
}
}
}
21.求质数:接收用户输入的数字,判断是否为质数
质数:一个大于1的自然数,除了1和它自身外,不能被其他自然数整除
规定:1既不是质数,也不是合数
import java.util.Scanner;
public class PrimeNumber {
public static void main(String[] args) {
System.out.print("请输入要判断的自然数：");
int n = new Scanner(System.in).nextInt();
//调用getPrimeNumber()方法，判断n是否为质数
getPrimeNumber(n);
}
public static void getPrimeNumber(int n) {
if(n<2) {//此范围内的数均不为质数
System.out.println(n+"不是质数");
return;//结束程序
}
if(n == 2) {
System.out.println("2是质数");
return;
}
//在 2到 1+n开方范围(数学理论)，找能把n整除的值(这个值也称作因子)
//如果找到可以把n整除的第三个数，那n就不是质数,反之,n为质数
double max = 1+ Math.sqrt(n);//max保存的是查找因子的范围
//依次遍历范围内的所有数,验证是否存在n的因子
for(int i=2; i<max; i++) {
//判断n能不能被i整除,如果有,说明不是质数
if(n%i == 0) {
System.out.println(n+"不是质数");
return;
}
}
//如果判断了范围内的所有值，没有能整除的,则说明n是质数
System.out.println(n+"是质数");
}
}22.接收用户输入的数字,判断在此范围内质数的个数
import java.util.Scanner;
public class CountPrimeNumber {
public static void main(String[] args) {
System.out.println("输入整数n，求n内质数的数量");
int n = new Scanner(System.in).nextInt();
count(n);
}
public static void count(int n) {
if(n<2) {
System.out.println("没有质数");
return;
}
if(n==2) {
System.out.println("有1个质数");
return;
}
//定义计数变量
int count = 1;//已知有一个质数
outer: //从3到n寻找质数
for(int i=3; i<=n ;i++) {
//判断i是否是质数
double max = 1+ Math.sqrt(i);
for(int j=2; j<max; j++) {//在2到<max，找能把i整除的数
if(i%j == 0) {//i被j整除，i不是质数
//跳到i++，继续判断下一个i值
continue outer;//跳到外部outer的位置
}
}
//内层j循环结束，i是质数
count++;
}
System.out.println(n+"内质数的数量："+count);
}
}23.生成一个顺序数组,将这个数组的元素打乱顺序后输出
import java.util.Arrays;
import java.util.Random;
public class ShuffleArray {
//方法一
public static void main(String[] args) {
//调用f()方法，从方法获取一个int[]数组
int[] a = f();
//遍历打印数组数据
for(int i=0; i<a.length; i++) {
System.out.println(a[i]);
}
System.out.println("\n\n----------------");
//把a数组，传递到 shuffle() 方法打乱顺序
shuffle(a);
//打印乱序后的数组
System.out.println(Arrays.toString(a));
}
public static int[] f() {
//新建int[]数组，长度5
//再把它的内存地址存到变量 a
int[] a = new int[5];
//遍历访问5个位置，填入1,2,3,4,5
for(int i=0; i<a.length; i++) {
a[i] = i+1;
}
//返回数组，把数组返回到调用位置
//本质是把数组地址返回去
return a;
}
public static void shuffle(int[] a) {
/*
* j
* [4, 2, 3, 1, 5]
* i
*
* *) i循环遍历数组
* *) 随机定位下标j与i交换
*/
for (int i = 0; i < a.length; i++) {
//随机下标j，范围：[0, a.length)
int j = new Random().nextInt(a.length);
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
//方法二
public static void main(String[] args) {
int[] a=new int[10];//先创建一个大小为10的数组
//用循环先给数组赋值，得到一个顺序数组
for(int i=0;i<a.length;i++) {
a[i]=i;
}
//输出打乱前的数组
System.out.println("打乱前的数组："+Arrays.toString(a));
System.out.println("-------------------");//分割线
//再用随机数来实现这个打乱的操作
for (int i = 0; i < a.length; i++) {
int j=new Random().nextInt(a.length);
//random().nextInt(int n);返回的是[0，n)的范围的随机数
//用范围为[0,a.length)的随机数j作下标与a[i]进行交换操作，达到打乱的效果
int t=a[i];
a[i]=a[j];
a[j]=t;
}
//输出打乱后的数组
System.out.println("打乱后的数组："+Arrays.toString(a));
//Arrays.toString(数组名)，这个方法是用来将数组转换成String类型输出的
}
}24.打印全三角形
需求:接收用户输入的行数,打印对应的全三角形
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
//1.提示并接收用户输入的行数:
System.out.println("请输入您要打印星星的行数:");
int n = new Scanner(System.in).nextInt();
//2.开始打印图形
//2.1外层循环控制打印的行数 i的取值范围:[1,n],一共n行
for(int i=1;i<=n;i++){
//2.2内层循环1
//控制每行打印空格的个数 j的取值范围:[0,n-i),即1 2 3...
for(int j=0;j<n-i;j++){
System.out.print(" ");
}
//2.3内层循环2
//控制每行打印星星的个数 k的取值范围:[1,2*i-1],即1 3 5 ...
for(int k=1;k<=2*i-1;k++){
System.out.print("*");
}
//2.4打印完本行所有内容后添加换行
System.out.println();
}
}
}25.体彩中有一项是双色球，要求在1-33号共33个红色球里选出6个，1-16号共16个蓝色球中选出一个作为中奖号码
import java.util.Arrays;
import java.util.Random;
public class ColorBall {
public static void main(String[] args) {
//准备两个号码数组
int[] r = zbsz(33);//[1,2,3,4,5....33]
int[] b = zbsz(16);//[1,2,3...16]
System.out.println(Arrays.toString(r));
System.out.println(Arrays.toString(b));
//选择红球
int[] red = selectRed(r);
//选择蓝球
int blue = selectBlue(b);
System.out.println("红球："+Arrays.toString(red));
System.out.println("蓝球："+blue);
}
private static int[] zbsz(int n) {//准备数组的方法
//新建n个长度的int[]数组，存到a
int[] a = new int[n];
//遍历a数组，填入1到n
for (int i = 0; i < a.length; i++) {
a[i] = i+1;
}
//返回数组
return a;
}
private static int[] selectRed(int[] r) {//选择红球
/*
* j
* r [10, 5, 1, 4, 2, 6, 7, 8, 9, 3, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33]
* i
*
* [i, r.length)
* i+ [0, r.length-i)
*/
//i循环从0到<6
for (int i = 0; i < 6; i++) {
//j随机定位
int j =
i+ new Random().nextInt(r.length-i);
int t = r[i];
r[i] = r[j];
r[j] = t;
}
//截取前6个位置，生成一个新数组返回
return Arrays.copyOf(r, 6);
}
private static int selectBlue(int[] b) {//选择蓝球
return b[new Random().nextInt(16)];
}
}26.求任意自然数各位数之和
import java.util.Scanner;
public class SumNum {
public static void main(String[] args) {
//1.提示并接收用户要计算的自然数:
System.out.println("请输出您要求和的自然数:");
int n = new Scanner(System.in).nextInt();
//2.定义一个变量用来保存最终求和的结果
int sum=0;
//3.循环获取每一位上的数
while(n!=0){
//4.求当前的个位数,并将个位数累加
sum = sum + (n%10);
//5.去掉刚刚累加过的最后一位数,得到新的整数
//比如刚刚的十位就变成了现在的个位
n=n/10;
}
//6.打印最终的结果:
System.out.println(sum);
}
}27.求任意数组中所有元素的最大值
public class GetArrayMaxNum {
public static void main(String[] args) {
//1.定义一个数组
int[] arr={90,1562,43,2,44,8,6666};
//2.选取数组中的第一个元素开始比较
int max=arr[0];
//3.依次遍历数组中的每个元素
for(int i=1;i<arr.length;i++){//i指的是下标,我们通过下标来操作数组中的元素
//4.判断当前元素与目前最大值的大小
if(arr[i]>max){
//5.如果当前数组元素大于max,就讲此元素的值赋值给max
max=arr[i];
}
}
//6.打印最终的结果
System.out.println(max);
}
}28.求1000以内的完数
如果一个数等于其所有因子之和,我们就称这个数为"完数",比如6的因子为1,2,3 6 = 1 + 2 + 3,那么6就是一个完数
public class GetNum {
public static void main(String[] args) {
//1.循环遍历1000以内的所有数
for(int i=1;i<=1000;i++){
//2.定义一个变量来保存求和的结果
int sum = 0;
//3.求i的因子
for(int j=1;j<=i/2;j++){
//4.判断是否能被整除
if(i % j == 0){
//5.如果能整除,就是因子,因子需要累加
sum+=j;
}
}
//6.如果因子累加之和为本轮判断的数,则当前数是完数,输出
if(sum==i){
System.out.println(i);
}
}
}
}29. 随机数组的归并:生成两个任意的随机数组，并将这两个数组按照数字大小按顺序归并到一个新数组中
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class MergingArrays {
public static void main(String[] args) {
int[] a = suiJi();
int[] b = suiJi();
Arrays.sort(a);
Arrays.sort(b);
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
int[] c = heBing(a, b);
System.out.println(Arrays.toString(c));
}
private static int[] suiJi() {
int n = 5+ new Random().nextInt(6);
int[] a = new int[n];
for (int i = 0; i < a.length; i++) {
a[i] = new Random().nextInt(100);
}
return a;
}
private static int[] heBing(int[] a, int[] b) {
/*
* a[1,1,2,3,4]
* j
* b[1,2,4,5,6,8,9]
* k
*
* c[ ]
* i
*/
//新建数组
int[] c = new int[a.length+b.length];
//对新数组遍历
for(int i=0,j=0,k=0;i<c.length;i++) {
if(j>=a.length) {//j越界，b数组数据一个一个放入新数组
//c[i] = b[k];
//k++;
//continue;
System.arraycopy(b,k,c,i,b.length-k);
break;
} else if(k>=b.length) {//k越界,a数组数据一个个放入新数组
//c[i] = a[j];
//j++;
//continue;
System.arraycopy(a,j,c,i,a.length-j);
break;
}
//j和k，较小值放入i位置，并递增
if(a[j]<=b[k]) {
c[i] = a[j];
j++;
} else {
c[i] = b[k];
k++;
}
}
return c;
}
}30.15个猴子围成一圈选大王,依次1-7循环报数,报到7的猴子被淘汰,直到最后一只猴子称为大王,问:哪只猴子会成为大王?
/**猴子选大王*/
public class MonkeyKing {
public static void main(String[] args) {
//1.定义长度为15的数组保存猴子,boolean类型是为了判断猴子是否存活
boolean[] b=new boolean[15];
//2.依次遍历每一只猴子
//true---未淘汰 false---已淘汰
for(int i=0;i<b.length;i++){
b[i]=true;//先把所有猴子设置成存活
}
//3.定义变量保存猴子报的数
int num=0;
//4.定义变量保存剩余的猴子数
int monkeyLeft=15;
//5.定义数组下标
int index=0;
//6.循环,直到只剩最后一只猴子(猴子王)
while(monkeyLeft>1){//判断条件
//7.检测猴子是否已淘汰
if(b[index]){
//8.报数
num++;
//9.判断报数是否为7
if(num==7){
b[index]=false;//为7淘汰
monkeyLeft--;//猴子数减一
num=0;//报数归零
}
}
//10.下标移动
index++;
//11.围成一圈---最后一个置为0
if(index==15){
index=0;
}
}
//遍历数组,找到最后活着的那个猴子王
for(int i=0;i<b.length;i++){
if(b[i]){
System.out.println(i+1);
}
}
}
}31.斐波那契
斐波那契数列的前几个数分别为0,1,1,2,3,5…从第三项开始,每一项都等于前两项的和.请接收用户输入的整数n,求出此数列的前n项
import java.util.Scanner;
/**斐波那契数列*/
public class Faibonacci {
public static void main(String[] args) {
System.out.println("请输入您要测试的数:");
int n = new Scanner(System.in).nextInt();
//判断n是否是不正常的范围
if(n<1){
System.out.println("输入数据有误！！！");
}
//n==1
if(n==1){
System.out.println(0);
}
//n==2
if(n==2){
System.out.println(0+"\t"+1);
}
//n==3
if(n==3){
System.out.println(0+"\t"+1+"\t"+1);
}
//拼接前n项
if(n>3){
System.out.print(0+"\t"+1+"\t"+1+"\t");
}
//循环输出后面的数据
int f1=1;
int f2=1;
int next=0;
for(int i=4;i<=n;i++){
next=f1+f2;
f1=f2;
f2=next;
System.out.print(next+"\t");
}
}
}32.回文数
打印5位数中的所有回文数，每行打印10个数。最后统计一下一共有多少个5位回文数
注：回文数即正反读都是一个数，5位数的话，只要个位与万位相同，十位与千位相同就是一个回文数
public class JavaBasic01 {
public static void main(String[] args) {
/*
//打印所有的5位回文数 ≠ 判断一个数是否是回文数
int count = 0;
//Dig_1表示个位数字，Dig_2表示十位数字，Dig_3表示百位数字
for (int Dig_1 = 1;Dig_1 < 10;Dig_1 ++)
for (int Dig_2 = 0;Dig_2 < 10;Dig_2 ++)
for (int Dig_3 = 0;Dig_3 < 10;Dig_3 ++){
System.out.print(Dig_1 + "" + Dig_2 + "" + Dig_3 + "" + Dig_2 + "" +Dig_1 + " ");
count ++;
if (count % 10 == 0)
System.out.println();
}
System.out.print("5位回文数的个数是：" + count + "个");
*/
//另外给出 判断输入的数是否是回文数的算法
Scanner input = new Scanner(System.in);
System.out.print("请输入需要判断的数(位数不限):");
int n = input.nextInt();
boolean flag = true;
//或者采用num%10、num/10的循环方式，将其存入int型数组
String s = Integer.toString(n); //将输入的正整数转换成字符串
char arr[] = s.toCharArray(); //将字符串存入字符数组
for (int i = 0;i < arr.length / 2 ; i ++)
if (arr[i] != arr[arr.length - i - 1]) { //数组中从左向右数第i个数对应从左向右数第arr.length - i - 1个数(从右向左为第i个数)
flag = false;
System.out.print("您输入的数不是回文数！");
break;
}
if (flag)
System.out.print("您输入的数是回文数！");
input.close();
}
}33.求成绩（if/switch）
键盘录入一个学生成绩（用int表示），自动输出该同学的成绩评级。
学生的分数取值范围[0,100]
分数大于等于90的，评级"优秀"；
分数大于等于80，小于90的，评级"良好"；
分数大于等于70，小于80的，评级"中等"；
分数大于等于60，小于70的，评级"及格"；
分数小于60的，评级"不及格"
public class JavaBasic03 {
public static void main(String[] args) {
System.out.print("请输入该学生的成绩:");
Scanner input = new Scanner(System.in);
double score = input.nextDouble();
/*
//采用 if多分支方法求求解
if(score < 60)
System.out.print("该同学的成绩评级为：不及格");
else if (score < 70)
System.out.print("该同学的成绩评级为：及格");
else if (score < 80)
System.out.print("该同学的成绩评级为：中等");
else if (score < 90)
System.out.print("该同学的成绩评级为：良好");
else if (score <= 100)
System.out.print("该同学的成绩评级为：优秀");
else
System.out.print("您输入的学生成绩有误！");
*/
//采用switch来做
switch ((int) (score / 10)) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.print("该同学的成绩评级为：不及格");
break;
case 6:
System.out.print("该同学的成绩评级为：及格");
break;
case 7:
System.out.print("该同学的成绩评级为：中等");
break;
case 8:
System.out.print("该同学的成绩评级为：良好");
break;
case 9:
System.out.print("该同学的成绩评级为：优秀");
break;
default:
if (score == 100) //只有100是优秀，101则是输入错误，故不可以用case 10来判断
System.out.print("该同学的成绩评级为：优秀");
else
System.out.print("您输入的学生成绩有误！");
}
input.close();
}
}34.求素数
判断101-200之间有多少个素数，并输出其中所有素数。
注：素数即是除了1和它本身以外不再有其他因数的自然数。程序中可以用这个数，遍历除以2到这个数减去1。如果能够被整除，则表明此数不是素数，反之是素数。
public class JavaBasic05 {
public static void main(String[] args) {
//另解：按照题目的提示：用这个数，遍历除以2到这个数减去1。如果能够被整除，则表明此数不是素数，反之是素数。
//下面采用的解题思路：如果一个数能被小于等于此数平方根的素数整除，则此数不是素数，否则是素数
//1不是素数，2是素数
Scanner input = new Scanner(System.in);
System.out.print("请输入判断区间的下界(不包括此数)：");
int min = input.nextInt();
System.out.print("请输入判断区间的上界(不包括此数)：");
int max = input.nextInt();
//法一和法二的ArrayList集合定义
//List<Integer> prime = new ArrayList<Integer>(); //使用ArrayList集合可以很方便的直接在集合后面添加素数，而使用数组则需要找出数组中填写的最后一个元素的位置
//prime.add(2); //最小的素数是2
//法一法二主要一步是控制输出大于下界的素数，而不是全部素数。也可以在for循环中直接设置，不用设置其他变量较为发杂的做法。（思路见法三）
/*
//法一：通过定义标签找出第一个大于下界的数在ArrayList集合中的位置，从而使输出的素数均大于下界
boolean first = true; //用于判断是否是第一个大于下界的数
int k = 0,count = 0;
for (int i = 3;i < max;i ++){
boolean flag = true;
for (int j = 0;j < prime.size();j ++) { //如果一个数能被小于此数的素数整除，则此数不是素数，否则是素数
if (i % prime.get(j) == 0) {
flag = false;
break;
}
}
if (flag) {
prime.add(i);
if (i > min) {
count ++;
if (first) {
first = false;
k = prime.indexOf(i);
}
}
}
}
System.out.print("在此区间内(不包括区间的头尾两数)的素数是： ");
for (;k <prime.size();k ++)
System.out.print(prime.get(k) + " ");
System.out.print("\n数量是：" + count);
*/
/*
//法二：通过两个计数器找出第一个大于下界的数在ArrayList集合中的位置，从而使输出的素数均大于下界
int countAll = 0,countInterval = 0;//countAll用于统计最大值以前素数的个数, countInterval用于统计判断区间内的素数个数
for (int i = 3;i < max;i ++){
boolean flag = true;
for (int j = 0;j < prime.size();j ++) {
if (prime.get(j) > Math.sqrt((double)i)) //如果一个数能被小于等于此数平方根的素数整除，则此数不是素数，否则是素数
break;
if (i % prime.get(j) == 0 ) {
flag = false;
break;
}
}
if (flag) {
countAll ++; //最大值以前素数的个数加1
prime.add(i);
if (i > min) {
countInterval ++; //区间内的素数个数加1
}
}
}
System.out.print("在此区间内(不包括区间的头尾两数)的素数是： ");
for (int k = countAll - countInterval;k <prime.size();k ++)
System.out.print(prime.get(k) + " ");
System.out.print("\n数量是：" + countInterval);
*/
//使用数组来求
/*一维数组的三种声明方法：
数据类型 [ ] 数组名 = new 数据类型 [ 长度 ] ;
数据类型 [ ] 数组名 = { 数据，数据，…，数据 } ;
数据类型 [ ] 数组名 = new 数据类型 [ ] { 数据，数据，…，数据 };
*/
//此时输出数组，数组中元素的初始值(默认值)为false
boolean [] prime = new boolean[max] ; //创建大小为max的数组,数组最大数是max-1。数组的下标表示数，其中的内容表示此数是否是素数
//下面的这种方法错误！这种形式不能用于赋值操作！
//for (boolean element : prime) //数组的循环遍历，只能从左到右一次遍历数组中的所有元素
// element = true; //初始化数组元素为true
for (int k = min + 1;k < max ;k ++) //此时prime[min]为false，即min初始化为不是素数
prime[k] =true;
prime[0] = prime[1] = false; //0和1不是素数，2是素数
for (int i = min;i < max ;i ++) //直接将for中的i初始化为 min （若是素数则设置为false，不是则按照初始化的值为flase，结果相同）或者初始化为min + 1（从min + 1位开始检测）
for (int j = 2 ; j <= Math.sqrt((double) i) ;j ++)
if (i % j == 0) {
prime[i] = false;
break;
}
int count = 0;
System.out.print("在此区间内(不包括区间的头尾两数)的素数是： ");
for (int k = 0;k < max ;k ++)
if (prime[k] == true) {
//或者上面第一个for循环中设置k初始值为0，即设置prime数组中的所有元素为true（除0、1），第二个for循环中设置i初始值为3，即这两个for循环常规写法
//然后将上面这个if语句写成 if (prime[k] == true && k > min),在输出的时候检测是否大于下界
count ++;
System.out.print(k + " ");
}
System.out.print("\n数量是：" + count);
input.close();
}
}35.给20块钱买饮料，每瓶饮料3块钱，喝完之后退瓶子可以换回1块钱。问最多可以喝到多少瓶饮料？
public class JavaBasic24 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("您现在有多少钱（元）？");
int money =input.nextInt();
int bottleNum = 0,bottleNumAll = 0; //bottleNum记录暂时的瓶子数，bottleNumAll记录总共的瓶子数，即输出的结果
while (money >= 3) { //剩下的钱不够买饮料的
bottleNum = money / 3 ; //第一步：买20 / 3 =6瓶饮料 //第四步：买8 / 3 =2瓶饮料 //第六步：买4 / 3 =1瓶饮料
bottleNumAll += bottleNum;
money = money - bottleNum *3 +bottleNum; //第二步：还剩20 - 18 +6 =8元 //第五步：还剩8 - 6 +2 =4元 //第七步：还剩4 - 3 + 1 =2元
}
System.out.print("您一共可以购买 " + bottleNumAll + " 瓶饮料。");
input.close();
}
}36.打印出1-100之间所有不是7的倍数和不包含7的数字， 并求和
public class JavaBasic27 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入判断区间的上界(不包括此数)：");
int max = input.nextInt();
int sum = 0;
//因为知道上界是三位数，也可以分别求出 个、十、百 位置上的数字 于 7 进行比较
//下面采用求素数的思想
boolean[] arr = new boolean[max];
for (int i = 0;i < arr.length;i ++)
arr[i] = true;
for (int j = 7;j < max;j ++) {
if (j % 7 == 0) //去掉是7的倍数的数
arr[j] = false;
else {
int temp = j;
while (j != 0) {
if (j % 10 == 7) //去掉包含7的数字
arr[temp] = false;
j /= 10;
}
j = temp;
}
}
for (int k = 1;k < arr.length;k ++)
if (arr[k]) {
System.out.print(k + " ");
sum += k;
}
System.out.println();
System.out.print("1 - " + max + " 之间所有不是7的倍数和不包含7的数字 之和是：" + sum);
input.close();
}
}37.输入年份和月份，输出这个月应该有多少天（使用switch结构，考虑平年和闰年)
public class JavaBasic29 {
public static void main(String[] args) {
//闰年是指能被4整除，但是不能被100整除的年份 或者 能被400整除的年份
//平年2月有28天，闰年2月有29天
Scanner input = new Scanner(System.in);
System.out.print("请输入年份和月份:");
int year = input.nextInt();
int month = input.nextInt();
int day = 28;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
day = 31;
break;
case 2:
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
day = 29;
break;
case 4:
case 6:
case 9:
case 11:
break;
}
System.out.print("在 " + year + " 年 " + month + " 月一共有 " + day + " 天。");
input.close();
}
}38.随机给十个数字，对它们进行排序。（可以给一个有10个整数元素的数组，然后对数组排序）
public class JavaExtend03 {
//输出数组中的元素
public static void print(int[] arr) { //这里一定要是static
for (int i = 0;i < arr.length;i++)
System.out.print(arr[i] + " ");
System.out.println();
}
//获取一个打乱的数组
public static int[] getRandomArr(int num) {
int[] arr = new int[num];
for (int i = 0;i < arr.length;i ++)
arr[i] = new Random().nextInt(arr.length);
return arr;
}
//1、对数组中的元素进行 直接插入排序
public static void Insertsort(int[] arr) { //这里一定要是static
if (arr.length >= 2) { //数组长度为1时，没有必要进行排序
//不采用哨兵，数组中元素从0位置开始存放，如果采用哨兵，数组中元素从1位置开始存放，则arr[0]为哨兵
for (int i = 1; i < arr.length; i++) { //从数组的第二个元素开始处理
int x = arr[i]; //用x存放现在处理的数据，以便后面进行数据的插入操作。
int j = i -1 ;
for (;j >= 0 && arr[j] > x;j --) //将待处理的元素与这一元素前面的元素进行比较，这里循环中的x不可以写成arr[i],因为此时arr[i]上的元素可能已经变化，不是原来的值
arr[j + 1] = arr[j]; //进行数据的移动操作
arr[j + 1] = x; //将处理的这个元素插入到合适的位置
}
}
}
//2、对数组中的元素进行 冒泡排序
public static void Bubblesort(int[] arr) {
for (int i = 0;i < arr.length - 1 ;i ++) {
boolean flag = false; //表示本趟冒泡是否发生交换的标志
for (int j = arr.length - 1 ;j > i ;j --) //一趟冒泡过程
if (arr [j - 1] > arr [j]) { //若为逆序
//swap (arr[j-1],arr[j]) 交换
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
flag = true;
}
if (flag == false) //本趟遍历后没有发生交换，说明表已经有序
break; //或者return;
}
}
//3、对数组中的元素进行 快速排序
public static void Quicksort(int[] arr,int low,int high) {
if (low < high){ //递归跳出的条件
int pivotpos = Partition(arr,low,high); //划分
Quicksort(arr,low,pivotpos - 1);
Quicksort(arr,pivotpos + 1 ,high);
}
}
//划分元素操作，将表arr[low...high]划分为满足上述条件的两个子表
public static int Partition(int[] arr,int low,int high) { //一趟划分
int pivot = arr[low]; //设当前表中第一个元素为枢轴，对表进行划分
while(low < high) { //循环跳出条件
while (low < high && arr[high] >= pivot) --high;
arr[low] = arr[high]; //将比枢轴小的元素移动到左端
while (low < high && arr[low] <= pivot) ++low;
arr[high] = arr[low]; //将比枢轴大的元素移动到右端
}//while
arr[low] = pivot; //枢轴元素存放到最终位置
return low; //返回存放枢轴的最终位置
}
//4、对数组中的元素进行 简单选择排序
public static void Selectsort(int[] arr) {
for (int i = 0; i < arr.length - 1 ;i ++){ //一共进行 n - 1 趟
int min = i; //记录最小元素位置
for (int j = i + 1 ;j < arr.length;j ++) //在arr[i...n-1]中选择最小的元素
if (arr[j] < arr[min])
min = j; //更新最小元素位置
if (min != i) {
//swap (arr[i],arr[min]) 交换
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}
//5、对数组中的元素进行 归并排序
public static void Mergesort(int[] arr,int low,int high) {
if (low < high){ //递归跳出的条件
int mid = (low + high) / 2; //从中间划分两个子序列
Mergesort(arr,low,mid); //对左侧子序列进行递归排序
Mergesort(arr,mid+1,high); //对右侧子序列进行递归排序
Merge(arr,low,mid,high); //归并
}
}
//Merge（）的功能是将前后相邻的两个有序表归并为一个有序表。
//设两段有序表arr[low...mid]、arr[mid+1...high]存放在同一顺序表中的相邻位置，先将它们复制到辅助数组temp中。
//每次从对应temp数组中的两个段取出一个记录进行关键字比较，将较小者放入arr中，
//当辅助数组temp中有一段的下标超出其对应的表长（即该段的所有元素都已经复制到数组arr中）时，将另一段中的剩余部分直接复制到arr数组中。
public static void Merge(int[] arr,int low,int mid,int high) {
//表arr的两段A[low...mid]和arr[mid+1...high]各自有序，将它们合并成一个有序表
//Java中没有malloc对内存进行直接操作的函数，直接使用new来申请。
int[] temp = new int[arr.length+1]; //创建一个辅助数组temp
int i,j,k;
for (k = low;k <= high; k ++)
temp[k] = arr[k]; ///将arr中所有元素复制到temp中
for (i =low,j = mid + 1,k = i;i <= mid && j <= high ;k ++) {
if (temp[i] <= temp[j]) //比较temp的左右两段中的元素
arr[k] = temp[i++]; //将较小值复制到arr数组中
else
arr[k] = temp[j++];
}//for
//下面的两个while循环只有1个会执行
while (i <= mid)
arr[k++] = temp[i ++]; //若第一个表未检测完，复制
while (j <= high)
arr[k++] = temp[j++]; //若第二个表未检测完，复制
}
//测试
public static void main(String[] args) {
int[] arr = getRandomArr(10);
System.out.print("直接插入排序后：");
Insertsort(arr);
print(arr);
System.out.print("冒泡排序后：");
Bubblesort(arr);
print(arr);
System.out.print("快速排序后：");
Quicksort(arr,0,arr.length - 1);
print(arr);
System.out.print("简单选择排序后：");
Selectsort(arr);
print(arr);
System.out.print("归并排序后：");
Mergesort(arr,0,arr.length - 1);
print(arr);
//也可以采用Arrays.sort(arr)对数组进行排序
//或者采用Arrays.sort(arr,int fromIndex, int toIndex)对数组的下标从fromIndex 到 toIndex - 1进行排序，toIndex元素不参与排序。
}
}39.有一个已经排好序的int数组{1, 2, 3, 4, 5, 6, 7, 8} 。现输入一个数（要求该数在1-8之间），按原来的规律将它插入数组中。
public class JavaExtend04 {
//JavaBasic03中的getRandomArr(int num)方法进行部分修改
public static int[] getRandomArr(int num , int digit) {
int[] arr = new int[num + 1]; //将数组的元素设置成num + 1，因为后面还要插入一个元素，设置成num会出现java.lang.ArrayIndexOutOfBoundsException：数组越界错误
int i = 0;
for (;i < num;i ++)
arr[i] = new Random().nextInt(arr.length); //数组中前面的 num 个数随机生成，后面一个数用户输入或者随机生成，数组中一共 num +1 个数。
arr[i] = digit;
return arr;
}
//JavaBasic03中的Insertsort(int[] arr)方法进行部分修改
//1、对数组 前面的num个 元素 进行 直接插入排序
public static void Insertsort(int[] arr ,int length) { //这里一定要是static
if (length >= 2) { //数组长度为1时，没有必要进行排序
//不采用哨兵，数组中元素从0位置开始存放，如果采用哨兵，数组中元素从1位置开始存放，则arr[0]为哨兵
for (int i = 1; i < length; i++) { //从数组的第二个元素开始处理
int x = arr[i]; //用x存放现在处理的数据，以便后面进行数据的插入操作。
int j = i -1 ;
for (;j >= 0 && arr[j] > x;j --) //将待处理的元素与这一元素前面的元素进行比较，这里循环中的x不可以写成arr[i],因为此时arr[i]上的元素可能已经变化，不是原来的值
arr[j + 1] = arr[j]; //进行数据的移动操作
arr[j + 1] = x; //将处理的这个元素插入到合适的位置
}
}
}
//JavaBasic03中的print(int[] arr)方法进行部分修改
//输出数组中的前length个元素
public static void print(int[] arr,int length) { //这里一定要是static
for (int i = 0;i <length;i++)
System.out.print(arr[i] + " ");
System.out.println();
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//或者采用Random r = new Random(); int digit = r.nextInt(10); 效果一样的
int digit = new Random().nextInt(10); //要求插入的数据随机生成
System.out.print("请输入已经排好序的int数组的元素数：");
int num = input.nextInt(); //表示已经排好序的int数组的元素数
//使用数组做，手动将数组移位
int[] arr = getRandomArr(num , digit); //数组中的元素随机生成
//当待排序的元素数目n较小时，采用直接插入排序或简单选择排序更好
System.out.print("已经排好序的初始int数组是：");
Insertsort(arr,num);
print(arr ,num);
//下面采用 直接插入排序 的思想
//也可以将待插入的数字，放在数组的末尾，再次将整个数组进行排序，因为此时数组基本有序，故采用直接插入排序效率较高。
int i = arr.length - 2;
for (;arr[i] > digit;i --) //将待处理的元素与这一元素前面的元素进行比较
arr[i + 1] = arr[i]; //进行数据的移动操作
arr[i + 1] = digit; //将处理的这个元素插入到合适的位置
System.out.print("将 " + digit + " 加入已经排好序的int数组后：");
JavaExtend03.print(arr);
input.close();
//也可以采用Arrays类中的sort()方法对数组进行排序，
}
}40.给出一个int数组，把它最大的元素与第一个元素交换，最小的元素与最后一个元素交换，输出交换后的数组。
public class JavaExtend05 {
//交换函数，与JavaBasic22中四、利用数组完全一样。
//定义为静态方法
//如果不定义为静态方法，则在主函数中需要依赖于对象，需要通过对象来调用
public static void swap(int[] arr,int num1,int num2){
int temp = arr[num1];
arr[num1] = arr[num2];
arr[num2] = temp;
}
//本题的关键在于找出给出的int数组的最大元素和最小元素
public static void main(String[] args) {
int num = new Random().nextInt(10); //数组元素的个数随机生成（10以内）
int[] arr = JavaExtend03.getRandomArr(num); //获取一个长度随机，元素内容随机的数组
System.out.print("随机生成的int数组是：");
JavaExtend03.print(arr);
int min = 0,max = 0; //min 和 max 分别是数组中最小值的下标和最大值的下标
for (int i = 0;i < arr.length;i ++) {
if (arr[i] < arr[min])
min = i; //因为最后还要交换最大值与第一个元素，最小值与最后一个元素，故要知道最小值和最大值的下标
if (arr[i] > arr[max])
max = i;
}
System.out.println("数组中的最大值是 " + arr[max] + ",最小值是 " + arr[min]);
//将题目中的交换理解为：先将数组中最大元素与第一个元素交换，然后再将第一次交换后的数组中的最小元素与此时的最后一个元素交换
swap(arr,0,max);
if (min == 0)
swap(arr,arr.length-1,max);
else
swap(arr,arr.length-1,min);
System.out.print("交换后的int数组是：");
JavaExtend03.print(arr);
}
}41.购物
某商场购物可以打折，具体规则如下：
普通顾客购不满100元不打折，满100元打9折；
会员购物不满200元打8折，满200元打7.5折；
不同打折规则不累加计算。
请根据此优惠计划进行购物结算，键盘录入顾客的类别（0表示普通顾客，1表示会员）和购物的折前金额（整数即可），输出应付金额（小数类型）。
//1.导包
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
// 2.创建键盘录入对象
Scanner sc = new Scanner(System.in);
// 3.调用方法获取键盘录入的顾客类别和购物金额
System.out.println("请输入顾客类别（0表示普通顾客，1表示会员顾客）：");
int type = sc.nextInt();
System.out.println("请输入购物金额：");
int money = sc.nextInt();
// 4.先判断顾客类别
if (type == 0) {
// 4.1.普通顾客，再判断购物金额
if (money > 0 && money < 100) {
System.out.println("您的应付金额为：" + money);
} else if (money >= 100) {
System.out.println("您的应付金额为：" + money * 0.9);
} else {
System.out.println("您输入的金额有误");
}
} else if (type == 1) {
// 4.2.会员顾客，再判断购物金额
if (money > 0 && money < 200) {
System.out.println("您的应付金额为：" + money * 0.8);
} else if (money >= 200) {
System.out.println("您的应付金额为：" + money * 0.75);
} else {
System.out.println("您输入的金额有误");
}
} else {
System.out.println("您输入的顾客类别有误");
}
}
}42.创建一个长度为6的整数数组，数组中有六个整数(直接赋值即可)。遍历数组中的每个元素，元素之间用空格隔开
public class Test1 {
public static void main(String[] args) {
int [] arr={1,2,3,4,5,6};//定义整数类型数组
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+"\t");
}
}
}43.现有一个小数数组{12.9,53.54,75.0,99.1,3.14};找出数组中的最小值并打印
/* 1. 数组的元素是小数，需要定义小数类型数组。
2. 找最小值和找最大值的思路是一样的。*/
public class Test2 {
public static void main(String[] args) {
double[] arr={12.9,53.54,75.0,99.1,3.14};//定义一个double数组
double min=arr[0];
for(int i=1;i< arr.length;i++)
{
if(min>arr[i])
{
min=arr[i];
}
}
System.out.println("最小值是"+min);
}
}44.创建一个长度为6的整数数组,随机生成六个0-100之间的整数存放到数组中，然后再计算出数组中元素的和并打印
import java.util.Random;
public class Test3 {
public static void main(String[] args) {
int[] arr =new int[6];
Random random =new Random();
int sum=0;
for(int i=0;i<arr.length;i++)
{
arr[i]=random.nextInt(101);
System.out.println("被赋值的数组值是"+arr[i]);
sum+=arr[i];
}
System.out.println("随机数赋值后的数组值之和是"+sum);
}
}45.有一个整数数组，让数组的最后一个元素代表个位，倒数第二个元素代表十位，以此类推。最终得到一个大的整数。
public class Test4 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {1, 3, 5, 7, 9};
//2.定义变量存储最终的整数
int num = 0;
//3.对数组进行遍历
for (int i = 0; i < arr.length; i++) {
//4.计算
num = num * 10 + arr[i];
}
//5.打印结果
System.out.println(num);
}
}46.定义一个数组来存储10个学生的成绩{72,89,65,87,91,82,71,93,76,68}，计算并输出学生的平均成绩
public class Test5 {
public static void main(String[] args) {
int[] arr={72,89,65,87,91,82,71,93,76,68};
int sum=0;
for(int i=0;i<arr.length;i++)
{
sum+=arr[i];
}
System.out.println("学生成绩的最后平均分是"+(sum/ arr.length));
}
}47.有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入一个整数数字。要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排列的
import java.util.Scanner;
public class Test6 {
public static void main(String[] args) {
int[] arr={12,14,23,45,66,68,70,77,90,91};//定义数组arr
int[] brr=new int[arr.length+1];//再定义数组brr
Scanner scanner=new Scanner(System.in);//键盘录入
System.out.println("请输入一个数字");
int num=scanner.nextInt();
int index=0;//定义一个索引变量 ，未来是存储所要插入的位置
for(int i=0;i< arr.length;i++)
{
if(arr[i]<=num)
{
brr[i]=arr[i];
index=i+1;//每次循环都要赋值一次
}
else
{
brr[i+1]=arr[i];//大于输入值num的arr数组里面数全部往后赋值一位到brr数组
}
}
brr[index]=num;//把输入值num赋值给要插入的位置
for(int i=0;i< brr.length;i++)
{
System.out.print(brr[i]+"\t");//输出数组
}
}
}48.小李用自己的钱买了十只股票，年末他看了各只股票的收益分别是10.4%,-3%,-6.2%,1.2%,-6.1%,-19%,-3.8%,0.9%,-4.5%,5.5%。请使用数组相关知识编程，帮他统计赚钱的股票和赔钱的股票分别有多少只？
打印效果：赚钱的股票一共有：4只
赔钱的股票一共有：6只
public class Test7 {
public static void main(String[] args) {
double[] stock={10.4,-3,-6.2,1.2,-6.1,-19,-3.8,0.9,-4.5,5.5};
int earnMoney=0;
int loseMoney=0;
for(int i=0;i<stock.length;i++)
{
stock[i]*=0.01;
if(stock[i]>=0)
{
earnMoney++;
}
else if(stock[i]<0)
{
loseMoney++;
}
}
System.out.println(" 赚钱的股票一共有:"+earnMoney+"只");
System.out.println(" 赔钱的股票一共有:"+loseMoney+"只");
}
}49.定义一个数组其中包含多个数字，奇数放在数组的左边，偶数放在数组的右边。
import java.util.Random;
public class Test8 {
public static void main(String[] args) {
Random random=new Random();
int num1=random.nextInt(10)+5;//定义5-14的随机数
System.out.println("随机赋值了:"+num1+"个数数组的长度是:"+num1);
int[] arr=new int[num1];
int left=0;
int right= arr.length-1;
int[] brr=new int[num1];
//1.循环遍历，每次都从0-9这几个数当中随机选一个数赋值给数组元素
for(int i=0;i<arr.length;i++)
{
arr[i]=random.nextInt(10)+5;//每次都从0-9这几个数当中随机选一个数赋值给数组元素
}
//2.
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+"\t");//输出数组元素
}
System.out.println("\n");
//3.
for(int i=0;i<arr.length;i++)
{
if(arr[i]%2==1)//以此判定是奇数
{
brr[left]=arr[i];
left++;
}
else //以此判定是偶数
{
brr[right]=arr[i];
right--;
}
}
//3.循环输出
for(int i=0;i<brr.length;i++)
{
System.out.print(brr[i]+"\t");
}
System.out.println("\n");
System.out.println("奇数的值是:"+left);
System.out.println("偶数的值是:"+(brr.length-left));
}
}50.买飞机票
机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
按照如下规则计算机票价格：旺季（6-10月）头等舱9折，经济舱8.5折，其余月份为淡季头等舱7折，经济舱6.5折
import java.util.Scanner;
public class Test9 {
public static void main(String[] args) {
double price=getPrice();
System.out.println("现在机票的价格是:"+price+"元");
}
public static double getPrice()
{
System.out.println("请输入价格");
double price = getDada();
System.out.println("请输入月份");
double month = getDada();
System.out.println("请选择舱号类型:1.(头等舱),2.(经济舱)");
double type = getDada();
if (month >= 6 && month <= 10) {//旺季
if (type == 1) {
System.out.println("头等舱");
price *= 0.9;
} else if (type == 2) {
System.out.println("经济舱");
price *= 0.85;
} else {
System.out.println("没有该类型");
}
} else {
if (type == 1) {
System.out.println("头等舱");
price *= 0.7;
} else if (type == 2) {
System.out.println("经济舱");
price *= 0.65;
} else {
System.out.println("没有该类型");
}
}
return price;
}
public static double getDada() {//定义一个公共的获取数据//的方法
Scanner scanner = new Scanner(System.in);
double data = scanner.nextDouble();
return data;
}
}51.验证码
定义方法实现随机产生一个5位数的验证码，每位可能是数字、大写字母、小写字母
import java.util.Random;
public class Test10 {
public static void main(String[] args) {
char[] c=method();
System.out.println(getCode(4,c));
}
public static String getCode(int num,char[] chars)
{
String s="";
Random random=new Random();
for(int k=0;k<num;k++)
{
int i=random.nextInt(62);//随机5个数字
s+=chars[i];//num代表拼接了次从62个字符里面选的然后再拼接
}
return s;
}
public static char[] method()
{
char[] chars=new char[62];
int index=0;//定义该变量，该变量用于统计数组长度
for(char num='0';num<='9';num++)
{
chars[index]=num;
index++;//自增
}
for (char upCase = 'A'; upCase <='Z'; upCase++) {
chars[index]=upCase;
index++;
}
for (char lowCase='a';lowCase<'z'; lowCase++) {
chars[index]=lowCase;
index++;
}
return chars;
}
}52.数组复制,将一个数组里的元素复制到另外一个数组
public class Test11 {
public static void copy(int[] arr1)
{
int[] arr2=new int[arr1.length];
for(int i=0;i<arr1.length;i++)
{
arr2[i]=arr1[i];
}
System.out.print("[");
for(int i=0;i<arr2.length;i++)
{
System.out.print(arr2[i]);
if(i< arr2.length-1)
{
System.out.print(",");
}
}
System.out.print("]");
}
public static void main(String[] args) {
int[] arr1={1,3,6,7};
copy(arr1);
}
} 53.数字元素加密
加密某系统的数字密码，比如1983，采用加密方式进行传输，规则如下:先得到每位数，然后每位数都加上5，再对10求余，最后将所有数字反转，得到一串新数
import java.util.Scanner;
public class Test12{
public static void method()
{
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个值");
int num = sc.nextInt();
int count=1;//数字位数
int[] arr = new int[num];//初始化一个数组
while (true) {
int ge = num%10;
//count--;
arr[count-1] = ge;
if (num/10==0){//当结果是0的时候，那么循环了几次//就有几位数
break;
}else {
num/=10;
count++;
}
}
// count++;
int[] newarr = new int[count];
for (int i = 0; i < count; i++) {
newarr[i] = (arr[i]+5)%10;//输出那么多数组就行，count变量很！重要！
System.out.print(newarr[i]+"\t");
}
//反转
for(int begin=0,end=newarr.length-1;begin<end;begin++,end--)
{
int temp=newarr[end];
newarr[end]=newarr[begin];
newarr[begin]=temp;
}
String s="";
for(int i=0;i<newarr.length;i++)
{
s+=newarr[i];
}
System.out.print("最后的值是"+s);
}
public static void main(String[] args) {
method();
}
}54.双色球 ,前面的六位数字都是红色，最后一位是蓝色
投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1-33中选择，蓝色球号码从1-16中选择
import java.util.Random;
public class Test13 {
//方法一
public static void method()
{
int[] arr=new int[7];
/*arr[0]-arr[5]是前6个红色球号码*/
arr[0]=randomNumber(arr);
arr[1]=randomNumber(arr);
arr[2]=randomNumber(arr);
arr[3]=randomNumber(arr);
arr[4]=randomNumber(arr);
arr[5]=randomNumber(arr);
arr[6]=new Random().nextInt(17)+1;//arr[6]是蓝色球号码
//增强for循环输出
for(int arr2:arr)
{
System.out.print(arr2+" ");
}
}
public static int randomNumber(int[] arr)
{
int number;
while (true) {
number = new Random().nextInt(33) + 1;
boolean flag = false;
for (int i = 0; i < arr.length - 1; i++) {
if (number == arr[i]) {
flag = true;
break;//这里的break只能打断for（）循环，无法中断while（）循环，所以while可以持续运行直到num符合条件
}
}
if (flag == false) {//说明符合条件
break;//这里是符合条件所以打断while（）大循环·输出number
}
}
return number;//返回的一定是符合条件而且不重复的数字number
}
public static void main(String[] args) {
method();
}
//方法二
public static void main(String[] args) {
//创建数组七位数 六位红号 一位蓝号 红号1-33 蓝号1-16
//第一步生成随机中奖号
int arr[] = new int[7];
Random random = new Random();
//随机蓝号
arr[6] = random.nextInt(16) + 1;
int crr[] = honghao(arr);
for (int i = 0; i < crr.length; i++) {
System.out.print(crr[i] + "\t");
}
//返回用户号码
int yonghu[] = suer();
bijiao(crr,yonghu);
}
// 用户号码与中奖号码取比较
//第一部分 生成随机数
public static int[] honghao(int brr[]) {
//循环遍历将随机红号赋值给数组减一
//随机红号
while (true) {
Random random = new Random();
for (int i = 0; i < 6; i++) {
boolean c = false;
int sun = random.nextInt(33) + 1;
for (int j = 0; j <= i; j++) {
if (sun == brr[j]) {
i--;
c = true;
break;
}
}
if (c != true) {
brr[i] = sun;
}
}
break;
}
return brr;
}
// 存储用户输入的数据
public static int [] suer() {
Scanner sc = new Scanner(System.in);
int brr[] = new int[7];
for (int i = 0; i < 7; i++) {
System.out.println("请输入第" +( i+1) + "位数：");
int shuru = sc.nextInt();
brr[i] = shuru;
}
return brr;
}
public static void bijiao(int crr[],int brr1[]) {
//循环遍历 去对比
//用户号码
//int arr[] = suer();
//中奖号码
// int brr1[] = honghao(arr);
//定义变量 计算红色中奖号码
int sum = 0;
//变量计算蓝号是否中奖
int sum1 = 0;
for (int i = 0; i < crr.length - 1; i++) {
for (int i1 = 0; i1 < brr1.length - 1; i1++) {
if (crr[i] == brr1[i1]) {
sum++;
}
}
}
if (crr[6] == brr1[6]) {
sum1++;
}
if
}55.定义一个数组{1,3,4,2,6,2,6,2,8,2,6},要求输出结果是不重复的数
public static void main(String[] args) {
int[] arr = {1,3,4,2,6,2,6,2,8,2,6};
int[] arr1 = new int[arr.length];
int count =1;
arr1[0] =arr[0];
for (int i = 1; i < arr1.length; i++) {
boolean flag =false;
for (int j = 0; j < count; j++) {
if (arr[i] == arr1[j]){
flag = true;
break;
}
}
if (!flag){
arr1[count] = arr[i];
count++;
}
}
for (int i = 0; i < count; i++) {
System.out.print(arr1[i]+" ");
}
}56.输入数组(数组的长度和数组各个位上的值都在控制台输入)，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组
public class Work {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你想创建的数组长度：");
int length = sc.nextInt();
int[] nums = new int[length];
for (int i = 0; i < nums.length; i++) {
System.out.println("请输入数组中的第" + (i + 1) + "个元素的值：");
nums[i] = sc.nextInt();
}
System.out.println("您输入的数组是：" + Arrays.toString(nums));
int max = nums[0];
int maxIndex = 0;
for (int i = 0; i < nums.length; i++) {
if (nums[i] > max) {
max = nums[i];
maxIndex = i;
}
}
int temp1 = nums[0];
nums[0] = max;
nums[maxIndex] = temp1;
int min = nums[0];
int minIndex = 0;
for (int i = 0; i < nums.length; i++) {
if (nums[i] < min) {
min = nums[i];
minIndex = i;
}
}
int temp2 = nums[nums.length - 1];
nums[nums.length - 1] = min;
nums[minIndex] = temp2;
System.out.println("交换完数据后的数组是：" + Arrays.toString(nums));
sc.close();
}
}57.给定一个数组，大小为10，输入十个同学的成绩，求这些成绩的总分数；某一天转入2个新同学，请再次求12个同学的平均成绩（使用扩容做）
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入10个同学的成绩：");
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i] = scanner.nextInt();
}
int sum = sumScore(arr);
System.out.println("总成绩为：" + sum);
// 新转来两个，数组扩容
arr = expandCapacity(arr);
System.out.println(Arrays.toString(arr));
sum = sumScore(arr);
float aver = sum / arr.length;
System.out.println("平均值为：" + aver);
}
public static int[] expandCapacity(int[] arr) {
// 数组扩容
Scanner scanner = new Scanner(System.in);
System.out.print("请输入两个新同学的成绩：");
int[] arr1 = new int[arr.length + 2];
for (int i = 0; i < arr1.length; i++) {
if (i < arr.length) {
arr1[i] = arr[i];
}else {
arr1[i] = scanner.nextInt();
}
}
return arr1;
}
public static int sumScore(int[] arr) {
// 求和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
}58.数组的反转
现有数组String[] arr=new String[] {"aa","bb","cc","dd","ee"};将数组arr反转输出
public static void main(String[] args) {
String[] arr=new String[] {"aa","bb","cc","dd","ee"};
System.out.print("反转前：");
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
for(int i=0;i<arr.length/2;i++) {
String temp=arr[i];
arr[i]=arr[arr.length-1-i];
arr[arr.length-1-i]=temp;
}
System.out.print("\n"+"反转后：");
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
}59.打印四个方向的99乘法表
public static void main(String[] args) {
System.out.println("左下");
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(i+"*"+j+"="+(i*j)+"\t");
}
System.out.println();
}
System.out.println("左上");
for (int i = 9; i >= 1; i--) {
for (int j = 1; j <= i; j++) {
System.out.print(i+"*"+j+"="+(i*j)+"\t");
}
System.out.println();
}
System.out.println("右下");
for(int i=1;i<=9;i++) {
for(int j=9;j>=1;j--) {
if(j>i) {
System.out.print("\t");
}else {
System.out.print(i*j+"="+i+"*"+j+"\t");
}
}
System.out.println();
}
System.out.println("右上");
for(int i=9;i>=1;i--) {
for(int j=9;j>=1;j--) {
if(j>i) {
System.out.print("\t");
}else {
System.out.print(i*j+"="+i+"*"+j+"\t");
}
}
System.out.println();
}
}60.由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出
import java.util.Scanner;
public class Test4 {
public static void main(String[] args) {
System.out.println("请输入三个整数.");
Scanner scanner = new Scanner(System.in);
System.out.print("num1=");
int num1 = scanner.nextInt();
System.out.print("num2=");
int num2 = scanner.nextInt();
System.out.print("num3=");
int num3 = scanner.nextInt();
System.out.println("您输入的三个整数分别为: " + num1 + ", " + num2 + ", " + num3);
if(num1 <= num2){
if(num3 <= num1){
System.out.println(num3 + ", " + num1 + ", " + num2);
}else if(num3 >= num2){
System.out.println(num1 + ", " + num2 + ", " + num3);
}else{
System.out.println(num1 + ", " + num3 + ", " + num2);
}
}else{
if(num3 <= num2){
System.out.println(num3 + ", " + num2 + ", " + num1);
}else if(num3 >= num1){
System.out.println(num2 + ", " + num1 + ", " + num3);
}else{
System.out.println(num2 + ", " + num3 + ", " + num1);
}
}
}
}
9141
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
