Java组队学习Task03

数组

一组连续的存储空间，存储多个相同数据类型的值。同一种类型数据的集合。其实数组就是一个容器。运算的时候有很多数据参与运算,那么首先需要做的是什么.不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的方式，能存数据的地方我们称之为容器，容器里装的东西就是数组的元素, 数组可以装任意类型的数据，虽然可以装任意类型的数据,但是定义好的数组只能装一种元素， 也就是数组一旦定义，那么里边存储的数据类型也就确定了。

数组的特点

类型相同，长度固定，可以自动给数组中的元素从0开始编号，方便操作这些元素。

数组的定义

• 数组的创建

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

• 声明数组变量：必须在程序中声明数组，并指定数据类型；声明数据类型为int，容器使用数组那么如何标识数组呢？在java中我们使用[]符号标识，然后接着是定义数组的名称为arr，格式为 int[] arr。注意：int x[] 也是一种创建数组的格式。推荐使用int[] x 的形式声明数组。

• 创建数组：要使用一个新的关键字叫做new，new 用来在内存中产生一个容器实体，数据要存储是需要有空间的，存储很多数据的空间用new 操作符来开辟，new int[5]; 这个5是元素的个数。右边这部分就是在内存中定义了一个真实存在的数组，能存储5个元素。注意：int [] x = new int[5] 做了两件事情，首先使用new int[5] 创建了一个数组，然后把这个数组的引用赋值给数组变量x。

思考：arr是属于什么数据类型？ 任何一个变量都得有自己的数据类型。注意这个arr不是int 类型的 。int 代表的是容器里边元素的类型。那么x 是数组类型的，数组是一种单独的数据类型。数据类型分为2大派，分为基本数据类型和引用数据类型。 第二大派是引用数据类型。引用数据类型三种当中的一种就是数组类型。

定义数组主要有两种格式： 格式一：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 
示例：int[] arr1 = new int[5];
示例：float[] arr2 = new float[5];

格式二：

元素类型[] 数组名 = new 元素类型[]{元素，元素，……}; 
int[] arr1 = new int[]{3,5,1,7}; 
float[] arr2 = {1.3,1.5,1.1,1.7};

注意：给数组分配空间时，必须指定数组能够存储的元素个数来确定数组大小，体现了数组长度固定的特点；创建数组之后不能修改数组的大小。可以使用length 属性获取数组的大小。

数组的初始化

数组的声明与赋值

int[] arr = new int[2];
a[0] = 10;
a[1] = 20;

另一种方式也可以直接明确数组的长度,以及数组中元素的内容：

int[] arr = new int[]{20,30,40};
int[] arr = {20,30,40};

如果数组初始化中不使用运算符new。需要注意：下列写法是错误的：

int[] arr; 
arr = {20,30,40};

代码实例：

public class Arraylist {
    public static void main(String[] args) {
        // 数组大小
        int size = 10;
        // 定义数组
        double[] myList = new double[size];
        myList[0] = 5.6;
        myList[1] = 4.5;
        myList[2] = 3.3;
        myList[3] = 13.2;
        myList[4] = 4.0;
        myList[5] = 34.33;
        myList[6] = 34.0;
        myList[7] = 45.45;
        myList[8] = 99.993;
        myList[9] = 11123;
        // 计算所有元素的总和
        double total = 0;
        for (int i = 0; i < size; i++) {
            total += myList[i];
        }
        System.out.println("总和为： " + total);
    }
}

结果：

总和为： 11367.373

数组内存分析

• 栈内存：栈内存存储的都是局部变量，变量一旦出了自己的作用域，那么就会马上从内存的消失，释放内存空间。

• 堆内存：堆内存存储的都是对象内存，对象一旦被使用完，并不会马上从内存中消失，而是等待垃圾回收器不定时的把垃圾对象回收，这时候该对象才会消失，释放内存。

• 凡是以new关键字创建的对象，JVM都会在堆内存中开辟一个新的空间，创建一个新的对象。

• 对象如果没有变量引用了，那么该对象就是一个垃圾对象了。

 示例代码：

public class Test2 {
    public static void main(String[] args) {
        int[] arr1 = new int[2];
        int[] arr2 = new int[3];
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
 
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
 
        // 给arr1数组的索引为0元素赋值100
        arr1[0] = 100;
        // 给arr2数组的索引为0元素赋值200
        arr2[0] = 200;
 
        System.out.println("-----------");
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
 
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }
}

 运行结果：

[I@677327b6
0
0
[I@14ae5a5
0
0
0
-----------
[I@677327b6
100
0
[I@14ae5a5
200
0
0

 多维数组

二维数组可以看作是特殊的一维数组，它有两种声明方式：

数组元素类型 数组名字[][];
数组元素类型[][] 数组名字;
int arr1[][]; 
char[][] arr2;

同一维数组一样，二维数组在声明时也没有分配内存空间，同样要使用关键字new来分配内存，然后才可以访问每个元素。
为二维数组分配内存有两种方式∶

int a[][];
a = new int[2][4];  //直接分配行列
int b[][];
b = new int[2][];   //先分配行，再分配列
b[0] = new int[2];  //给第一行分配列
b[1] = new int[2];  //给第二行分配列

注意： 创建二维数组的时候，可以只声明"行"的长度，而不声明"列"的长度。

二维数组的赋值：

二维数组的初始化方法与一维数组类似，也有3种方式。但不同的是，二维数组有两个索引（即下标），构成由行和列组成的一个矩阵。

 三种方式初始化二维数组

public class InitTDArray {
	public static void main(String[] args) {
		/* 第一种方式 */
		int tdarr1[][] = { { 1, 3, 5 }, { 5, 9, 10 } };
		/* 第二种方式 */
		int tdarr2[][] = new int[][] { { 65, 55, 12 }, { 92, 7, 22 } };
		/* 第三种方式 */
		int tdarr3[][] = new int[2][3]; // 先给数组分配内存空间
		tdarr3[0] = new int[] { 6, 54, 71 }; // 给第一行分配一个一维数组
		tdarr3[1][0] = 63; // 给第二行第一列赋值为63
		tdarr3[1][1] = 10; // 给第二行第二列赋值为10
		tdarr3[1][2] = 7; // 给第二行第三列赋值为7
	}
}

多维数组 

比一维数组维数高的叫多维数组，理论上二维数组也属于多维数组。Java也支持三维、四维等多维数组，创建其他多维数组的方法与创建二维数组类似。

int a[][][] = new int[3][4][5];
//创建三维数组

char b[][][][] = new char[6][7][8][9];
//创建四维数纹

double c[][][][][]= new double[10][11][12][13][14]; // 建wu维数组

通过二维数组输出不同版本的古诗

public static void PoetryPrint() {
        char arr[][] = new char[4][]; // 创建一个4行的二维数组
        arr[0] = new char[]{'春', '眠', '不', '觉', '晓'}; // 为每一行赋值
        arr[1] = new char[]{'处', '处', '闻', '啼', '鸟'};
        arr[2] = new char[]{'夜', '来', '风', '雨', '声'};
        arr[3] = new char[]{'花', '落', '知', '多', '少'};
        /* 横版输出 */
        System.out.println("-----横版-----");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print(arr[i][j]);
            }
            if (i % 2 == 0) {
                System.out.println(",");
            } else {
                System.out.println(".");
            }
        }
        /* 竖版输出 */
        System.out.println("\n-----竖版-----");
        for (int j = 0; j < 5; j++) { // 列变行
            for (int i = 3; i >= 0; i--) { // 行变列，反序输出
                System.out.print(arr[i][j]); // 输出数组中的元素
            }
            System.out.println(); // 换行
        }
        System.out.println("。，。，"); // 输出最后的标点
    }

结果：

-----横版-----
春眠不觉晓,
处处闻啼鸟.
夜来风雨声,
花落知多少.

-----竖版-----
花夜处春
落来处眠
知风闻不
多雨啼觉
少声鸟晓
。，。，

不规则数组

上文讲的数组都是行、列固定的矩形方阵， Java同时也支持不规则的数组，例如二维数组中，不同行的元素个数可以不同，例如∶

a[][] = new int[3][];
// 创建二维数组，指定行数，不指定列数
a[0]= new int[5];// 第一行分配5个元素

a[1] = new int[3];// 第二行分配3个元素
a[2] = new int[4];// 第三行分配4个元素

声明一个不规则二维数组，输出数组每行的元素个数及各元素的值，代码如下∶ 

 public static void IrregularArray(){

        int a[][] = new int[3][];
        a[0] = new int[]{1,2,3};
        a[1] = new int[]{4,5,6,7};
        a[2] = new int[]{8,9,10,11,12};

        for (int i = 0; i < a.length; i++) {
            System.out.print("a[" + i + "]中有" + a[i].length + "个元素，分别是：");
            for (int tmp : a[i]){
                System.out.print(tmp+"");
            }
            System.out.println();
            
        }
    }

结果：

a[0]中有3个元素，分别是：123
a[1]中有4个元素，分别是：4567
a[2]中有5个元素，分别是：89101112

处理数组

遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。遍历一维数组很简单，也很好理解，下面详细介绍遍历二维数组的方法。 
 遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。

练一练：使用二维数组实现杨辉三角算法。

public class YangHui {// 杨辉三角算法的实现
	public static void main(String[] args) {
		// 定义一个长度为10的二维数组
		int[][] Array_int = new int[10][];
		// 向数组中记录杨辉三角形的值
		for (int i = 0; i < Array_int.length; i++) {// 遍历行数
			Array_int[i] = new int[i + 1];// 定义二维数组的列数
			// 遍历二维数组的列数
			for (int j = 0; j < Array_int[i].length; j++) {
				if (i <= 1) {// 如果是数组的前两行
					Array_int[i][j] = 1;// 将其设置为1
					continue;
				} else {
					// 如果是行首或行尾
					if (j == 0 | j == Array_int[i].length - 1)
						Array_int[i][j] = 1;// 将其设置为1
					else// 根据杨辉算法进行计算
						Array_int[i][j] = Array_int[i - 1][j - 1] + Array_int[i - 1][j];
				}
			}
		}
		for (int i = 0; i < Array_int.length; i++) {// 输出杨辉三角
			for (int j = 0; j < Array_int[i].length; j++)
				System.out.print(Array_int[i][j] + "\t");
			System.out.println();
		}
	}
}

结果：

1	
1	1	
1	2	1	
1	3	3	1	
1	4	6	4	1	
1	5	10	10	5	1	
1	6	15	20	15	6	1	
1	7	21	35	35	21	7	1	
1	8	28	56	70	56	28	8	1	
1	9	36	84	126	126	84	36	9	1	

Array类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

• 给数组赋值：通过 fill 方法。
• 对数组排序：通过 sort 方法,按升序。
• 比较数组：通过 equals 方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。