Java数组

数组概述

相同类型数据的有序集合

按先后次序排列组合

每一个数据都可称作数组元素，每个数组元素可以通过一个下标访问它们

数组定义

声明数组：变量类型[] 数组名 = new 变量类型[大小]；

数组长度：array.lenth()

数组第一个下标为0

内存分析

Java内存：堆、栈和方法区

堆：

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

栈：

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

方法区：

• 可以被所有线程共享
• 包含了所有的class和static变量

1. 声明数组

   int[] array =null; 在栈中

2. 创建数组 在堆中开辟一个空间

   array = new int[10];

3. 给数组元素赋值 在堆中空间内存放

   array[0]=1;

   

初始化

静态初始化

定义之后不可改变

创建+赋值

int[] a ={0,1,2};

动态初始化 （包含默认初始化）

int[] b =new int[10];

b[0]=1;

数组特点

1. 长度是确定的，一旦被创建，其大小不可以改变
2. 元素必须为相同类型
3. 数组中元素可以是任何数据类型，包括基本类型和引用类型
4. 数组的变量属于引用类型，数组本身就是对象，对象在堆中（new 出来的都是堆中的）数组元素相当于对象的成员变量
5. java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常

多维数组

多维数组可以看成数组的数组

二维数组定义： int a[] []=new int[2] [5];

package com.dy.array;

public class Demo02 {
    public static void main(String[] args) {
        int a[][]={{1,2},{2,3},{3,4},{4,5}};
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
    }
}

Arrays类

Arrays里的方法都是static修饰的静态方法，可以直接通过类名进行调用

package com.dy.array;

import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        int[] a ={1,3,6,3,80,3874,9940,293};
        System.out.println(a);//地址
        //打印数组元素
        System.out.println(Arrays.toString(a));
        //排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //填充
        Arrays.fill(a,500);
        System.out.println(Arrays.toString(a));
    }

}

冒泡排序

八大排序

package com.dy.array;

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        int[] a = {1,26,13,7,2};
        int[] b=sort(a);
        System.out.println(Arrays.toString(b));
    }
    //冒泡排序
    //比较相邻两个元素，如果第一个比第二个大，交换他们的位置
    //每次比较，会产出一个最大，或者一个最小
    //下一轮可以少一次拍讯 直至结束
    private static int[] sort(int[] arrays){
        int max;
        for (int i = 0; i < arrays.length-1; i++) {
            for (int j = 0; j < arrays.length-1-i; j++) {
                if (arrays[j+1]>arrays[j]){
                    max=arrays[j];
                    arrays[j]=arrays[j+1];
                    arrays[j+1]=max;
                }
            }
        }
        return arrays;
    }
}

稀疏数组

package com.dy.array;

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        int[][] a =new int[11][11];
        a[1][2]=1;
        a[2][3]=2;
        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("=========================");
        //转化为稀疏数组保存
        //1.获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (a[i][j]!=0){
                    sum++;
                }
            }
        }
        //2.创建一个稀疏数组
        int[][] array2=new int[sum+1][3];
        array2[0][0]=a.length;
        array2[0][1]=a[0].length;
        array2[0][2]=sum;
        int count=0;
        //遍历二维数组，将非零的值，存放稀疏数组中
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (a[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=a[i][j];
                }
            }
        }
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        System.out.println("==========================");
        //还原
        int[][] arrays=new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
                arrays[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        for (int[] ints : arrays) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}