Java基础练习（三）数组

1、定义一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68}，

统计各成绩等级（90分以上为‘A’，80_{89分为‘B’，70}79分为‘C’，60~69分为‘D’，60分以下为E）学生人数，
并将其放入到数组count中，其中：count[0]存E级的人数，count[1]存D级的人数，……，count[4]存A级的人数。

public class ArrayPractice01 {
    public static void main(String[] args) {
        int[] grade={72,89,65,58,87,91,53,82,71,93,76,68};
        int[] count=new int[5];
        int numA=0,numB=0,numC=0,numD=0,numE=0;
        for (int i = 0; i <grade.length ; i++) {
            if(grade[i]/10==9){
                numA++;
                count[4]=numA;
            }else  if(grade[i]/10==8){
                numB++;
                count[3]=numB;

            }else  if(grade[i]/10==7){
                numC++;
                count[2]=numC;

            }else  if(grade[i]/10==6){
                numD++;
                count[1]=numD;

            }else{
                numE++;
                count[0]=numE;
            }
        }
        for (int i = 0; i <count.length ; i++) {
            switch (i){
                case 0 :
                    System.out.println("E:"+count[i]);
                    break;
                case 1 :
                    System.out.println("D:"+count[i]);
                    break;
                case 2 :
                    System.out.println("C:"+count[i]);
                    break;
                case 3 :
                    System.out.println("B:"+count[i]);
                    break;
                case 4 :
                    System.out.println("A:"+count[i]);
                    break;
            }

        }
    }
}

程序分析：统计每个等级的人数赋值给对应的数组元素

2、从键盘输入8个整数存放在一个数组中，然后

将奇数和偶数分别存入到两个不同的数组中，并按奇数、偶数交替的顺序输出这两个数组中的所有数据
（先交替输出，如果奇数个数多，则再输出剩下的奇数，如果偶数个数多，则再输出剩下的偶数）。
（提示与要求：
（1）定义一个数组存储从键盘输入的8个整数，先判断这8个整数中奇数和偶数的个数，才能定义存储奇数和偶数的数组的长度；
（2）把一个大的数组分别存放在奇数和偶数数组中并交替输出的过程定义为方法）

import java.util.Scanner;

public class ArrayPractice02 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int[] num=new int[8];

//      键入数字赋值给数组元素
        System.out.println("请输入八个数字：");
        for (int i = 0; i < num.length; i++) {
            num[i]=s.nextInt();
        }
        changeOutput(num);
    }

    //把一个大的数组分别存放在奇数和偶数数组中并交替输出的过程定义为changeOutput方法
    public static  void changeOutput(int[] num) {
        int a_odd = 0;
        int b_even = 0;

//        int[] num_odd=new int[a_odd];
//        int[] num_even=new int[b_even];//不能在此定义数组长度，此时变量的值为0，当变量在后面发生变化后，数组的长度并不会改变

        //判断数组中存在的奇偶个数  从而确定奇偶数组的长度
        for (int i = 0; i < num.length; i++) {
            if (num[i] % 2 == 0) {
                b_even++;
            } else {
                a_odd++;
            }
        }

        //在得到 a_odd和b_even的值后才能定义数组的长度
        int[] num_odd = new int[a_odd];
        int[] num_even = new int[b_even];
        //定义奇偶数组的下标值
        int a = 0;
        int b = 0;
        //将奇偶数分别给到奇偶数组中
        for (int i = 0; i < num.length; i++) {
            if (num[i] % 2 == 0) {
                num_even[a] = num[i];//偶数
                a++;
            } else {
                num_odd[b] = num[i];
                b++;
            }
        }

        //判断奇数与偶数数组的长度
        if (num_even.length > num_odd.length) {
            //偶数数组长度大于奇数数组长度，先交替输出相同下标的数字
            for (int i = 0; i < num_odd.length; i++) {
                System.out.print(num_odd[i] + "," + num_even[i] + ",");
            }
            //余下的偶数数组数字从上面最后输出的数字下标开始输出
            for (int i = num_odd.length; i < num_even.length; i++) {
                System.out.println(num_odd[i] + ",");
            }
        } else {
            //奇数多于偶数个数.....
            for (int i = 0; i < num_even.length; i++) {
                System.out.print(num_odd[i] + "," + num_even[i] + ",");
            }
            for (int i = num_even.length; i < num_odd.length; i++) {
                System.out.println(num_even[i] + ",");
            }
        }
    }
}

程序分析：使用for遍历数组元素中奇偶的个数，确定存放奇数数组和存放偶数数组的长度；

然后再次遍历该数组将奇数和偶数分别放到对应的数组中；

最后判断判断奇数与偶数数组的长度，按序输出。

3、定义一个数组,数组成员10个,找出数组中最大数连同下标一起输出

public class ArrayPractice03 {
    public static void main(String[] args) {
        int[] num={0,1,2,3,4,85,6,7,8,9};
        int[] num_copy=new int[num.length];
        //保存未排序前的数组
        for (int i = 0; i <num.length ; i++) {
            num_copy[i]=num[i];
        }
        //排序确定最大值，使用冒泡排序
        for (int i = 0; i <num.length-1 ; i++) {
            for (int j = 0; j <num.length-1-i ; j++) {
                if(num[j]>num[j+1]){
                    int temp=num[j];
                    num[j]=num[j+1];
                    num[j+1]=temp;
                }
            }
        }
//        从小到大排序后最大值为num[num.length-1],最大下标=数组长度-1
        //遍历复制数组，确定最大数原来所在下标
        for (int i = 0; i <num_copy.length ; i++) {
            if (num[num.length-1]==num_copy[i]){
                System.out.println("最大值下标为："+i);
            }
        }
    }
}

程序分析：将数组排序，确定最大值，最后确定最大值排序前的下标值

4、给定一个整型数组，数组成员10个,求该数组中第二大的数的下标

public class ArrayPractice04 {
    public static void main(String[] args) {
        int[] num={0,1,2,3,4,85,6,7,48,19};
        int[] num_copy=new int[num.length];
        //保存未排序前的数组
        for (int i = 0; i <num.length ; i++) {
            num_copy[i]=num[i];
        }
        //排序确定最大值，使用选择排序
        for (int i = 0; i <num.length-1 ; i++) {
            for (int j = i+1; j<num.length ;j++) {//j不从0开始++，行内比较为数组长度减一即j<数组长度
                if(num[i]>num[j]){
                    int temp=num[i];
                    num[i]=num[j];
                    num[j]=temp;
                }
            }
        }
//        从小到大排序后第二大值为num[num.length-2]
        //遍历复制数组，确定最大数原来所在下标
        for (int i = 0; i <num_copy.length ; i++) {
            if (num[num.length-2]==num_copy[i]){
                System.out.println("第二大值下标为："+i+"   第二大值为"+num_copy[i]);
            }
        }
    }
}

程序分析：同第4题，不过确定的是第二大的值而已

5、B哥去参加青年歌手大奖赛,有10个评委打分,(去掉一个最高一个最低)求平均分?

public class ArrayPractice05 {
    public static void main(String[] args) {
        int[] score={10,9,8,7,7,8,6,9,7,9};
        double avg=0;
        int sum=0;
        //排序
        for (int i = 0; i <score.length-1 ; i++) {
            for (int j = i+1; j <score.length ; j++) {
                if(score[i]>score[j]){
                    int temp=score[i];
                    score[i]=score[j];
                    score[j]=temp;
                }
            }
        }
        //排序后遍历数组时跳过第一个和最后一个
        for (int i=1;i<score.length-1;i++){
            sum=sum+score[i];
            System.out.println(score[i]);//排序后减去最大值和最小值后的分数
        }
        avg=sum/(score.length-2);
        System.out.println("B哥平均分为："+avg);
    }
}

程序分析：排序，然后遍历数组时跳过第一个和最后一个，于是平均分=数组元素相加/数组长度-2

6、定义数组，存放5个学生的成绩【成绩值自己设定】，将成绩从大到小排序，获得成绩之和，平均成绩，最小成绩，最大成绩。

import java.util.Scanner;

public class ArrayPractice06 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int grade[]=new int[5];
        int sum=0;
        double avg=0;
        System.out.println("请输入5个学生的成绩：");

        for (int i = 0; i < grade.length; i++) {
            grade[i]=s.nextInt();
        }
        for (int i = 0; i <grade.length-1 ; i++) {
            for (int j = 0; j <grade.length-1-i ; j++) {
                if(grade[j]<grade[j+1]){
                    int temp=grade[j];
                    grade[j]=grade[j+1];
                    grade[j+1]=temp;
                }
            }
        }

        for (int i = 0; i <grade.length ; i++) {
            sum=sum+grade[i];
            System.out.print(grade[i]+" ");
        }
        avg=sum/grade.length;
        System.out.println("成绩之和为："+sum);
        System.out.println("平均值为"+avg);
        System.out.println("最大成绩为："+grade[0]+"，最小成绩为："+grade[grade.length-1]);//由成绩排序可知
    }
}

程序分析：排序之后啥都知道了

7、提取一个方法，将指定数组中的数组元素进行反转

例如：{10,23,2,45,6}—>{6,45,2,23,10}

public class ArrayPractice07 {
    public static void main(String[] args) {
        int[] a={10,23,2,45,6};
        conversion(a);
    }

    public static void conversion(int[] a){
        for (int i = a.length-1; i >=0; i--) {
            System.out.print(a[i]+",");
        }
    }
}
//逆序输出

8、现在有如下的一个数组：int[] oldArr = {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;

要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：

int[] newArr = {1,3,4,5,6,6,5,4,7,6,7,5} ;

public class ArrayPractice08 {
    public static void main(String[] args) {
        int[] oldArr = {1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5};
        int sum_0 = 0;


        //确定数组中0的个数，从而确定不含0数组的长度
        for (int i = 0; i < oldArr.length; i++) {
            if (oldArr[i] == 0) {
                sum_0++;
            }
        }

        int n = 0;//定义新数组的下标
        int[] newArr = new int[oldArr.length - sum_0];//sum_0变量值改变后定义新数组的长度
        for (int i = 0; i < oldArr.length; i++) {
            if (oldArr[i] == 0) {
                sum_0++;
            } else {
                newArr[n] = oldArr[i];//当旧数组中数不为0时，将值赋给新数组，然后新数组的下标加一，避免因两个数组下标相同而出现缺省
                n++;
            }
        }

        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + ",");
        }
    }
}

分析：确定新数组的长度，遍历老数组有0，新数组的下标不变；

9、现在给出两个数组：
数组a：“1,7,9,11,13,15,17,19”
数组b：“2,4,6,8,10”

两个数组合并为数组c。

public class ArrayPractice09 {
    public static void main(String[] args) {
        int a[]={1,7,9,11,13,15,17,19};
        int b[]={2,4,6,8,10};
        int c[]=new int[a.length+b.length];

        for (int i = 0; i < c.length; i++) {
            if(i>=a.length){
                c[i]=b[i-a.length];
            }else {
                c[i]=a[i];
            }
            System.out.print(c[i]+",");
        }
    }
}

分析：遍历c数组，当c中数组长度小于a数组长度时，将c数组按同a数组下标赋值，当c数组长度大于a数组长度时，减去a从数组长度；

10、找到在第一个数组array1中出现，而在第二个数组array2中没有出现的数字。

public class ArrayPractice10 {
    public static void main(String[] args) {
        int[] array1={1,2,3,4,5,6,7,8,9,10};
        int[] array2={87,1,3,5,7,9,55,20,44,99};
        int repeat=0;//重复次数

//      通过for循环得到重复数字出现的次数
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array2.length ; j++) {
                if (array1[i]==array2[j]){
                    repeat++;
                    break;//防止数组array1中的数字与数组array2中的其他相同导致重复数字不准确
                }
            }
        }
        //定义新的数组存放array1中未重复的数字
        int[] arrayNum=new int[array1.length-repeat];
        int a=0;//新数组的下标
        boolean flag=false;//将循环值判断完才知道结果，设置标记
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array2.length ; j++) {
                //判断array1中的每一个数字与array中是否有相同的，没有令flag=true，表示这个array1中的数字可以给与新的数组arrayNum
                if (array1[i]==array2[j]){
                    flag=false;
                    break;
                }else{
                    flag=true;
                }
            }
            if (flag){
                arrayNum[a]=array1[i];
                a++;
            }
        }
        for (int i = 0; i <arrayNum.length ; i++) {
            System.out.print(arrayNum[i]+",");
        }
    }
}

分析： 通过for循环得到重复数字出现的次数，然后建一个新的数组保存第一个数组array1中出现，而在第二个数组array2中没有出现的数字；