Java4 数组

数组

目录

1. 数组的概述
2. 数组声明创建
3. 数组使用
4. 多维数组
5. Arrays类
6. 稀疏数组

什么是数组

数组的定义

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

String [ ] ={1,2,3,4,5]

数组声明创建
必须声明数组变量，才可以在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar; //首选方法
或
dataType arrayRefVar[]; //效果相同，但不是首选方法

Java语言使用new操作符来创建数组

dataType[] arrayRefVar =new daaType[ arraySize]

数组的元素是通过索引访问，数组索引从0开始

获取数组长度： arrays.length

内存分析

Java内存分析：
堆 1.存放new的对象和数组
2.可以被所有的线程共享，不会存放别的对象引用

Java内存  		栈         1.存放基本变量类型（会包含这个基本类型的具体数值）
									 2引用对象的变量(会存放这个引用在堆里面的具体地址)

							方法区     1.可以被所有的线程共享
											2.包含了所有的class和static变量

三种初始化

	- 静态初始化

int [] a={1,2,3}
Man[] mans ={new Man(1,1),new Man(2,2)}

	- 动态初始化

int [] a = new int[2];
a[0] =1;
a[1] =2;

	- 数组的默认初始化
		-数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间	，其中每个元素也被按照实例变量同样的方式被隐式初始化

数组的四个基本特点

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

数组的边界

• 下表的合法区间：[0，length-1]，如越界就会报错

public static void main(String[] args){
int[] a=new int[2];
System.out.println(a[2]);
}

• ArrayIndexOutOfBoundsException:数组下标越界异常！

小结：
数组是相同数据类型（数据类型可以为任意类型）的有序集合
数组也是对象。数组元素相当于对象的成员变量
数组长度的确定的，不可变的。如果越界，则报：ArrayIndexOutofBounds

数组的使用

• for-each循环
• 数组作方法入参
• 数组作返回值

/*
数组的使用
 */
public class ArrayStudy03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //打印全部的数组元素
        for (int i=0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }
        System.out.println("=========");
        //计算所有的元素的和
        int num=0;
        for (int i=0;i<arrays.length;i++){
            num += arrays[i];
        }
        System.out.println("num="+num);
        System.out.println("===========");

        //查询最大的元素
        int max=arrays[0];

        for (int i=1;i<arrays.length;i++){
            if (arrays[i]>max){
                max =arrays[i];
            }
            System.out.println("max="+max);
        }
    }
}

多维数组
多维数组可以堪称数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

二维数组

int a[] [] =new int [2] [5];

解析：以上二维数组a可以堪称一个两行五列的数组

Arrays类

• 数组的工具类java.util.Arrays
• 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作
• 查看jdk帮助文档
• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而”不用“使用对象调用（注意：是不用 而不是不能）

具有一下常用功能：
给数组复制：通过fill方法
对数组排序：通过sort方法，按升序
比较数组：通过equals方法比较数组中元素值是否相等
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

/**
 * 冒泡排序
 */
public class ArrayStudy05 {
    public static void main(String[] args) {
        int[] a={1,4,5,6,84,6,78,91};

        int[] sort =sort(a);

        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] array){

        int temp=0;
        for (int i=0;i<array.length-1;i++){

            for (int j=0;j<array.length-1-i;j++){
                if (array[j+1] >array[j]){
                   temp = array[j];
                   array[j] =array[j+1];
                   array[j+1] =temp;

                }


            }
        }

        return array;
    }
}

稀疏数组

package array;

/**
 * 稀疏数组
 */
public class ArrayStudy06 {
    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[] 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;

        //遍历二维数组，将非零的值，存放稀疏数组中
        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"
            );
        }

    }
}