Java基础（三）——数组

数组

数组：
用来存储同一类型多个元素的容器
数组长度固定
通过索引查找元素,索引下标从0开始

public class Ran {
	public static void main(String[] args) {
		// 数组的声明
		// 数组类型[] 变量名 = new 数组类型[数组长度]
		// 方式一 数组的动态初始化，只给出长度，系统提供默认的初始化
		int[] i = new int[5];
		// String[] str = {"a","b","c","d","e"};//方式二 静态初始化
		// int [] i2 = new int[] {1,2,3,4};//方式三	静态初始化
		//方式二最常用，但是这种方式不能作为返回值,return {1,2,3}
		
		//数组的赋值与访问，数组有下标（索引），从0开始，依次递增
		i[0] = 2;
		i[1] = 5;
		i[2] = 57; //利用索引赋值
		i[3] = 7;
		i[4] = 6;
		//i[5]=70; 数组常见的异常——索引越界异常
		System.out.println(i[2]);//57	//利用索引取单个值
		
		//获取数组中所有的值:遍历
		for(int index = 0 ;index < i.length ; index++) {
		//length是数组的属性,表示数组的元素个数
			System.out.println(i[index]);
		}

		//增强for遍历
		for(int ret : i){
			System.out.println(ret);
			//没有索引,无法直接操作数组元素;但是减少了代码量,方便了数组的遍历
		}
		
	}
	public static String[] add() {
		return new String[]{"1"};
	}

}

Java对内存分为5个区域：

		寄存器:内存，CPU之间
		本地方法区：JVM调用了系统中的功能
		方法和数据共享区：运程序行期，class进入的地方
		方法栈：所有方法运行时进入的内存
		堆：存储容器和方法
	简易流程
	1.方法和数据共享区加载运行class文件
	2.main方法进入栈内存运行
	创建引用int[] i 
	3.在堆中创建容器存储
	new int[5]
	将堆中的内存地址赋值给栈的引用
	System.out.println(i) 输出的就是引用中的内存地址，而不是数组中具体的元素
	
	栈内存是先进后出
	长度为0的数组并不是null
	空数组的引用不指向任何对象
Java的内存分配：
		A:栈 存储局部变量（方法中定义或声明的变量）
		B:堆 存储所有new出来的
		C:方法区(面向对象部分详细讲解)
		D:本地方法区(系统相关)
		E:寄存器(CPU使用)

二维数组

//二维数组
		int [] [] i = new int[3][4];
		//最简单的定义int [] [] i = { {1,2,3} , {4,5,6} , {7,8,9} }
		//赋值
		i[0][0] = 1;
		i[0][1] = 2;
		i[0][2] = 3;
		i[1][0] = 3;
		i[1][1] = 3;
		i[1][2] = 3;

数组最值

public static void main(String[] args) {
		//数组最值
		int[] i = {1,5,2,5,4,7,6,9,87,54,67,35};
		int max = i[0];
		for(int index = 1; index < i.length ; index ++ ) {
			if(i[index]	> max) {
				max = i[index];
			}
		}
		System.out.println("数组中最大值为:" + max);

	}

数组的冒泡排序

public static void main(String[] args) {
		//数组的冒泡排序
		int[] arr = {1,5,2,5,4,7,6,9,87,54,67,35};
		for(int i = 0; i < arr.length ; i ++ ) {
			boolean flag = false;
			for(int j = 0; j < arr.length - 1 - i; j ++) {
				if(arr[j] > arr[j+1] ) {
					int f = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = f;
					flag = true;
				}
			}
			
			if (!flag){
			//优化点：如果某一次排序后，元素没有发生交换，说明此事元素已经排序完毕，
			//当前元素后面的元素就不需要在继续比较了
				break;
			}
		}

数组的选择排序

int [] arr = {1,25,62,14,22,23,32,54,14};
		//选择排序
		for(int i = 0 ;i < arr.length - 1; i++ ) {
			int min = i; //最小值下标为i
			for(int j = i + 1 ; j < arr.length; j++) {
				if (arr[j] < arr[min]) {
					min = j;
				}
			}
			
			if (min != i) { //减少交换次数
				int temp = arr[i];
				arr[i] = arr[min] ;
				arr[min] = temp;
			}
		}
		//遍历
		for (int i : arr) {
			System.out.print(i + " ");
		}

冒泡排序与选择排序的区别:

冒泡排序是每次比较两个相邻元素大小;
选择排序是假设首位为最大/最小值去按顺序与后面的元素一一比较
冒牌排序每次比较后,位置不对都会交换位置
选择排序每次比较完后不会交换位置,只会在比较了一轮后才交换位置

数组元素反转

		int [] i = {1,2,3,4,5,6,7,8,9};
		
		for(int start = 0,end = i.length - 1; start < end; start++, end--) {
			int temp = i[start];
			i[start]  = i[end];
			i[end] = temp;
		}
		//for遍历
		for(int ret : i) {
			System.out.println(ret);
		}

数组工具类Arrays和ArrayUtils

Arrays:	rt.jar中java.util包下面的类
ArrayUtils:	commons-lang.jar中org.apache.commons.lang3包下下面的类

Arrays方法
asList():将数组转为集合,转换后的集合不能修改长度,本质还是一个长度不可变的数组
sort():	实现数组的排序
equals():	比较两个数组是否相等
binarySearch(): 此法为二分搜索法，查询前需要用sort()方法将数组排序,返回查询值的下标

String[] strings = { "a", "d", "g", "e", "x", "j" };
Arrays.sort(strings);//排序
int binarySearch = Arrays.binarySearch(strings, "a");//返回下标
for (String string : strings) {
	System.out.print(string + " ");
}
List<String> asList = Arrays.asList(strings);//转为集合

ArrayUtils方法
toArray():	将可迭代对象转为数组
getLength(array) : 获取数组长度
isEmpty( array): 判断数组是否为空或为null
isSameLength(array1,,array2): 判断两个数组是否长度一致
nullToEmpty(array): 将null转化为相应数组
remove(array,int index): 根据数组下标删除元素
reverse(array): 反转数组元素
toString( array,"数组为null打印这句话"): 打印数组元素
toMap(array): 将数组转为Map,数组类型必须为Map.Entry or an Array这种类型
...
...

	int [] arr1 = null;
    int [] arr2 = ArrayUtils.nullToEmpty(arr1);