数组

数组

在程序中对于某些类型相同的数据进行计算是需要定义大量的变量，会使程序显得十分麻烦，为了解决这一问题就有了数组的出现。数组就是一系列空间大小都相等而且存储地址连续的一片存储空间。数组存在于堆内存中，但凡在堆内存之中的数据都称之为对象，数组变量存的就是在堆内存中首元素的地址， 数组依靠角标来访问数组中的数据，计算方式：首地址加角标*数据类型大小。数组长度定义后不可更改。

数组的三种创建方式

• 数据类型[]  数组名=new 数据类型[长度]
• 数据类型[]  数组名=new 数据类型[]{1，2，3，4}
• 数据类型[]  数组名={1,2,3,4,5}

数组常见错误

1.角标越界

ArrayIndexOutOfBoundsException 数组角标越界--角标越界指的是，它的角标超过已有角标的范围

class Test04{
    public static void main(String[] args){
        int[] arr=new int[3];
        System.out.println(arr[15]);
     }
}

2.空指针异常

NullPointerException 空指针异常

class Test04{
    public static void main(String[] args){
        int[] arr=new int[5];
        int[] arr2=arr;
        arr2[0]=10;
        System.out.println(arr[0]);
        arr2=null;
        System.out.println(arr2[0]);
        arr=null;
        //此时此刻 数组对象没有任何变量引用它
        //数组对象在堆内存中就没有存在的意义了
        //所以该对象变成垃圾，由【垃圾回收器gc】处理
        //【垃圾回收期】是JVM中的一个程序 专门用于负责处理堆内存中垃圾数据的
        //垃圾的处理并不是及时的，有【gc】来控制，当垃圾堆攒到一定程度时由【gc】来处理
        //特殊的 在C/C++中 如果出现对象垃圾 必须由程序员手动处理 free()及时处理
    }
}

常见操作

赋值，最大值及最小值

import java.util.Scanner;
class Test05{
    public static void main(String[] args){
        //遍历操作
        // bianli();
 
        //赋值操作
        // fuzhi();
 
        //最大值/最小值
        maxormin();
    }
    public static void maxormin(){
        //计算最大值或最小值的 值
        //计算最大值或最小值的 角标
        //需求 获取最大的值10 获取最小值的角标4
        int[] arr={10,2,8,3,1,6,4,7,9,5};
        int max=arr[0];
        int min_index=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<arr[min_index]){
                min_index=i;
            }
        }
        System.out.println("最大值"+max);
        System.out.println("最小值角标"+min_index);
 
    }
    public static void fuzhi(){
        Scanner scanner=new Scanner(System.in);
        // System.out.print("请输入10个数字：");
        int[] arr2=new int[10];
        for(int i=0;i<arr2.length;i++){
            System.out.print("请输入1个数字：");
            arr2[i]=scanner.nextInt();
        }
        for(int i=0;i<arr2.length;i++){
            System.out.print(arr2[i]+" ");
        }
    }
    public static void bianli(){
        int[] arr={1,2,3,4,5,6,7,8,9};//[0,8]
        //数组只有一个唯一的属性 length 数组的长度
        System.out.println(arr.length);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

二分查找

二分查找的前提为数组必须有序，二分查找与二叉树相似。从中间分为两半，判断需要的数字在那一边。

public class Test12 {
  public static void main(String[] args) {
      // 有序的被查找数组
      int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
      int index = getIndex(arr, 5);
      // 输出
      System.out.println("index:" + index);
  }
 
  public static int getIndex(int[] arr, int num) {
      // 查找数组范围的最左侧，先从0开始
      int left = 0; 
      // 查找数组范围的最右侧，先从最大开始
      int right = arr.length - 1;
      // 查找范围的中间值
      int mid;
      while (left <= right) {
          // 中间 = (左侧  + 右侧) / 2
          // mid = (left + right) / 2; 
          // 为了提高效率，我们可以用位运算代替除以运算
          mid = (left + right) >>> 2 
          if (arr[mid] > num) {
              //如果中间元素大于要查找元素，则在中间元素的左侧去找正确元素，最右侧变为mid - 1
              right = mid - 1;
          } else if (arr[mid] < num) {
              //如果中间元素小于要查找元素，则在中间元素的右侧去找正确元素，最左侧变为mid + 1
              left = mid + 1;
          } else {
              // 如果不大不小，那么就正好是找到了，返回找到的
              return mid;
          }
      }
      // 当查找范围的最左侧和最右侧重叠后还没有找到元素，则返回-1表示没有找到
      return -1;
  }
}