java学习之数组

数组

1数组的概述

• 数组时相同数据类型的有序集合。
• 数组描述的是相同数据类型的若干数据，按照一定的先后的顺序组合而成。
• 其中，每一个数据称作一个数组的元素，每个数组的元素可以通过一个下标来访问他们。

2 数组的声明和创建

创建如下：

package com.Hai.array;

public class ArrayDem01 {
    //变量的类型 变量的名字=变量的值
    public static void main(String[] args) {
        //int num[];//定义数组
        int[] num2;//定义数组；
        num2=new int[10];//2、创建一个数组

        //以上可以简介成：
        // int[] num=new int[10];

        //3、给数组赋值
        num2[0]=1;
        num2[1]=2;
        num2[2]=3;
        num2[3]=4;
        num2[4]=5;
        num2[5]=6;
        num2[6]=7;
        num2[7]=8;
        num2[8]=9;
        num2[9]=10;


        //计算所有元素的和
        int sum=0;
        for (int i = 0; i < num2.length; i++) {
            sum=sum+num2[i];
        }
        System.out.println("总和为："+sum);
    }
}

数组的四个基本特点：

• 其长度是确定的。数组一旦被创建，他的大小就是不可以改变的；
• 其元素必须是相同的数据类型，不可以是混合的数据类型；
• 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
• 数组变量属引用类型，数组也可以看成对象，数组中的每个元素相当于对该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始数据类型还是其他数据类型，数组本身是在堆中的。

3 二维数组

二维数组的使用，遍历和 初始化

package com.Hai.array;

public class ArrayDem02 {
    public static void main(String[] args) {
        //二维数组的使用
        int[][] array={{1,2},{3,4},{5,6},{7,8}};
        for (int i = 0; i <array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }

4 数组的常用方法

package com.Hai.array;

import java.util.Arrays;
public class ArrayDem03 {
    public static void main(String[] args) {
        int[] a={1,2,3,2342,456,54,233};
        System.out.println(a);//打印的是一个对象：[I@4554617c

        //打印数组元素,使用toString()方法
        System.out.println(Arrays.toString(a));
        printArray(a);//自己写的方法

        //对数组进行排序,使用Arrays.sort()方法
        Arrays.sort(a);//升序排序
        System.out.println(Arrays.toString(a));

        //fill()方法用于填充；
        Arrays.fill(a,0);//用0填充数组里的元素
        System.out.println(Arrays.toString(a));
    }


    //Arrays.toString()这个方法，自己也可以写
    public static void printArray(int[] a){
        for (int i = 0; i <a.length; i++) {
            if(i==0){
                System.out.print("[");
            }
            if(i==a.length-1){
                System.out.println(a[i]+"]");
            }else{
                System.out.print(a[i]+", ");
            }
        }
    }
}

5 冒泡排序

使用冒泡排序对数组进行排序，具体代码如下：

package com.Hai.array;

import java.util.Arrays;

public class arrayDem04 {
    public static void main(String[] args) {
        int[] array={1,23,34,33,2,3,53,55,32,2222};
        int[] arr=bubbleSort(array);
        System.out.println(Arrays.toString(arr));

    }
    //冒泡排序
    public static int[] bubbleSort(int[] a){
        for (int i = 0; i <a.length-1; i++) {
            boolean flag=false;
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j+1]<a[j]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                    flag=true;
                }
            }
            if(flag=false){
                break;
            }
        }
        return a;
    }
}

6 稀疏数组的存储

稀疏数组就是在二维数组中存储的元素很少，如下图;数组中存储了当量的0，只有少量的数据是关键，使用二维数组浪费了大量的空间，可以使用三元组的方式对数据进行压缩存储。三元组如下图的左边；

采用三元组进行数组的压缩存储，原理就是：在找出二维数组中有数据的元素的行和列，在用一个二维数组array存储下来，array[0][0]存储数组的行，array[0][1]存储数组的列，array[0][3]存储数组的值。主要代码如下：

package com.Hai.array;

import java.util.Arrays;

public class arrayDem05 {
    public static void main(String[] args) {
        //创建一个二维数组11*11，0表示 没有棋子，1表示黑棋，2表示白棋
        int[][] array1=new int[11][11];//定义一个数组
        array1[1][2]=1;
        array1[2][3]=2;
        System.out.println("数出原始的数组：");
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print(array1[i][j]+" ");
            }
            System.out.print("\n");
        }

        //获取数组中非0的元素
        int sum=0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("========================");
        System.out.println("输出数组的值个数："+sum);

        System.out.println("========================");
        //创建一个存储稀疏数组的数组
        int[][] array2=new int[sum+1][3];
        array2[0][0]=11;//第一列存储的是行
        array2[0][1]=11;//第二列存储的是列
        array2[0][2]=sum;//第三列存储的是元素的值；

        int count=0;
        for (int i = 0; i <array1.length; i++) {
            for (int j = 0; j <array1.length; j++) {
                if(array1[i][j]!=0){
                    count++;
                    array2[i][0]=i;//存下该元素的行号
                    array2[i][1]=j;//存i下该元素的列号
                    array2[i][2]=array1[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");
        }

        System.out.println("========================");
        //还原数组
        int[][] array3=new int [array2[0][0]][array2[0][1]];
        for (int i = 1; i <array2.length; i++) {//此处的i是从1开始，应为第一行存储的是头部信息
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        System.out.println("输出还原数组为：");

        //使用for增强型数组循环，打印输出还原的数组
        for(int[] ints:array3){
            for(int anInt:ints){
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
    }
}

运行结果如下：