Java_数组

06_数组

数组的概念

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

(保证有效元素连续)

特点：

1、类型相同；2、长度固定

数组的创建

//声明int数组类型变量，定义变量名为arr
int[] arr = new int[5]; //分配长度为5的连续空间

数组的使用

数组中的每个数据被称为“数组元素”

对每个元素进行复制或取值操作被称为“元素的访问”

访问元素时，需要使用“下标”(从0考试，一次+1，自动生成)

访问的语法：数组名 [下标]; 例如：存a[0]=10; 取 a[0]

下表范围：0~~数组长度-1

数组的遍历

遍历：从头到尾，逐一对数组的每个元素进行访问

数组长度：数组名.length 可以动态获取数组长度

注意：在没有为数组元素赋值的情况下依旧可以正确访问

数组的默认值：

整数	0
小数	0.0
字符	\u0000 (空格)
布尔	false
其他	null

数组创建语法

1、先声明、再分配空间：

int[] arr;          //数据类型[] 数组名;
arr = new int[2];   //数组名 = new 数据类型[长度];

2、声明并分配空间：

//数据类型[] 数组名 = new 数据类型[长度]；
int[] arr = new int[3];

3、声明并赋值（繁）

//数据类型[] 数组名 = new 数据类型[]{value1,value2,...};

4、声明并赋值（简）

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

数组的扩充

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

扩充数组思路：

1、创建大于原数组长度的新数组

2、将原数组中的元素依次复制到新数组中

复制数组的方式

1、循环将原数组中所有元素注意赋值给新数组

2、System.arraycopy(原数组，原数组起始，新数组，新数组起始，长度);

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

地址的替换

数组作为引用类型（数组，字符串，对象）之一，其变量中存储的是数组的地址

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

可变长参数

可接收多个同类型实参，个数不限，使用方式与数组相同

语法：

//数据类型... 形参名  (必须定义在形参列表的最后，且只能有一个)
public class TestArrayParamter{
  public static void main(String[] args) {
    //可变长参数赋予任意个数的实际参数
    printArray(11,22,33,44,55);
  }
    //定义int类型的可变长参数
  public static void printArray(int... oneArray){
    for (int i = 0;i<oneArray.length ;i++ ) {
        System.out.println(oneArray[i]);
    }
  }
}

数组的排序

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

public static void boom(){
        int[] arr = {1,5,2,7,3};
        int temp;
        for (int i = 0;i<arr.length-1 ;i++ ) {
            for (int j = 0;j<arr.length-1-i ;j++ ) {
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for (int i = 0;i<arr.length ;i++ ) {
            System.out.println(arr[i]);
        }
     }

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

public static void select(){
        int[] arr = {1,5,2,7,3};
        int temp;
        for (int i=0;i<arr.length-1 ;i++ ) {
            for (int j=i+1;j<arr.length ;j++ ) {
                if (arr[i]>arr[j]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }               
            }
        }
        for (int i = 0;i<arr.length ;i++ ) {
            System.out.println(arr[i]);
        }
     }

3、JDK排序：java.util.Arrays.sort(数组名)；//JDK提供（升序）

public class TestArrayParamter{
  public static void main(String[] args) {
    int[] arr = {22,11,55,88,33};
    java.util.Arrays.sort(arr);
    for (int i = 0;i<arr.length ;i++ ) {
        System.out.println(arr[i]);
    }
  }
}

执行结果

二维数组

一维数组中的一维数组；数组中的元素还是数组

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

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

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

高维数组中的每一个元素，保存了低维数组的地址

二维数组的内存分配

高维数组中的每一个元素，保存了低维数组的地址

二维数组的访问

array[i].length //访问低维长度array[0].length首个低维数组的长度
//访问低维数组元素：array[0][0]首个低维数组的首个元素

二维数组创建语法

1、先声明，再分配空间

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

2、声明并分配空间

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

3、声明并赋值（繁）

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

4、声明并赋值（简）

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

补充

---

值传递

基本数据类型进行传递（赋值）拷贝的是值的副本（拷贝值的副本，一方改变，不会影响另一方）

地址传递

引用数据类型进行传递（赋值），拷贝的是地址的副本（引用传递，拷贝的是地址的副本，一方改变，会影响另一方）

函数结束，局部变量回收

public class Test{
    public static void main(String[] args) {
        int a=10;
        m(a);// int n = a; 
            //值传递：基本数据类型进行传递（赋值）拷贝的是值的副本
        System.out.println(a);  //打印的a的值为10
    }
    public static void m(int n){
        n++;
    }   //函数结束，局部变量回收
}

杨辉三角

public class TestYH{
    public static void main(String[] args) {
         test(4);
    }
    public static void test(int a){                             //a代表行数，也代表高维
        int[][] arr = new int[a][]; 

        for (int i = 0;i<a ;i++ ) {                             //每一高位的元素个数，即：行数
        arr[i] = new int[i+1];  
        for (int j=0;j<i+1 ;j++ ) {                         //每一行的元素个数
            if(j==0 || j==arr[i].length-1){                 //每行最左边和最右边为1
                arr[i][j] = 1;
            }else{
                arr[i][j] = arr[i-1][j-1]+arr[i-1][j];      //否则，元素等于上边左右元素之和
                }
            }
        }
        //遍历二维数组
        for (int i = 0;i<a ;i++ ) {
            for (int j=0;j<arr[i].length ;j++ ) {
                System.out.print(arr[i][j]+"\t");       
            }
        System.out.println();
        }
    }
}

①”+”主动类型提升；②拼接字符串；③加法