数组的使用

一：数组的介绍
数组是一种数据结构，它可以存储多个数据，一个数据就是一个元素，通常可以通过元素的下标来访问元素和为元素赋值！
一个数组中，只能存储一种数据类型的数据

二：数组的创建方式
2.1：静态初始化：由程序员显示的指定每个元素的初始值，由系统决定长度

int[] arr = new int[]{1,2,3};
int[] arr = {1,2,3}; //简化形式: 推荐

2.2：动态初始化：由程序员指定长度，由系统为数组元素分配初始值
byte,short, int, long: 0
float,double: 0.0
char: '\u0000'
boolean: false
引用类型(类，接口，数组): null

int[] arr = new int[3];

注：动态初始化和静态初始化不能同时使用！ 

三：遍历数组
3.1：普通for

public class Demo7 {

	public static void main(String[] args) {
		
		String[] ss = {"hello","world","java"};
		
		for(int i=0; i<ss.length; i++) {
			ss[i] = "test";
		}
		
		System.out.println(Arrays.toString(ss));//[test, test, test]
		
	}
}

3.2：增强for（foreach并不能改变数组元素的值）

public class Demo {

	public static void main(String[] args) {
		

		for (String s : ss) {
			s = "test";
		}
		System.out.println(Arrays.toString(ss));//[hello, world, java]

	}
}

四：数组的内存图解
4.1：基本类型数组的初始化

public class Demo {

	public static void main(String[] args) {
		//定义一个int[]类型的引用变量
		int[] arr; //①
		
		//初始化数组,长度为3
		arr = new int[3];//②
		
		//为数组元素赋值
		for(int i=0; i<arr.length; i++) { //③
			arr[i] = i+10;
		}
	}
}

解释：
①步骤的时候，只是定义了一个引用变量，该变量没有指向任何有效的内存！
②步骤的时候，new关键字出现了，这时系统为数组开辟了空间，并给了默认值（因为数组的元素类型是int,所以默认值为0）
③步骤的时候，为数组中每一个元素赋完值后的效果图

4.2：引用类型数组的初始化

public class Demo{

	public static void main(String[] args) {
		//定义一个Person[]类型的引用变量ps
		Person[] ps;
		
		//为这个数组动态初始化,长度为2
		ps = new Person[2];
		
		//创建Person实例
		Person p1 = new Person("wzj",22);
		Person p2 = new Person("sbt",30);
		
		ps[0] = p1;
		ps[1] = p2;
		
		//下面两句执行效果一样！
		System.out.println(p1.MySelfIntroduce());;
		System.out.println(ps[0].MySelfIntroduce());;
	}
}


class Person{
	String name; 
	int age;
	
	public Person() {
		super();
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String MySelfIntroduce() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}

 为什么最后两句输出的内容相同呢？原因是p1和ps[0]指向的是同一个对象！

五：没有多维数组：
int[][]，你可以看成就是一个一维数组，只不过里面的元素是int[]类型的罢了
int[][] arr = new int[3][2];

public class Demo {

	public static void main(String[] args) {
        //静态初始化，可以看出来数组的长度为2,元素是一个一维数组长度也是2
		int[][] arr = new int[][] {
			{1,2},
			{3,4}
		};

        //动态初始化
        //方式一: 同时初始化两个维数
        int[][] arr = new int[3][2];

        //方式二: 先初始化数组的长度
        int[][] arr = new int[3][];
	}
}

 注：int[][] arr = new int[x][]; 如果是动态初始化第一个[]必须写明长度

六：数组的工具类 Arrays
查找，复制，填充，排序等等

public class Demo7 {

	public static void main(String[] args) {
		
		int[] arr = {4,2,5,8,1,7};
		int[] arr2 = {4,2,5,8,1,7};
		int[] arr3 = {4,2,5,8,1,9};
		int[] arr4 = {1,2,3};
		int[] arr5 = {1,2,3,4};
//		System.out.println(binarySearch(arr,23));
		System.out.println(equals(arr,arr2));//为了不影响效果，应该把上一行注释掉！
		System.out.println(file(arr3, 1));
		
		int[] copy = copy(arr4,6); //大于原数组的长度--> copy:{1,2,3,0,0,0}
		System.out.println(Arrays.toString(copy));//[1, 2, 3, 0, 0, 0]
		
		int[] copyOfRange = copyOfRange(arr5,0,2);
		System.out.println(Arrays.toString(copyOfRange));
	}
	
	/**
	  *   只复制： 数组中from...to的索引，包左不包右，不会发生数组越界异常！
	 * @param arr5
	 * @param from
	 * @param to
	 * @return
	 */
	private static int[] copyOfRange(int[] arr5, int from, int to) {
		return Arrays.copyOfRange(arr5, from, to);
	}

	/**
	 * 	将原数组复制成一个新数组,参数i是新数组的长度
	 * 	如果i>原数组的长度，那么多出来的就根据原数组的类型补默认值
	 *        如果i<原数组的长度, 那就只复制这么长！
	 * @param arr4
	 * @param i
	 * @return
	 */
	private static int[] copy(int[] arr4, int i) {
		return Arrays.copyOf(arr4, i);
	}

	/**
	 * 	 将数组中所以元素都填充成 i
	   *    注：也可以在数组中指定范围填充
	 * @param arr3
	 * @param i
	 * @return 
	 */
	private static String file(int[] arr3, int i) {
		Arrays.fill(arr3, i);
		return Arrays.toString(arr3);
	}

	/**
	  *  比较两个数组的长度和元素是否相同
	 *  	相同：返回true, 否则返回false
	 * @param arr
	 * @param arr2
	 * @return 
	 */
	private static boolean equals(int[] arr, int[] arr2) {
		return Arrays.equals(arr, arr2);
	}

	/**
	 * binarySearch(byte[], byte key): 
	 * 		查询key在byte[]中的索引，前提是该数组是排完顺序的
	 * 		否则返回负数：怎么判断负数：(变量 & 1) != 0
	   *                注：也可以在数组中指定范围查找key
	 */
	private static int binarySearch(int[] arr, int i) {
		Arrays.sort(arr);
//		System.out.println(Arrays.toString(arr));//[1, 2, 4, 5, 7, 8]
		return Arrays.binarySearch(arr,i);
	}
}

七：数组的应用：一般是装一些固定的值：比如一年中的月份