java 数组

数组

概念

是计算机内存中的一块连续的存储空间,特点为可以同时存放多个相同数据类型的值

创建

1. 先声明,后指明长度

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

数据类型[] 数组名;

数据类型 []数组名;

数据类型 数组名[];

• 创建的时候必须指明长度, 方便内存分配空间
• 长度必须为正整型

2. 声明的同时直接指明长度

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

3. 创建的同时直接赋值

   数据类型[] 数组名=new 数据类型[]{值1,值2,..};
   int [] arr =new int []{10,20};

• 数组长度由值的个数决定
• 中括号指明长度不可与大括号赋值同时存在

4. 创建的同时直接赋值

   数据类型[] 数组名={值1,值2,..};
   int[] arr={10,20,30};

• 无法先声明后大括号直接赋值

     		//先声明
             int[] arr5;
             //后直接大括号赋值
             arr5 = new int[]{10, 20, 30};
             //arr5 ={10, 20, 30}; 错误

		//先声明,后指明长度
        int[] arr1;
        arr1 = new int[3];
        //声明的同时直接指明长度
        int[] arr2 = new int[3];
        //创建的同时直接赋值
        int arr3[] = new int[]{20, 23, 21};
        int[] arr4 = {20, 21, 22};

下标

1. 必须通过下标操作数组元素

2. 从0开始,至数组长度前一位结束

3. 使用:

   取值: 数组名[下标]
   赋值: 数组名[下标]=值;
   

4. 当下标使用超出界限时, 运行时会报出数组下标越界异常

   java.lang.ArrayIndexOutOfBoundsException
   

5. 可以通过数组名.length获取数组长度

遍历

for(int i=0;i<数组名.length;i++){
    //数组名[i]就代表当前正在被遍历的元素
}

//创建一个长度为3的数组
        int[] arr = new int[3];
        //赋值
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

数组高级

1. 属于引用类型 .
2. 底层存放
   

• 引用中存放对应的堆地址
• 程序员在操作时必须先进入栈，再由栈中储存的堆地址进入堆中操作数据

3. 引用类型之间相互赋值传递的是堆地址

int[] arr1 = {10, 20, 30, 40, 50};
        int[] arr2 = arr1;

        arr2[0] = 66;

        int[] arr3 = arr1;
        arr3 = new int[]{11, 22, 33};

        System.out.print("arr1: ");
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+"\t");
        }// 66 20 30 40 50
        System.out.println();
        System.out.print("arr2: ");
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+"\t");
        }// 66 20 30 40 50

        System.out.println();
        System.out.print("arr3: ");
        for (int i = 0; i < arr3.length; i++) {
            System.out.print(arr3[i]+"\t");
        }//11 22 33

4. 逢new必开: 只要执行到new关键字,就一定会有新的堆空间被开辟创建

5. 数组存在默认值。作用为方便内存分配空间

   默认值：编译器赋予

   初始值：程序员第一次手动赋值

   int: 0

   double: 0.0

   String: null (所有引用类型都是null)

   boolean: false

数组扩容

1. 创建一个长度更大的数组（通常为原数组2倍）

2. 将原数组的数据复制到新数组中

3. 将引用的地址转向新数组

 public static void main(String[] args) {
        //原数组：整型数组
        int a[] = {10, 20, 30, 40, 50};
        //需求：将数组a扩容2倍

        //1. 创建一个长度为a的2倍的数组
        int[] newA=new int[a.length*2];//{10,20,30,40,50,0,0,0,0,0}
        //2. 将原数组数据复制到新数组中
        System.arraycopy(a,0,newA,0,a.length);

        //3. 将引用的地址转向新数组地址
        a = newA;

        //查看原数组数据
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }

    }

利用copyOf方法

• 新数组地址 java.util,Arrays.copyOf

public static void main(String[] args) {
        //原数组：整型数组
        int a[] = {10, 20, 30, 40, 50};
        //需求：将数组a扩容2倍

        a=Arrays.copyOf(a, a.length * 2);

        //查看原数组数据
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }

    }

选择排序

1. 固定一个下标位置，让其他下标位置与其比较，根据比较结果决定是否换位
2. 每轮比较结束后，固定下标位置的值将被确定
3. 实现思路：外层循环遍历固定下标，内层循环遍历与其比较的下标

int[] a = {99, 55, 77, 1};
        for (int i = 0; i < a.length - 1; i++) {//固定的下标范围
            for (int j = i + 1; j < a.length; j++) {//比较的下标
                //判断比较位置的值是否小于固定位置的值
                //从小到大：小于号  从大到小：大于号
                if (a[j] < a[i]) {
                    //值换位
                    int temp = a[j];
                    a[j] = a[i];
                    a[i] = temp;
                }
            }
        }