Java数组基础

一、数组的概念

1、为什么使用数组

• 如何存储100名学生的成绩？

• • 办法：定义100个变量，每个变量代表一个学生的成绩。
  • 缺点：非常麻烦。
  • 解决方案：数组

2、数组的概念

数组在内存中是一块连续的空间，可以保存相同类型多个数据的容器

3、数组的特点

• 数组中保存数据必须是相同的数据类型
• 数组是定长的(数组一旦定义不能改变长度)

二、数组的创建

1、初始化

• 语法1:

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

• 语法2:

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

2、静态初始化

• 语法1：
  数据类型[] 数组名 = {数据1,数据2,...};
• 语法2：
  数据类型 数组名[] = {数据1,数据2,...};
• 语法3：
  数据类型[] 数组名 = new 数据类型[]{数据1,数据2,...};

3、数组的细节

• 数组中的每一个数据称之为数组元素
• 数组中的每一个元素都对应有一个下标
• 数组中的下标范围0~数组的长度-1
• 数组的长度通过数组名.length获取
• 数组的长度如果超出的边界会报错（ArrayIndexOutOfBoundsException数组下标越界异常）

三、数组的遍历

遍历：获取、保存数据中每一个元素(循环)

四、数组的默认值

• 整数型数组默认值：0
• 浮点型数组默认值：0.0
• 布尔类型数组默认值：false
• 字符型数组默认值：0 或者' '或者 '\u0000'
• 引用类型数组默认值：null
  null是一种特殊的值，表示当前对象在内存中没有指向任何地址。
  ""表示空字符串，在内存中有对应的内存地址

五、数组的扩容

数组的扩容和缩容

• 步骤1：定义一个新数组，然后新数组的长度比原数组增加或者是减小
• 步骤2：将原来数组的元素拷贝到新数组中
• 步骤3：将原数组的变量指向新数组

//定义原数组
int[] arr1 = {1,3,46,22,11};

//1、定义新数组   扩容
int[] arr2 = new int[arr1.length+1];

//将原来数组的元素拷贝到新数组中
//arr2[i] = arr1[i]

//2、数组的拷贝
for (int i = 0; i < arr1.length; i++) {
    arr2[i] = arr1[i];
}

//3、将原数组的变量指向新数组
arr1 = arr2;

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

//定义原数组
int[] arr1 = {1,3,46,22,11};

//1、定义新数组
int[] arr2 = new int[arr1.length-1];

//2、数组拷贝
for (int i = 0; i < arr2.length; i++) {
    arr2[i] = arr1[i];
}

//3、将原数组的变量指向新数组
arr1 = arr2;

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

六、数组拷贝

数组的拷贝有三种方式：

• 通过自定义循环将原数组中的元素拷贝到新数组中

• System类提供数组拷贝方法

• //1、System类提供数组拷贝方法
  int[] arr1 = {1,3,46,22,11};

  //定义目标数组
  int[] arr2 = new int[arr1.length + 5];

  /**
  * src:原数组
  * srcPos：原数组的起始位置
  * dest：目标数组
  * destPos：目标数组的起始位置
  * length：拷贝的长度
  */
  System.arraycopy(arr1, 1, arr2, 3, 4);

  for (int i = 0; i < arr2.length; i++) {
      System.out.print(arr2[i]+"\t");
  }

• Arrays类提供数组拷贝方法

• //2、Arrays类提供数组拷贝方法
  int[] arr1 = {1,3,46,22,11};

  /**
   * original：原数组
   * newLength：新数组的长度
   * 返回值：返回新数组 
   */

  arr1 = Arrays.copyOf(arr1, arr1.length+1);
  for (int i = 0; i < arr1.length; i++) {
      System.out.print(arr1[i]+"\t");
  }

七、数组排序

1、冒泡排序

冒泡排序升序思想：

• 1、将相邻的两个元素进行比较，如果前面一个元素比后面的大，就交换位置(一轮比较)
• 2、将上面的操作循环（比较n-1轮）

• public class Main {
      public static void main(String[] args) {
          int[] array = {5, 2, 8, 12, 1, 6};

          System.out.println("原始数组：");
          printArray(array);

          bubbleSort(array);

          System.out.println("排序后的数组：");
          printArray(array);
      }

      public static void bubbleSort(int[] array) {
          int n = array.length;

          for (int i = 1; i < n ; i++) {
              for (int j = 0; j < n - i ; j++) {
                  if (array[j] > array[j + 1]) {
                      // 交换相邻元素的位置
                      int temp = array[j];
                      array[j] = array[j + 1];
                      array[j + 1] = temp;
                  }
              }
          }
      }

      public static void printArray(int[] array) {
          for (int num : array) {
              System.out.print(num + " ");
          }
          System.out.println();
      }
  }

• 2、选择排序

  选择排序升序思路：

• 1、将当前这个数，与他后面每一个数字比较，选择最小的那个数，交换到当前位置
• 2、循环选择当前位置上的数

• public class Main {
      public static void main(String[] args) {
          int[] array = {5, 2, 8, 12, 1, 6};

          System.out.println("原始数组：");
          printArray(array);

          selectionSort(array);

          System.out.println("排序后的数组：");
          printArray(array);
      }

      public static void selectionSort(int[] array) {
          int n = array.length;

          for (int i = 0; i < n - 1; i++) {
              int minIndex = i;

              for (int j = i + 1; j < n; j++) {
                  if (array[j] < array[minIndex]) {
                      minIndex = j;
                  }
              }

              // 交换最小元素和当前位置的元素
              int temp = array[minIndex];
              array[minIndex] = array[i];
              array[i] = temp;
          }
      }

      public static void printArray(int[] array) {
          for (int num : array) {
              System.out.print(num + " ");
          }
          System.out.println();
      }
  }

3、Arrays工具类排序方法

public class Demo03 {
    //Arrays类提供的数组排序的方法
    public static void main(String[] args) {
        int[] arr = {11,22,33,31,41,15};

        //Arrays类提供的数组排序的方法     快速排序
        Arrays.sort(arr);

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("==============================================");
        String[] names = {"cxk","rose","lihua","lilei","zhaosi"};

        Arrays.sort(names);

        for (int i = 0; i < names.length; i++) {
            System.out.print(names[i]+"\t");
        }

    }
}

4、二分查找法

二分查找法(折半查找法)

• 前提：数组中的元素是有序的
• 思路:

• //二分查找法
  public static int search2(int[] arr,int num) {
      //1、获取最小、大值的下标
      int min = 0;
      int max = arr.length -1;

      while(min <= max) {
          //2、获取中间值的下标
          int middle = (min + max) / 2;

          //3、将要查找的数字与中间值做比较
          if(num > arr[middle]) {
              min = middle +1;
          }else if(num < arr[middle]) {
              max = middle -1;
          }else {
              return middle;
          }
      }
      return -1;
  }