数组玩法（一）

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

第一种玩法：
找数组中的最大，最小值，顺便求和，算个平均数。
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();

    }
}

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