java替换数组指定位置元素

一、数组使用

• For-Each循环 & 普通for循环

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6};

        // JDK1.5 没有下标   for-each
        for (int array : arrays) {
            System.out.println(array);
        }
        System.out.println("=================");

        //打印全部的数组元素   普通for循环
        for (int i=0; i<arrays.length; i++){
            System.out.println(arrays[i]);
        }
        System.out.println("=================");
        //计算素有元素的和
        int sum=0;
        for (int i=0; i<arrays.length;i++){
            sum+=arrays[i];
        }
        System.out.println("sum="+sum);
    }
}

• 数组作为方法入参
• 数组作为返回值

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6};

        printArray(arrays);
        System.out.println("\n==============");
        int[] rever=reverse(arrays);
        printArray(rever);
    }

    //遍历数组  数组作为入参
    public static void printArray(int[] arrays){
        for (int i=0; i<arrays.length; i++){
            System.out.print(arrays[i]+" ");
        }
    }
    //反转数组，数组作为入参，结果返回值
    public static  int[] reverse(int[] arrays){
        int[] result= new int[arrays.length];

        for (int i=0,j=result.length-1;i<arrays.length;i++,j--){
            result[i] = arrays[j];
        }
        return result;
    }
}

二、多维数组

• 多维数组可以看成是数组的数组，比如二位数组 就是一个特殊的一维数组，其每一个元素都是一个一维数组
• 二维数组int a[][] = new int[4][2];
• 解析：以上二维数组a可以看成一个4行2列的数组。
• 思考：多维数组的使用？

public class ArrayDemo05 {

    public static void main(String[] args) {
        /** a[4][2]
         * 1 2
         * 2 3
         * 3 4
         * 4 5
         */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};

        System.out.println(array[0]);//输出的是一个对象,hashcode
        printArray(array[0]);
        System.out.println();
        System.out.println(array[0][0]);//打印第一行第一列的元素

        //遍历二维数组
        for (int i=0; i<array.length; i++){
            for(int j=0; j<array[i].length; j++){
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }

    //遍历数组  数组作为入参
    public static void printArray(int[] arrays){
        for (int i=0; i<arrays.length; i++){
            System.out.print(arrays[i]+" ");
        }
    }
}

三、Arrays 类

• 数组的工具类 java.util.Arrays
• 由于数组对象本身并没有什么方法可以供我们调用，但API提供了一个工具类Arrays供我们使用，从而可以对数组对象一些基本的操作。
• 查看JDK帮助文档
• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意是“不用”而不是“不能”）
• 具有以下常用功能：

• 给数组复制：通过fill方法
• 对数组排序：通过sort方法，按升序
• 比较数组：通过equal方法比较数组中元素值是否相等
• 查找数组元素：通过binarySearch方法能对排序号的数组进行二分查找法操作。

public class ArrayDemo06 {

    public static void main(String[] args) {
        int[] a = {1,2,3,666,888,222,9999};
        System.out.println(a);//输出一个对象，hashcode
        //打印数组元素 Arrays.toString()
        System.out.println(Arrays.toString(a));
        //对数组进行排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

       // Arrays.fill(a,0);//全部元素替换为0
        //System.out.println(Arrays.toString(a));

        Arrays.fill(a,2,4,0);//部分替换
        System.out.println(Arrays.toString(a));
    }
}

四、冒泡排序

• 冒泡排序是最为出名的排序算法之一，总共有八大排序
• 冒泡排序原理：两层循环，外层冒泡轮数，里层一次比较。算法的时间复杂度O(n2)

• 比较相邻的元素。如果第一个比第二个大，就交换他们。
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这点，最后的元素应该会是最大数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到乜有任何一对数字需要比较。

public static int[] sort(int[] array){
        int temp=0;
        for (int i=0;i<array.length-1;i++){
            for (int j=0; j<array.length-1; j++){
                if(array[j]>array[j+1]){
                    temp = array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;
    }


//优化
public static int[] sort1(int[] array){
        int temp=0;
        for (int i=0;i<array.length-1;i++){
            boolean flag=false;
            for (int j=0; j<array.length-1; j++){
                if(array[j]>array[j+1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = true;
                }
            }
            if(flag==false){//如果为false,说明里层循环乜有进行交换的，已经排好序了，可以直接退出外层循环了
                break;
            }
        }

        return array;
    }

五、稀疏数组

• 需求：编写五子棋游戏中，有存盘退出和续上盘的功能。
• 分析问题：因为该二维数组的值是默认值0，因此记录了很多没有意义的数据。
• 解决：稀疏数组

5.1稀疏数组介绍

• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
• 稀疏数组的处理方式是：

• 记录数组一个有几行几列，有多少个不同值
• 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

• 如下图：左边是原始数组，右边是稀疏数组
• 稀疏数组的创建及还原

public class ArrayDemo09 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11 0：没有棋子 1：黑棋 2：白棋
        int[][] a = new int[11][11];
        a[1][2]=1;
        a[2][3]=2;
        //输出原始数组
        System.out.println("输出原始数组");
        printArray(a);

        //转换为稀疏数组保存
        System.out.println("==========================");
        System.out.println("转换为稀疏数组保存");
        //1、获取有效值个数
        int num=0;
        for (int i=0; i<11; i++){
            for (int j=0; j<11; j++){
                if(a[i][j]!=0){
                    num++;
                }
            }
        }
        System.out.println("有效值个数num="+num);

        //2、创建一个稀疏数组 肯定是3列，第一行存放几行几列，以及有几个有效值
        int[][] a2= new int[num+1][3];
        a2[0][0]=11;
        a2[0][1]=11;
        a2[0][2]=num;

        //3、遍历二维数组，将非0的值存在在稀疏数组中
        int count=0;
        for(int i=0; i<a.length; i++){
            for(int j=0; j<a[i].length; j++){
                if (a[i][j]!=0){
                    count++;
                    a2[count][0]=i;
                    a2[count][1]=j;
                    a2[count][2]=a[i][j];
                }
            }
        }
        //4、打印稀疏数组
        System.out.println("打印稀疏数组");
        printArray(a2);

        //还原到原始数组
        System.out.println("==========================");
        System.out.println("还原到原始数组");
        int[][] a3 =new int[a2[0][0]][a2[0][1]];

        // i<a2.length 或者 i<a2[0][2]+1  即稀疏数组的行数
        for (int i=1; i<a2[0][2]+1; i++){
            a3[a2[i][0]][a2[i][1]] = a2[i][2];
        }

        printArray(a3);

    }

    //打印二维你数组
    public static void printArray(int[][] array){
        for (int[] ints: array){
            for (int anInt: ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

• 执行结果如下：

• 输出原始数组

0	0	0	0	0	0	0	0	0	0	0	

0	0	1	0	0	0	0	0	0	0	0	

0	0	0	2	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

==========================

转换为稀疏数组保存

有效值个数num=2

打印稀疏数组

11	11	2	

1	2	1	

2	3	2	

==========================

还原到原始数组

0	0	0	0	0	0	0	0	0	0	0	

0	0	1	0	0	0	0	0	0	0	0	

0	0	0	2	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0	

0	0	0	0	0	0	0	0	0	0	0