Java基础语法_数组

Java基础语法_数组

1.数组的定义

数组就是用来存储一批同种类型数据的容器

例子：

20, 10, 80, 60, 90
int[] arr = {20, 10, 80, 60, 90};

牛二, 西门, 全蛋
String[] names = {"牛二", "西门", "全蛋"};

1.1静态初始化数组

• 定义数组的时候直接给数组赋值

格式：

/** 完整格式
数据类型[]  数组名 = new 数据类型[]{元素1，元素2 ，元素3… };
*/
double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
int[] ages = new int[]{12, 24, 36}

/** 简化格式
  数据类型[] 数组名 = { 元素1，元素2 ，元素3，… };
*/
int[] ages = {12, 24, 36};

1.1.1数组的基本原理

数组变量名中存储的是数组在内存中的地址，数组都是引用类型。

1.1.2数组的访问

/**
数组名称[索引]
*/
// 赋值
arr[2] = 100;
System.out.println(arr[2]); // 100

1.1.3数组的长度属性

// 获取数组的长度（就是数组元素的个数）
System.out.println(arr.length); // 3

注意

数组的最大索引为：数组名. length – 1 数组名. length – 1

1.1.4注意事项

• 数据类型[] 数组名”也可以写成 “数据类型 数组名[]

int[] ages =...;  
int ages[] =...;  

double[] scores = ...;
double scores[] = ...;

• 什么类型的数组存放什么类型的数据，否则报错
• 数组一旦定义出来，程序执行的过程中，长度、类型就固定了

1.2动态初始化数组

1.2.1数组的动态初始化

定义数组的时候只确定元素的类型和数组的长度，之后再存入数据

1.2.2数组动态初始化格式

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

// 后赋值
arr[0] = 10;
System.out.println(arr[0]); // 10

1.2.3动态初始化数组的元素的默认值

1.2.3.1元素默认规则

数据类型	明细	默认值
基本类型	byte、short、char、int、long	0
基本类型	float、double	0.0
基本类型	boolean	false
引用类型	类、接口、数组、String	null

1.2.3.2使用场景、注意事项

• 动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。
• 静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景。
• 两种格式的写法是独立的，不可以混用。

2.数组的遍历

一个一个数据的访问

int[] ages = {20, 30, 40, 50};
for (int i = 0; i < ages.length; i++) {
    System.out.println(ages[i]);
}

3.数组内存图

3.1Java内存分配介绍

3.1.1Java内存分配介绍

3.2两个数组变量指向同一个数组对象

4.数组的排序和查找

4.1数组的排序

冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。

冒泡排序流程至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

例子：冒泡排序

public class Array_BubbleSort {
    public static void main(String[] args) {
       int[] arr = {9,8,5,4,2,0};		
		/*
		 *  趟i:  1,2,3,... arr.length-1
		 *  
		 *  每趟次数 j：   i=1  j=5(0,1,2,3,4)
		 *           i=2  j=4(0,1,2,3)
		 *           i=3  j=3
		 *           
		 *                j=arr.length-i-1
		 * 
		 * */
		for(int i=1;i<arr.length;i++)//趟
		{
			for(int j=0;j<arr.length-i;j++)//次
			{
				if(arr[j]>arr[j+1])
				{
					//交换位置
					int tmp = arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=tmp;
				}
			}
		}	
		//打印数组
		for(int i=0; i<arr.length;i++)
		{
			System.out.println(arr[i]);
		}
    }
}

4.1.1Arrays.sort的用法

• 定义：对数组进行从小到大排序

Arrays.sort(数组名)为数组排序的操作,但这个方法在 java.util 这个包里面,所以在用到的时候需要先将它导入。
Arrays.sort方法有两种常用方式，具体参数如下：
Arrays.sort(arr_name) 
Arrays.sort(arr_name,fromIndex,toIndex)
/**
arr_name：数组名称
fromIndex：排序的起始下标
toIndex：排序的终止下标
*/

例子

class ArraySort_sample {
    public static void main(String args[]){
        int[ ] point = {1,6,2,3,9,4,5,7,8};
        Arrays.sort(point);
        for(int i=0;i<point.length;i++){
            System.out.print(point[i]+" ");
        }
    }
}

4.2数组的查找

二分查找的前提是需要查找的数组必须是已排序的，这里实现默认前提为升序。查找时将数组分为三部分，依次是中值（所谓的中值就是数组中间位置的那个值）前，中值，中值后；将要查找的值和数组中的值进行比较，若小于中值则在中值前面找，若大于中值则在中值后面找，等于中值时直接返回。从描述上就可以看出这个算法适合用循环来实现。

例子：二分查找

public class BinarySearch {
         public static void main(String[] args) {
                   int[] sort = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
                   int key = 6;// 需要查找的值
                   int locale = -1;// 记录 查找位置的变量
                   int low = 0;
                   int high = sort.length - 1;
                   while (high >= low) {
                            int mid = (low + high) / 2;
                            if (key < sort[mid])
                                     high = mid - 1;
                            else if (key == sort[mid]) {
                                     locale = mid;
                                     break;
                            } else
                                     low = mid + 1;
                   }
                   if (locale == -1)
                            System.out.println("数组中不存在元素" + key);
                   else
                            System.out.println("元素" + key + "在数组中的下标是" + locale);
         }
}

5.数组的赋值(System.arraycopy的用法)

Java中的数组的复制使用System.arraycopy方法就可以实现，System.arraycopy所带参数如下所示： System.arraycopy(source,srcPos,dest,destPos,length)

复制source数组中从下标srcPos开始的length个元素到目标数组dest，并从目标数组的下标为destPos的位置开始储存 ，其中各个参数的含义如下：

@source： 源数组 srcPos： 源数组中的起始位置

@dest： 目标数组

@destPos：目标数组中的起始位置

@length： 要复制的数组元素的个数

例子：数组的赋值

复制数组{1,2,3,4,5}中从下标0开始的5个元素到目标数组{6,7,8,9,10,11,12,13,14,15}，并从目标数组的下标为0的位置开始储存

class Array_copy {
         public static void main(String args[]) {
                   int aa[] = new int[] { 1, 2, 3, 4, 5 };
                   int bb[] = new int[] { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
                   System.arraycopy(aa, 0, bb, 0, 5);
                   for (int i = 0; i < aa.length; i++) {
                            System.out.print(aa[i] + " ");
                   }
                   System.out.println();
                   for (int j = 0; j < bb.length; j++) {
                            System.out.print(bb[j] + " ");
                   }
                   System.out.println();
         }
}

6.数组常见的问题

• 问题1：如果访问的元素位置超过最大索引，执行时会出现ArrayIndexOutOfBoundsException(数组索引越界异常)

int[] arr = new int[]{11, 22, 33};
System.out.println(arr[2]);
System.out.println(arr[3])  // 出现异常 
//出现ArrayIndexOutOfBoundsException异常

• 问题2：如果数组变量中没有存储数组的地址，而是null, 在访问数组信息时会出现NullPointerException(空指针异常)

arr = null;
System.out.println(arr); // null
System.out.println(arr.length)  // 出现异常 
//出现NullPointerException异常