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);
}
}