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[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:数组下标越界异常

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 
多维数组 
定义多维数组 
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 
Arrays类 
数组的工具类java.util.Arrays由于数组对象本身并没有什么方法可以供我们使用，但是API提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本操作。查看JDK基本文档Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而"不用"使用对象来调用（注意：是”不用“，而不是”不能“）具有一下常用功能 
 
 
给数组赋值：通过fill方法对数组排序：通过sort方法，按升序比较数组：通过equals方法比较数组中元素值是否相等（String比较时必须用equals）查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找
 
 
binarySearch//二分查找
 
 
查看API来得知函数如何使用
 
冒泡排序 
//比较数组中相邻的两个数，如果第一个数比第二个数大，就交换位置
//每一次比较，都会产生一个最大，或者最小的数字
//下一轮可以少一次排序
//依次循环，直到结束

public static int[] bubbleSort(int[] arrays){
    //外层循环：判断我们需要走多少次
    for(int i=0;iarrays[j]){
                int temp=arrays[j];
                arrays[j]=arrays[j+1];
                arrays[j+1]=temp;
                flag=true;
            }
        }
        if(flase==flase){
            break;//如果走的这一次没有进行排序，说明已经有序，直接跳出循环
        }
    }
    return arrays;
}
 
稀疏数组（数据结构） 
当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组稀疏数组的处理方式： 
 
 
记录数组一共有几行几列，有多少不同值把具有不同元素和行列以及它的值记录在一个小规模的数组中，来缩小程序规模
 
 
原矩阵
 
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矩阵");
        for (int[] matrix : Matrix) {
            for (int i : matrix) {
                System.out.print(i+"t");
            }
            System.out.println();
        }
    }

}