2020年7月29日 数组操作练习

Posted 2020-12-19 douyunpeng

/*
1、数组的练习
用一个数组存储本组学员的成绩，并遍历显示
（1）其中学员的人数从键盘输入
（2）学员的成绩从键盘输入
*/
class Test08_Exer4{
    public static void main(String[] args){
        /*
        步骤：
        1、先确定人数，从键盘输入
        2、声明并创建数组，用来存储成绩
        3、确定每一个成绩：为每一个元素赋值
        4、遍历显示
        */
        
        //1、先确定人数，从键盘输入
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入本组的人数：");
        int count = input.nextInt();
        
        //2、声明并创建数组，用来存储成绩
        //int[] scores = new int[长度];
        int[] scores = new int[count];
        
        //3、确定每一个成绩：为每一个元素赋值
        for(int i=0; i<count; i++){
            System.out.print("请输入第"+ (i+1) + "个学员的成绩：");
            //为元素赋值：为谁赋值，就把谁写在=的左边
            scores[i] = input.nextInt();//用键盘输入的值为元素赋值
        }
        
        //4、遍历显示
        System.out.println("本组学员的成绩如下：");
        for(int i=0; i<scores.length; i++){
            System.out.print(scores[i]+"	");
        }
    }
}
/*
2、数组的练习
用一个数组存储26个英文字母的小写形式，
并遍历显示
‘a‘->‘A’
*/
class Test09_Exer5{
    public static void main(String[] args){
        //用一个数组存储26个英文字母的小写形式
        //(1)声明并创建数组
        char[] letters = new char[26];
        
        //(2)为元素赋值，即把‘a‘,‘b‘等存储到letters数组中
        //因为有规律，所以用循环赋值
        for(int i=0; i<letters.length; i++){
            letters[i] = (char)(‘a‘ + i);
        }
        
        //(3)显示结果
        //‘a‘->‘A’
        //->左边就是元素的值，右边是根据元素的值，算出来的
        //‘a‘的编码值是97，‘A‘编码值为65，差32
        //‘b‘的编码值是98，‘B‘编码值为66，差32
        for(int i=0; i<letters.length; i++){
            System.out.println(letters[i] +"->" + (char)(letters[i]-32));
        }
    }
}
/*
数组的相关的算法操作：
1、在数组中找最大值/最小值
*/
class Test11_FindMax{
    public static void main(String[] args){
        int[] array = {4,2,6,8,1};
        
        //在数组中找最大值
        //类似于：猴子掰玉米
        //先假设第一个最大，然后与后面的元素一一比较，如果有比手上还大，就修改手上的玉米
        
        //(1)//先假设第一个元素最大
        int max = array[0];
        //(2)用max中的值，与后面的元素一一比较，如果有比max的值还大，就修改max的值
        //这里i=1的原因，max与[1,长度-1]的元素比较就可以了，不用再与[0]元素进行比较
        for(int i=1; i<array.length; i++){
            if(array[i] > max){
                max = array[i];
            }
        }
        
        System.out.println("最大值是：" + max);
    }
}
/*
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
*/
class Test12_FindMaxAndIndex{
    public static void main(String[] args){
        int[] array = {4,2,-7,8,1,9};
        
        //最小值及其下标
        //(1)假设第一个元素最小
        int min = array[0];
        int index = 0;
        
        //(2)用min与后面的元素一一比较
        for(int i=1; i<array.length; i++){
            if(array[i] < min){
                min = array[i];
                index = i;
            }
        }
        System.out.println("最小值是：" + min);
        System.out.println("最小值的下标是：" + index);
    }
}
/*
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
*/
class Test12_FindMaxAndIndex_2{
    public static void main(String[] args){
        int[] array = {4,2,-7,8,1,9};
        
        //最小值及其下标
        //(1)假设第一个元素最小
        int minIndex = 0;//array[minIndex]就是最小值
        
        //(2)用min与后面的元素一一比较
        for(int i=1; i<array.length; i++){
            if(array[i] < array[minIndex]){
                minIndex = i;
            }
        }
        System.out.println("最小值是：" + array[minIndex]);
        System.out.println("最小值的下标是：" + minIndex);
    }
}
/*
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
*/
class Test12_FindMaxAndIndex_3{
    public static void main(String[] args){
        int[] array = {4,2,-7,8,1,-7};
        
        //找出最小值，及其下标，但是如果最小值有两个或多个
        /*
        （1）先找出最小值
        （2）找出所有最小值的下标
        */
        //（1）先找出最小值
        int min = array[0];
        for(int i=1; i<array.length; i++){
            if(array[i] < min){
                min = array[i];
            }
        }
        System.out.println("最小值：" + min);
        
        //（2）找出所有最小值的下标
        System.out.println("最小值的下标有：");
        for(int i=0; i<array.length; i++){
            if(array[i] == min){
                System.out.print("[" + i + "]	");
            }
        }
        
    }
}
/*
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
*/
class Test13_SumAndAvg{
    public static void main(String[] args){
        /*
        有一组学员的成绩存储在数组中，统计总分和平均分
        */
        int[] scores = {78,89,56,99,100};
        
        //求总分
        int sum = 0;
        for(int i=0; i<scores.length; i++){
            sum += scores[i];
        }
        
        //求平均值
        double avg = (double)sum / scores.length;
        System.out.println("总分：" + sum);
        System.out.println("人数：" + scores.length);
        System.out.println("平均分：" + avg);
        
    }
}
/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构

数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
*/
class Test14_Reverse_2{
    public static void main(String[] args){
        //有一个数组，存储26个字母
        //‘A‘~‘Z‘
        char[] letters = new char[26];
        for(int i=0; i<letters.length; i++){
            letters[i] = (char)(‘A‘ + i);
        }
        
        //需求：要反转整个数组
        //原来letters[0]中存储的是‘A‘-->现在letters[0]中存储的是‘Z‘
        //...
        //原来letters[25]中存储的是‘Z‘-->现在letters[25]中存储的是‘A‘
        //方式二：首尾交换
        //问题1：交换几次   次数 = 长度/2  例如：6个元素交换3次，5个元素交换2次
        /*
        这个i可以用作下标，同时循环的次数，可以表示交换的次数
        */
        for(int i=0; i<letters.length/2; i++){
            //问题2：谁和谁交换
            //letters[0] ~ letters[25]
            //letters[1] ~ letters[24]
            //..
            //首尾交换
            //letters[i] ~ letters[长度-1 - i]
            
            //问题3：如何交换
            //借助第三个变量
            char temp = letters[i];
            letters[i] = letters[letters.length-1-i];
            letters[letters.length-1-i] = temp;
        }
        
        //显示结果
        for(int i=0; i<letters.length; i++){
            System.out.println(letters[i]);
        }
    }
}

/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构

数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
（1）复制一个和原来一样的数组，长度和元素
（2）复制一个比原来数组短的
    例如：从原数组中截取一部分
（3）复制一个比原来的长的
    例如：数组扩容，那么新数组会比原来的数组长
*/
class Test15_Copy_01{
    public static void main(String[] args){
        //（1）复制一个和原来一样的数组，长度和元素
        int[] arr = {1,2,3,4,5};
        
        /*
        (1)创建一个新数组，和原来的数组一样
        */
        int[] newArr = new int[arr.length];
        /*
        (2)复制元素
        */
        for(int i=0; i<newArr.length; i++){
            newArr[i] = arr[i];
        }
        
        //(3)遍历新数组
        for(int i=0; i<newArr.length; i++){
            System.out.println(newArr[i]);
        }
    }
}
/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构

数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
（1）复制一个和原来一样的数组，长度和元素
（2）复制一个比原来数组短的
    例如：从原数组中截取一部分
（3）复制一个比原来的长的
    例如：数组扩容，那么新数组会比原来的数组长
*/
class Test15_Copy_02{
    public static void main(String[] args){
        //（1）复制一个比原来数组短的
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        
        //复制原来的数组的一部分，来构成新数组，例如：[2]~[8]
        int start = 2;
        int end = 8;
        /*
        （1）创建新数组，新数组的长度 = 8-2
        */
        int[] newArr = new int[end-start+1];
        
        //(2)复制元素
        for(int i=0; i<newArr.length; i++){
            /*
            newArr[0] = arr[2] = arr[start+0];
            newArr[1] = arr[3] = arr[start+1];
            ...
            */
            //newArr[i] = 值;
            newArr[i] = arr[start+i];
        }
        
        //(3)遍历结果
        for(int i=0; i<newArr.length; i++){
            System.out.println(newArr[i]);
        }
    }
}
/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构

数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
（1）复制一个和原来一样的数组，长度和元素
（2）复制一个比原来数组短的
    例如：从原数组中截取一部分
（3）复制一个比原来的长的
    例如：数组扩容，那么新数组会比原来的数组长
*/
class Test15_Copy_03{
    public static void main(String[] args){
        //（3）复制一个比原来的长的
        int[] arr = {1,2,3,4,5};
        
        //需求：新增加了几个数据，需要存储，此时需要把数组进行扩容
        //(1)创建一个新数组，例如：新数组的长度为原来的2倍
        int[] newArr = new int[arr.length*2];
        
        //(2)复制元素
        for(int i=0; i<arr.length; i++){
            newArr[i] = arr[i];
        }
        
        //(3)遍历结果
        for(int i=0; i<newArr.length; i++){
            System.out.println(newArr[i]);
        }
    }
}
/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构

数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
（1）复制一个和原来一样的数组，长度和元素
（2）复制一个比原来数组短的
    例如：从原数组中截取一部分
（3）复制一个比原来的长的
    例如：数组扩容，那么新数组会比原来的数组长
*/
class Test15_Copy_04{
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5};
        
        /*
        复制一个新数组，新数组的长度由键盘输入，可能和原来一样，可能比原来的短，可能比原来的长
        */
        /*
        （1）从键盘输入新数组的长度
        */
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入新数组的长度：");
        int len = input.nextInt();
        
        //（2）创建新数组
        int[] newArr = new int[len];
        
        //（3）复制元素，这里都是从原数组的[0]开始复制
        //i<arr.length && i<newArr.length保证newArr[i] = arr[i];左右两边都不越界
        for(int i=0; i<arr.length && i<newArr.length; i++){
            newArr[i] = arr[i];
        }
        
        //(4)遍历结果
        for(int i=0; i<newArr.length; i++){
            System.out.println(newArr[i]);
        }
    }
}