java方法案例

求和

设计一个方法，用于计算整数的和

import java.util.Scanner;

/**
 * date：2023/8/11  19:06
 */
//设计一个方法，用于计算整数的和
public class MethodExercises1 {
    public static void main(String[] args) {
        int n1=input();
        int n2=input();
        int sum=sum(n1,n2);
        System.out.println("这两个数的和是"+sum);
    }
    public static int sum(int n1,int n2){
      return n1+n2;
    }
    public static int input(){
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个数：");
        int score = sc.nextInt();
        return score;
    }
}

阶乘

编写一个方法，接受一个正整数作为参数，并返回它的阶乘

import java.util.Scanner;

/**
 * date：2023/8/11  19:10
 */

public class MethodExercises2 {
    //编写一个方法，接受一个正整数作为参数，并返回它的阶乘
    public static void main(String[] args) {
        int n=input();
        System.out.println("这个数的阶乘是："+ factorial(n));
    }
    public static int factorial(int n){
        int result=1;
        for (int i=1;i<=n;i++){
           result*=i;
        }
        return result;
    }
    public static int input(){
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个数：");
        int score = sc.nextInt();
        return score;
    }
}

判断素数

编写一个方法，接受一个整数作为参数，并判断它是否为素数（质数）

import java.util.Scanner;

/**
 * date：2023/8/11  19:27
 */

public class MethodExercises3 {
    //编写一个方法，接受一个整数作为参数，并判断它是否为素数（质数）
    public static void main(String[] args) {
        int n=input();
        suShu(n);
    }

    //判断一个数是否为素数
    public static void suShu(int num){
        int count = 0;
        for (int i = 2; i < num; i++) {
            if (num % i == 0) {
                count++;
            }
        }
        if (count == 0) {
            System.out.println(num + "是素数");
        } else {
            System.out.println(num + "不是素数");
        }
    }
    public static int input(){
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个数：");
        int score = sc.nextInt();
        return score;
    }
}

翻转数组

编写一个方法，接受一个字符数组，将其翻转并输出。

import java.util.Arrays;

/**
 * date：2023/8/11  19:36
 */

public class MethodExercises4 {
    //编写一个方法，接受一个字符数组，将其翻转并输出。
    public static void main(String[] args) {
        char[] arr = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
        System.out.println("原数组"+Arrays.toString(arr));
        char[] array=array(arr);
        System.out.println("翻转后的数组"+Arrays.toString(array));
    }

    public static char[] array(char[] arr){
        char arr1[]=new char[arr.length];
        int j=0;
        for (int i=arr.length-1;i>=0;i--){
            arr1[j++]=arr[i];
        }
        return arr1;
    }
}

回文数

编写一个方法，接受一个整数作为参数，判断它是否为回文数（正着读和倒着读都一样）

import java.util.Scanner;

/**
 * date：2023/8/11  19:53
 */

public class MethodExercises5 {
    //编写一个方法，接受一个整数作为参数，判断它是否为回文数（正着读和倒着读都一样）
    public static void main(String[] args) {
        int n=input();
        System.out.println(huiWenShu(n));
    }
    public static boolean huiWenShu(int n){
        int w=0;
        int i=n,k=n;
        while(i>0){
            i= i/10;
            w++;
        }
        int t=0;
        for(int j=1;j<=w;j++){
            int s=n%10;
            n=n/10;
            t=t*10+s;

        }
        if (t==k){
            return true;
        }
        return false;
    }
    public static int input(){
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个数：");
        int score = sc.nextInt();
        return score;
    }
}

交换元素位置

编写一个方法，接受一个整数数组和两个索引作为参数，交换数组中指定索引位置的两个元素。

import javax.swing.*;
import java.lang.reflect.AccessibleObject;
import java.util.Arrays;

/**
 * date：2023/8/11  20:12
 */

public class MethodExercises6 {
    //编写一个方法，接受一个整数数组和两个索引作为参数，交换数组中指定索引位置的两个元素。
    public static void main(String[] args) {
        int[] arr = {2, 3, 1, 8, 5, 9, 6};
        System.out.println("原始数组");
        System.out.println(Arrays.toString(arr));
        int n1= 2;
        int n2= 5;
        int[] arr1=array(n1,n2,arr);
        System.out.println("交换第"+(n1+1)+"位和第"+(n2+1)+"位位置后的数组");
        System.out.println(Arrays.toString(arr1));
    }
    public static int[] array(int n1,int n2,int[] arr){
        for (int i = 0; i < arr.length; i++) {
            int temp =arr[n1];
            arr[n1]=arr[n2];
            arr[n2]=temp;
        }
        return arr;
    }
}

数组元素左移

编写一个方法，接受一个整数数组和一个正整数 k 作为参数，将数组中的元素左移 k 个位置。

import java.util.Arrays;

/**
 * date：2023/8/11  20:24
 */

public class MethodExercises7 {
    //编写一个方法，接受一个整数数组和一个正整数 k 作为参数，将数组中的元素左移 k 个位置。
    public static void main(String[] args) {
//        int[] arr = {2, 3, 1, 8, 5, 9, 6};
//        int k=2;
//        int[] arr1=array(k,arr);
//        System.out.println(Arrays.toString(arr1));


   //方法一降低时间复杂度
        int[] nums = {1, 2, 3, 4, 5, 6, 7};
        rotateLeft(nums, 2);
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }
        //降低时间复杂度
        public static void rotateLeft(int[] nums, int k){
            if (nums == null || nums.length <= 1 || k <= 0) {
                return; // 检查输入是否有效
            }
            int n = nums.length;
            k = k % n; // 保证 k 在 0 到 n-1 之间

            int[] temp = new int[k];
            // 保存前 k 个元素
            System.arraycopy(nums, 0, temp, 0, k);
            // 将后面的元素移动到前面
            System.arraycopy(nums, k, nums, 0, n - k);
            // 将临时数组中保存的元素复制到数组的尾部
            System.arraycopy(temp, 0, nums, n - k, k);
        }

   //方法2

    public static int[] array(int k,int[] arr){
        for (int i = 0; i < k; i++) {
            int num=arr[0];
            for (int j=1;j<arr.length;j++){
                arr[j-1]=arr[j];
            }
            arr[arr.length-1]=num;
        }
        return arr;
    }
}