Java语言基础1--练习题

- 1、编写一个方法，计算并返回给定int数组的和

/*
    需求：1）编写一个方法，计算并返回给定int数组的和。
*/

public class Demo1
{
    public static void main(String[] args) 
    {
        int[] a = {56,98,73,22,56,95};
        System.out.println(sum(a));
    }
    // 求和思想
    public static int sum(int[] a)
    {
        // 定义和的临时变量
        int sum = 0;
        // 遍历数组实现 求和
        for (int i = 0; i < a.length; i++) 
        {
            sum += a[i];    
        }
        return sum;
    }
}

---

- 2、提示用户输入一个整数n，生成一个int数组，数组的长度为n，并且数组元素从1依次递增到n,如 {1,2,3…n}

/*
    需求：2）提示用户输入一个整数n，生成一个int数组，数组的长度为n，
            并且数组元素从1依次递增到n,如 {1,2,3...n}
*/
import java.util.Scanner;
import java.util.Arrays;

public class Demo2
{
    public static void main(String[] args) 
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数组的长度(n)：");
        int n = sc.nextInt();
        // 动态初始化：只给定数组的长度
        int[] arr = new int[n];
        // 遍历数组，实现动态初始化
        for (int i = 0; i < arr.length; i++) 
        {
            // 根据题目所给例子描述，得出规律
            arr[i] = i + 1;
        }
        // 使用Arrays数组类的静态方法实现生成数组的输出
        System.out.println("生成数组为：" + Arrays.toString(arr));
    }
}

---

- 3、编写一个方法，bool isEquals(int[] nums1,int[] nums2)，比较两个数组的内容是否完全相等(对应索引位置的元素完全相等)

/*
    需求：3）编写一个方法，bool isEquals(int[] nums1,int[] nums2)，
        比较两个数组的内容是否完全相等(对应索引位置的元素完全相等)。
*/
import java.util.Arrays;

public class Demo3
{
    public static void main(String[] args) 
    {
        // 静态初始化数组
        int[] nums1 = {1,2,3,4,5};
        int[] nums2 = {1,2,3,4,5};
        int[] nums3 = {};
        int[] nums4 = {3,4,5};
        int[] num = null;       
        System.out.print(Arrays.toString(nums1)+" 和 "+Arrays.toString(num)+" 是否相等?\t\t");
        System.out.println(isEquals(nums1,num));
        System.out.print(Arrays.toString(nums1)+" 和 "+Arrays.toString(nums3)+" 是否相等?\t\t");
        System.out.println(isEquals(nums1,nums3));
        System.out.print(Arrays.toString(nums1)+" 和 "+Arrays.toString(nums4)+" 是否相等?\t\t");
        System.out.println(isEquals(nums1,nums4));
        System.out.print(Arrays.toString(nums1)+" 和 "+Arrays.toString(nums1)+" 是否相等?\t\t");
        System.out.println(isEquals(nums1,nums2));
    }

    public static boolean isEquals(int[] nums1,int[] nums2)
    {
        // 1、如果数组有一个为空null，则直接返回false
        if(nums1 == null || nums2 == null)
        {
            return false;
        }

        // 2、如果数组有一个长度为0，则直接返回false
        if(nums1.length == 0 || nums2.length == 0)
        {
            return false;
        }

        // 3、如果数组长度不同，则直接返回false
        if (nums1.length != nums2.length) 
        {
            return false;
        }

        // 遍历数组，发现不同元素，则直接返回false
        for (int i = 0; i < nums1.length; i++) {
            if(nums1[i] != nums2[i])
            {
                return false;
            }
        }

        // 对比所有元素均相同，则返回true
        return true;
    }
}

---

- 4、编写方法getMax，它带有3个int 型参数a,b,c，返回a,b,c这三个数的最大值

/*
    需求：4）编写方法getMax，它带有3个int 型参数a,b,c，返回a,b,c这三个数的最大值。
*/
public class Demo4
{
    public static void main(String[] args)
    {
        int a = 12;
        int b = 34;
        int c = -26;
        int max = getMax(a,b,c);
        System.out.println(a + "," + b + "," + c + " 中的最大值是：" + max);
    }

    private static int getMax(int a,int b)
    {
        if(a > b)
        {
            return a;
        }
        else{
            return b;
        }
    }

    public static int getMax(int a,int b,int c)
    {
        /*  1、为了使用方法重载(OverLoad)，将问题分解：
            1)、先得到前两个数据的较大值
            2)、再和第三个数据对比获取最大值
        */

        return getMax(getMax (a, b), c);

        /* 2、使用嵌套的if...else...if实现
        if(a > b)
        {
            if(a > c)
            {
                return a;
            }
            else{
                return c;
            }
        }
        else{
            if(b > c)
            {
                return b;
            }
            else{
                return c;
            }
        }
        */

        /* 3、使用三元运算符嵌套实现
        return (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c); 
        */
    }
}

---

- 5、用户输入年、月、日，计算该日是该年的第几天？(注意2月份)

/*
    需求：5）用户输入年、月、日，计算该日是该年的第几天？(注意2月份)
*/
import java.util.Scanner;

public class Demo5
{
    public static void main(String[] args)
    {
        int year;     //接受用户的输入年
        int month;    //接受用户的输入月
        int day;      //接受用户的输入日

        Scanner sc = new Scanner(System.in);
        System.out.println("请依次输入年、月、日(使用空格分隔):");
        year = sc.nextInt();
        month = sc.nextInt();
        day = sc.nextInt();

        // 1、年月日必须均为正整数
        if(year <= 0 || month <= 0 || day <= 0)
        {
            System.out.println("年月日必须均为正整数");
            return;
        }

        // 2、月份必须是1-12之间的正整数
        if(month > 12)
        {
            System.out.println("月份必须是1-12之间的正整数");
            return;
        }

        // 设置变量leap获取函数的返回值（确定是否为闰年）
        boolean leap = isLeap(year);

        // 3、根据不同的月份判定最大天数
        switch(month)
        {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                if(day > 31)
                {
                    System.out.println("该月份的天数最多是 31 天！");
                    return;
                }
                break;
            case 2:
                if(leap && (day > 29))
                {
                    System.out.println("该月份的天数最多是 29 天！");
                    return;
                }
                else if(day > 28)
                {
                    System.out.println("该月份的天数最多是 28 天！");
                    return;
                }
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                if(day > 30)
                {
                    System.out.println("该月份的天数最多是 30 天！");
                    return;
                }
                break;
        }

        /* 4、根据给定年是否是闰年判定2月份的天数
            定义数组 arrDays 存放当前年份的所有月份的天数(按照平年初始化)
        */
        int[] arrDays = {31,28,31,30,31,30,31,31,30,31,30,31};;
        if(leap)
        {
            // 如果是闰年，2月份的天数是29
            arrDays[1] = 29;
        }

        /* 5、求该日是该年的第几天(days)?
            年 决定如何初始化.
            月 确定数组求和的终止条件.
            日 直接累加，即可.
        */
        int days = 0;
        for(int i = 0; i < month-1; i++)
        {
            days += arrDays[i];
        }
        days += day;
        System.out.print(year + " 年 " + month + " 月 " + day + " 日 ");
        System.out.println("是 " + year + " 年的第 " + days + " 天!");
    }

    /* 闰年的2月是29天，平年是28天
        根据给定的年判断是否闰年
    */
    public static boolean isLeap(int year)
    {
        /* 以下情况之一的是闰年：
            ①、普通年能被4整除且不能被100整除的为闰年
            ②、世纪年能被400整除的是闰年
        */
        if(year % 400 == 0)
        {
            return true;
        }
        if(year % 4 == 0 && year % 100 != 0)
        {
            return true;
        }
        return false;
    }
}

---

- 6、给定一个int数组：int[] nums = {3,5,9,2,22,12};写一个方法int[]reverse(int[] nums)，对数组进行反向处理。也就是返回：{12,22,2,9,5,3} 这样一个int数组

/*
    需求：6）给定一个int数组：int[] nums = {3,5,9,2,22,12};
        写一个方法int[]reverse(int[] nums)，对数组进行反向处理。
        也就是返回：{12,22,2,9,5,3} 这样一个int数组

    分析：

    实现：2种实现方式

          1）输出到新的数组中
           遍历数组将数组中的第一个元素给新的数组的最后一个元素，
            第二个给新的数组中的倒数第二个，以此类推

          2）数组内部实现交换
           遍历数组，让数组两端的数据进行交换
*/
import java.util.Arrays;

public class Demo6
{
    public static void main(String[] args)
    {
        int[] nums = {3,5,9,2,22,12};

        System.out.println("逆置前的数组是：" + Arrays.toString(nums));
        System.out.println();
        System.out.println("(方式一实现)逆置后的数组是：" + Arrays.toString(reverse1(nums)));
        System.out.println("(方式二实现)逆置后的数组是：" + Arrays.toString(reverse2(nums)));
    }

    public static int[] reverse1(int[] nums)
    {
        /*
            1）输出到新的数组中
        */
        int[] numsNew = new int[nums.length];
        for(int i = 0; i < nums.length; i++)
        {
            numsNew[i] = nums[nums.length-1-i];
        }
        return numsNew;
    }

    public static int[] reverse2(int[] nums)
    {
        /*
            2）数组内部实现交换（利用之前总结的四种整数的交换的方式）
        */
        for(int i = 0; i < (nums.length/2); i++)
        {
            int temp;
            temp = nums[i];
            nums[i] = nums[nums.length-1-i];
            nums[nums.length-1-i] = temp;
        }
        return nums;
    }
}

---

- 7、问答： 下面代码的执行结果是什么？为什么？

/*
    需求：7）问答： 下面代码的执行结果是什么？为什么？
*/
    int i=0;
    System.out.println(i++);
    int j=0;
    System.out.println(++j);
    int z=0;
    System.out.println(z=z+1);

    // 输出：
        0
        1
        1

    // 明确：
        1、后++，是先赋值，再自增（i=i+1）
        2、前++，是先自增（i=i+1），再赋值

    // 分析：
        System.out.println(i++);
        System.out.println(++j);
        System.out.println(z=z+1);

    // 相当于：
        System.out.println(i);
        i = i + 1;

        j = j + 1;
        System.out.println(j);

        z = z + 1;
        System.out.println(z);

---