数组

数组

一维数组

一维数组声明方式

• int[] ii;

一维数组初始化

• 动态初始化：数组声明且为数组元素分配空间与赋值操作分开进行

 int[] arr = new int[3]; //声明一个能存放4个int类型数据的数组
 arr[0] = 3;
 arr[1] = 9;
 arr[2] = 5;

int[] ii = new int[2]; //使用动态初始化的时候，数组的元素会有默认值，数字类型的默认值是0，对象的默认类型是null
System.out.println(ii[0]); //此处结果输出为0

• 静态初始化：再定义数组的同时就为数组元素分配空间并赋值

int a[] = new int[] {3,9,5}; // 声明一个存放了3，9，5这三个数的数组
int[] a = {3,9,5};

数组元素的引用

• 定义并用运算符new为之分配空间之后，才可以引用数组中每个元素；

• 数组元素的引用方式：数字名[数组元素下标]

  • 数组元素下标可以是整型常量或整形表达式，如 a[3], b[i]，c[6*i];
  • 数组元素下标从0开始:长度为n的数组合法下标取值范围:0- >n-1; 如int a[]=new int[3];可引用的数组元素为a[0]、a[1]、 a[2]

  String[] strs = new String[]("c","a","b");//数组内的元素都有一个引用的元素下标，这个下标是个数字，数字是从左到右，从0开始
  System.out.println(strs[1]); //输出a
  

• 每个数组都有一个属性length指明它的长度，例如: a.length 指明数组a的长度(元素个数）

  • 数组一旦初始化，其长度是不可变的

  System.out.println("strs的数组长度是：" + strs.length); //可以知道每个数组有多少个元素

  长度 .length

数组元素的默认初始化

• 数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如: (20.1.4这里不太懂)

public class Test {
	public static void main(String arg[]){
 		int a[]= new int[5];
		System.outprintln(a[3]);  //a[3]的默认值为0
    }
 }

多维数组

二维数组

• 格式一（动态初始化）:

int[][]arr = new int[3][2];

定义了名称为arr的二维数组

二维数组中有3个一维数组

每一个一维数组中有两个元素

一维数组的名称分别为arr[0],arr[1],arr[2]

给第一个一维数组赋值为78的写法是:

arr[0][1] = 78

int[][] ii0 = new int[2][3]; //第一部分长度是2，第二维也就是第一维的每个元素的长度是3
//        {
//            {1,23,4},
//            {2,4,6}
//        };

• 格式二（动态初始化）：

int[][]arr = new int[3][];

二维数组中有三个一维数组

每个一维数组都是默认初始化值null（注意：区别于格式一）

可以对这三个一维数组分别进行初始化

arr[0] = new int[3];
arr[1] = new int[1];
arr[3] = new int[2]; //注意：int[][]arr = new int[][3];非法

int[][] ii1 = new int[2][]; //只定义第一维的长度，第二维不定义

• 格式三（静态初始化）

int[][]arr = new int[][]{3,8,2},{2,7},{9,0,1,6};

定义一个名称为arr的二维数组，二维数组中有三个一维数组

每一个一维数组中具体元素也都以初始化

第一个一维数组arr[0] = {3,8,2}

第二个一维数组arr[1] = {2,7}

第三个一维数组arr[2] ={9,0,1,6}

第三个一维数组的长度表示为：arr[2].length;

int[][] ii = new int[][]{
      {1,2}, //这是第0个元素
      {4,2} //这是第一个元素
};
 System.out.println(ii[1][0]); //取4

数组中涉及的常见算法

1. 求数组元素的最大值，最小值，总和，平均数
2. 数组的复制，反转

        int[] arr = new int[]{4,2,7,1,3,5};
        //最大值
        int max = arr[0]; //假设arr[0]是目前最大值
        for (int i = 0;i < arr.length; i++){
            if (max < arr[i]){
                max = arr[i]; //存放目前最大值
            }
        }
        System.out.println("max:" + max);

        //最小值
        int min = arr[0]; //假设arr[0]是目前最小值
        for (int i = 0;i < arr.length; i++){
            if (min > arr[i]){
                min = arr[i]; //把目前最小的值赋给min
            }
        }
        System.out.println("min:" + min);

        //总和，平均数
        int res = 0;
        for (int i = 0;i < arr.length;i++){
            res += arr[i];
        }
        System.out.println("总和：" + res);
        System.out.println("平均数：" + (res / arr.length));

        //注意：复制不是赋值
        //int[] aa = arr; //这是赋值
        int[] copy = new int[arr.length]; //声明一个与arr长度一致的数组
        for (int i = 0;i < arr.length;i++){ //复制
            copy[i] = arr[i]; //遍历arr，把arr的每一个元素安装顺序拿出来，给copy的每一个匀速赋值，在这里i就是copy的arr数组的元素下标
        }
        //int[] arr = new int[]{4,2,7,1,3,5};
        //考虑声明一个数组temp，数组temp的长度与arr长度一致，我们倒着循环arra正着给temp的元素赋值
        //temp[0] = arr[5],temp[1] = arr[4],temp[2] = arr[3] , temp[3] = arr[2], temp[4] = arr[1], temp[5] = arr[0]
        //temp就是arr的倒叙的数组，然后把temp赋值个arr（arr = temp）
        //一个数组的最后一个元素，它的下标等于数组的长度-1，因为元素的下标是从0开始


        //for (int i = 9;i >=0; i--) //这是倒着循环，输出结果为986543210
        int[] temp = new int[arr.length];
        int k = 0; //这就是temp的元素下标
        for (int i = arr.length - 1;i >=0; i--){
            //一个数组的最后一个元素，它的下标等于数组的长度-1，因为元素的下标是从0开始
//            System.out.println(arr[i]);
            temp[k] = arr[i]; //第一次循环，k = 0,i = 5,相当于temp[0] = arr[5]
            k++;
        }
        arr = temp;
        for (int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }

3. 数组元素的排序

• 插入排序:直接插入排序，折半插入排序，Shell排序（希尔排序）
• 交换排序：冒泡排序，快速排序（或分区交换排序）
• 选择排序：简单选择排序，堆排序
• 归并排序
• 基数排序

冒泡排序

• 排序思想

相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作

int[] arr = new int[]{4,7,3,1};
int temp = 0;
for (int i = 0; i < arr.length - 1; i++){ //外层循环是循环轮次，轮次循环的次数是数字长度-1
for (int j = 0; j < arr.length - 1 - i; j++){ //每一轮次的数字对比排序，每轮次循环依次4，3，2，轮次长度-1-i
//想要倒叙的话更改大于号小于号就行
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]);
}

数组操作常见问题

• 数组下标越界异常：访问到了数组中不存在的脚本是发生

int[] arr = new  int[3];
System.out.println(arr[4]);

• 空指针异常：引用没有指向实体，却在操作实体的元素时发生

int[] arr =null;
System.out.println(arr[0]);