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

## 百钱百鸡--小试牛刀

* 需求：

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

~~~java
  /**
   * @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}; 键盘录入一个数据，查找该数据在数组中的索引，并在控
   制台输出找到的索引值。

~~~java
  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

~~~java
/**
 * @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);
    }
}

~~~

## 数组内容相同

* 需求：

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

~~~java
  /**
   * @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}。

~~~java
  /**
   * @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个评委平均值 (不考虑小数部分)。

~~~java
  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个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
  假如兔子都不死，问第二十个月的兔子对数为多少？

~~~java
/**
 * @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，并且只能是偶数。

~~~java
  /**
   * @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]

~~~java
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类型数组，输出这个数组中只出现一次的数字及个数

~~~java
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案例_数组拓展

目录