Java基础知识（JavaSE）案例_数组拓展

基础阶段一：JavaSE学习_数组拓展

基础阶段一：JavaSE学习_数组拓展

建议：先根据题目要求进行编写，然后再与我所提供的答案进行对比。因为你的方法和思路可能是最完美的!

百钱百鸡–小试牛刀

需求：

我国古代数学张邱建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡崽三值钱一。
百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

/**
 * @Author: ✎﹏ Sunflower丶
 */

public class Demo01 {
      
      
    public static void main(String[] args) {
      
      
        //计数器
        int num = 0;
        //用于表示鸡翁的范围，初始化表达式的变量定义为i=0,判断条件i<=20
        for (int i = 0; i < 20; i++) {
      
      
            //定义变量记录鸡雏数
            int chick = 0;
            //用于表示鸡母的范围，初始化表达式的变量定义为j=0,判断条件j<=20
            for (int j = 0; j < 33; j++) {
      
      
                //计算鸡雏的数
                chick = 100 - i - j;
                //判断是否全部满足条件
                if (chick % 3 == 0 && chick / 3 + i * 5 + j * 3 == 100) {
      
      
                    num++;
                    System.out.println("方案"+num+":\t鸡翁有：" + i + ",鸡母有:" + j + ",鸡雏有:" + chick);
                }
            }
        }
    }
}

数组基本查找

需求：

已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控
制台输出找到的索引值。

import java.util.Scanner;

/**
 * @Author: ✎﹏ Sunflower丶
 */
public class Demo02 {
      
      
    public static void main(String[] args) {
      
      
        //已知数组
        int[] arr = {
      
      19,28,37,46,50};
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //获取输入数值
        int num = sc.nextInt();
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
      
      
            //将数组值与键盘录入值进行比较。
            if (num == arr[i]) {
      
      
                System.out.println(i);
                return;
            }
        }
        System.out.println("输入有误！");

    }
}

公司年销售额求和

需求：

某公司季度和月份统计的数据如下：单位(万元)
第一季度:22,66,44
第二季度:77,33,88
第三季度:25,45,65
第四季度:11,66,99

/**
 * @Author: ✎﹏ Sunflower丶
 */
public class Sale {
    
    
    public static void main(String[] args) {
    
    
        //数组
        int[][] arr ={
    
    {
    
    22, 66, 44}, {
    
    77, 33, 88}, {
    
    25, 45, 65}, {
    
    11, 66, 99}};
        //记录每个季度的和
        int sum1 = 0;
        //求和变量，准备记录最终求和结果
        int  sum2 = 0;
        //遍历二维数组
        for (int i = 0; i < arr.length; i++) {
    
    
            sum1 = 0;
            //遍历二维数组中的一维数组
            for (int j = 0; j < arr[i].length; j++) {
    
    
                sum1 += arr[i][j];
            }
            //输出季度和
            System.out.println(sum1);
            sum2 += sum1;
        }
        //输出总和
        System.out.println(sum2);
    }
}

数组内容相同

需求：

设计一个方法，用于比较两个数组的内容是否相同。

扫描二维码关注公众号，回复： 14230524 查看本文章

/**
 * @Author: ✎﹏ Sunflower丶
 */
public class Demo03 {
      
      

    public static void main(String[] args) {
      
      
        //调用方法
        boolean method = method(new int[]{
      
      1, 2, 3, 4, 5}, 1, 2, 3, 4, 5);
        //输出结果
        System.out.println(method);
    }

    public static boolean method(int[]arr1,int...arr2) {
      
      
        //判断两数组长度是否相等
        if (arr1.length == arr2.length) {
      
      
            //循环遍历一个数组
            for (int i = 0; i < arr1.length; i++) {
      
      
                //比较两数组对应元素是否相等，若有一次不相等，就直接结束方法，返回false
                if (arr1[i] != arr2[i]) {
      
      
                    return false; 
                }
            }
            return true;
        }
        return false;
    }
}

反转

需求：

已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换，交换后的数组arr={50,46,37,28,19};并在控制台输出交换后的数组{50,46,37,28,19}。

/**
 * @Author: ✎﹏ Sunflower丶
 */
public class Demo04 {
      
      
    public static void main(String[] args) {
      
      
        //根据数据，定义数组
        int[] arr = {
      
      19, 28, 37, 46, 50};
        //用变量记录数组最后一个索引
        int num = arr.length - 1;
        for (int i = 0; i <= arr.length / 2; i++) {
      
      
            int temp = arr[i];
            arr[i] = arr[num - i];
            arr[num - i] = temp;
        }
        method(arr);
    }
    //定义一个能遍历数组并且可以数组格式输出的方法
    public static void method(int[] arr) {
      
      
        System.out.print("{");
        for (int i = 0; i < arr.length; i++) {
      
      
            if(i != arr.length - 1) {
      
      
                System.out.print(arr[i] + ",");
            }else {
      
      
                System.out.print(arr[i] + "}");
            }
        }
            System.out.println();
    }
}

评委打分

需求：

在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。选手的最后得分为：去掉一个最高分和一个最低分后的4个评委平均值 (不考虑小数部分)。

import java.util.Scanner;

/**
 * @Author: ✎﹏ Sunflower丶
 */
public class Demo05 {
      
      
    /*
    案例:评委打分
    在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
              选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
     */
    public static void main(String[] args) {
      
      
        //创建一个长度为6的数组
        int[] arr = new int[6];
        //定义一个记录平均分的变量
        int sum = 0;
        //剩下的评委
        int s = 0;
        //遍历数组，通过输入，依次接收并记录评委的分数
        for (int i = 0; i < arr.length; i++) {
      
      
            System.out.print("请输入分数：");
            Scanner sc = new Scanner(System.in);
            int grade = sc.nextInt();
            //判断是否没有正确输入分数，条件判断语句为true则执行循环，否则结束循环
            while (grade < 0 || grade > 100) {
      
      
                System.out.print("输入有误！请输入0~100的分数：");
                grade = sc.nextInt();
            }
            //保存分数
            arr[i] = grade;
        }
        //记录最大值，最小值
        int max = arr[0], min = arr[0];
        //遍历数组，查找最大值和最小值
        for (int i = 0; i < arr.length; i++) {
      
      
            if (max < arr[i]) {
      
      
                max = arr[i];
            }
            if (min > arr[i]) {
      
      
                min = arr[i];
            }
        }
        //
        for (int i = 0; i < arr.length; i++) {
      
      
            if (arr[i] != max && arr[i] != min) {
      
      
                System.out.println(arr[i]);
                sum += arr[i];
                s++;
            }
        }
        //去掉一个最高分和一个最低分后 的4个评委平均值
        sum /= s;
        //输出分数
        System.out.println(sum);
    }

}

不死神兔

需求：

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
假如兔子都不死，问第二十个月的兔子对数为多少？

/**
 * @Author: ✎﹏ Sunflower丶
 */
public class Demo06 {
    
    
    /*不死神兔
    有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
    假如兔子都不死，问第二十个月的兔子对数为多少？

     */
    public static void main(String[] args) {
    
    
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //月份
        int[] mount =new int[sc.nextInt()];
        mount[0] = 1;
        mount[1] = 1;
        //遍历
        for (int i = 2; i < mount.length ; i++) {
    
    
            mount[i] = mount[i - 1] + mount[i - 2];
        }
        System.out.println(mount[mount.length - 1]);
    }
}

数组元素求和

需求：

有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和，
要求是:求和的元素个位和十位都不能是7，并且只能是偶数。

/**
 * @Author: ✎﹏ Sunflower丶
 */
public class Demo07 {
      
      
    public static void main(String[] args) {
      
      
        //创建数组，并赋值
        int[] arr = {
      
      68,27,95,88,171,996,51,210};
        //定义求和变量
        int sum = 0;
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
      
      
            //判断数组是几位数
            boolean ge =(arr[i] % 10 != 7) , shi = false;
            if (arr[i] >= 0 && arr[i] < 100) {
      
      
                //记录数组元素的个位和十位是七的数
                shi = (arr[i] / 10 != 7);
            }else if(arr[i] >= 100 && arr[i] < 1000) {
      
      
                //记录数组元素的个位和十位是七的数
                shi = (arr[i] % 100 / 10 != 7);
            }
            //判断条件是否成立
            if (ge && shi && (arr[i] % 2 == 0)) {
      
      
                System.out.println(arr[i]);
                sum += arr[i];
            }
        }
        System.out.println(sum);
    }
}

综合

案例1

需求：

1.键盘录入6个int类型的数据存数数组arr中
2.将arr数组中的内容反转
3.将翻转后的数组角标为奇数的互相交换 1和3换, 3和5换,以此类推
4.最后将数组最后一个角标为奇数的元素和数组中第一个角标为奇数的元素交换
5.打印最终的数组(实现了 1-4 步之后的数组)
6.如：用户输入的6个int数字为[1,2,3,4,5,6],最后输出的结果为[6, 5, 4, 1, 2, 3]

import java.util.Scanner;

/**
 * @Author: ✎﹏ Sunflower丶
 */
public class Test01 {
    
    
    public static void main(String[] args) {
    
    
        //1.键盘录入6个int类型的数据存数数组arr中
        //在录入数据之前必须要有一个6个长度的数组
        int[] arr = new int[6];
        //创建键盘输入对象
        Scanner sc = new Scanner(System.in);
        //输入几个数据? 6 个  , 换个角度来思考  : 数组有多长就需要录入几个
        //循环遍历数组,循环几次就录入几次
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.println("请输入第"+(i+1)+"个数据:");
            arr[i] = sc.nextInt();
        }

        //循环结束后,数组中就有6个数据了!!!
        //2.将arr数组中的内容反转
        int start = 0;
        int end = arr.length-1;

        while (start < end){
    
    
            //循环里做什么事情?  交换元素的位置
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;

            start++;
            end--;
        }

       //3.将翻转后的数组角标为奇数的互相交换 1和3换, 3和5换,以此类推
        //arr.length-2: 就是为了控制循环只循环到倒数第二个奇数索引
        for (int i = 0; i < arr.length-2; i++) {
    
    
            //判断一下,索引是否为奇数
            if (i % 2 != 0){
    
    
                //交换位置
                int temp = arr[i];
                arr[i] = arr[i+2];
                arr[i+2] = temp;
            }
        }

        //最后将数组最后一个角标为奇数的元素 和数组中第一个角标为奇数的元素交换
        if (arr.length % 2 == 0){
    
    
            //数组的长度-1就是最后一个奇数索引
            int temp = arr[1];
            arr[1] = arr[ arr.length-1 ];
            arr[ arr.length-1 ] = temp;
        }else{
    
    
            //数组的长度-2就是最后一个奇数索引
            int temp = arr[1];
            arr[1] = arr[ arr.length-2 ];
            arr[ arr.length-2 ] = temp;
        }

        //打印最终的数组(实现了 1-4 步之后的数组)
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.println(arr[i]);
        }
    }
}

案例2

需求：

1.键盘录入10个整数存入数组中
2.定义一个方法将奇数放在数组的左侧,偶数放在数组的右侧
3.定义一个方法打印原数组和处理后的数组
4.定义一个方法传入一个int类型数组，输出这个数组中只出现一次的数字及个数

import java.util.Scanner;

/**
 * @Author: ✎﹏ Sunflower丶
 */
public class Test02 {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = new int[6];
        //创建键盘输入对象
        Scanner sc = new Scanner(System.in);
        //输入几个数据? 6 个  , 换个角度来思考  : 数组有多长就需要录入几个
        //循环遍历数组,循环几次就录入几次
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.println("请输入第" + (i + 1) + "个数据:");
            arr[i] = sc.nextInt();
        }

        //键盘输入之前打印
        print(arr);
        //2.定义一个方法将奇数放在数组的左侧,偶数放在数组的右侧
        //调用方法交换
        swap(arr);
        //交换之后打印数组的元素
        print(arr);
        //4.定义一个方法传入一个int类型数组，输出这个数组中只出现一次的数字及个数
        printNumber(arr);
    }

    /*
        三个明确:
                方法要做的事情
                        输出这个数组中只出现一次的数字及个数
                方法的参数
                        数组  int[] a
                方法的返回值
                        不需要 void
     */
    public static void printNumber(int...arr) {
    
    
        //写一个循环的嵌套
        int count1 = 0;
        //外循环 循环一次,内循环要循环一圈
        for (int i = 0; i < arr.length; i++) {
    
    
            //定义一个计数器
            int count = 0;
            for (int j = 0; j < arr.length; j++) {
    
    
                //拿着外循环遍历到的元素和 内循环遍历到的元素进行比较
                if (arr[i] == arr[j]) {
    
    
                    //计数器++
                    count++;
                }
            }

            //每次当内循环结束的时候,判断一下计数器
            if (count == 1) {
    
    
                System.out.println("数组中只出现一次的数据为: " + arr[i]);
                //每次打印的时候就说明找到了 只出现一次的数据,那么让count1++
                count1++;
            }

        }

        System.out.println("数组中一共有 " + count1 + " 只出现一次的元素");
    }


    /*
        三个明确:
                方法要做的事情
                        奇数放在数组的左侧,偶数放在数组的右侧
                方法的参数
                        数组  int[] a
                方法的返回值
                        不需要 void
     */
    public static void swap(int...a) {
    
    
        //定义一个变量, 作为奇数存储的索引 int index = 0;
        int index = 0;
        //循环遍历数组
        for (int i = 0; i < a.length; i++) {
    
    
            //判断数组的元素是否为奇数
            if (a[i] % 2 != 0) {
    
    
                //如果是奇数,那么就让当前的元素和 arr[index] 进行交换
                int temp = a[index];
                //每次进行了交换,一定要记得让index++
                a[index] = a[i];
                a[i] = temp;

                index++;
            }
        }
    }

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

Java基础知识(JavaSE)案例_数组拓展