数组，冒泡排序，棋盘

效果相同 建议第一种
int[] nums;
int nums[];c++
nums =new int[10];可存放10个元素
int sum=0;
nums [0]=1;
nums [1]=2;
nums [2]=3;
nums [3]=4;
nums [4]=5;
for(int i; i<array.length;i++){
sum+=nums[i]

}
System.out.println(sum);
//静态
int[]a={1,2,3,4,56,7};

二维数组：
就是数组嵌套
int[][] array={{1,2},{3,4}{5,6},{6,7}};

冒泡排序

比较数组中两个相邻的元素，如果第一个比第二个数大，我们就交换他们的位置。
每一次比较都会产生一个较大的，较小的数字。
下一次轮侧可以少一个排序
依次循环直到结束

package com.company;
import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
         int[]a ={1,2,5,4,464,456};

        int [] sort = sort(a);
        System.out.println(Arrays.toString(sort));
        }
     public static int[] sort(int[] array){
        int temp =0;
        for(int i = 0; i <array.length-1 ; i++) {
            boolean flag = false;
            for (int j = 0;   j<array.length-i; j++) {
                if(array[j+1]>array[j]){
                    temp=array[j];
                    array[j]=array[temp];//数字交换
                    array[j+1]=temp;
                    flag=true;
                }
            }
  if(flag==false){
    break;
}
        }
        return array;
        }
    }

棋盘：

package com.company;

public class Main {
    public static void main(String[] args) {
  int[][] arg= new int[11][11];
        arg[1][2]=10;
        arg[2][3]=30;
        System.out.println("   ");
        for (int[] ints:arg) {
            for (int a:ints) {
                System.out.print(a+"\t");
            }
            System.out.println();
        }
        int sum=0;
        for (int i = 0; i <11; i++) {
            for (int  j= 0;  j< 11; j++) {
                if(arg[i][j]!=0){
                    sum++;
                }

            }

        }
        System.out.println("有效值个数"+sum);
        //创建一个稀疏数组
        int[][] arg2 = new int[sum+1][3];
        arg2[0][0] =11;
        arg2[0][1] =11;
        arg2[0][2] =sum;
        //遍历二维数组，将非零的值，存放在稀疏数组中
        int count=0;
        for (int i = 0; i <arg.length ; i++) {
            for (int j = 0; j <arg[i].length ; j++) {
                if(arg[i][j]!=0){
                    count++;
                    arg2[count][0]=i;
                    arg2[count][1]=j;
                    arg2[count][2]=arg[i][j];
                }

            }

        }
        //输出
        System.out.println("稀疏数组");
        for (int i = 0; i <arg2.length ; i++) {
            System.out.println(arg2[i][0]+"\t"+
                    arg2[i][1]+"\t"+
                    arg2[i][2]+"\t");

        }
        System.out.println("======");
        System.out.println("还原");
        //读取稀疏数组
        int[][]arg3 = new int[arg2[0][0]][arg2[0][1]];
        //给其中元素还原值
        for (int i = 1; i <arg2.length ; i++) {
            arg3[arg2[i][0]][arg2[i][1]]=arg2[i][2];
        }
        //打印
        System.out.println("输出原来的值");
        for (int[] ints:arg3) {
            for (int a:ints) {
                System.out.print(a+"\t");
            }
            System.out.println();
        }
        }

    }