Java数组基础

Java数组基础

数组概述

• 数组是相同类型的数据有序集合
• 每一个数据是一个数组元素，每个数组元素可以用下标来访问

数组声明创建

• 数组声明

数据类型[] 数组名称  //首选方法
    或者
数据类型 数组名称[] //不推荐使用
    
int[] nums;//定义

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

数据类型[] 数组名称 = new 数据类型[数组大小]
    
int[] nums = new int[10];//开辟了可以存放10个数字的数组
或者
int[] nums;
nums = new int[10];

• 数组元素通过索引访问，数组索引从0开始
• 获取数组长度

arrays.length;//获得数组的大小

内存分析

• 堆
• 栈
• 方法区

int[] array = null;//声明数组，在栈中存放数组名array
array = new int[10];//创建数组，在堆中开辟了10个空间
for(int i=0;i<num.length;i++){//给数组赋值
    cin>>num[i];
}

三种初始化

• 静态初始化**（创建+赋值）**

int[] a={1,2,3};//放多少个数，a的大小就是多大，之后就不可改变a的大小。这里a的大小就固定是3了
Man[] mans={new Man(1,1),new Man(2,2)};//引用类型

• 动态初始化**（包含默认初始化，为赋值的数都为0）**

int[] a= new int[5];
a[0]=1;
a[1]=2;
System.out.println(a[4]);//输出0

• 数组默认初始化

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

数组四个基本特点

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

数组边界

• 下标合法区间：[0,length-1],如果越界，就会报如下错误

ArrayIndexOutOfBoundsException:数组下标越界异常

数组使用

For-Each 循环（没有下标）

int[] arrays = {1,2,3,4,5,6};
//IDEA的快捷键： arrays.for,自动生成下面代码
//没有下标
for(int array : arrays){
    //打印操作
    System.out.println(array);
}

数组作为方法入参

//打印数组元素(数组当参数)
public static void printArrays(int[] arrays){
    for(int array: arrays){
        System.out.println(array);
    }
}

数组返回值

//反转数组（数组当返回值）
public static int[] reverseArrays(int[] arrays){
    int[] result = new int[arrays.length];
    
    //反转操作
    //i=0,j=result.length-1表示i初始化为0并且j初始化为length-1
    for(int i=0,j=result.length-1;i<arrays.length;i++,j--){
        result[j]=arrays[i];
    }
    return result;//返回数组
}

多维数组

• 定义多维数组

int[][] array={{1,2},{2,3},{3,4},{4,5}};
//表示int[4][5],四行五列
1,2
2,3
3,4
4,5
    
int[][][] array={ { {1,2},{2,3} } , { {3,4},{4,5} } }//数组里面嵌套数组
//表示int[2][2][2]

• 遍历多维数组

int[][] a={ {1,2},{3,4},{5,6}}

for(int i=0;i<a.length;i++){
    for(int j=0;j<a[i].length;j++){
        System.out.println(a[i][j]);
    }
}
//输出
1
2
3
4
5
6

Arrays类

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

1. 给数组赋值：通过fill方法
2. 对数组排序：通过sort方法，按升序
3. 比较数组：通过equals方法比较数组中元素值是否相等（String比较时必须用equals）
4. 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找

binarySearch//二分查找

查看API来得知函数如何使用

冒泡排序

//比较数组中相邻的两个数，如果第一个数比第二个数大，就交换位置
//每一次比较，都会产生一个最大，或者最小的数字
//下一轮可以少一次排序
//依次循环，直到结束

public static int[] bubbleSort(int[] arrays){
    //外层循环：判断我们需要走多少次
    for(int i=0;i<arrays.length-1;i++){
        boolean flag=false;
        //内层循环，比较判断两个数，如果第一个数比第二个数大，就交换位置
        //i每加1次，就表明有一个最大或最小产生，可以少走一步，每次j循环可以少比较i次
        for(int j=0;j<arrays.length-1-i;j++){
            if(arrays[j+1]>arrays[j]){
                int temp=arrays[j];
                arrays[j]=arrays[j+1];
                arrays[j+1]=temp;
                flag=true;
            }
        }
        if(flase==flase){
            break;//如果走的这一次没有进行排序，说明已经有序，直接跳出循环
        }
    }
    return arrays;
}

稀疏数组（数据结构）

• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组
• 稀疏数组的处理方式：

1. 记录数组一共有几行几列，有多少不同值
2. 把具有不同元素和行列以及它的值记录在一个小规模的数组中，来缩小程序规模

原矩阵

0	0	0	2
0	0	0	0
0	1	0	0
0	3	0	0

稀疏矩阵

	行	列	值
[0]	4	4	3
[1]	0	3	2
[2]	2	1	1
[3]	3	1	3

注意：[0]的位置表示原来矩阵有4行4列，有3个不同的值

[1]那一行表示，第1个元素出现在第1行，第4列，值为2

package com.operator.test01;
import java.util.Scanner;
import java.util.Arrays;
public class Scannertest {
    public static void main(String[] args) {
        int[][] arrays=new int[5][5];
        //创建矩阵
        arrays[3][2]=2;
        arrays[1][0]=1;
        //打印矩阵
        System.out.println("原来的矩阵：");
        for (int[] array : arrays) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }
        //创建稀疏矩阵
            //先数有几个不同的数
        int sum=0;
        for (int[] array : arrays) {
            for (int i : array) {
                if(i!=0){
                    sum++;
                }
            }
        }

        int[][] newArrays = new int[sum+1][3];//第一列表示行，第二列表示列，第三列表示值
        //第一行用来记录原来矩阵的特征,之后的行数用来记录是第几个不同的数
        newArrays[0][0]=5;//表示原来矩阵的行
        newArrays[0][1]=5;//表示原来矩阵的列
        newArrays[0][2]=sum;//表示有多少个不同的数


        int index=1;
        for(int i=0;i<arrays.length;i++){
            for(int j=0;j<arrays[i].length;j++){
                if(arrays[i][j]!=0){
                    newArrays[index][0]=i;//记录第index个不同的数的行数
                    newArrays[index][1]=j;//记录第index个不同的数的列数
                    newArrays[index][2]=arrays[i][j];//记录第index个不同的数的值
                    index++;
                }
            }
        }

        //输出稀疏矩阵
        System.out.println("稀疏矩阵:");
        for (int[] newArray : newArrays) {
            for (int i : newArray) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }


        //将稀疏矩阵还元为矩阵
        int[][] Matrix=new int[newArrays[0][0]][newArrays[0][1]];
        for(int i=1;i<=sum;i++){
            Matrix[newArrays[i][0]][newArrays[i][1]]=newArrays[i][2];
        }

        //输出稀疏矩阵还原后的矩阵
        System.out.println("稀疏矩阵->矩阵");
        for (int[] matrix : Matrix) {
            for (int i : matrix) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }
    }

}