数组

印度阿三17 2020-05-17

展开全文

数组

数组概述

什么是数组？ 数组是【相同类型数据】的有序集合

数组声明和创建方式

有三种创建方式

静态初始化 int[] a = {1,2,3,4,5};
动态初始化 int[] b = new int[5]; b[0] = 1; b[1] = 2;
默认初始化数组是引用类型，它的元素下相当于类的实例变量

，因此一经分配空间，其中每个元素也按照实例变量同样的方式

被隐式的初始化。

数组的边界

下标合法区域 [0,lenth-1] 常见的异常数组下标越界异常

ArrayIndexOutOfBoundsException

数组长度

数组有个属性 length 数组.length 就是数组的长度

数组使用

1 数组的遍历 for(int i = 0 ; i<array.lenth; i ) {System.out.println(array[i]);}

增强for for（int x ：arrays）{

System.out.println(array[i]);

}

2 数组内的元素访问通过下标索引来访问数组元素 array[i]

3 数组可以作为参数传入方法也可以作为方法返回值

多维数组

多维数组就是数组的数组

数组的元素还是数组，

数组是一种数组结构同时也是引用类型是个对象这也是为什么通常

没有三维甚至多维数组的使用场景的原因。

Arrays工具类

Arrays 工具类都是操作数组的【静态方法】

常用：

toString() 打印数组
sort() 升序拍序
fill（）给数组元素赋值；
equals 比较数组元素是否匹配；

冒泡排序

冒泡排序是非常简单的排序方法江湖人尽皆知

用嵌套for循环外层循环来控制冒泡轮数，内层来依次比较

废话不多说撸代码

public static void main(String[] args){
    //创建一个中间临时变量来交换数据
    int  temp = 0;
    int[] a = {423 ,232 ,1 23,424};
   
    //外层控制冒泡轮数  2个数 2个数比较几次
    for(int i = 0 ;  i < a.length-1; i  ){
         boolean flag = false ;
        //内层2个数依次比较
        for(int j = 0 ; j<a.length-1-i; j  ){
            if(a[j]>a[j 1]){
                temp = a[j 1];
                a[j 1] = a[j];
                a[j] = temp ;
                flag = true;
                
            }
            if(flag==false){
                break;
            }
        }
        System.out.println(Arrays.toString(a));
    }
    
    
}

稀疏数组

1 使用目的：压缩数据空间

2 使用场景：当一个数组大多数元素为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

上面这个 2维数组转化成稀疏数组的样子为

行列有效值个数

[0] 4 6 2

[1] 1 1 1

[2] 2 2 2

上一个示例代码

package com.niu.www.array;

public class ArrayDemo03 {
    public static void main(String[] args) {
        //创建二维数组来构建棋盘模型
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt "\t");
            }
            System.out.println();
        }
        System.out.println("===========================================");
        //转换稀疏数组保存
        //获取有效值个数
        int sum = 0;
        for (int i = 0; i <array1.length ; i  ) {
            for (int j = 0; j <array1[i].length ; j  ) {
                if (array1[i][j]!=0){
                    sum  ;
                }

            }

        }
        System.out.println("有效值个数是：" sum);
        //输出稀疏数组
        //创建一个稀疏数组结构
        // 行和列都是固定的  行是 有效值 1  列就是固定的3列
        int[][] array2 = new int[sum 1][3];
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;

        //遍历原来的二位数组 把非0的值存入稀疏数组中
        int count= 0;
        for (int i = 0; i <array1.length ; i  ) {
            for (int j = 0; j <array1[i].length ; j  ) {
                if (array1[i][j]!=0){
                    count  ;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][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]);
        }
        System.out.println("=========================");
        System.out.println("还原稀疏数组");
        //创建 新数组来接收 还原的稀疏数组  , 代码就是容器 和信息 的转换和传递
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i <array2.length ; i  ) {
            //遍历稀疏数组array2 把有效值赋值给 array3
            array3[array2[i][0]][array2[i][1]] = array2[i][2];



        }
        //输出还原后的稀疏数组
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt "\t");
            }
            System.out.println();
        }

    }
}