数组基础知识

1.数组的创建

格式：变量（数组）类型 变量（数组）名 = 变量（数组）值

1. int[] nums ; // 声明一个数组

   nums = new int[10]; // 创建一个数组

2. int[] nums = new int[10]; // 创建并声明一个数组

3. nums[0] = 1;

   nums[1] = 2;

   nums[2] = 3;

   nums[3] = 4;

   nums[4] = 5;

   nums[5] = 6;

   nums[6] = 7;

   nums[7] = 8;

   nums[8] = 9;

   nums[9] = 10; // 给数组元素赋值

    

    // 计算所有元素的和
           int sum = 0;
   ​
           // 获取数组长度：arrays.length
           for (int i = 0; i < nums.length; i++) {
               sum += nums[i];
           }
           System.out.println(sum);

    

2.数组的初始化

1. 静态初始化

   // 静态初始化:创建 + 赋值
           int[]   a = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8};

2. 动态初始化

   // 动态初始化
           int [] b = new int[10];
           b[0] = 10;
   ​
           System.out.println(b[0]); // 动态

3. 默认初始化

   int [] b = new int[10];
           b[0] = 10;
   ​
           System.out.println(b[0]); // 动态
           System.out.println(b[1]); // 默认
           System.out.println(b[2]); // 默认
           System.out.println(b[3]); // 默认

    

小结

• 数组是相同数据类型（数据类型可以为任意类型）的有序集合

• 数组也是对象。数组元素相当于对象的成员变量

• 数组长度是确定的，不可变的。如果越界，则报：ArrayIndexOutofBounds（下标越界异常）

数组的使用

• 普通的for循环

• for-each循环

          // JDK1.5,没有下标
  //        for (int array : arrays) {
  //            System.out.println(array);
  //        }
  //        reverse(arrays);

• 数组作为方法入参

      // 打印数组元素
      public static void printArray(int[] arrays){
          for (int i = 0; i < arrays.length; i++) {
              System.out.print(arrays[i] + " ");
          }
          System.out.println();
      }

• 数组作返回值

  // 反转数组
  public static int[] reverse(int[] arrays){
      int[] reverse = new int[arrays.length];
      for(int i = 0,j = reverse.length - 1;i < arrays.length;i++, j--){
          reverse[j] = arrays[i];
      }
      return reverse;
  }

   

二维数组

遍历二维数组

    // 创建一个二维数组
        int[][] array = {{1 , 2 , 3} , {2 , 3} , {3 , 4} , {4 , 5}};
​
        for (int i = 0; i < array.length; i++) { // array.length为外层数组个数
            for (int j = 0; j < array[i].length; j++) { // array[i].length为内层每个数组的长度
                System.out.println(array[i][j]);
            }
        }
    }

冒泡排序

package com.kuang.array;
​
public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] arr = {9 , 6 , 7 , 4 , 3 , 5 , 8 , 2};
​
        search(arr);
        sort(arr);
        System.out.println();
        search(arr);
    }
​
    // 冒泡排序
    // 1.比较数组中两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    // 2.每一次比较，都会产生一个最大，或者最小的数字
    // 3.下一轮则可以少一次排序
    // 4.依次循环，直到结束
​
    // 自己写的冒泡排序
    public static void sort(int[] arr){
        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;
                }
            }
        }
    }
​
    // 遍历数组
    public static void search(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}