目录

5.1数组

一维数组

初始化：

        动态初始化：先声明数组并且为数组元素分配空间，之后再进行赋值 

        静态初始化：声明数组，分配空间的同时赋值

多维数组

5.2数组常见算法  

求数组元素的最大值、最小值、总和、平均数

 数组的复制

数组输出(Arrays.toString方法)

数组输出（循环）

数组的反转（循序倒置） 

数组交换排序之冒泡排序

优化冒泡排序法

5.1数组

        如果我们需要定义很多相同类型的变量的时候，就要用到数组

        数组就是存放多个相同类型变量的有序集合

一维数组

        声明一维数组：

                        数据类型  数组名 [  ]        或        数据类型[  ]  数组名

        例如：

                int  arr[ ];        int[ ]  arr;        float  a[ ];        //是不是感觉少了点东西？？没错，就是中括号里的东西——元素个数（数组长度），下面我们会逐步了解。

初始化：

        动态初始化：先声明数组并且为数组元素分配空间，之后再进行赋值 

int[] arr = new int[3];    //声明一个能存放3个int类型数据的数组
arr[0] = 2;    //第一个元素为2
arr[1] = 4;    //第二个元素为4

        动态初始化时，数组默认初始化为0，当我们用new给数组创建内存后，它就已经隐式初始化了（看不见摸不着），我们未给元素赋值时，它的值为0。若元素为对象，那么默认类型是null。

int[] arr = new int[3];

System.out.println(arr[1]);    //此时arr[1]的值为0

        静态初始化：声明数组，分配空间的同时赋值

int[] arr = new int[ ] {1,2,3};    //声明一个存放了1，2，3的数组

数组声明了，如何引用呢？—— 数组名 [ 元素下标 ]

        new创建内存之后，才能引用数组中的元素

        元素下标可以时整型常量或整型表达式：如a[ 3 ]、arr[ x ]、array[ 2*i ]

        简单理解为数组中第几个元素

        由于元素下标是从0开始的，所以第一个元素为a[0]，第n个元素为[ n-1 ]

指明数组长度（数组名.length）

    int arr[ ] = new int[ ] {1,2,3,4};
    System.out.println(arr.length);    //arr.length用于指明数组arr的长度（元素个数）

多维数组

        二维数组：一维数组的每个元素都是数组，那么该数组就是二维数组。（“数组的数组”（一维数组技能升级））

        声明二维数组（与一维数组类似）：

                        数据类型  数组名 [  ] [  ]    或    数据类型  [  ] [  ]  数组名    或    

                        数据类型 [  ] 数组名 [  ]

    int arr[ ][ ] = new int[m][n];    //第一维长度为m，第二维=第一维每个元素的长度是n

        初始化：与一维数组类似分为动态初始化和静态初始化

        int arr[   ][   ] = new int[ 1 ][   ]；        只定义第一维，不定义第二维也可以

        注：int[  ] a,b[  ];        a是一维数组，b是二维数组

    int arr[ ][ ] =new int[ ][ ]{
        {1,3,5},    //第0个元素
        {2,4,6}    //第1个元素
    };

//arr[0][0] = 1    arr[0][1] = 3    arr[0][2] = 5
//arr[1][0] = 2    arr[1][1] = 4    arr[1][2] = 6

5.2数组常见算法  

求数组元素的最大值、最小值、总和、平均数

//最大值
    int[] arr = new int[] { 3, 2, 5, 1, 6, 4 };
    int max = arr[0];    //假设第一个元素最大
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }

//最小值同理
    int[] arr = new int[] { 3, 2, 5, 1, 6, 4 };
    int min = arr[0];    //假设第一个元素最小
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }

//求和、平均数
    int[] arr = new int[] { 3, 2, 5, 1, 6, 4 };
    int sum = 0;
    for(int i = 0; i 

 数组的复制

    int[] arr = new int[] { 1, 2, 3, 4, 5 };
    int[] copy = new int[arr.length];    //数组 copy与数组 arr长度相同，初始值默认为0
	for (int i = 0; i < arr.length; i++) {
		copy[i] = arr[i];    //遍历数组，将 arr中每一个元素传给 copy
	}
//这里需要自己运行，观察下边的输出有什么不同
    System.out.println(arr);
	System.out.println(copy);
	
    System.out.println(Arrays.toString(arr));
	System.out.println(Arrays.toString(copy));
    
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }

数组输出(Arrays.toString方法)

        观察上边数组复制代码中的输出语句，我们发现通过 System.out.println(arr); 输出的是数组的首地址，而 System.out.println(Arrays.toString(arr)); 可以输出各个元素，其中我们用Arrays.toString( )的方法，将数组以字符串形式输出

数组输出（循环）

    int[] arr = new int[] { 1, 3, 5, 7 };
    for (int i = 0; i < arr.length; i++){
        System.out.println(arr[i]);
    }

数组的反转（循序倒置） 

//temp[0] = arr[3]	temp[1] = arr[2]	temp[2] = arr[1]	temp[3] = arr[0]
    int[] arr = new int[] { 1, 2, 3, 4 };
	int[] temp = new int[arr.length];
	int j = 0;
	for (int i = arr.length - 1; i >= 0; i--) {
		temp[j] = arr[i];
		j++;
	}
	System.out.println(Arrays.toString(temp));
    

数组交换排序之冒泡排序

        冒泡排序，就像碳酸饮料的气泡一样，一个一个冒出来，因此得名

        原理（升序）：相邻元素比较，如果前者比后者大，二者交换循序，从第一对到最后一对，依次进行排序，直到没有任何一对数字进行比较时循环结束

//	升序
//	9,5,3,7,1
//	第一轮：5,3,7,1,9	最大的数字放在最后
//	第二轮：5,3,1,7,9 	第二大的数组放在倒数第二位
//	第三轮：3,1,5,7,9 	第三大的数组放在倒数第三位
//	第四轮：1,3,5,7,9 	第四大的数组放在倒数第四位    
    int[] arr = new int[] { 9, 5, 3, 7, 1 };
	int temp;	//声明临时变量，用于交换
	for (int i = 0; i < arr.length - 1; i++)	//外层循环为轮次，次数为 arr.length-1
		for (int j = 0; j < arr.length - 1; j++) {	//进行 arr.length-1 次比较
			if(arr[j] > arr[j+1]) {
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	System.out.println(Arrays.toString(arr));

优化冒泡排序法

        针对问题：数据顺序排好之后，冒泡算法仍进行下一次比较，直到arr.length-1次为止，后续比较无意义

        解决思路：设置标志位flag，判断元素位置是否发生改变， 如果该轮发生了交换，flag设置为true，否则为false。

这样当一轮比较结束后如果flag仍为false，即：这一轮没有发生交换，说明数据的顺序已经排好，没有必要继续进行下去。

代码：

    int[] arr = new int[] { 1, 3, 2, 5, 4 };
	int temp; // 临时变量
	boolean flag; // 是否交换的标志
	for (int i = 0; i < arr.length - 1; i++) { // 表示轮次，一共 arr.length-1 次
		// 每次遍历标志位都要先置为false，才能判断后面的元素是否发生了交换
		flag = false;
		for (int j = arr.length - 1; j > i; j--) { // 选出该趟排序的最大值往后移动
			if (arr[j] < arr[j - 1]) {
				temp = arr[j];
				arr[j] = arr[j - 1];
				arr[j - 1] = temp;
				flag = true; // 只要有发生了交换，flag就置为true
			}
		}
		// 判断标志位是否为false，如果为false，说明后面的元素已经有序，就直接return
		if (!flag)
			break;
	}