Java自学——数组

数组

数组基础

• 概念
  数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
• 定义

• 方式一
  数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
• 方式二
  数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
• 方式三
  数据类型[] 数组名 = {元素1,元素2,元素3…};

int[] arr1=new int[3];//方式一
int[] arr2=new int[]{1,2,3,4,5};//方式二
int[] arr3= {1,2,3,4,5};//方式三

• 访问

• 索引
  每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
  格式:

数组名[索引]

例：

public static void main(String[] args) {
		int[] arr=new int[] {1,2,3,4,5};
		System.out.println(arr.length);
		int i=arr[4];
		System.out.println(i);
		}

输出结果：5,5
PS：最大索引值是数组名length-1，即大于4则错误。

• 长度属性
  每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：* 数组名.length* ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为*数组名.length-1 *。
• 索引访问数组中的元素：

• 为数组中的元素赋值

数组名[索引]=数值

• 获取出数组中的元素

变量=数组名[索引]

例：

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

输出结果：5,6,6

数组原理内存图

区域名称	作用
寄存器	给CPU使用，和我们开发无关。
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

AND：

方法栈	堆内存
运行方法（主要是main方法）	存储数组（可存储多个数组）

笔者看到三种，分别是

• 一个数组内存

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

运行结果：
[I@7852e922（数组内存地址）

• 两个数组内存

public static void main(String[] args) {
		int[]arr1=new int[3];
		System.out.println(arr1);
		int[]arr2=new int[] {1,2,3,4,5};
		System.out.println(arr2);
	}

运行结果：
[I@7852e922
[I@4e25154f

• 两个变量指向一个数组

public static void main(String[] args) {
		int[] arr1= {1,2,3};
		System.out.println(arr1[0]);
		System.out.println(arr1[1]);
		System.out.println(arr1[2]);
		int[] arr2=arr1;
		arr2[0]=100;
		System.out.println(arr1[0]);		
	}

运行结果：
1
2
3
100
PS：若不赋值，初始值都是0，赋值后，分别为1,2,3。（如下图）
之后将arr1的地址赋给arr2，他们就完全相同，改变arr2即也改变了arr1的值。

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

输出结果：0,0,0

数组的常见操作

数组越界异常

就是访问不存在的索引，通常是由于访问索引大于数组名.length-1

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

输出结果：
0
0
0
Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3
at Day09.Demo02.main(Demo02.java:241)

数组空指针异常

arr=null表示堆中不再保存数组的地址了

public static void main(String[] args) {
		int[]arr= {1,2,3};
		arr=null;
		System.out.println(arr[1]);
	}

输出结果：
Exception in thread “main” java.lang.NullPointerException
at Day09.Demo02.main(Demo02.java:246)

数组遍历

就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

	public static void main(String[] args) {
		int[] arr1= {1,2,3};
		System.out.println(arr1[0]);
		System.out.println(arr1[1]);
		System.out.println(arr1[2]);
		}

改造成循环的写法。数组的索引是0 到lenght-1 ，可以作为循环的条件出现。

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

public static void main(String[] args) {
		int[] arr= {1,2,3};
		for(int i = 0;i<=arr.length-1;i++) {
			System.out.println(arr[i]);		
		}
	}

以上输出结果都是1,2,3

数组获取最大值元素

最大值获取：从数组的所有元素中找出最大值。
实现思路：

1. 定义变量，保存数组0索引上的元素
2. 遍历数组，获取出数组中的每个元素
3. 将遍历到的元素和保存数组0索引上值的变量进行比较
4. 如果数组元素的值大于了变量的值，变量记录住新的值
5. 数组循环遍历结束，变量保存的就是数组中的最大值

public static void main(String[] args) {
		int[] arr= {1,10,100,1000,10000};
		int max=arr[0];
		for(int i=0;i<arr.length;i++) {
			if(arr[i]>max) {
				max=arr[i];
			}
		}
		System.out.println(max);
	}

输出结果：10000

数组反转

数组的反转： 数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1
实现思想：

1. 数组最远端的元素互换位置。
2. 实现反转，就需要将数组最远端元素位置交换
3. 定义两个变量，保存数组的最小索引和最大索引
4. 两个索引上的元素交换位置
5. 最小索引++，最大索引–，再次交换位置
6. 最小索引超过了最大索引，数组反转操作结束

public static void main(String[] args) {
		int[] arr= {1,2,3,4,5};
		int min=0,max=arr.length-1;
		for(;min<=max;min++,max--) {
			int t=arr[min];
			arr[min]=arr[max];
			arr[max]=t;	
		}
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
	}

输出结果：5,4,3,2,1

数组作为方法参数和返回值

引用类型的数组进行参数传递。

数组作为方法参数

数组作为方法参数传递，传递的参数是数组内存的地址。

public static void main(String[] args) {
		int[]arr= {1,2,3,4,5};
		printArray(arr);
	}

	private static void printArray(int[] arr) {
		// TODO Auto-generated method stub
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}	
	}

输出结果：1,2,3,4,5

数组作为返回值

数组作为方法的返回值，返回的是数组的内存地址。

public static void main(String[] args) {
		int[] arr=printArray();
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
			}
	}

	private static int[] printArray() {
		// TODO Auto-generated method stub
		int[]arr= {1,2,3,4,5};
		return arr;
	}

输出结果：1,2,3,4,5
另，两个例子：
1.

public static void main(String[] args) {
		int a = 1;
		int b = 2;
		System.out.println(a);
		System.out.println(b);
		change(a, b);
		System.out.println(a);
		System.out.println(b);
		}
		
public static void change(int a, int b) {
		a = a + b;
		b = b + a;
		}

输出结果：1,2,1,2
另，稍稍修改了代码

public static void main(String[] args) {
		int a = 1;
		int b = 2;
		System.out.println(a);
		System.out.println(b);
		change(a, b);
		
		System.out.println(a);
		System.out.println(b);
		}
		
		public static void change(int a, int b) {
		a = a + b;
		b = b + a;
		System.out.println(a);
		System.out.println(b);
		
		}

输出结果：1，2，3，5，1，2
顺序为什么不是1,2,1,2,3,5，此处存疑
2.

public static void main(String[] args) {
		int[] arr = {1,3,5};
		System.out.println(arr[0]);
		change(arr);
		System.out.println(arr[0]);
		}
		public static void change(int[] arr) {
	    arr[0]=200;
		}

输出结果：1,200
总结：方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.