day07-java数组_2



day07-java数组_2一、前期知识回顾-成员/局部变量-构造器-static二、数组-两种排序方法 + 二分查找法三、数组扩容，模拟ArrayList中的add方法



一、前期知识回顾-成员/局部变量-构造器-static

  • 成员变量跟局部变量的区别？
  • 成员变量是在类中定义的一些变量，作用范围是整个类
  • 局部变量是在某一代码块中定义的一些变量，作用范围仅仅是这个代码块，并且在代码块执行完毕后，该局部变量就销毁了。
  • 局部变量在使用之前必须进行初始化，成员变量可以不用手动初始化，但是会有一个默认的零值初始化。
  • 构造器的作用：
  • 在一个类产生一个实例化的对象时候，这个类的构造器就会自动被调用，这样我们就可以给对象在构造器中进行一些初始化的操作。
  • static的作用与特性？
  • 作用：用来修饰变量或者方法的修饰符。成为静态变量和静态方法
  • 特性：
  1. 被static修饰的变量是大家共享的，人人都可以操作该变量，所以只能修饰全局变量。
  2. 被static修饰的变量只会初始化一次，在修饰成员变量时候，不管你new多少个对象，static修饰的变量只会在第一次时候初始化，后期该变量如有改变，就不可恢复，取到的就是修改后的值。
  3. 被static修饰的成员变量和方法，都可以用类名直接调用。随着类的加载而存在，优先于对象的存在，且与对象无关。
  4. 被static修饰的代码块叫静态代码块，也是随着类的加载而加载，而且只执行一次，用于给类进行一些初始化的操作。

二、数组-两种排序方法 + 二分查找法

  1. 冒泡排序：
    每一趟找到最大的数字冒泡到最末尾（或者最前端），循环n-1次。

这里倒数第二趟就完成了，因为前面两个换过了刚好有序。

代码实现：

private static void maopaoSort(int[] arr) {
  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]) {
     arr[j] = arr[j] ^ arr[j + 1];
     arr[j + 1] = arr[j] ^ arr[j + 1];
     arr[j] = arr[j] ^ arr[j + 1];
    }
   }
  }
  1. 选择排序：
    一次下来找到当前数中小（或者最大的）那个数，然后记录下标的位置，一次完成后，将该最小的数与数组的第一位交换位置，依次循环n-1次。
代码实现：

//方式一：找最小的放前面
private static void xuanzeSort1(int[] arr) {
   for (int i = 0; i < arr.length - 1; i++) {
  int minIndex = i;
  for (int j = i + 1; j < arr.length; j++) {
   if (arr[j] < arr[minIndex]) {
    minIndex = j;
   }
  }
  int temp = arr[i];
  arr[i] = arr[minIndex];
  arr[minIndex] = temp;
 }
方式二：//找最大的放后面
private static void xuanzeSort2(int[] arr) {
  for (int i = 0; i < arr.length - 1; i++) {
   int maxIndex = 0;
   for (int j = 0; j < arr.length - i; j++) {
    if (arr[j] > arr[maxIndex]) {
     maxIndex = j;
    }
   }
   int temp = arr[maxIndex];
   arr[maxIndex] = arr[arr.length - 1 - i];
   arr[arr.length - 1 - i] = temp;
  }



 

  1. 二分查找法：
    数组必须有序，否则无法查找。每次折半缩小要找的值所在的范围。

代码实现：



private static void halfSearch(int[] arr, int key) {
  int min = 0;
  int max = arr.length - 1;
  int mid = 0;
  while (min <= max) {//当min>max时候就找不到了
   //因为每次都要执行这个操作，可以抽取出来
   mid = (min + max) >> 1;
   if (key > arr[mid]) {
    min = mid + 1;
   } else if (key < arr[mid]) {
    max = mid - 1;
   } else {
    System.out.println("找到了在第" + (mid + 1) + "位");
    break;
   }
  }
  //没找到就min就会大于max
  if(min>max) {
   System.out.println("对不起没有");
  }
 }



 

 

三、数组扩容，模拟ArrayList中的add方法

  • 数组长度固定后，就没法存放更多的数据了，这时候可以新定义一个更大的数组，将原来的数组中的内容复制到新的数组中，将地址引用赋值给原来的数组引用变量，就可以实现数组扩容。
    代码实现：
static int[] arr = new int[3];//全局变量，定义一个固定长度的数组，对其进行扩容。 
private static void arraykuorong() {
        Scanner scanner = new Scanner(System.in);
        int index = 0;
        while (true) {
            System.out.println("请输入一个数");
            if (index == arr.length) {
                insert();
            }
            arr[index++] = scanner.nextInt();
            System.out.println("是否继续输入？Y/N");
            scanner.nextLine();
            String ans = scanner.nextLine();
            if ("Y".equals(ans)) {
                continue;
            } else {
                for (int i : arr) {
                    System.out.print(i + " ");
                }
                break;
            }
        }
    }
    
    /**
     * 数组扩容 原理实现
     */
    private static void insert() {
        // 新创建一个数组，容量在原来的基础上增加1
        int[] b = new int[arr.length + 1];
        // 复制原来数组的内容到新数组
        for (int i = 0; i < arr.length; i++) {
            b[i] = arr[i];
        }
        // 把新数组的地址引用给原来的数组，让原来的arr指向b,就实现了数组扩容
        arr = b;

    }