第六天：Java数组-CSDN博客

数组

数组概述

数组是相同类型数据的有序集合。
数组中的元素可以是任意数据类型，包括基本类型和引用类型
数组描述是相同类型的若干个数据，按照一定的先后顺序排列组合而成。
数组下标从0开始。

数组声明与创建

数组的声明

int[] nums;//声明一个数组（建议）
int nums2[];//也是声明数组,C，C++也是这样用的

创建数组

int[] nums;//声明数组（建议）
nums=new int[5]; //数组的创建，分配了空间

获取数组长度

数组名.length

为数组元素赋值

方式1

nums[0]=1;
nums[1]=1;
nums[2]=1;
nums[3]=1;
nums[4]=1;

方式2

int [] number={1,2,3,4,5};

内存分析

堆

存放new的对象跟数组
可以被所有的线程共享，不会存放别的对象引用。

栈

存放基本变量类型（会包含这个基本类型的具体数值）
引用对象的变量（会存放这个引用在堆里面的具体地址）

数组三种初始化

静态初始化

//静态初始化: 创建+赋值
int [] a={1,2,3,4,5};

动态初始化

//动态初始化,默认初始化了b[3]=0,b[4]=0;
int[] b=new int [5];
b[0]=1;
b[1]=2;

默认初始化

int[] b=new int [5];//默认初始化为0

下标越界及小结

下标合法区间在[0~length-1]

数组的使用

打印所有的元素

public static void main(String[] args) {
    int[] arrays={1,2,3,4,5};
    //打印所有的元素
    for (int i : arrays){
        System.out.println(i);
    }
    System.out.println("===============");
    printarray(arrays);
}

数组作为方法参数

public static void printarray(int[] arrays){
    for (int i : arrays){
        System.out.println(i);
    }
}

数组作为方法返回值

public  static int[]  reverse(int[] arrays){
    int[] b=new int[arrays.length];
    for (int i = 0; i < arrays.length; i++) {
        b[i]=arrays[arrays.length-1-i];
    }
    return b;
}

多维数组

int[][] array={{1,2,3},{4,5,6},{7,8,9}};

public static void main(String[] args) {
    int[][] array = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    //printarray(array[0]);
    System.out.println("=======================");
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.println(array[i][j]);
        }
    }
}

Arrays类

toString打印数组

package com.xie.array;
import java.util.Arrays;
public class Demo6 {
    public static void main(String[] args) {
        int[] a={1,3333,4,2,6};
        System.out.println(a);//[I@14ae5a5
        //打印数组元素
        System.out.println(Arrays.toString(a));//[1, 3333, 4, 2, 6]
    }
}

sort排序数组

package com.xie.array;

import java.util.Arrays;

public class Demo7 {
    public static void main(String[] args) {
        int[] a={1,3333,4,2,6};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

fill方法

将指定的数覆盖指定数组中的每个数

package com.xie.array;

import java.util.Arrays;

public class Demo8 {
    public static void main(String[] args) {
        int[] a={1,3333,4,2,6};
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));//[0, 0, 0, 0, 0]
    }
}

冒泡排序算法

public class Demo9 {
    public static void main(String[] args) {
        int[] a={2,6,4,5,8};
        boolean flag=false;
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-1-i; j++) {
                int temp=0;
                if (a[j+1]>a[j]){
                    temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                    flag=true;
                }
            }
            if (flag==false){
                break;
            }
        }
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}

稀疏数组

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

package com.xie.array;

import java.util.Arrays;

public class Demo10 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11  0：没有棋子   1：黑棋   2：白棋
        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();
        }
        //转成稀疏数组
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效数组个数为："+sum);

        //创建一个稀疏数组
        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]+"\t");
        }
        System.out.println("========================");

        //还原稀疏数组
        System.out.println("还原");
        int[][] arrays3=new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
            arrays3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        System.out.println("输出还原的数组");
        for (int[] ints : arrays3){
            for (int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}