一维二维数组

1. 数组

数组是引用数据类型 , 用来保存多个数据

1.1. 数据结构

数据结构是计算机存储、组织数据的方式 . 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合 . 通常情况下 , 精心选择的数据结构可以带来更高的运行或者存储效率 . 数据结构往往同高效的检索算法和索引技术有关.

1.2. 数组特性

连续存储 , 下标从0开始 , 数组一旦创建 , 长度不能修改.

查询和修改效率极高 , 添加和删除效率较低(并且数组没有提供添加和删除操作)

想要添加新数据 , 需要建一个新数组 , 把源数组内容复制过去 , 再放一个新数据即可.

数组中有length属性 , 保存了数组的长度

1.3. 数组声明

1.3.1. 静态声明

静态声明 :

在已知每个元素的时候使用静态声明

数据类型 [ ] 变量 = {值,值,值......}

int[] arr1 = { 1, 2, 3, 4 };

int arr1[] = { 1, 2, 3, 4 };

1.3.2. 动态声明

动态声明:

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

int[] arr2 = new int[10];

1.4. 内存中存储方式

1.5. 数组使用

1.5.1. 获取数据

查询 :

                数组 [ 下标 ] 下标从0开始

                System.out.println(arr1[0]);

                System.out.println(arr1[3]);

查新最后一个数据

        System.out.println(arr1[arr1.length-1]);

长度

        System.out.println(arr1.length)

1.5.2. 更改数据

修改 :

数组 [下标] =值;

array[2] = 12;

1.5.3. 遍历

遍历 :

        for (int i = 0; i < arr1.length; i++) {

        System.out.println(arr1[i]);

        }

1.5.4. 常见异常

下标越界

// 常见异常

// Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10

// 运行时异常,下标越界

// 下标最大为 length-1

        arr1[10] = 2;

// 会终止程序执行

        System.out.println("===============");

1.5.5. 数组传递

public static void main(String[] args) {

        int i = 1;

        m1(i);

        m1(1);

        int[] arr = { 1, 3, 4 };

        m1(arr);

// 字面量写法

        m1(new int[] { 1, 3, 4 });

}

        public static void m1(int a) {

}

        public static void m1(int[] arr) {

}

1.5.6. 给Main方法传参

1.6. 传值和传址

引用类型传递,因为是传递的地址,所以两个变量会指向同一个堆内存对象数据

所以某一个地方把对象中数据进行修改,则所有进行访问该对象的数据时,都是修改之后的

public static void main(String[] args) {

        int i = 10;

        m1(i);

                System.out.println(i);

        int[] arr = {1,2};

        m2(arr);

                System.out.println(arr[0]);

}

public static void m1(int i) {

        i++;

        System.out.println(i);

        }

public static void m2(int[] arr){

        arr[0] = 11;

                System.out.println(arr[0]);

}

1.7. 数组替换复制

public static void main(String[] args) {

    int [] src = {1, 2, 3, 4, 5, 6, 7, 8 };

    int [] dest = { 11, 12, 13, 14, 15, 16, 17, 18 };

// 源数组,源数组起始位置(包含),目标数组,目标数组起始位置(包含),复制个数


        arraycopy(src, 1, dest, 1, 3);

        for (int i = 0; i < dest.length; i++) {

                System.out.println(dest[i]);

        }

}

public static void arraycopy(int[] src, int srcIndex, int[] dest,

        int destIndex, int length) {

        for (int i = 0; i < length; i++) {

                dest[destIndex] = src[srcIndex];

                        destIndex++;

                        srcIndex++;

        }

}

1.8. 数组插入复制

public static void main(String[] args) {

// TODO Auto-generated method stub

        int[] src = {1,2,3,4,5,6,7,8};

        int[] Dest = {11,22,33,44,55,66,77,88};

// {11,22,33,}

        int dest[] = array(src, 1, Dest, 2, 3);

        for (int i = 0; i < dest.length; i++) {

                System.out.println(dest[i]);

        }



}

public static int[] array(int[] src , int srcIndext , int[] Dest ,

        int DestIndext , int length) {

//定义一个新数组

        int[] newDest = new int[Dest.length + length];

//将目标数组的初始位置之前(包含)的数据传到新数组中

        for (int i = 0; i <DestIndext+1; i++) {

                newDest[i] = Dest[i];

}

//将原数组初始位置到插入长度位置(包含)的数据传入到新数组中

        int Index = DestIndext;

        for (int j = srcIndext; j < srcIndext+length; j++) {

            Index++;
    
            newDest[Index] = src[j];
    


        }

        //将目标数组中的剩余数据传入到新数组中

        for (int k = DestIndext+1; k < Dest.length; k++) {

            Index++;

            newDest[Index] = Dest[k];

        }

        return newDest ;

}

2. 二维数组

2.1. 声明方式

数据类型[] 变量 = {值,值....};

int[] arr1 = { 1, 2, 7, 5, 3 };

二维数组,保存的都是一维数组

int[][] arr2 = {arr1,arr1};

二维数组声明

1 静态声明

int[][] arr3 = {

{1,2,3},{4,3,2},{1,5,3,7}

};

2 动态声明

二维数组中,有3个一维数组,并且每个一维数组中有5个元素

int[][] arr4 = new int[3][5];

2.2. 内存中存储方式

2.3. 使用方式

2.3.1. 获取数据

// 查询 数组[下标]

        int i = arr1[2];

        int[] arr3_0 = arr3[0];

        int arr3_0_1 = arr3_0[1];

// 第0个一维数组中的第1个数据(下标)

// 二维数组[下标][下标]

                arr3_0_1 = arr3[0][1];

// 第一个一维数组中的第一个元素

                System.out.println(arr3[0][0]);

// 最后一个一维数组中的最后一个元素

        System.out.println(arr3[2][3]);

        int[] arr3_2 = arr3[arr3.length-1];

        int arr3_2_3 = arr3_2[arr3_2.length-1];

                System.out.println(arr3_2_3);

                System.out.println(arr3[arr3.length-1][arr3[arr3.length-1].length-1]);

2.3.2. 更改数据

        arr4[2][3] = 29;

2.3.3. 遍历

遍历 :

        for (int j = 0; j < arr4.length; j++) {

// int[] arri = arr4[j];

        for (int k = 0; k < arr4[j].length; k++) {

        System.out.print(arr4[j][k] + " ");

}

        System.out.println();

2.3.4. 动态声明锯齿状(典型杨辉三角)

public static void main(String[] args) {

// TODO Auto-generated method stub

int[][] array = new int[7][];

// 给二维数组中的一维数组规定个数

        for (int i = 0; i < array.length; i++) {

                array[i] = new int[i + 1];

}

// 写出杨辉三角规则

        for (int i = 0; i < array.length; i++) {

                for (int j = 0; j < array[i].length; j++) {

                        if (j == 0|| j == array[i].length-1) {

        array[i][j] = 1;

                } else {

array[i][j] = array[i-1][j-1] + array[i-1][j];

                }

        }

}



// 遍历打印前七行

        for (int i = 0; i < array.length; i++) {

                for (int j = 0; j < array[i].length; j++) {

                        System.out.print(array[i][j]);

                }

                System.out.println();

        }



}

3. 交换变量得值

    

    int a = 10;

        int b = 5;

// 1 开发常用,中间变量,简单易懂

int c = b;

b = a;

a = c;

// 2 相加

a = 10;

b = 5;

a = a + b;

b = a - b;

a = a - b;

// 2 异或运算,面试常用

a = 10;

b = 5;

// a= 0000 1010

// b= 0000 0101

// a= 0000 1111

a = a ^ b;

// b= 0000 1010

b = a ^ b;

// a= 0000 0101

a = a ^ b;

System.out.println(a + " : " + b);