java山崖奇遇之数组

数组

为了储存大量的数据，数组出现了，数组就是储存多个数据的容器，多个同类型的变量空间连在一起组成的结构叫数组

数组主要解决多变量多数据的存储问题

数组的本质就是一些列空间大小相等且地址连续的地址空间，为了方便统一维护我们的数据，必须保证数据之间的类型是相同的

在Java中，数组存储原始值(int, char，…)或引用(a.k。一个指针)到对象。

当使用“new”创建对象时，将在堆中分配内存空间并返回引用。

数组也是如此，因为数组是Java中的对象。

总结：

• 数组就是一片地址连续且空间大小一致的存储空间；
• 数组存储在堆内存中，但凡在堆内存中存储的数据都称为；、
• 数组提供角标来访问数组当中的元素；
• 数组变量存的就是数组在堆内存中收元素的地址；
• 数组通过角标来访问的具体计算方式是*数据类型大小；
• 数组一旦定义下来不可改变；数组中有几个地址？就看数组有几个元素空间

• 

数组的定义：

数据类型[]  数组名=new  数据类型[长度]---------------创建数组只指定长度但不指定内容

数据类型[]  数组名=new  数据类型[]1{},2,3,4,5}------创建数组指定内容（指定长度）

数据类型[]  数组名=[1,2,3,4,5]----------------------------创建数组指定内容（指定长度）

int arr[]=new int[3];

int[] arr只是对包含3个整数的数组的引用。

如果您创建一个包含10个整数的数组，它是相同的——分配一个数组并返回一个引用。

public class Test03{
    public static void main(String[] args) {
        int [] arr=new int[5];
        System.out.println(arr[0]);
        System.out.println(arr[3]);
        System.out.println(arr[5]);


    }
}





结果为：
0
0
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5

System.out.println(arr[0]);和System.out.println(arr[3]);打印出的结果都是零，这是因为这是一个空数组
 而System.out.println(arr[5]);是因为角标越界

再来看数组的遍历

public class Test01{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6,7,8,9，10};
        //数组只有一个唯一的属性 length 数组的长度
        System.out.println(arr.length);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }


}

数组的赋值操作

import java.util.Scanner;
public class Test01{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int[] arr=new int[10];
        for(int i=0;i<arr.length;i++){
            System.out.print("请输入1个数字：");
            arr[i]=scanner.nextInt();
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
}

找到最大值的问题

import java.util.Scanner;
public class Test01{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int[] arr=new int[10];
        int max=arr[0];
        int minjiaobiao=0;
        for(int i=0;i<arr.length;i++){
            System.out.print("请输入1个数字：");
            arr[i]=scanner.nextInt();
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<arr[minjiaobiao]){
                minjiaobiao=i;
            }
        }
        System.out.println("最大值"+max);
        System.out.println("最小值角标"+minjiaobiao);
}

二分查找

二分查找的也称为折半查找，由于每次都能够将查找区间缩小为原来一半，这种算法的时间复杂度为O(logN)。

计算中值的方法有两种
m = (low+ hight) / 2
m = low + (hight - low) / 2

数组中查找指定元素

public class Test11 {
  public static void main(String[] args) {
      int[] arr = { 2, 3, 5, 1, 6, 4, 9, 7, 8 }; 
      //调用查找方法查找给定数组中5元素所在的索引值，并接收查找到的索引
      int index = getIndex(arr, 5);
      //输出索引
      System.out.println("index:"+index);
  }

  public static int getIndex(int[] arr, int num) {
      for (int i = 0; i < arr.length; i++) {
          //按顺序遍历获取数组中的每个元素和要查找的元素进行比较
          if (num == arr[i]) {
              //如果要查找的元素值等于对应位置的元素值，则返回索引
              return i;
          }
      }
      //如果所有的元素都不等于要查找的元素，则返回-1表示没有找到
      return -1;
  }
}

 

二分法查找

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;
  }
}