Java练习题 – 方法

求和

封装一个方法sum，输入一个非负整数，求1 ~ 一个数之间的和，并返回

public class Demo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int sum = sum(a);
        System.out.println(sum);
    }

    public static int sum(int num) {
        int sum = 0;
        for (int i = 1; i <= num; i++) {
            sum+=i;
        }
        return sum;
    }
}

封装一个方法sum，输入两个非负整数，求两个数之间的和，并返回 （提升）

public class Demo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        int sum = sum(a,b);
        System.out.println(sum);
    }

    public static int sum(int num1,int num2) {
        int sum = 0;
        int max = num1>num2?num1:num2;
        int min = num1<num2?num1:num2;
        for (int i = min; i <= max ; i++) {
            sum+= i;
        }
        return sum;
    }
}

最大值

封装一个方法max2，求两个数的最大值，并返回

public class Demo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        int max = max2(a, b);
        System.out.println(max);
    }

    public static int max2(int num1,int num2) {
        return num1>num2?num1:num2;
    }  
}

封装一个方法max3，求三个数的最大值，并返回（提升）

• 方法一：

  public class Demo {
      public static void main(String[] args) {
          Scanner scan = new Scanner(System.in);
          int a = scan.nextInt();
          int b = scan.nextInt();
          int c = scan.nextInt();
          int max = max3(a, b, c);
          System.out.println(max);
      }
  
      public static int max3(int num1,int num2,int num3) {
          return num1>num2?(num1>num3?num1:num3):(num2>num3?num2:num3);
      }
  }
  

• 方法二：

  public class Demo {
      public static void main(String[] args) {
          Scanner scan = new Scanner(System.in);
          int a = scan.nextInt();
          int b = scan.nextInt();
          int c = scan.nextInt();
          int max = max2(max2(a, b),c);
          System.out.println(max);
      }
  
      public static int max2(int num1,int num2) {
          return num1>num2?num1:num2;
      }
  }
  

求各个位数之和

封装一个sum方法，给定一个四位的数字，求各个位数之和

public class Demo {
    public static void main(String[] args) {
        sum1(1234);
    }

    /**
     * 通过方法达到
     * 手动输入一个4位数，求各位数字之和
     * @param num
     * @return 无返回值 方法执行结束输出一条语句
     */
    public static void sum1(int num){
        int sum = 0;//和
        while (num > 0 ){
            sum+=num%10;
            num=num/10;
        }
        System.out.println("各位数字之和: " + sum);
    }
}

封装一个sum方法，给定一个四位的数字，求各个位数之和，并返回

public class Demo {
    public static void main(String[] args) {
        //调用方法 sum2
        int result = sum2(1234);
        System.out.println(result);
    }

    /**
     * 通过方法达到
     * 手动输入一个4位数，求各位数字之和
     * @param num
     * @return 有返回值 返回值类型为int 方法执行结束返回一个int值给调用方
     */
    public static int sum2(int num){
        int sum = 0;//和
        while (num > 0 ){
            sum+=num%10;
            num=num/10;
        }
        return sum;
    }
}

敲7

封装一个方法，打印出1 ~ 100 之间所有不是7的倍数和不包含7的数字，并求和

public class Demo {
    public static void main(String[] args) {
        //调用方法 sum1
        sum1();
    }

    /**
     * 通过方法达到
     * 打印出1-100之间所有不是7的倍数和不包含7的数字，并求和
     * @return 无返回值 方法执行结束输出一条语句
     */
    public static void sum1(){
        int sum = 0;//和
        for(int i = 1; i <= 100; i++) {
            //  i%7 == 0   表示 7的倍数
            //  i/10 == 7  表示十位数上的数字为7
            //  i%10 == 7  表示个位数上的数字为7
            if (i % 7 == 0 || i / 10 == 7 || i % 10 == 7){
                continue;
            }
            System.out.print(i + " ");
            sum += i;
        }
        System.out.println("和为: " + sum);
    }
}

封装一个方法，求1 ~ 100 之间所有不是7的倍数和不包含7的数字之和 ，将该值返回

public class Demo {
    public static void main(String[] args) {
        //调用方法 sum2
        int result = sum2(1, 100);
        System.out.println("和为: " + result);
    }

    /**
     * 通过方法达到
     * 打印出1-100之间所有不是7的倍数和不包含7的数字，并求和
     * @return 有返回值 返回值类型为int 方法执行结束返回一个int值给调用方
     */
    public static int sum2(){
        int sum = 0;//和
        for(int i = 1; i <= 100; i++) {
            //  i%7 == 0   表示 7的倍数
            //  i/10 == 7  表示十位数上的数字为7
            //  i%10 == 7  表示个位数上的数字为7
            if (i % 7 == 0 || i / 10 == 7 || i % 10 == 7){
                continue;
            }
            sum += i;
        }
        return sum;
    }
}

数组的操作

封装一个generate方法，用于生成指定长度的int数组，数组的元素为0到指定范围的随机数，并将该数组返回

public class Demo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int len = scan.nextInt();
        int max = scan.nextInt();
        int[] arr = generate(len,max);
        System.out.println(Arrays.toString(arr));
    }

    public static int[] generate(int len,int max) {
        int[] arr = new int[len];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random()*(max+1));
        }
        return arr;
    }
}

给出两个数组：

• 数组a：{1，7，9，11，13，15，17，19}；
• 数组b：{2，4，6，8，10}

封装一个方法mergeArr将两个数组合并为数组c，按升序排列，并将数组返回。

public class Demo {
    public static void main(String[] args) {
        int[] arr1 = {1,7,9,11,13,15,17,19};
        int[] arr2 = {2,4,6,8,10};
        int[] arr = mergeArr(arr1,arr2);
        System.out.println(Arrays.toString(arr));
    }

    public static int[] mergeArr(int[] arr1,int[] arr2) {
        int[] arr = new int[arr1.length+arr2.length];
        System.arraycopy(arr1,0,arr,0,arr1.length);
        System.arraycopy(arr2,0,arr,arr1.length,arr2.length);
        Arrays.sort(arr);
        return arr;
    }
}