数据结构(1):稀疏数组使用java实现

　　　　主要是用于数组压缩,去除无效的数组内容:

　　　

原数组内容:
0    0    0    0    0
0    1    0    0    0
0    0    0    2    0
0    0    0    0    0
0    0    0    0    0

转换成

稀疏数组
5    5    2
1    1    1
2    3    2    

思路:

韩老师留的最后课后作业代码完成:

代码实现:

package Array_Test;

import java.io.*;

public class Test4 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        writeFile("/Users/maniac/Sparse.txt");
        readFile("/Users/maniac/Sparse.txt");
    }

    public static void readFile(String filename) throws IOException, ClassNotFoundException {
        File file =new File(filename);
        FileInputStream fileInputStream =new FileInputStream(file);
        ObjectInputStream objectInputStream =new ObjectInputStream(fileInputStream);
        int[][] data = (int[][]) objectInputStream.readObject();
        System.out.println("反序列化:");
        for(int i=0;i<data.length;i++){
            for(int j=0;j<data[i].length;j++){
                System.out.printf("%d\t",data[i][j]);
            }
            System.out.println();
        }

        //还原成二维数组
        int[][] array = new int[data[0][0]][data[0][1]];
        //输出默认数组  5x5:
        System.out.println("默认数组:");
        for(int d[]:array){
            for(int t:d){
                System.out.printf("%d\t",t);
            }
            System.out.println();
        }

        //稀疏数组赋值给二维数组
        //赋值不需要稀疏数组第一行数据去除掉,从第二行开始。
        //列是固定的
        for(int i=1;i<data.length;i++){
            //data[i][0] = 1,2
            //data[i][1] = 1,3
            //data[i][2] = 1,2 结果
            //相当于 1-1  2-3
            array[data[i][0]][data[i][1]] = data[i][2];
        }

        //输出二维数组
        System.out.println("稀疏数组还原二维数组:");
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array[i].length;j++){
                System.out.printf("%d\t",array[i][j]);
            }
            System.out.println();
        }
    }
    public static void writeFile(String filename) throws IOException {
        int[][] data =new int[5][5];
        data[1][1] = 1;
        data[2][3] = 2;
        System.out.println("原数组内容:");
        for(int d[]:data){
            for(int t:d){
                System.out.printf("%d\t",t);
            }
            System.out.println();
        }

//       原数组转稀疏数据
//       获取有效原数组数据
        int sum = 0;
        for(int i=0;i<data.length;i++){
            for(int j=0;j<data[i].length;j++){
                if(data[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("二维数组有效数据有"+sum+"个");
        int[][] array2 = new int[sum+1][3];
        //已知稀疏数组固定3列
        array2[0][0] = data.length;
        array2[0][1] = data.length;
        array2[0][2] = sum;

        //把二维数组赋值给稀疏数组
        int num =0 ;
        for(int i=0;i<data.length;i++){
            for(int j=0;j<data[i].length;j++){
                if(data[i][j]!=0){
                    num++;
                    //第一行已经设置好内容,从第二行开始就是1开始赋值
                    array2[num][0]=i;
                    array2[num][1]=j;
                    //把原始数组中存在的内容赋值给第三列数据
                    array2[num][2]=data[i][j];
                }
            }
        }

        System.out.println("输出稀疏数组内容:");
        for(int i=0;i<array2.length;i++){
            for(int j=0;j<array2[i].length;j++){
                System.out.printf("%d\t",array2[i][j]);
            }
            System.out.println();
        }

        //序列化数组对象
        File file =new File(filename);
        ObjectOutputStream objectOutputStream =new ObjectOutputStream(new FileOutputStream(file));
        objectOutputStream.writeObject(array2);
        objectOutputStream.close();
    }
}

输出:

原数组内容:
0    0    0    0    0
0    1    0    0    0
0    0    0    2    0
0    0    0    0    0
0    0    0    0    0
二维数组有效数据有2个
输出稀疏数组内容:
5    5    2
1    1    1
2    3    2
反序列化:
5    5    2
1    1    1
2    3    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    1    0    0    0
0    0    0    2    0
0    0    0    0    0
0    0    0    0    0    

java数组即对象:

对象即类创建出来的实例。对象具有各种属性,并且具有一些特定的行为,对象是内存中的内存块,在这个内存块中封装了一些数据,也就是类中定义的各个属性,所以对象就是用来封装数据。

数组就是封装数据，如果定义int类型他就是存储int类型数据

 

package Array_Test;public class Test {
    public static void main(String[] args) {
        //数组的父类是Object
        int[] a=new int[8];
        String[] data = new String[8];
        Object b = a;
        Object[] c=data;

        int length = a.length;
        if(b instanceof int[]){
            System.out.println("obj的真实类型是int[]");
        }

        //Object类内置方法
//        a.hashCode();
        System.out.println(length);
        System.out.println(a.getClass().getName());
        System.out.println(a.getClass().getSuperclass().getName());
        Father.Son son =new Father.Son();
        Father.Son[] sons =new Father.Son[8];
        Father.Father2[] fa = sons;
        System.out.println(sons.getClass().getSuperclass().getName());
    }
}

数组即对象，他的父类型是object类型。

序列化和反序列化就是序列化对象，然后在反序列化对象，原封不动还原对象内容:

序列化然后反序列化:

 

package Array_Test;

import java.io.*;
import java.util.Arrays;

public class Test2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        writeFile("/Users/maniac/array1.txt");
        readFile("/Users/maniac/array1.txt");
    }

    public static void readFile(String filename) throws IOException, ClassNotFoundException {
        FileInputStream  fileInputStream =new FileInputStream(new File(filename));
        ObjectInputStream objectInputStream =new ObjectInputStream(fileInputStream);
        int[] d= (int[]) objectInputStream.readObject();
        System.out.println(d.length);
        System.out.println(Arrays.toString(d));
    }

    public static void writeFile(String filename) throws IOException {
        int[] data =new int[8];
        data[0]=1;
        FileOutputStream fileOutputStream =new FileOutputStream(new File(filename));
        ObjectOutputStream objectOutputStream =new ObjectOutputStream(fileOutputStream);
//       序列化数组对象
        objectOutputStream.writeObject(data);
        objectOutputStream.close();

    }
}

参考:韩顺平java数据结构和算法