数组玩法（一）

太过爱你忘了你带给我的痛 2022-09-24 11:25 162阅读 0赞

本文主要以一个**基本类型的数组**为例子，展现数组的常用玩法。

**第一种玩法：**  
找数组中的最大，最小值，顺便求和，算个平均数。  
1.就找数组中的**所有元素**的最大，最小，求和算平均数（没有限制）  
根据值的形式找最大，最小  
方法：直接声明一个max变量，并将下标为0的数组元素的值copy给它，然后遍历，在遍历的时候进行判断，若比它大，修改它的值，否则不修改。 最小，类似  
求和，算平均小case直接看代码

/**
        int型数组，遍历，求和，最大值，最小值
    */
    public class ArrayTest {
        
    
        public static void main(String[] args) {
    
            int[] arr = new int[8];
            for (int i = 0; i < arr.length; i++) {
                //0~20
                arr[i] = (int)(Math.random() * 20);
            }
            // 遍历
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();
    
            // 求和
            int sum = 0;
            for (int i = 0; i < arr.length; i++) {
                sum += arr[i];
            }
            // 求最大值
            int max = arr[0];
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            // 求最小值
            int min = arr[0];
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] < min) {
                    min = arr[i];
                }
            }
            System.out.println("sum:" + sum + ",max:" + max + ",min:" + min);
    
            // 遍历
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();
        }
    }

根据下标找最大，最小
    方法：定义一个maxIdex变量并赋值为0，maxIdex[0]就可以表示下标为0的数组元素，然后遍历的时候判断，依旧是若是比它大修改maxIdex值，若是没有不做任何操作。要把握maxIdex是一个下标，而不是具体的值。

/**
        利用下标找最大，最小
    */
    class ArrayTest3 {
    
        public static void main(String[] args) {
            int[] arr = new int[8];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int)(Math.random() * 20);
            }
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
            //0 1 2 3 4 5  6  7
            //2 6 9 0 5 11 18 0
            // 最大值下标为6
    
            int maxValueIndex = 0;
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > arr[maxValueIndex]) {
                    maxValueIndex = i;
                }
            }
            System.out.println("最大值:" + arr[maxValueIndex]);
            int minValueIndex = 0;
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] < arr[minValueIndex]) {
                    minValueIndex = i;
                }
            }
            System.out.println("最小值:" + arr[minValueIndex]);
        }
    }

2.有条件的情况下找最大，最小，求和，算平均  
例如不知道数组是什么情况，也不能赋数组中第一个元素的值或者下标怎么解决？  
直接给最大，最小赋极值  
求最大，赋max最小  
求最小，赋min最大

/**
        在并不知道第一个数组元素值是什么的时候，找最大值，最小值
    */
    class ArrayTest4 {
    
        public static void main(String[] args) {
            int[] arr = new int[8];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int)(Math.random() * 20 - 100);
            }
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
            //9 13 7 13 17 14 11 5
            int max = 0x80000000;
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            System.out.println("max:" + max);
            int min = 0x7fffffff;
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] < min) {
                    min = arr[i];
                }
            }
            System.out.println("min:" + min);
        }
    }

穿插个增强for循环和经典for循环

/**
        增强型for循环，变量值和数组元素值关系，copy过去的，相互独立，互不影响
    */
    class ArrayTest2 {
    
        public static void main(String[] args) {
    
            int[] arr = new int[8];
    
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int)(Math.random() * 20);
            }
    
            // 遍历
            // 经典for循环
            for (int i = 0; i < arr.length; i++) { 
                int var = arr[i];   //将值copy过去，不改变原数组元素的值
                System.out.print(var + " ");
                //var = 10000 * i; 赋值不会影响数组元素的值
            }
            System.out.println();
    
            // 增强型for循环, 仅用于遍历数组, 对于数组的访问是只读的
            /*
            for (元素类型 变量 : 数组名) {
                System.out.println(变量);
            }*/
    
            for (int var : arr) {
                System.out.print(var + " ");
                //var = 1000 * i;
            }
        }
    }

**第二种玩法** 数组复制  
利用数组复制，可以实现数组复制，找子数组，数组扩容

/**
        数组复制
    */
    class ArrayTest5 {
    
        public static void main(String[] args) {
            int[] arr = new int[8];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int)(Math.random() * 20);
            }
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
    
            //0 1 2 3 4 5 6  7
            //2 1 0 6 9 2 12 3 
            //数组复制
            //0 1 2 3 4 5 6  7
            //0 0 0 0 0 0 0  0 
            //2 1 0 6 9 2 12 3 
            int[] arr2 = new int[arr.length];
            for (int i = 0; i < arr.length; i++) {
                arr2[i] = arr[i];
            }
            //遍历
            for (int var : arr2) {
                System.out.print(var + " ");
            }
            System.out.println();
        }
    }

/**
        获取子数组---> 1.创建一个容量小的数组
                     2.复制一定数目的数组元素
    */
    class ArrayTest6 {
    
        public static void main(String[] args) {
            int[] arr = new int[8];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int)(Math.random() * 20);
            }
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
    
            //0 1 2 3 4 5 6  7
            //2 1 0 6 9 2 12 3 
            //获取子数组
            //0 1 2 3
            //0 0 0 0
            //2 1 0 6
            int[] child = new int[arr.length / 2];
            for (int i = 0; i < child.length; i++) { // 循环次数以容量小的为准
                child[i] = arr[i];
            }
    
            for (int var : child) {
                System.out.print(var + " ");
            }
            System.out.println();
        }
    }
    /**
        数组扩容 -->1创建一个容量的大数组
                  2复制原数组中的元素
                  3修改原数组名指向
    */
    class ArrayTest7 {
    
        public static void main(String[] args) {
            int[] arr = new int[8];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int)(Math.random() * 20);
            }
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
    
            //0 1 2 3 4 5 6  7
            //2 1 0 6 9 2 12 3
            //扩容
            //0 1 2 3 4 5 6  7 8 9          15
            //0 0 0 0 0 0 0  0 0 0 0 0 0 0 0 0 
            //2 1 0 6 9 2 12 3 0 0 0 0 0 0 0 0 
            int[] bigger = new int[arr.length * 2];
            for (int i = 0; i < arr.length; i++) {
                bigger[i] = arr[i];
            }
            arr = bigger;
    
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
        }
    }

**第三种玩法：**  
**在满足一定条件下的情况下玩数组，输出符合含有符合要求的值的数组。**  
这里可以是任何具有可操作性的条件下，大体的做法都一致。

例如：将一个数组中的偶数提取出来保存，生成新的数组  
关键点：count计数器记录原数组中有多少个偶数  
常用方法：  
1.先创建一个新数组，长度和原数组一致  
2.遍历原数组，符合条件，将原数组的元素值copy写入新数组，特别注意新数组的下标有可能和原数组不一致。\*\*使用count：newArr\[count\] = arr\[i\]; count++;\*\*count只有在满足条件下才增加  
3.利用count准确记录，设置最终数组，然后将新数组中的元素值copy写入最终数组

/**
        输出满足一定值的数组
    */
    class ArrayTest8 {
    
        public static void main(String[] args) {
            int[] arr = new int[8];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int)(Math.random() * 20);
            }
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
    
            //0 1 2 3 4 5 6  7
            //2 1 0 6 9 2 12 3
            //取出所有偶数,存入一个新数组
            //0 1 2 3 4  5 6 7
            //0 0 0 0 0  0 0 0
            //2 0 6 2 12 0 0 0 
            //最终数组
            //0 1 2 3 4
            //0 0 0 0 0 
            //2 0 6 2 12
            int[] newArr = new int[arr.length];
            int count = 0; // 最关键变量, 用于指示新数组中赋值的下标
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] % 2 == 0) {
                    newArr[count] = arr[i];
                    count++; // 赋完值后,自增,用于下一次再往数组中保存值时的新下标
                }
            }
            int[] finalArr = new int[count]; // 最后count值就是新数组中的有效元素个数
            for (int i = 0; i < count; i++) { // 依次把所有有效元素存入最终数组中即可
                finalArr[i] = newArr[i];
            }
            //遍历
            for (int var : finalArr) {
                System.out.print(var + " ");
            }
            System.out.println();
            // 把所有奇数提取成一个新的子数组
        }
    }

**第四种玩法** **数组反转**  
将数组元素顺序倒着来。

/**
        数组的反转
    */
    class ArrayTest9 {
    
        public static void main(String[] args) {
            int[] arr = new int[8];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int)(Math.random() * 20);
            }
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
    
            //0 1 2 3 4 5 6  7
            //2 1 0 6 9 2 12 3
            //反转
            //3 12 2 9 6 0 1 2 
            for (int i = 0; i < arr.length / 2; i++) {
                // 交换i位置和arr.length - 1 -i位置的元素
                int tmp = arr[i];
                arr[i] = arr[arr.length - 1 - i];
                arr[arr.length - 1 - i] = tmp;
            }
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
        }
    }

**第五种玩法**  
数组排序–>最简单，最慢的冒泡排序

/**
        数组排序-冒泡排序
    */
    class ArrayTest10 {
    
        public static void main(String[] args) {
            int[] arr = new int[8];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int)(Math.random() * 20);
            }
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
    
            // 外循环控制比较交换的趟数, 需要处理数组长度-1趟
            for (int j = 0; j < arr.length - 1; j++) {
                // 内循环处理每趟中比较交换的次数
                for (int i = 0; i < arr.length - 1 - j; i++) { // 总是从最左边开始处理, 比较i位置和右边相邻位置的元素的值
                    if (arr[i] > arr[i + 1]) { // 如果左大右小, 进行交换
                        int tmp = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = tmp;
                    }
                }
            }
    
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
        }
    }

最快的排序—>快速排序  
java直接给我们提供了调用方法

/**
        利用快速排序，注意在使用的时候要导util包
    */
    class ArrayTest11 {
    
        public static void main(String[] args) {
            int[] arr = new int[8];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int)(Math.random() * 20);
            }
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
    
            Arrays.sort(arr); // 改良版快速排序
    
            //遍历
            for (int var : arr) {
                System.out.print(var + " ");
            }
            System.out.println();
    
        }
    }

数组玩法（二）例子是引用型数组  
大家还有什么玩法可以留言，共同学习，共同进步。