经典基础编程50题

第一题：
使用for循环,求出1-100之间的奇数之和.

public class GetSum {
    public static void main(String[] args) {
      int sum=0;
        for (int i = 1; i <=100; i++) {
            if(i%2==1){
                sum+=i;
            }

        }
        System.out.println(sum);
    }

}

第二题：
定义一个int类型变量接收一个大于100的三位数,求出100到该数字之间满足如下要求的数字之和:
1.数字的个位数不为7;
2.数字的十位数不为5;
3.数字的百位数不为3;

 public static void main(String[] args) {
        int num=1200;
        int sum=0;
        if(num<=1000){
            for (int i = 100; i < num; i++) {
                int ge=num%10;
                int shi=num/10%10;
                int bai=num/10/10%10;
                if(ge!=7&&shi!=5&&bai!=3){
                    sum+=i;
                }
            }
            System.out.println(sum);

        }else{
            System.out.println("你输入的不是三位数!");
        }


    }

第三题：
分析以下需求，并用代码实现：
1.根据工龄(整数)给员工涨工资(整数),工龄和基本工资自定义
2.涨工资的条件如下：
[10-15) +5000
[5-10) +2500
[3~5) +1000
[1~3) +500
[0~1) +200
3.如果自定义的工龄为10，基本工资为3000，程序运行后打印格式"您目前工作了10年，基本工资为 3000元, 应涨工资 5000元,涨后工资 8000元"

public static void main(String[] args) {
        int s = 3000;
        int age=16;
        if(age>=0&&age<1){
            s=s+200;
            System.out.println("你目前工作了"+age+"年,基本工资为3000元,应涨工资为 200元,涨后工资为"+s+"元");

        }else  if(age>=1&&age<3){
            s=s+500;
            System.out.println("你目前工作了"+age+"年,基本工资为3000元,应涨工资为 500元,涨后工资为"+s+"元");

        }else   if(age>=3&&age<5){
            s=s+1000;
            System.out.println("你目前工作了"+age+"年,基本工资为3000元,应涨工资为 1000元,涨后工资为"+s+"元");

        }else  if(age>=5&&age<10){
            s=s+2500;
            System.out.println("你目前工作了"+age+"年,基本工资为3000元,应涨工资为 2500元,涨后工资为"+s+"元");

        }else  if(age>=00&&age<15){
            s=s+5000;
            System.out.println("你目前工作了"+age+"年,基本工资为3000元,应涨工资为 5000元,涨后工资为"+s+"元");

        }else{
            System.out.println("对不起,没有这个选项");
        }


    }

第四题：
分析以下需求，并用代码实现：
1.功能描述：模拟计算器功能，对定义的int类型的数据进行加、减、乘、除的运算，并打印运算结果
2.要求：
(1)定义三个int类型变量接收三个数据,其中前两个整数代表参加运算的数据，
第三个整数为要进行的运算(0:表示加法运算,1:表示减法运算,2:表示乘法运算,3:表示除法运算)
(2)使用今天所学知识完成功能
(3)演示格式如下:
第一个整数:30
第二个整数:40
您要进行的运算(0:表示加法运算,1:表示减法运算,2:表示乘法运算,3:表示除法运算):0
控制台输出:30+40=70

public static void main(String[] args) {
    int a=20;
    int b=0;
    int mark=3;
    switch (mark){
        case 0:
            System.out.println("第一个整数:"+a);
            System.out.println("第二个整数:"+b);
            System.out.println("结果是:"+a+"+"+b+"="+(a+b));
            break;
        case 1:
            System.out.println("第一个整数:"+a);
            System.out.println("第二个整数:"+b);
            System.out.println("结果是:"+a+"-"+b+"="+(a-b));
            break;
        case 2:
            System.out.println("第一个整数:"+a);
            System.out.println("第二个整数:"+b);
            System.out.println("结果是:"+a+"*"+b+"="+(a*b));
            break;
        case 3:
            if(b!=0){
                System.out.println("第一个整数:"+a);
                System.out.println("第二个整数:"+b);
                System.out.println("结果是:"+a+"/"+b+"="+(a/b));
            }else{
                System.out.println("除数不能为0");
            }
            break;
        default:
            System.out.println("数据错误");
            break;
    }

}

第五题：
已知数组int[] nums = {5,10,15},要求创建一个新数组
1.新数组的长度和已知数组相同
2.新数组每个元素的值 是已知数组对应位置元素的2倍
3.在控制台中打印新数组的所有元素

 public static void main(String[] args) {
        int[]nums={5,10,15};
        int[]arr=new int[3];
        for (int i = 0; i < nums.length; i++) {
            arr[i]=nums[i]*2;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

第六题：
看程序说结果，请不要提前运行（题目见图片第六题.png）？
567
第七题：
分析以下需求并用代码实现：
1.统计整数1-100（包括1和100）之间能同时被3和7整除的数字的个数
2.使用步骤1统计的个数创建该长度的数组
3.使用该数组存储整数1-100（包括1和100）之间能同时被3和7整除的数字
4.遍历数组，打印数组内元素，格式示例如下：
[元素1,元素2，元素3…]

 public static void main(String[] args) {
        int count = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 3 == 0 && i % 7 == 0) {
                count++;
            }

        }

        int[] arr = new int[count];
        int index=0;
        for (int i = 1; i <= 100; i++) {
            if (i % 3 == 0 && i % 7 == 0) {
                arr[index]=i;
                index++;

            }

        }
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
           if(i==arr.length-1){
               System.out.println(arr[i]+"]");
           }else{
               System.out.print(arr[i]+",");
           }

        }
    }

第八题：
有如下数组int[] arr={10,20,30,40,60,80};
定义一个方法求出数组这元素相加的结果并打印

public static void main(String[] args) {
        int []arr={10,20,30,40,60,80};
       
        System.out.println(getSum(arr));

    }

    private static int  getSum(int[]arr) {
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
           sum+=arr[i];
        }
        return sum;

    }

第九题：
主方法中给定数组int[] arr= {10,20,30,40,50,60};这个数组没有重复元素.
定义一个方法可以接受这个给定的数组并返回这个数组中最大元素值的索引值

 public static void main(String[] args) {
        int[]arr={10,20,30,40,50,60};
        System.out.println(getmaxindex(arr));

    }

    private static int getmaxindex(int[]arr) {
        int max=arr[0];
        int maxindex=0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[maxindex]

第十题：
方法的练习：
1.求两个数据之和(整数和小数)
2.判断两个数据是否相等(整数和小数)
3.获取两个数中较大的值(整数和小数)并返回
4.获取两个数中较小的值(整数和小数)并返回
5.否能用一个方法实现3和4的两个功能

public static void main(String[] args) {
        getSum(10, 4.5);
        System.out.println("两数是否相等:" + getEquals(17, 10.0));
       double result1= getMax(110,20);
        System.out.println("较大值:"+result1);

        double result2=getMin(10,15);
        System.out.println("较小值:"+result2);


  double [] result=getJudge(10,20.1);
        System.out.println("较大值:"+result[0]);
        System.out.println("较小值:"+result[1]);

    }
private static double[] getJudge(int a, double b) {
   double []arr1=new double[2];
  double max;
 double min;
  if(a>b){
      max=a;
      min=b;
  }else{
     min=a;
      max=b;
  }

  arr1[0]=max;
  arr1[1]=min;
    return arr1;
}

private static double getMin(int a,double b) {

    double min=ab){
         max=a;
    }else{
        max=b;
    }
    return max;
}

private static boolean getEquals(int a, double b) {
    if (a == b) {
        return true;
    } else {
        return false;
    }
}

private static void getSum(int a, double b) {
    System.out.println("两数之和:" + (a + b));
}

第十一题：
定义一个方法,求出给定的数字在给定int型数组中出现的次数,如果一次没有出现则返回0。
如:给定数字3 求出3在数组 int[] arr = {3,4,3,5,7,9};中出现的次数

public static void main(String[] args) {
        int[] arr = {3, 4,  3, 5, 7, 9};
        int num = getCount(arr);
        System.out.println(num);
    }

    private static int getCount(int[] arr) {
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 3) {
                count++;
            }
        }

        return count;

    }

第十二题：
定义一个方法，查找指定数字在数组中出现的位置(若出现多次，多次打印)
如: 数组[1232]要查找的数是2 则方法内部会打印索引值 1 ,3
数组[1232] 要查找的数是5 则会打印 “数组中没有这个数字”

 public static void main(String[] args) {

    int []arr={1,2,3,2};
    getnumber(arr);
}

private static void getnumber(int []arr) {
    int num=5;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i]==num){
            System.out.println(i);

        }
    }



}

第十三题（15分）：
定义 getNewArr()方法:要求传入一个int类型的数组arr,遍历数组，将数组中小于10的元素替换成0，然后返回修改之后的数组
在main方法中完成:
1.定义一个长度为5的int类型的数组
2.手动给出5个随机的数值存入数组，并把数组中的元素打印在控制台
3.调用getNewArr方法,在控制台打印返回后的数组中的元素
格式如下:
随机生成的数组中的元素是:
48 8 35 25 39
调用方法修改后的数组中的元素是:
48 0 35 25 39

public class Test01 {
 
    public static void main(String[] args) {
//        1.数组静态初始化，直接给出5个元素
        int[] arr = {48, 8, 35, 25, 39};
        System.out.println("随机生成的数组中的元素是:");
//        遍历数组并打印
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
//        调用方法返回新数组
        int[] newArr = getNewArr(arr);
        System.out.println("调用方法修改后的数组中的元素是:");
//        遍历新数组并打印
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + " ");
        }
    }

    public static int[] getNewArr(int[] arr) {
//        遍历数组
        for (int i = 0; i < arr.length; i++) {
//            判断数组元素是否小于10
            if (arr[i] < 10) {
//                将小于10的元素替换成0
                arr[i] = 0;
            }
        }
//        将数组进行返回
        return arr;
    }
}

第十四题（15分）：
1.定义长度为100的整数类型数组,并对数组进行赋值1-100之间的整数数据(包括1和100),
2.定义方法,传递数组,将数组中元素能同时被3和5整除的存入到新数组1中,并将新数组返回
3.定义print方法,打印传递的数组内的元素,打印格式如下:数组元素:[元素1,元素2,元素3…]

public class Test02 {
   
    public static void main(String[] args) {
//        定义长度为100的数组
        int[] arr = new int[100];
//        循环赋值
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }
        System.out.println("原数组中元素为:");
//        调用打印数组方法
        print(arr);
//        调用获取新数组方法
        int[] newArr = getNewArr(arr);
        System.out.println("新数组中元素为:");
//        调用打印数组方法
        print(newArr);
    }

    public static void print(int[] arr) {
//        先不换行打印左括号
        System.out.print("[");
//        排除数组最后一个元素
        for (int i = 0; i < arr.length - 1; i++) {
//            不换行打印元素，中间用逗号进行分隔
            System.out.print(arr[i] + ",");
        }
//        打印最后一个元素及右括号，并换行
        System.out.println(arr[arr.length - 1] + "]");
    }

    public static int[] getNewArr(int[] arr) {
//        定义计数器，统计满足条件的数据的个数
        int count = 0;
//        遍历数组
        for (int i = 0; i < arr.length; i++) {
//            判断并统计满足条件的数据的个数
            if (arr[i] % 3 == 0 && arr[i] % 5 == 0) {
                count++;
            }
        }
//        根据统计个数创建存储满足条件数据的新数组
        int[] newArr = new int[count];
//        定义索引，初始值为0，目的是为了将原数组中满足条件的数据存储到新数组中
        int index = 0;
//        遍历原数组
        for (int i = 0; i < arr.length; i++) {
//            判断并获取满足条件的数据
            if (arr[i] % 3 == 0 && arr[i] % 5 == 0) {
//                将满足条件的数据存储到新数组指定索引位置，并让索引自增
                newArr[index++] = arr[i];
            }
        }
//        返回新数组
        return newArr;
    }
}

第十五题（20分）：
(1)创建长度为10的int类型数组,并使用手动给出10个随机的数值存入数组为数组赋值
(2)定义findNum方法,传递数组及手动给出的一个int类型数据,判断该数据在数组中是否存在,
如果存在,则打印数字在数组中最后一次出现的位置
如果不存在,则打印"不存在",并且不存在只需要提示一次
(3)定义方法,统计数组中小于平均值元素的个数,将结果返回并进行输出

public class Test03 {
        //    
        public static void main(String[] args) {
    //        静态初始化数组
            int[] arr = {3, 7, 22, 48, 50, 24, 15, 18, 22, 44};
    //        定义变量记录一个数据
            int num = 22;
    //        调用方法
            findNum(arr, num);
    //        调用方法，接收结果
            int count = getCount(arr);
            System.out.println("数组中小于平均值元素的个数为:" + count);
    
        }

    public static int getCount(int[] arr) {
//        定义求和变量
        int sum = 0;
//        遍历数组
        for (int i = 0; i < arr.length; i++) {
//            累加求和
            sum += arr[i];
        }
//        计算平均值
        int avg = sum / arr.length;
//        定义计数器
        int count = 0;
//        遍历数组
        for (int i = 0; i < arr.length; i++) {
//            判断是否小于平均值，并统计
            if (arr[i] < avg) {
                count++;
            }
        }
//        将统计结果返回
        return count;
    }

    public static void findNum(int[] arr, int num) {
//        定义变量，用来接收数据在数组中出现的位置，初始化值-1（若存在，最小索引至少为0）
        int index = -1;
//        遍历数组，查找元素出现的位置并进行接收
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                index = i;
            }
        }
//        判断变量值是否发生改变
//        若没有发生改变，证明不存在
        if (index == -1) {
            System.out.println("不存在");
        } else {
            System.out.println("数字在数组中最后一次出现的位置:" + index + "索引");
        }
    }
}

第十六题（10分）：
定义一个int类型变量，手动接收一个2-100之间（包括2和100）的数据，求2到该变量之间的偶数个数及奇数的和，并打印到控制台上

public class Test01 {
       
    public static void main(String[] args) {
//        定义变量接收数据
        int num = 98;
//        判断数据是否合法
        if (num > 100) {
            System.out.println("数据不合法");
        } else {
//            定义求和变量
            int sum = 0;
//            定义统计变量
            int count = 0;
//            查找2到该数字之间的数据
            for (int i = 2; i <= num; i++) {
//                判断是否为偶数
                if (i % 2 == 0) {
//                    偶数统计个数
                    count++;
                } else {
//                    奇数求和
                    sum += i;
                }
            }
//            打印结果
            System.out.println("偶数个数为:" + count);
            System.out.println("奇数和为:" + sum);
        }
    }
}

第十七题（10分）：
1.定义长度为50的int类型数组，并循环赋值1-50（包括1和50）
2.遍历数组，打印数组中能同时被3和5整除的数字

public class Test02 {

    public static void main(String[] args) {
//        定义长度为50的数组
        int[] arr = new int[50];
//        遍历数组并赋值
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }
//        再次遍历数组
        for (int i = 0; i < arr.length; i++) {
//            判断当前元素是否满足条件
            if (arr[i] % 3 == 0 && arr[i] % 5 == 0) {
//                满足条件，打印元素
                System.out.print(arr[i] + " ");
            }
        }
    }
}

第十八题（15分）：

1.打印1到100之内的整数，但数字中包含9的要跳过,
2.每行输出5个满足条件的数，之间用空格分隔,打印格式如下:
1 2 3 4 5

public class Test03 {
   
    public static void main(String[] args) {
//        定义计数器。统计满足条件的数据的个数
        int count = 0;
//        获取1-100之间的数字
        for (int i = 1; i < 100; i++) {
//            获取当前数字的个位及十位
            int ge = i % 10;
            int shi = i / 10 % 10;
//            判断个位及十位是否为9，为9则跳过当前循环
            if (ge == 9 || shi == 9) {
                continue;
            } else {
//                不为9，不换行打印当前元素，并用空格进行分隔
                System.out.print(i + " ");
//                进行统计
                count++;
//                判断统计了多少个数据，如果是5的倍数个，则进行换行
                if (count % 5 == 0) {
                    System.out.println();
                }
            }
        }
    }
}

第十九题.分析以下需求并用代码实现：
1.打印1到100之内的整数，但数字中包含7的要跳过,
2.每行输出7个满足条件的数，之间用空格分隔,打印格式如下:
1 2 3 4 5 6 8
3.打印满足条件的数据的个数

public class Test01 {
    public static void main(String[] args) {
//        定义计数器，记录满足条件的数据的个数，用来判断换行
        int count = 0;
//        循环1-100，每循环一次获取一个数字
        for (int i = 1; i < 101; i++) {
//            获取该数字的个位及十位的数字
            int ge = i % 10;
            int shi = i / 10 % 10;
//            方法1：跳过包含7的
//            if (ge == 7 || shi == 7) {
//                continue;
//            }
//            System.out.print(i + " ");
//            count++;
//            if (count % 7 == 0) {
//                System.out.println();
//            }
//            方法2，筛选不包含7的
            if (ge!=7&&shi!=7){
//                不换行打印满足条件的数据
                System.out.print(i + " ");
//                计数器计数
                count++;
//                判断计数器记录的数量
                if (count % 7 == 0) {
//                    换行
                    System.out.println();
                }
            }
        }
//        打印计数器记录的结果
        System.out.println("个数：" + count);
    }
}

第二十题.模拟计算器:
定义三个整数类型变量num1,mark,num2
根据mark的值选择运算类型,
mark值为0,调用getSum方法,计算num1和num2的和并打印;
mark值为1,调用getDifference方法,计算num1和num2的差并打印;
mark值为2,调用getProduct 方法,计算num1和num2的乘积并打印;
mark值为3,调用getQuotient 方法,计算num1和num2的商并打印;
mark值为4,调用getRemainder 方法,计算num1和num2的余数并打印;
如果mark值大于4,则提示"没有这种计算方式"

 打印格式如下:例如当mark值为0,num1值为1,num2值为2时打印:

您进行的计算为:加法
表达式及结果:1 + 2 = 3;

public class Test02 {
    //   
    public static void main(String[] args) {
        int num1 = 1;
        int mark = 0;
        int num2 = 2;
//        方法1
//        if (mark == 0) {
//            getSum(num1, num2);
//        } else if (mark == 1) {
//
//        } else if (mark == 2) {
//
//        } else if (mark == 3) {
//            getQuotient(num1, num2);
//        } else if (mark == 4) {
//
//        } else {
//            System.out.println("没有这种计算方式");
//        }

        //方法2
        switch (mark) {
            case 0:
//                alt + enter
                getSum(num1, num2);
                break;
            case 1:
                getDifference(num1, num2);
                break;
            case 2:
                getProduct(num1, num2);
                break;
            case 3:
                getQuotient(num1, num2);
                break;
            case 4:
                getRemainder(num1, num2);
                break;
            default:
                System.out.println("没有这种计算方式");
                break;
        }
    }

    public static void getRemainder(int num1, int num2) {
        System.out.println("余数：" + (num1 % num2));
    }

    public static void getProduct(int num1, int num2) {
        System.out.println("积：" + (num1 * num2));
    }

    public static void getDifference(int num1, int num2) {
        System.out.println("差：" + (num1 - num2));
    }

    public static void getSum(int num1, int num2) {
        System.out.println("和：" + (num1 + num2));
    }

    public static void getQuotient(int num1, int num2) {
//        分母不能为0
        if (num2 == 0) {
            System.out.println("分母为0！！！");
        } else {
            System.out.println("商为：" + (num1 / num2));
        }
    }
}

第二十一.分析以下需求并用代码实现：
1.定义长度为100的整数类型数组,并对数组进行赋值1-100之间的整数数据(包括1和100),

2.定义方法,传递数组,将数组中元素能同时被3和5整除的存入到新数组中,并将新数组返回
3.定义方法,传递数组及一个整数数据,判断该数据在数组中是否存在,如果存在,则打印该元素在数组中出现的位置,
如果不存在则提示"不存在"（只需提示一次）
/ 4.定义print方法,打印传递的数组内的元素,打印格式如下:数组元素:[元素1,元素2,元素3…]
//分析：1.数组动态初始化 长度100 int类型 遍历数组并赋值
// 2.定义计数器，统计原数组中满足条件的数据的个数，作为新数组的长度–创建新数组
// 3.遍历原数组，将满足条件的数据存入到新数组（两个数组长度不一致，定义变量模拟新数组索引增长情况），返回新数组

public class Test03 {
   
    public static void main(String[] args) {
//        1.数组动态初始化 长度100 int类型
        int[] arr = new int[100];
//        2.遍历数组并赋值,遍历数组要使用length属性
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }
        int num = 10;
        findNum(arr, num);


        print(arr);
//        1.在主方法中，选中方法体，alt + ctrl + m -- 选择修饰符 public -- 方法名
//        2.在方法中，修改返回值类型 -- 快速修正 -- alt + enter
//        3.在主方法，方法调用的位置，点击方法名 -- alt + enter -- introduce local var
        int[] newArr = getNewArr(arr);

//        4.定义print方法,打印传递的数组内的元素,打印格式如下:数组元素:[元素1,元素2,元素3...]
        print(newArr);
    }

    public static void findNum(int[] arr, int num) {
        //        如果不存在则提示"不存在"（只需提示一次）
//        标记
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (num==arr[i]){
                System.out.print(i+" ");
                count++;
            }
        }
        if (count==0){
            System.out.println("不存在");
        }
    }

    public static void print(int[] newArr) {
        System.out.print("[");
        for (int i = 0; i < newArr.length-1; i++) {
            System.out.print(newArr[i]+",");
        }
        System.out.println(newArr[newArr.length-1]+"]");
    }

    public static int[] getNewArr(int[] arr) {
        //        3.定义计数器，统计原数组中满足条件的数据的个数，作为新数组的长度--创建新数组
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%3==0&&arr[i]%5==0){
                count++;
            }
        }
//        4.作为新数组的长度--创建新数组
        int[] newArr = new int[count];
//        5.遍历原数组，将满足条件的数据存入到新数组（两个数组长度不一致，定义变量模拟新数组索引增长情况），返回新数组
//        两个数组长度不一致，定义变量模拟新数组索引增长情况
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%3==0&&arr[i]%5==0){
                newArr[index] = arr[i];
                index++;
            }
        }
        return newArr;
    }
}

第二十二题.功能描述:给定月份，输出对应的季节
要求:
(1)定义一个月份，例如：int month = 5;
(2)输出该月份对应的季节
3,4,5春季
6,7,8夏季
9,10,11秋季
12,1,2冬季
(3)演示格式如下:
定义的月份:5
控制台输出:5月份是春季*/
//1，完全使用if （month == 1）{
// }
//2,swtich
//如果要匹配一个范围，那么我们一般是使用if
//如果要匹配的有限个，需要任选其一。swtich
//当case中代码重复的时候，我们为了减少重复代码的书写，case穿透

public class Demo1 {


public static void main(String[] args) {
    int month = 1;
    switch (month) {
        case 1:
        case 2:
        case 12:
            System.out.println("冬季");
            break;
        case 3:
        case 4:
        case 5:
            System.out.println("春季");
            break;
        case 6:
        case 7:
        case 8:
            System.out.println("夏季");
            break;
        case 9:
        case 10:
        case 11:
            System.out.println("秋季");
            break;
        default:
            System.out.println("没有这样的月份");
            break;
    }
}
}

第二十三题
/1.打印1到100之内的整数，但数字中包含9的要跳过
2.每行输出5个满足条件的数，之间用空格分隔
3.如：1 2 3 4 5/

public class Demo2 {
   
public static void main(String[] args) {
    //相对比较综合的题目时，要学会分解题目
    //分解的步骤从题目中来
    //先分解，再完成，一步一步的完成。
    //一次只完成一步

    //1.打印1到100之内的整数
    //2.包含9的要跳过
    //3.每行输出5个

    /*for (int i = 1; i <= 100; i++) {
        if (i % 10 == 9 || i / 10 % 10 == 9) {
            //把if判断大声的读出来
            //.... 读作.....
           continue;
        }else{
            System.out.println(i);
        }
    }*/
    int count = 0;//定义一个计数器，用来统计，当前打印的是第几次。
                    //每打印一次，就要自增一次
    for (int i = 1; i <= 100; i++) {
        if (i % 10 != 9 && i / 10 % 10 != 9) {
            System.out.print(i + " ");
            count++;//判断当前打印的次数是不是5的倍数

            //这个if不能写在外面，因为只有打印的时候才会进行判断
            //如果包含9，那么不会打印，不打印就不会判断当前的打印次数。
            if(count % 5 == 0){
                System.out.println();
            }
        }
    }
}
}

第二十四题
/* 1.想在控制台输出2次:“Java基础班” 括号()里面应该填写什么?
2.想在控制台输出7次:“Java基础班” 括号()里面应该填写什么?
3.想在控制台输出13次:“Java基础班” 括号()里面应该填写什么?*/

   //分析：
        //1，先看循环是循环10次。
        //2，在打印第三次之前，我将循环停止。
        //思路：在打印第三次之前，进行一个循环的跳出。 break
    //分析：
        //1，先看循环是循环10次。
        //2，间歇的跳过
        //  当x = 3 x = 6 x = 9 的时候不打印。
        //  1  2   4   5   7   8  10   7次        continue;
    //在判断中加  continue; 就相当于 当x = 3 ， 6 ， 9 的时候
        //直接跳过  不打印。

    //分析：
        //1，先看循环是循环10次。
        //2，我们要在循环10次的基础上，多打印3次。
        //3，在x =3 x = 6 x = 9 的时候 多打印一次。

public class Demo3 {
    public static void main(String[] args) {
   
    for(int x=1; x<=10; x++) {
        if(x%3==0) {
            //()在此处填写代码
            System.out.println("Java基础班");
        }
        System.out.println("Java基础班");
    }
}
}

第二十五题
//1,打印了一个矩形
//2，通过这个矩形改成了直角三角形
//3.通过这个直角三角形改成99乘法表。

    //1。先不要方里面的内容
    //2，先把外面的形状给打印出来。
    //3。等形状有了之后，再想着里面的内容

public class Demo4 {
    /* 1*1=1
       1*2=2	2*2=4
       1*3=3	2*3=6	3*3=9*/
    public static void main(String[] args) {
  

    for (int i = 1; i <= 9; i++) {//外层循环相当于就是控制的行数。
        //就是将每一行打印9个*这个动作重复了9次。--- 就是打印9行
        for (int j = 1; j <= i; j++) { //内存循环打印的是每一行的数据
            System.out.print(j + " * " + i + " = " + (i * j) + "\t");//  \t 就是一个制表符
        }
        System.out.println();
    }
    //关于字符串的拼接
    //1，把要打印的数据全部粘贴到输出语句中
    //2，把这个字符串中有可能发生变化的用变量替代。
    //3，选中变量。进行 ctrl + x 的剪切
    //4.光标不要动 按下两个 ""
    //5,在两个双引号中间按下 两个 +
    //6在两个+中间 粘贴你刚刚剪切的内容
}

}

第二十六题
使用for循环,求出1-100之间的奇数之和.

public class GetSum {
    public static void main(String[] args) {
      int sum=0;
        for (int i = 1; i <=100; i++) {
            if(i%2==1){
                sum+=i;
            }
    }
    System.out.println(sum);
}

}

第二十七题
定义一个int类型变量接收一个大于100的三位数,求出100到该数字之间满足如下要求的数字之和:
1.数字的个位数不为7;
2.数字的十位数不为5;
3.数字的百位数不为3;

 public static void main(String[] args) {
        int num=1200;
        int sum=0;
        if(num<=1000){
            for (int i = 100; i < num; i++) {
                int ge=num%10;
                int shi=num/10%10;
                int bai=num/10/10%10;
                if(ge!=7&&shi!=5&&bai!=3){
                    sum+=i;
                }
            }
            System.out.println(sum);

        }else{
            System.out.println("你输入的不是三位数!");
        }


    }

第二十八题
分析以下需求，并用代码实现：
1.根据工龄(整数)给员工涨工资(整数),工龄和基本工资自定义
2.涨工资的条件如下：
[10-15) +5000
[5-10) +2500
[3~5) +1000
[1~3) +500
[0~1) +200
3.如果自定义的工龄为10，基本工资为3000，程序运行后打印格式"您目前工作了10年，基本工资为 3000元, 应涨工资 5000元,涨后工资 8000元"

 public static void main(String[] args) {
            int s = 3000;
            int age=16;
            if(age>=0&&age<1){
                s=s+200;
                System.out.println("你目前工作了"+age+"年,基本工资为3000元,应涨工资为 200元,涨后工资为"+s+"元");

        }else  if(age>=1&&age<3){
        s=s+500;
        System.out.println("你目前工作了"+age+"年,基本工资为3000元,应涨工资为 500元,涨后工资为"+s+"元");

    }else   if(age>=3&&age<5){
        s=s+1000;
        System.out.println("你目前工作了"+age+"年,基本工资为3000元,应涨工资为 1000元,涨后工资为"+s+"元");

    }else  if(age>=5&&age<10){
        s=s+2500;
        System.out.println("你目前工作了"+age+"年,基本工资为3000元,应涨工资为 2500元,涨后工资为"+s+"元");

    }else  if(age>=00&&age<15){
        s=s+5000;
        System.out.println("你目前工作了"+age+"年,基本工资为3000元,应涨工资为 5000元,涨后工资为"+s+"元");

    }else{
        System.out.println("对不起,没有这个选项");
    }


}

第二十九题
分析以下需求，并用代码实现：
1.功能描述：模拟计算器功能，对定义的int类型的数据进行加、减、乘、除的运算，并打印运算结果
2.要求：
(1)定义三个int类型变量接收三个数据,其中前两个整数代表参加运算的数据，
第三个整数为要进行的运算(0:表示加法运算,1:表示减法运算,2:表示乘法运算,3:表示除法运算)
(2)使用今天所学知识完成功能
(3)演示格式如下:
第一个整数:30
第二个整数:40
您要进行的运算(0:表示加法运算,1:表示减法运算,2:表示乘法运算,3:表示除法运算):0
控制台输出:30+40=70

public static void main(String[] args) {
        int a=20;
        int b=0;
        int mark=3;
        switch (mark){
            case 0:
                System.out.println("第一个整数:"+a);
                System.out.println("第二个整数:"+b);
                System.out.println("结果是:"+a+"+"+b+"="+(a+b));
                break;
            case 1:
                System.out.println("第一个整数:"+a);
                System.out.println("第二个整数:"+b);
                System.out.println("结果是:"+a+"-"+b+"="+(a-b));
                break;
            case 2:
                System.out.println("第一个整数:"+a);
                System.out.println("第二个整数:"+b);
                System.out.println("结果是:"+a+"*"+b+"="+(a*b));
                break;
            case 3:
                if(b!=0){
                    System.out.println("第一个整数:"+a);
                    System.out.println("第二个整数:"+b);
                    System.out.println("结果是:"+a+"/"+b+"="+(a/b));
                }else{
                    System.out.println("除数不能为0");
                }


                break;
            default:
                System.out.println("数据错误");
                break;
        }

    }

第三十题
已知数组int[] nums = {5,10,15},要求创建一个新数组
1.新数组的长度和已知数组相同
2.新数组每个元素的值 是已知数组对应位置元素的2倍
3.在控制台中打印新数组的所有元素

public static void main(String[] args) {
        int[]nums={5,10,15};
        int[]arr=new int[3];
        for (int i = 0; i < nums.length; i++) {
            arr[i]=nums[i]*2;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

第三十一题
看程序说结果，请不要提前运行（题目见图片第六题.png）？
567
第三十二题
分析以下需求并用代码实现：
1.统计整数1-100（包括1和100）之间能同时被3和7整除的数字的个数
2.使用步骤1统计的个数创建该长度的数组
3.使用该数组存储整数1-100（包括1和100）之间能同时被3和7整除的数字
4.遍历数组，打印数组内元素，格式示例如下：
[元素1,元素2，元素3…]

 public static void main(String[] args) {
        int count = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 3 == 0 && i % 7 == 0) {
                count++;
            }

        }

        int[] arr = new int[count];
        int index=0;
        for (int i = 1; i <= 100; i++) {
            if (i % 3 == 0 && i %7 == 0) {
            arr[index]=i;
            index++;

        }

    }
    System.out.print("[");
    for (int i = 0; i < arr.length; i++) {
       if(i==arr.length-1){
           System.out.println(arr[i]+"]");
       }else{
           System.out.print(arr[i]+",");
       }

    }
}

第三十三题
有如下数组int[] arr={10,20,30,40,60,80};
定义一个方法求出数组这元素相加的结果并打印

 public static void main(String[] args) {
        int []arr={10,20,30,40,60,80};
       
        System.out.println(getSum(arr));
}

private static int  getSum(int[]arr) {
    int sum=0;
    for (int i = 0; i < arr.length; i++) {
       sum+=arr[i];
    }
    return sum;

}

第三十四题
主方法中给定数组int[] arr= {10,20,30,40,50,60};这个数组没有重复元素.
定义一个方法可以接受这个给定的数组并返回这个数组中最大元素值的索引值

 public static void main(String[] args) {
        int[]arr={10,20,30,40,50,60};
        System.out.println(getmaxindex(arr));

    }

    private static int ge

tmaxindex(int[]arr) {
        int max=arr[0];
        int maxindex=0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[maxindex]

第三十五题
方法的练习：
1.求两个数据之和(整数和小数)
2.判断两个数据是否相等(整数和小数)
3.获取两个数中较大的值(整数和小数)并返回
4.获取两个数中较小的值(整数和小数)并返回
5.否能用一个方法实现3和4的两个功能

public static void main(String[] args) {
        getSum(10, 4.5);
        System.out.println("两数是否相等:" + getEquals(17, 10.0));
       double result1= getMax(110,20);
        System.out.println("较大值:"+result1);

        double result2=getMin(10,15);
        System.out.println("较小值:"+result2);


  double [] result=getJudge(10,20.1);
        System.out.println("较大值:"+result[0]);
        System.out.println("较小值:"+result[1]);

    }

private static double[] getJudge(int a, double b) {
   double []arr1=new double[2];
  double max;
 double min;
  if(a>b){
      max=a;
      min=b;
  }else{
     min=a;
      max=b;
  }

  arr1[0]=max;
  arr1[1]=min;
    return arr1;
}

private static double getMin(int a,double b) {

    double min=ab){
         max=a;
    }else{
        max=b;
    }
    return max;
}

private static boolean getEquals(int a, double b) {
    if (a == b) {
        return true;
    } else {
        return false;
    }
}

private static void getSum(int a, double b) {
    System.out.println("两数之和:" + (a + b));
}

第三十六题
定义一个方法,求出给定的数字在给定int型数组中出现的次数,如果一次没有出现则返回0。
如:给定数字3 求出3在数组 int[] arr = {3,4,3,5,7,9};中出现的次数

public static void main(String[] args) {
        int[] arr = {3, 4,  3, 5, 7, 9};
        int num = getCount(arr);
        System.out.println(num);
    }

    private static in

t getCount(int[] arr) {
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 3) {
                count++;
            }
        }

        return count;

}

第三十七题
定义一个方法，查找指定数字在数组中出现的位置(若出现多次，多次打印)
如: 数组[1232]要查找的数是2 则方法内部会打印索引值 1 ,3
数组[1232] 要查找的数是5 则会打印 “数组中没有这个数字”

 public static void main(String[] args) {

    int []arr={1,2,3,2};
    getnumber(arr);
}

private static void getnumber(int []arr) {
    int num=5;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i]==num){
            System.out.println(i);

        }
    }



}

第三十八题

随机产生5个范围是[1,100]的整数,把这些数字中所有个位或十位为3的数字打印出来

public static void main(String[] args) {
        int []arr=new int[5];
        Random r=new Random();
        for (int i = 0; i < 5; i++) {
            int num=r.nextInt(100)+1;
           arr[i]=num;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();

    for (int i = 0; i < arr.length; i++) {

        if(arr[i]%10==3||arr[i]/10%10==3){
            System.out.print(arr[i]+" ");
        }
    }
}

第三十九题
分析以下需求，并用代码实现
1.提示用户输入10个整数，存入到int数组中；根据以下要求实现相关功能
2.提示用户输入一个数字作为数组索引，查找数组中该索引对应的元素，
（需要判断输入的数字是否在0-9之间包含临界值，如果该数字不符合要求则随机生成一个符合要求的索引）
3.将2中得到的索引对应的元素的左右两边元素进行互换，若对应的元素是第一个或最后一个则不做任何操作

public static void main(String[] args) {
       int[]array=new int[10];
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入十个整数:");
        for (int i = 0; i < 10; i++) {
            array[i]=sc.nextInt();
        }
        System.out.println(Arrays.toString(array));
        System.out.println("请输入一个索引:");
        int index=sc.nextInt();
        if(index>=0&&index<=9){
           if(index==0||index==9){
           }else{
               int temp;
               temp=array[index-1];
               array[index-1]=array[index+1];
               array[index+1]=temp;
               System.out.println(Arrays.toString(array));
           }

        }else {
            Random r=new Random();
        int index1=r.nextInt(8)+1;
        System.out.println("随机生成的索引是:"+index1);
        int temp;
        temp=array[index1-1];
        array[index1-1]=array[index1+1];
        array[index1+1]=temp;
        System.out.println(Arrays.toString(array));
    }

}

第四十题：
分析以下需求，并用代码实现
1.键盘录入班级人数
2.根据录入的班级人数创建数组
3.利用随机数产生0-100的成绩(包含0和100)
4.要求:
(1)打印该班级的不及格人数
(2)打印该班级的平均分
(3)演示格式如下:
请输入班级人数:
键盘录入:100
控制台输出:
不及格人数:19
班级平均分:87

 public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("输入班级人数:");
        int num=sc.nextInt();
        int []arr=new int[num];
        Random r=new Random();
        for (int i = 0; i < arr.length; i++) {
            int num2=r.nextInt(100);
            arr[i]=num2;
        }
        int count=0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<60){
                count++;
            }
        }
        System.out.println(count);
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        int age=sum/num;
        System.out.println(sum);
        System.out.println(age);
    }

第四十一题：
键盘录入一个整数，创建一个该长度的数组，为每一个元素赋值为1-10的随机整数，最后打印数组中所有值大于5且为偶数的元素.

public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[]arr=new int[n];
        Random r=new Random();
        for (int i = 0; i < n; i++) {
           arr[i]=r.nextInt(10) +1;
        }
        System.out.println(Arrays.toString(arr));
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>5&&arr[i]%2==0){
                System.out.println(arr[i]);
            }
        }
    }

第四十二题：
将数字1-10保存到一个长度为10的一维数组中
定义一个新数组,长度为3,取出原来数组中随机三个元素(不考虑是否重复)
给新数组的元素赋值
求新数组所有元素的和

public static void main(String[] args) {
        int[]arr=new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=i+1;
        }
        int []newarr=new int[3];
        Random r=new Random();
        for (int i = 0; i < newarr.length; i++) {
            int n=r.nextInt(10);
            newarr[i]=arr[n];
        }

    int sum=0;
    for (int i = 0; i < newarr.length; i++) {
        sum+=newarr[i];
    }
    System.out.println("新数组所有元素的和:"+sum);
}

第四十三题：
一、需求说明：创建三个图书类对象，找出价格最高的图书并打印该图书的所有信息。
二、设计“图书类”Book，要求有以下属性：
图书编号：
书名：
价格：

public class Book {
   private String id;
    private String name;
    private int price;
    int numid=0;
    public Book() {
        numid++;
    }

public Book(String id, String name, int price) {
    this.id = id;
    this.name = name;
    this.price = price;
}

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getPrice() {
    return price;
}

public void setPrice(int price) {
    this.price = price;
}


public void show(){

}
}


public static void main(String[] args) {
        Book one=new Book();
        Book two=new Book();
        Book three=new Book();
        one.setId("1");
        one.setName("java编程基础");
        one.setPrice(20);
        two.setId("2");
        two.setName("java技术");
        two.setPrice(30);
        three.setId("3");
        three.setName("java实训");
        three.setPrice(40);
        if(one.getPrice()>two.getPrice()&&one.getPrice()>three.getPrice()){
            System.out.println("书名:"+one.getName()+",编号:"+one.getId()+",价格:"+one.getPrice());

        }else if(one.getPrice()three.getPrice()){
            System.out.println("书名:"+t

wo.getName()+",编号:"+two.getId()+",价格:"+two.getPrice());
        }else{
            System.out.println("书名:"+three.getName()+",编号:"+three.getId()+",价格:"+three.getPrice());
        }



    }

第四十四题：
一、需求说明：请用户输入一个“QQ号码”，我们来判断这个QQ号码是否正确。
要求：使用方法来完成判断功能。

public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.next();
        int count=0;
        for (int i = 0; i < str.length(); i++) {
           char ch=str.charAt(i);
           if(ch<'0'||ch>'9'||str.charAt(0)=='0'||str.length()>11||str.length()<6){
               count++;
           }
        }
        if(count==0){
            System.out.println("请输入密码:");
        }else{
            System.out.println("你输入的号码非法,请重新输入!");
        }


        }

第四十五题：

1. 定义学生类Student，包含以下成员;
   成员属性:name(姓名):String类型，Chinese(语文):int类型，math(数学):int类型，属性使用private修饰。
   成员方法:
   (1).get/set方法，构造方法
   (2).void show()方法，打印对象所有属性的值以及对象的语文和数学成绩的总和到控制台

2. 定义类:Test类中定义main方法，按以下要求编写代码
   (1)定义如下方法；
   @定义public static ArrayList getSum(ArrayList list){…}方法；
   @@要求:遍历list集合，将list中语文成绩和数学成绩总和大于160分的元素存入到另一个ArrayList中并返回。
   (2)分别实例化三个Student对象，三个对象分别为：”李强”88,99,; “张强”,85,78,; “谢强”,86,50;
   (3)创建一个ArrayList集合，这个集合里面存储的是Student类型，分别将上面的三个Student对象添加到集合中，
   调用getSum方法，根据返回的list集合遍历对象并调用show()方法输出所有元素信息。

   public class Student {
   private String name;
   private int chinese;
   private int math;
   public Student() {
   }
   public Student(String name, int chinese, int math) {
   this.name = name;
   this.chinese = chinese;
   this.math = math;
   }

    public String getName() {
        return name;
    }
   
    public void setName(String name) {
        this.name = name;
    }
   
    public int getChinese() {
        return chinese;
    }
   
    public void setChinese(int chinese) {
        this.chinese = chinese;
    }
   
    public int getMath() {
        return math;
    }
   
    public void setMath(int math) {
        this.math = math;
    }
    public void show(){
        System.out.println("姓名:"+getName()+",语文:"+getChinese()+",数学:"+getMath());
   
    }
   

   }

   public class StudentTest {
   public static void main(String[] args) {
   ArrayList list = new ArrayList<>();

        Student s1 = new Student("李强", 88, 99);
        Student s2 = new Student("张强", 85, 78);
        Student s3 = new Student("谢强", 86, 50);
        list.add(s1);
        list.add(s2);
        list.add(s3);
   
        ArrayList listB = getSum(list);
        for (int i = 0; i < listB.size(); i++) {
            Student s=listB.get(i);
            System.out.println("姓名:"+s.getName()+",语文:"+s.getChinese()+",数学:"+s.getMath());
        }
        System.out.println("==========================");
   
        s1.show();
        s2.show();
        s3.show();
   
    }
   
    private static ArrayList getSum(ArrayList list) {
        ArrayList listB = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            Student s=list.get(i);
            if((s.getMath()+s.getChinese())>160){
                listB.add(s);
            }
   
   
        }
   
        return listB;
        }
   
    }
   

第四十六题：
1.定义Empl类，包含salary（工资属性私有化），提供空参带参构造方法，和set/get方法
2.定义ArrayList集合，存入3个Empl对象，对象的薪资属性分别为：100，123，567
3.遍历集合,将集合中元素的薪资小于等于300的元素删除，将集合中元素的薪资大于300的元素，元素值在原来基础上加100，
并在控制台打印输出修改后集合中所有元素的属性

public class Emplee {
    private String name;
    private String id;
    private int salary;
public Emplee() {
}

public Emplee(String name, String id, int salary) {
    this.name = name;
    this.id = id;
    this.salary = salary;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

public int getSalary() {
    return salary;
}

public void setSalary(int salary) {
    this.salary = salary;
}
public  void show(){
    System.out.println(getName()+getId()+getSalary());
}
}


public class EmpleeTest01 {
    public static void main(String[] args) {
        ArrayListlist=new ArrayList<>();
        Emplee e1=new Emplee("王维","123",100);
        Emplee e2=new Emplee("李白","456",123);
        Emplee e3=new Emplee("白居易","789",567);
        list.add(e1);
        list.add(e2);
        list.add(e3);
        for (int i = 0; i < list.size(); i++) {
            Emplee e=list.get(i);
            System.out.println(e.getName()+"--"+e.getId()+"---"+e.getSalary());
        }

    for (int i = 0; i < list.size(); i++) {
        Emplee e=list.get(i);
        if(e.getSalary()<300){
            list.remove(i);
            i--;
        }

        }
    System.out.println("===========");
    for (int i = 0; i < list.size(); i++) {
        Emplee e=list.get(i);
        System.out.println(e.getName()+"--"+e.getId()+"---"+e.getSalary());
    }
    for (int i = 0; i < list.size(); i++) {
        Emplee e=list.get(i);
        if(e.getSalary()>300){
            e.setSalary(e.getSalary() + 100);
        }

    }

    System.out.println("===========");
    for (int i = 0; i < list.size(); i++) {
        Emplee e=list.get(i);
        System.out.println(e.getName()+"--"+e.getId()+"---"+e.getSalary());
    }


    }


}

第四十七题：
请编写程序，键盘录入1个字符串，统计字符串中的大写字符个数，小写字符个数和数字的个数。
格式如下：
数字个数：3
请输入： 小写字符个数：2
大写字符个数：2

 public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.next();
        int bigcount=0;
        int smallcount=0;
        int numconut=0;
        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            if(ch>='A'&&ch<='Z'){
                bigcount++;
            }else if(ch>='a'&&ch<='z'){
                smallcount++;
            }else if(ch>='0'&&ch<='9'){
                numconut++;
            }
        }
        System.out.println("数字的个数:"+numconut);
        System.out.println("大写字符的个数:"+bigcount);
        System.out.println("小写字符的个数:"+smallcount);
    }

第四十八题：
1.定义ArrayList集合，存入如下字符串：“abc”，“123”，“java”，“mysql”，“别跑啊”
2.遍历集合，将长度小于4的元素左边填充字符串0，并在控制台打印输出修改后集合中所有元素
输出结果格式如下：
[0abc,0123,java,mysql,0别跑啊]

 public static void main(String[] args) {
        ArrayListlist=new ArrayList<>(List.of("abc","123","java","mysql","别跑啊"));
        System.out.println(list);
        for (int i = 0; i < list.size(); i++) {
            String str=list.get(i);
            if (str.length()<4){
               list.set(i,0+str);
            }
        }
        System.out.println(list);

}

第四十九题：
(1)定义数组,存储如下数据:“hElLo1”,“wOrLd002”,“jAVA3”,“bEst!”,“loVe”,“enJoy#”
(2)定义方法,统计数组中大写,小写,数字字符的个数并进行打印,打印格式如下:
大写字符: 个
小写字符: 个
数字字符: 个
(3)定义方法,将字符串中包含数字的字符串替换成"",并打印结果,打印格式如下:
替换前:[“hElLo1”,“wOrLd002”,“jAVA3”,“bEst!”,“loVe”,“enJoy#”]
替换后:["","","",“bEst!”,“loVe”,“enJoy#”]
(4)定义方法,将字符串的小写转换成大写,大写转换成小写(用码表值转换,大写转小写+32,小写转大写-32),
其他字符不变并打印结果,打印格式如下:
转换前:["","","",“bEst!”,“loVe”,“enJoy#”]
转换后:[, *, *, BeST!, LOvE, ENjOY#]

public class Tsst07 {
    public static void main(String[] args) {

    ArrayList list = new ArrayList<>(List.of("hElLo1", "wOrLd002", "jAVA3", "bEst!", "loVe", "enJoy#"));
    judgeCount(list);
    replace(list);
    resever(list);
}

private static void resever(ArrayList list) {

    for (int i = 0; i < list.size(); i++) {
        String str = list.get(i);
        char[] chs = str.toCharArray();
        for (int i1 = 0; i1 < chs.length; i1++) {
            if (chs[i1] >= 'a' && chs[i1] <= 'z') {
                chs[i1] -= 32;
            } else if (chs[i1] >= 'A' && chs[i1] <= 'Z') {
                chs[i1] += 32;
            }
        }
        str = new String(chs);
        list.set(i, str);
        //System.out.println(str);
    }
    System.out.println(list);

}

private static void replace(ArrayList list) {
    for (int i = 0; i < list.size(); i++) {
        String str = list.get(i);
        for (int x = 0; x < str.length(); x++) {
            char ch = str.charAt(x);
            if (ch >= '0' && ch <= '9') {
                list.set(i, "*");
                //str="*";
                //list.get(i) ="*";
            }
        }

    }
    System.out.println(list);
}

private static void judgeCount(ArrayList list) {
    String str = list.toString();
    int bigcount = 0;
    int smallcount = 0;
    int numcount = 0;
    for (int i = 0; i < str.length(); i++) {
        char ch = str.charAt(i);
        if (ch >= 'A' && ch <= 'Z') {
            bigcount++;
        } else if (ch >= 'a' && ch <= 'z') {
            smallcount++;
        } else if (ch >= '0' && ch <= '9') {
            numcount++;
        }
    }
    System.out.println("大写字符：" + bigcount + "个");
    System.out.println("小写字符：" + smallcount + "个");
    System.out.println("数字字符：" + numcount + "个");

}

}