java Gson 实例化 数组 java数组案例

数组案例：冒泡排序

• 什么是冒泡排序？

• 重复的走过每个元素列(可通过代码减少不必要的比较)，依次比较每个元素列，按从小到大的顺序(若前面一个数大于后面一个数，交换两个数的位置)，重复此操作，直到没有元素需要交换

•  主函数

 

• 排序方法

 

•  结果：

 

数组案例：稀疏数组

• 为什么要用稀疏数组？

• 当一个数组中大部分元素为0时，或者为同一值的数组可以使用稀疏数组来保存数组

• 处理方式：

• 记录数组有几行几列，有多少个有效值

• 把不同的元素的行，列，值，的数据记录在一个小的数组里从而缩小程序的规模



•  稀疏数组：
• 第[0]行记录原数组有几行几列几个有效值
• 其余行记录有效值在原数组几行几列，值为多少

• 创建稀疏数组，并赋值，打印出结果

•   结果

 

•  获取有效值个数
•  结果
•  创建稀疏数组，并向稀疏数组里填值

 

•  结果

 

•  还原稀疏数组
• 结果

 

 完整代码(冒泡排序)

import java.util.Arrays;
//冒泡排序
public class Bubble {
    public static void main(String[] args) {
        int[] a={1,2,3,58,5,6};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    public static int[] sort(int[] a){
        int temp=0;//定义临时变量，用来交换两个数的值
//定义每层循环，一次循环下来，至少有一个数被排到了最终位置
        for (int i = 0; i < a.length-1; i++) {
            //设置布尔值，如果内层循环没有走（即if (a[j]>a[j+1])语句没有执行，
            // 换句话说就是所有的数都到了正确的位置），那么这个布尔值就为false，
            boolean flag=false;
            //内层循环，用于两两数的比较大小排序，以数组的下标最大值(a.length-1),-i
            //(外层循环每以次循环结束后，会有一个数到了正确的位置需要减掉，以此减少不必要的较)
            for (int j=0;j<a.length-1-i;j++){
                //如果前一个数大于后一个数，交换位置（这样几次循环下来，小数在前，大数在后）
                if (a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                    flag=true;
                }
            }
            //若为false直接跳出内层循环。这样可以减少不需要的循环
            if (flag==false){
                break;
            }

        }
        return a;
    }
}

完整代码(稀疏数组)

public class XiShuArray {
    public static void main(String[] args) {
        int[][] a=new int[11][11];
        a[1][2]=1;
        a[2][3]=1;
        //创建并输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("----------");
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (a[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数"+sum);
        //创建一个稀疏数组
        int[][] array2=new int[sum+1][3];//三列，分别为，行，列，值
        //在稀疏数组的第[0]行写入原数组有几行几列几个有效值
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;
        //遍历二维数组，将非零的值，存放稀疏数组中
        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++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=a[i][j];
                }
            }
        }
        //打印稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
        }
        //还原稀疏数组
        int[][] b=new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
            b[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        //打印原来数组
        System.out.println("还原出原来的数组");
        for (int[] ints : b) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        }
    }

   参考书籍：Java核心技术 卷1(原书第11版)