java | 数组(ovo详细）

---

一 ：介绍

数组（Array)可以存放多个同一类型数据。数组也是一种数据类型，是引用类型。使用

 二：使用

先举个例子感受一下：

public static void main(String[] args) {
        //循环输入
        double[] scores=new double[4];
        Scanner myScanner=new Scanner(System.in);
        for(int i=0;i<scores.length;i++){
            System.out.println("请输入第"+(i+1)+"个元素的值");
            scores[i]=myScanner.nextDouble();
        }
        //循环输出
        System.out.println("数组的元素值如下：");
        for(int i=0;i<scores.length;i++){
            System.out.println("第"+(i+1)+"个元素的值="+scores[i]);
        }
    }

1  两种使用方式：

1） 动态初始化(在创建数组时，直接指定数组中元素的个数）

 double[] scores=new double[4];
数据类型[] 数组名=new 数据类型[大小]
数据类型 数组名[]=new 数据类型[大小]     一样的，也可以这样表示。 

先声明数组，再new分配空间 

double[] scores; //声明一个空数组

scores=new double[4]; //分配内存空间，可以存放数据

3）静态初始化（在创建数组时没有给元素个数，但给了具体值）

数据类型 数据名[]={元素值，元素值....}

int a[]={2,3,4,5,6}

//分开写 ,必须要new

int[] a;

new int[]={1,2,3,4}   

2  数组使用注意事项

1.数组中的元素可以是任何类型，包括基本类型和引用类型，但不能混用

2.数组创建后，如果没有赋值，有默认值

   int 0，short 0，long 0，byte 0；float 0.0，double 0.0，char \u0000；boolean false，string null

3.数组下标必须在指定范围内使用，否则报：下标越界异常

4.数组属于引用类型，数组型数据是对象

5.int[] arr=null,不能对一个null引用变量进行操作

再来两个练习感受一下：

1.  创建一个char类型的26个元素的数组，分别放置'A'-'Z' 。   提示：char类型数据运算'A'+1='B'

 public static void main1(String[] args) {
        char[] chars=new char[26];
        for(int i=0;i<26;i++){
            chars[i]=(char)('A'+i);
        }
        //循环输出
        System.out.println("=====arrays数组====");
        for(int i=0;i<26;i++){
            System.out.print(chars[i]+" ");
        }
    }

2.请求出一个数组的最大值和对应的下标。

 public static void main(String[] args){
        int[] arr={1,2,4,7,33,55,99,22,3};
        int max=arr[0];
        int maxIndex=0;//下标
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
                maxIndex=i;
            }
        }
        System.out.println("最大值为:"+max+" "+"下标为"+maxIndex);
    }

三：数组的赋值机制

1.基本类型赋值，这个值是具体的类型，而且互相不影响

值传递，值拷贝

 2.数组在默认情况下是引用传递，赋的是地址

引用传递，地址拷贝

---

 堆和方法区是所有线程共享的。

---

在java中，所有的传参方式都是以值传递

基本类型传参

 //基本类型传参
    /*
    形参和实参没有任何关系，因此在method方法中对形参进行修改时，不会产生任何影响
     */
    public static void method(int param) {
        System.out.println("修改前："+param);
        param=100;
        System.out.println("修改后："+param);
    }

    public static void main(String[] args) {
        int a=10;
        method(a);
        System.out.println("method方法调用结束后："+a);
    }

引用类型作为变量方法参数
再方法中并没有改变变量引用空间中的内容，此处改变的是引用本身

 /*
    引用类型作为变量方法参数
    再方法中并没有改变变量引用空间中的内容，此处改变的是引用本身
     */
    public static void method(int[] array) {
      array=new int[5];//重新申请了5个元素，0 0 0 0 0
      array[0]=100;
      array[1]=200;
    }

    public static void main(String[] args) {
       int[] arr=new int[3];
       method(arr);
       for(int x:arr){
           System.out.print(x+" ");

       }
    }

 引用类型作为方法的参数
在方法中修改的是引用形参指向空间中的内容 

当方法结束后，该修改会继续保留

/*
引用类型作为方法的参数
在方法中修改的是引用形参指向空间中的内容
 */
    public static void method3(int[] array){
        array[0]=100;
        array[1]=200;
    }

    public static void main(String[] args) {
        int[] arr=new int[3];
        method3(arr);
        for(int x:arr){
            System.out.print(x+" ");
        }
    }

 因此，交换两个数只能用数组来交换

 //交换两个数
    public static void swap(int[] array){
        int temp=array[0];
        array[0]=array[1];
        array[1]=temp;
        for(int x:array){
            System.out.print(x+" ");
        }
    }
    public static void main(String[] args){
        int[] arr={10,20};
        swap(arr);
    }

四：数组的遍历

数组的遍历：所谓遍历，即对当前数组

1) for 循环

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

注意：在数组中可以通过 数组对象.length 来获取数组的长度

2）for-each

for(int val:score){
    System.out.println(val);
}

五：数组打印

有以下三种： 

 int[] array={1,2,3};
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }

for(int x:array){
            System.out.print(x+" ");

        }

System.out.println(Arrays.toString(array));

六：数组拷贝

（1）创建一个新的arr2

 int[] arr1={1,2,3,4};
 int[] arr2=new int[arr1.length];
       for(int i=0;i<arr1.length;i++){
          arr2[i]=arr1[i];
          System.out.print(arr2[i]+" ");
        }

（2） copyof

  public static void main(String[] args) {
        int[] src={1,2,3,4,5};
        int[] array1=Arrays.copyOf(src,5);
        System.out.println(Arrays.toString(array1));
    }
//[1,2,3,4,5]

(3)copyOfRange 左闭右开

 int[] src={1,2,3,4,5};
 int[] array2=Arrays.copyOfRange(src,1,3);//[from,to)左闭右开
 System.out.println(Arrays.toString(array2));
//[2,3]

 六：数组反转

arr{11,22,33,44,55,66}  ---->  {66,55,44,33,22,11}

1）通过规律反转

  public static void main(String[] args){
        int[] arr={11,22,33,44,55};
        int len=arr.length;
        for(int i=0;i<len/2;i++){
            int tmp=arr[len-1-i];
            arr[len-1-i]=arr[i];
            arr[i]=tmp;
        }
       for(int i=0;i<len;i++){
           System.out.print(arr[i]+" ");
       }
    }

 2）使用逆序赋值方式

 int[]arr={11,22,33,44};
 int[] arr2=new int[arr.length];
    for(int i=arr.length-1,j=0 ; i>=0 ; i--,j++){
        arr2[j]=arr[i];
        }
 //for 循环结束后，arr2就是一个逆序数组
     arr=arr2;
     for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+" ");
     }

七：数组查找

（1）顺序查找

 //顺序查找
    public static int Find(int[] array,int key){
        for(int i=0;i<array.length;++i){
            if(key==array[i]){
                return i;
            }
        }
        return -1;
    }

    public static void main12(String[] args) {
        int[] arr={1,2,3,4};
        System.out.println(   Find(arr,4));
    }

（2）二分查找（更高效）

 //二分查找
    public static int binarySearch(int[] arr,int key){
        int left=0;
        int right=arr.length-1;
        while(left<=right){
            int mid=left+(right-left)>>1;
            if(key==arr[mid]){
                return mid;
            }else if(key<arr[mid]){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[]  arr={1,2,3,4,5,6,7};
        System.out.println(binarySearch(arr,4));
    }

八：数组排列

（1)Arrays.sort()

 public static void main(String[] args) {
        int[] arr={1,4,2,7,6,3,5};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

 (2)冒泡排序

 public static void bubbleSort(int[] array) {
        //外部循环：控制趟数
        for (int i = 1; i < array.length-1; ++i) {
            //j表示两个相邻元素中的后一个元素的下标
            for (int j = 1; j < array.length; ++j) {
                if (array[j - 1] > array[j]) {
                    int temp = array[j - 1];
                    array[j - 1] = array[j];
                    array[j] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr={1,4,2,7,6,3,5};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

九：常见异常

nullPointerException 空引用异常

arrayIndexOutofBoundException数组越界异常