java中数组的使用

一维数组

创建数组只指定长度但不指定内容

数据类型[] 数组名 = new 数据类型[长度];

例如：int [] ArraryDemo=new int [10];

double [] ArraryDemo=new double[10];

String [] ArraryDemo=new String[10];

 创建数组指定内容(同时长度就确定了)

数据类型[] 数组名 = new 数据类型[]{数据1, 数据2, 数据3, ..., 数据n};
数据类型[] 数组名 = {数据1, 数据2, 数据3, ..., 数据n};

例如：int [ ] arr=new int [ ]{12,13,14,15,16};

double [ ] arr=new double [ ]{12.2,13.0,16.5,17.0};

String [ ] arr=new String [ ]{"张三","李四","王五"}；

动态初始化数组默认值规则

public class ArraryDemo(){
    public static void main(String []args){
       //整形动态数值化数组的默认值为0
       int []ArraryIntDemo=new int[5];
       System.out.println(ArraryIntDemo[1]);
 
       //字符型动态数组的默认值为0
       char []ArraryCharDemo=new char[5];
       System.out.println((int)ArraryCharDemo[1]);
 
       //浮点型动态初始化数组的默认值0.0
       double []ArraryDoubleDemo=new double[5];
       System.out.println(ArraryDoubleDemo[1]);
 
       //布尔类型动态初始化数组的默认值false
       boolen []ArraryBoolenDemo=new boolen[5];
       System.out.println(ArraryBoolenDemo[1]);
 
       //引用类型动态初始化数组默认值null
       String ArraryStrDemo=new String[5];
       System.out.println(ArraryStrDemo[1]);
    }
}

数组遍历

运用数组名调用length可以得出数组的长度，最大索引值是数组长度-1。

public class ArrayTraversal {
public static void main(String[] args) {
int[] arr = new int[] { 1, 2, 3, 4, 5, 6 };
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
for (int i : arr) {
System.out.println(i);
        }
    }
}

数组的注意事项：

1、什么类型的数组存放什么类型数据

2、数组一旦被定义出来，执行过程中长度类型就固定了

3、数组的索引值不能超过数组的长度，否侧程序会报错无法运行

4、当已经知道存入的元素值时 用静态数组初始化

5、当不知道要存入数组的数据时 用动态数组初始化

数组的内存分配

理解数组的内存分配对学习数组至关重要，程序在运行时主要有，方法区、栈内存、堆内存，

方法区：字节码文件加载时进入的内存，例如HolloWorld.class

堆内存：new出来的东西会在这块内存中开辟空间并产生地址

栈内存：方法运行时所进入的内存，另外变量也在这里。

public class ArrMemory(){
      public static void main(String args[]){
          int i=5;//普通变量所存储的就是他本身的值
          int []Arr=new int[]{1,2,3};
          Arr[0]=11;
          Arr[1]=22;
          Arr[2]=33;
          for(int i=0;i<Arr.length-1;i++){
              System.out.println(Arr[i]);
        }
    }
}

程序开始运行时

1、首先将程序编译成ArrMemory.class文件并加载到方法区

2、将main()方法加载到栈内存，开始运行第一行代码i=5，将在栈内存中开辟一个a变量的区域将5存储到里边，然后在开辟一个空间用来存放数组变量Arr，随即系统将会在堆内存中开辟一段的数组空间用来存放数组元素，并将产生的地址赋值给数组变量Arr。

3、然后就可以通过数组变量Arr来访问堆内存中的数组元素

 数组排序

1.插入排序

将待插元素，依次与已排序好的子数列元素从后到前进行比较，如果当前元素值比待插元素值大，则将移位到与其相邻的后一个位置，否则直接将待插元素插入当前元素相邻的后一位置，因为说明已经找到插入点的最终位置

public static void sort(int[] arr) {
        if (arr.length >= 2) {
            for (int i = 1; i < arr.length; i++) {
                //挖出一个要用来插入的值,同时位置上留下一个可以存新的值的坑
                int x = arr[i];
                int j = i - 1;
                //在前面有一个或连续多个值比x大的时候,一直循环往前面找,将x插入到这串值前面
                while (j >= 0 && arr[j] > x) {
                    //当arr[j]比x大的时候,将j向后移一位,正好填到坑中
                    arr[j + 1] = arr[j];
                    j--;
                }
                //将x插入到最前面
                arr[j + 1] = x;
            }
        }
    }

2.冒泡排序

从数列的第一个元素开始，然后依次和剩余的元素进行比较, 跟列队一样, 从左到右两两相邻的元素比大小, 高的就和低的换一下位置. 最后最高值就排到后面了.重复数列长度-1次

public static void  sort(int[] arr){
        for (int i = 1; i < arr.length; i++) {  //第一层for循环,用来控制冒泡的次数
            for (int j = 0; j < arr.length-1-i; j++) {//第二层for循环,用来控制冒泡一层层到最后
                //如果前一个数比后一个数大,两者调换 ,意味着泡泡向上走了一层
                if (arr[j] > arr[j+1] ){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

3.选择排序 

首先在未排序数列中找到最小元素，然后将其与数列的首部元素进行交换，然后，在剩余未排序元素中继续找出最小元素，将其与已排序数列的末尾位置元素交换。以此类推，直至所有元素圴排序完毕

private static void selectSort() {
    int[] arr = { 6, 9, 1, 5, 2, 3, 8, 4, 7 };
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[j] = arr[i];
                    arr[i] = temp;
            }
        }
    }
}

 数组查找

二分查找

	public static int binarySearch01(int[] arr, int target) {
		int start = 0, end = arr.length - 1;
		while (start <= end) {
			int middle = (start + end) >> 1;
			
			if (arr[middle] > target) {
				end = middle - 1;
			} else if (arr[middle] < target) {
				start = middle + 1;
			} else {
				return middle;
			}
		}
		return -1;
	}

二维数组

就是一个由行和列组成的一个表格而已，矩阵Matrix。
在这个矩阵中访问元素的话，是根据元素的行角标和列角标所确定的。
二维数组具体是在内存中如何存储的呢？
无论是二维数组，还是多维数组，它们本身就是一个一维数组。
尤其对于二维数组而言，无非就是一个一维数组，只不过该一维数组中的每一个元素是另一个
一维数组罢了。

定义方式

数据类型[][] 变量名称 = new 数据类型[行数][列数];

//创建一个3行4列的二维数组，元素默认都是0
int[][] matrix = new int[3][4];
//创建个指定元素的二维数组
int[][] matrix = new int[][]{
{ 1, 2, 3, 4 } ,
{ 5, 6, 7, 8 } ,
{ 9, 10, 11, 12 }
};

遍历二维数组

遍历二维数组就是获取每个数组中的元素，在遍历时需要使用双层for循环，通过数组的length属性可获取数组的长度。

	public static void main(String[] args) {
		int[][] arr = new int[][]{
			{ 1, 2, 3, 4 } ,
			{ 5, 6, 7, 8 } ,
			{ 9, 10, 11, 12 }
			};
		for(int i=0;i<arr.length;i++) {
			for(int j=0;j<arr[i].length;j++) {
				System.out.print(arr[i][j]+" ");//输入元素
			}
			System.out.println();//换行
		}
}

结果: