数组

1、数组声明

/*
	数组的声明
	数组是一种类型，使用[]表示。
	只要存在一种类型，就会存在对应的数组类型。
	int ->  int[]
	String ->  String[]
	
	可以这样声明数组类型：
	int[] a;
	int a[];
	推荐使用第一种方式声明数组，因为第一种方式
	将变量类型与变量名进行有效的分离，而第二种
	没有。

*/
public class ArrayDec {
	public static void main(String[] args) {
		//声明一个int类型的变量
		int x;
		//声明数组类型的变量
		int[] a;
		//也可以这样来声明数组（不建议）
		int a[];
		//int[] a1, a2, a3;	//a1,a2,a3都是数组
		//int a1[], a2, a3;	//a1是数组，a2，a3是int类型。
	}
}

　　2、数组初始化

/*
	数组的初始化
	数组的每个数据称为数组的元素。
	数组元素的个数称为数组的长度。

	可以使用三种初始化方式
	int[] a = {1, 2, 3, 4 ,5};
	int[] a2 = new int[] {1, 2, 3, 4, 5};
	int[] a3 = new int[5];
	三种初始化的区别：
	第一种初始化方式，只能在声明的同时，进行赋值。
	第二，三种初始化方式，既可以在声明的同时赋值，
	也可以在声明之后再赋值。

	数组元素的访问
	通过数组名 + [下标（索引值）]
	数组的索引是从0开始的。
	a[0] = 100;

	数据具有一个属性：length
	length可以获得数组的长度（元素的个数）。

	数组越界
	访问数组的元素，如果提供的索引值<0，或者
	>=数组的长度（length），此时，就会发生
	数组越界。
	一旦数组越界，在编译时没有错误，但在运行
	时会产生异常（ArrayIndexOutOfBoundException）。
	
*/
public class ArrayInit {
	public static void main(String[] args) {
		int x = 1;
		int[] a = {1, 2, 3, 4 ,5};
		int[] a2 = new int[] {1, 2, 3, 4, 5};
		int[] a3 = new int[5];
		int y;
		y = 1;
		/*
		错误
		int[] a;
		a = {1, 2, 3, 4, 5};
		正确
		int[] a2;
		a2 = new int[] {1, 2, 3, 4, 5};
		int[] a3;
		a3 = new int[5];
		*/
		//System.out.println(a.length);
		/*
		System.out.println(a[0]);
		System.out.println(a[1]);
		System.out.println(a[2]);
		System.out.println(a[3]);
		System.out.println(a[4]);
		*/
		//遍历数组，局限：耦合性
		for (int i = 0; i < 5; i++) {
			//System.out.println(a[i]);
		}
		//改进：使用length属性	
		for (int i = 0; i < a.length; i++) {
			//System.out.println(a[i]);
		}
		//数组越界
		//a[-1] = 3;
		//a[10] = 3;
	}
}

　　3、变量内存分配情况

/*
	变量内存分配情况
	局部变量分配在栈内存当中，而对象分配在堆内存当中。

	栈内存结构会随着方法的调用而创建，随着方法的结束
	而销毁。每个方法都有自己的栈内存结构，彼此之间
	不受干扰。
	堆内存结构是长期存在的。对象存放在堆内存当中，当
	没有任何引用指向一个对象时，该对象就会成为垃圾回收
	器回收的目标，垃圾回收器会在下次启动时将其回收。

	对于基本数据类型，该值直接存放在变量当中，对于引用类型，
	变量没有存放真正的对象（真正的对象存放在堆内存中），
	变量存放的是该对象的起始地址。

	引用类型变量不存放对象，而存放对象起始地址的原因：
	1 栈是一个频繁创建而销毁的结构，意味着栈的空间非常
	有限（否则浪费资源，降低性能），而对象占用的空间
	较大。
	2 栈会随着方法调用结束而销毁，此时栈中所有的变量都将
	不复存在，如果对象分配在栈内存当中，我们就不能在方法
	调用结束后继续使用该对象。
*/
public class Room {
	public static void main(String[] args) {
		
	}
}

　　4、增强型for循环

/*
	增强型for循环
	优势：
	对于操作数组与集合，增强型for循环具有一定的方便性。
	局限性：
	1 逆序遍历数组
	2 访问数组的部分元素
	3 在循环中改变数组元素的值
*/

public class ForEach {
	public static void main(String[] args) {
		int[] x = {1, 2, 3, 4, 5};
		//传统for循环
		for (int i = 0; i < x.length; i++) {
			//System.out.println(x[i]);
		}
		//增强for循环
		//意思：数组x里面的每一个元素会依次赋值给i一次，
		//然后执行一次循环体。
		for (int i : x) {
			//System.out.println(i);
		}
		//逆序遍历数组
		for (int i = x.length -1; i >= 0; i--) {
			//System.out.println(x[i]);	
		}

		//访问数组的部分元素
		for (int i = 2; i < x.length - 1; i++) {
			
		}

		//在循环中改变数组元素的值
		for (int i = 0; i < x.length - 1; i++) {
			//x[i] = i + 100;
		}

		for (int i : x) {
			i = 100;
		}
		//不能通过i改变数组元素的值。
		for (int i : x) {
			System.out.println(i);
		}
	}
}

　　5、多维数组

/*
	多维数组
	Java中实际上不存在多维数组，所谓的多维数组，在Java中
	就是数组的数组。即数组的每一个元素还是数组。
	int[] x;	=>	每一个元素为int类型。
	String[] x; =>  每一个元素为String类型。
	T[] x;		=>	每一个元素为T类型。
	当T是int[]的一维数组时，
	=》	(int[])[] =>	int[][]
	n维数组里面每一个元素是n-1维数组类型。（2 <= n <= 255）

	二维数组初始化的三种方式，与一维数组相同。
	二维数组三种初始化区别与一维数组是相同的。

	在Java中，多维数组不要求是矩阵数组，即每个低维数组
	的长度不要求相同。

*/
public class MultiArray {
	public static void main(String[] args) {
		//二维数组的初始化
		int[][] x = {{1, 2}, {3, 4}, {5, 6}};
		int[][] x2 = new int[][] {
			{1, 2}, {3, 4}, {5, 6}
		};
		int[][] x3 = new int[3][2];

		x[1][0] = 3;
		//非矩阵数组
		int[][] y = {{1}, {2, 3}};
		//可以先分配高维，再分配低维
		int[][] y2 = new int[2][];
		y2[0] = new int[3];
		y2[1] = new int[2];

		//二维数组的遍历
		for (int i = 0; i < x.length; i++) {
			for (int j = 0; j < x[i].length; j++) {
				System.out.println(x[i][j]);
			}
		}

		for (int[] i : x) {
			for (int j : i) {
				System.out.println(j);
			}
		}
	}
}

　　6、对数组进行复制

/*
	对数组进行复制
	System.arraycopy
	src	源数组
	srcPos	源数组开始复制的位置
	dest 目标数组
	descPos  目标数组开始复制的位置
	length	复制的长度

	数组的clone方法
*/

public class Copy {
	public static void main(String[] args) {
		int[] x = {1, 2, 3, 4, 5};
		int[] y = new int[x.length];
		System.arraycopy(x, 0, y, 0, x.length);
		for (int i : y) {
			//System.out.print(i + " ");
		}

		int[] z = x.clone();
		for (int i : z) {
			System.out.print(i + " ");
		}
	}
}

　　7、Arrays类的使用

/*
	Arrays类的使用。
	Arrays中声明了很多对数组操作的方法。
	Arrays类声明在java.util包中。
*/

import java.util.Arrays;

public class ArraysTest {
	public static void main(String[] args) {
		int[] x = {5, 4, 3, 2, 1};
		//对进组进行排序
		//Arrays.sort(x);
		for (int i : x) {
			//System.out.print(i + " ");
		}
		//对数组进行排序（并行排序），在对CPU，多核心
		//环境下，性能可能会得到提升。
		//Arrays.parallelSort(x);
		for (int i : x) {
			//System.out.print(i + " ");
		}
		//对数组的指定区间进行排序
		//第1个参数为待排序的数组，第2个参数执行开始
		//区间（包括），第3个参数指定结束区间（不包括）。
		//Arrays.sort(x, 1, 4);
		//Arrays.parallelSort(x, 1, 4);
		for (int i : x) {
			//System.out.print(i + " ");
		}
		//对指定的关键字进行查找。要求数组
		//元素必须是升序排列的，否则返回的结果是不确定的。
		//如果找到，会返回数组元素的索引。
		//如果未找到，返回负值。（-插入点-1）
		//插入点就是我们要查找关键字放在数组当中的索引。
		//Arrays.sort(x);
		//System.out.println(Arrays.binarySearch(x, 4));
		x = new int[] {1, 3, 5, 7, 9};
		//System.out.println(Arrays.binarySearch(x, 6));
		int[] y = new int[] {1, 3, 5, 7, 9, 11};
		//判断两个数组是否相等（原则：长度相应，对应的元素
		//也相等），如果相等，返回true，否则返回false。
		//System.out.println(Arrays.equals(x, y));
		int[] z = new int[5];
		//对数组使用指定的值进行填充
		//Arrays.fill(z, 100);
		//对数组指定的区间，使用指定的值进行填充。
		//第1个参数：待填充的数组
		//第2个参数：填充的开始点（索引），包含。
		//第3个参数：填充的结束点（索引），不包含
		//第4个参数：填充的值
		Arrays.fill(z, 2, 4, 100);
		for (int i : z) {
			//System.out.print(i + " ");
		}
		//对数组进行复制，返回复制后的数组。
		//第1个参数：源数组
		//第2个参数：复制的长度。如果长度小于
		//源数组的长度，则源数组被截断。如果长度
		//大于源数组的长度，则多余的元素取默认值。
		int[] w = {1, 2, 3, 4, 5};
		//int[] wCopy = Arrays.copyOf(w, w.length);
		//int[] wCopy = Arrays.copyOf(w, w.length - 2);
		int[] wCopy = Arrays.copyOf(w, w.length + 2);
		for (int i : wCopy) {
			//System.out.print(i + " ");
		}
		//对数组指定区间进行复制。返回复制的数组。
		//参数1：源数组
		//参数2：开始点，包含
		//参数3：结束点，不包含。该值可以大于源数组的
		//长度，此时，多余的元素取默认值。
		int[] k = new int[]{1, 2, 3, 4, 5};
		//int[] kCopy = Arrays.copyOfRange(k, 1, 4);
		int[] kCopy = Arrays.copyOfRange(k, 1, 10);
		for (int i : kCopy) {
			//System.out.print(i + " ");
		}
		//将数组转换成String。（将数组的每个元素进行拼接，
		//使用,进行分隔。）
		String s = Arrays.toString(k);
		System.out.println(s);
	}
}

　　8、命令行参数

/*
	命令行参数
	我们在java运行程序时，可以在后面传递相应的参数，
	参数会依次称为args数组的元素。
	参数使用空格进行分隔，如果参数本身含有空格，
	那么可以使用""进行引用。
	如果参数本身还有"，可以使用\"进行转义。
*/

public class Args {
	public static void main(String[] args) {
		//System.out.println(args.length);
		for (String s : args) {
			//System.out.println(s);
		}
		//int limit = 100;
		//int limit = (int)args[0];
		int limit = Integer.parseInt(args[0]);
		int sum = 0;
		for (int i = 1; i <= limit; i++) {
			//sum = sum + i;
			sum += i;
		}
		System.out.println(sum);
	}
}