千锋学习day07 数组

数组

数组的概念

概念：一组连续的存储空间，存储多个i相同数据类型的值

特点：1、类型相同 2、长度固定

数组的创建

public class Test1{
	public static void main(String[] args){
        //声明int数组类型变量定义变量名为a
        int[] a = new int[5];
        //分配长度为5的连续空间
    }
}

数组的组成

• 数组中的每个数据格被称为"数组元素"
• 对每个元素进行赋值或取值的操作被称为"元素的访问"
• 访问元素时,需要使用"下表"(从0开始，依次+1，自动生成)
• 访问语法：数组名[下表]//例如 存 a[0] =10； 取a[0]；

数组的使用

public class Test2{
    public static void main(String[] args){
        //创建数组
        int[] a = new int[5];
        //依次赋值
        a[0] = 5;
        a[1] = 3;
        a[2] = 4;
        a[3] = 7;
        a[4] = 10;
        //依次取值
   		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]);
    }
}
/*
运行结果
5
3
4
7
10
*/

下表范围

public class Test3{
	    public static void main(String[] args){
        //有效下表范围：0~数组长度-1
        int[] a = new int[5];
        a[0] = 5;
        a[1] = 3;
        a[2] = 4;
        a[3] = 7;
        a[4] = 10;
   		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]);
        //访问无效下标,会导致数组下标越界
        System.out.println(a[5]);
    }
}

java.lang.ArrayIndexOutofBoundsException：数组下标越界异常

运行时异常

数组的遍历

便利：从头至尾，逐一对数组的每个元素进行访问

public class Test4{
	public static void main(String[] args){
        int[] a = new int[5];
        a[0] = 5;
        a[1] = 3;
        a[2] = 4;
        a[3] = 7;
        a[4] = 10;
        //数组名.length可以动态获得数组长度
        for(int i = 0; i<a.length;i++){
            //使用循环变量"i"充当下标,逐一访问数组钟的每个元素
            System.out.println(a[i]);
        }
}

数组的默认值

public class Test5{
    public static void main(String[] args){
        int[] a = new int[5];
        for(int i = 0; i < 5; i++){
            //在没有数组元素赋值的情况下,依旧可以正确访问
            System.out.println(a[i]);
        }
    }
}

数组的默认值：

• 整数：0
• 小数：0.0
• 字符：\u0000 （空格）
• 布尔：false
• 其他：null

数组创建语法

• 先声明、再分配空间：

  数据类型[] 数组名

  数组名 = new 数据类型[长度]

• 声明并分配空间：

  数据类型[] 数组名 = new 数据类型[长度]

• 声明并赋值(繁)

  数据类型[] 数组名 = new 数据类型[]{value1,value2,value3,…}

• 声明并赋值(简)

  数据类型[] 数组名 = {value1,value2,value3,…} //显示初始化,注意：不可换行

课堂案例

给定一个整数数组，统计数组中所有元素的平均值

package com.zcs.test;

public class Test1 {
	public static void main(String[] args) {
		int[] a = { 1, 2, 3, 4, 5 };
		int sum = 0;
		for (int i = 0; i < a.length; i++) {
			sum += a[i];
		}
		System.out.println(sum/a.length);
	}
}

给定一个整数数组，读入一个整数n，如果n在数组中存在，输出下标，不存在输出-1；

package com.zcs.test;

import java.util.Scanner;

public class Test2 {

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个数字：");
		int num = input.nextInt();
		int[] a = { 22, 33, 44, 55, 66 };
		int count = 0;
		for (int i = 0; i < a.length; i++) {
			if (num == a[i]) {
				System.out.println("数组下9标为:" + i);
				break;
			}else {
				count++;
			}
		}
		if(a.length == count) {
			System.out.println(-1);
		}
		System.out.println("程序结束");
	}
}

数组扩容

创建数组时，必须显示指定长度，并在创建之后不可改变长度。

扩容思想：

• 创建大于原数组长度的新数组
• 将原数组中的元素依次复制到新数组中

复制方式

循环将原数组中所以元素逐一赋值给新数组

System.arraycopy（原数组，原数组起始，新数组，新数组起始，长度）

java.util.Arrays.copyOf(原数组,新长度)//返回带有原值的新数组

地址的替换

数组作为引用类型之一，其变量中存储的是数组的地址

完成元素复制后，需将新数组地址，赋值给原变量进行替换

数组类型的参数

public class Test6{
	public static void main(String[] args){
        //假设nums地址为：oxoooA001
        int[] nums = {111,222,333,444,555};
        //参数传入后oneArray地址为：oxooooA001
        printArray(nums);
    }
    public static void printArray(int[] oneArray){
        for(int i = 0; i < oneArray.length; i++){
            System.out.println(oneArray[i]);
        }
    }
}

方法调用时，将nums中的地址赋值给oneArray，此时二者指向同一个数组

传递参数时，基本类型传递的是变量中的值，应勇类型传递的是变量中的地址

数组类型的返回值

public class Test7{    public static void main(String[] args){        int[] oa= {111,222,333,444,555};//ox000A111        //na变量接收expand返回的新数组        int[] na = expand(oa);        for(int i = 0; i < na.length; i++){            System.out.println(na[i]);        }    }    public static int[] expand(int[] oldArray){//ox000A111        //创建长度为2倍的新数组,保留原数据        int[] newArray = new int[oldArray.length*2];//ox0000B222        for(int i = 0; i < oldArray.length;i++){            newArray[i] = oldArray[i];        }        //返回长度为10的newArray        return newArray;//ox0000B222    }}

调用数组类型返回值的方法时，方法执行后，返回的是数组的地址

可变长参数

概念：可接收多个同类型实参，个数不限，使用与数组相同

语法：数据类型…形参名//必须定义在形参列表的最后，且只能有一个

public class Test8{	public static void main(String[] args){        //可为可变长参数赋予 0~N个实际参数        printArray(111,222,333,444,555);    }    public static void printArray(int... oneArray){        for(int i = 0; i < oneArray.length;i++){            System.out.println(oneArray[i]);        }    }}

数组的排序

冒泡排序：相邻的两个数值比较大小，互换位置

选择排序：固定值与其他值依次比较大小，互换位置

JDK排序：java.util.Arrays.sort（数组名）;JDK提供（升序）

二位数组

概念：一维数组中的一维数组；数组中的元素还是数组

当查找excel中的某个单元格时,需要两个下标：n代表行，m代表列，

二维数组相当于多一个多行多列的表格

二位数组的赋值

public class Test9{	public static void main(String[] args){		int[] array = new int[3][5];		array[0][0]=10;		array[0][0]=20;		array[1][1]=30;		array[1][2]=40;		array[2][4]=50;	}}

使用双下标访问二维数组中的元素，

第一个下标代表：行号（高维下标）

第二个下标代表：列号（低维下表）

二维数组的内存分配

高维数组中的每一个元素，保存了低维数组的地址。访问array[0]等价于访问0x0000A111；

二位数组创建语法

• 先声明、再分配空间：

  数据类型[][] 数组名；数组名 = new 数据类型[高维长度][低维长度]
  

• 声明并分配空间：

  数据类型[][] 数组名 = new 数据类型[高维长度][低维长度]
  

• 声明并赋值（繁）

  数据类型[][] 数组名 = new 数据类型[高维长度][]//不规则数组，自行new低维数组
  

• 声明并赋值（简）

  数据类型[][] 数组名 = new {{v1,v2,v3},{v4,v5},{v6,v7,v8,9}};//显示初始化
  

总结

• 数据的概念

  一组连续的存储空间，存储多个相同数据类型的值

• 数据的声明与赋值

  数据类型[] 数组名 = new 数据类型[长度];

  数组名[下标] = 值；

• 数组的遍历

  从头至尾，逐一对数组的每个元素进行访问

• 数组的排序

  冒泡排序、选择排序、JDK快速排序

• 数组的应用

  数组复制、数组扩容、数组参数、数组返回值、二维数组

增强for循环

package com.zcs.lession08;public class Demo6 {	public static void main(String[] args) {		int[] a = {21,22,23,24,25,26};				//增强for		=>for..each		/*		 * int wahaha 声明了1个int类型的变量		 * :后面写的是集合=>数组		 * */		//展示遍历,取值遍历的		for(int wahaha:a) {			wahaha=111;			System.out.println(wahaha);		}		System.out.println("=============");		for (int i : a) {			System.out.println(i);		}	}}