数组经典案例及应用场景

数组的应用场景及经典案例

1.保存数据

//  定义数组来保存数据
    public static void main(String[] args) {
        int [] array= {1,2,3,5,6,7};
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
    }

2.作为函数的参数

（1）参数传递基本类型

我们已经知道，Java的数据类型有：基本数据类型和引用数据类型，当基本类型作为函数参数进行传递时，因为Java中的传参方式是以值的形式进行传递的，因此在方法中对形参本身进行修改，对外部的实参没有任何影响；而传递引用类型，结果就不一样了；
下面看两个例子：

基本类型进行数据传参

//  基本类型进行数据传参
    //在方法中对形参本身进行修改，对外部的实参没有任何影响
    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);    //运行结果：修改之前：10，
   //修改之后：100，method方法调用之后：10
}

从上面可以看出：形参和实参没有任何关系，因此在method方法中对形参进行修改，并不会对实参产生影响；
（2）参数传递引用类型

引用类型进行数据传参

所谓的 “引用” 本质上只是存了一个地址，当进行参数传参时, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大)；

 //数组进行传参
    public static void method(int[] array) {
        array[0] = 100;   //修改数组中第一个数据
        array[1] = 200;   //修改数组中第二个数据
    }

    public static void main(String[] args) {
        int[] array = new int[3];   //默认 0 0 0
        method(array);
        for (int x : array) {
            System.out.println(x);  //输出 100 200 0
        }
    }

在方法中修改了引用形参所指向空间的内容，因此在method方法调用之后，实参所指向的空间内容也被随之修改了；

经典案例

1. 数组的打印

import java.util.Arrays;

public class ArrayPrint {
    public static void main(String[] args) {
        //  数组的打印
        int[] array={1,2,3,4,5,6};
        //  方式一：循环
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" "); //1 2 3 4 5 6 
        }
        System.out.println();
        //方式二：循环的变体
            for(int x:array){
                System.out.print(x+" ");//1 2 3 4 5 6 
        }
        System.out.println();
        //方式三：将数组转为字符串进行打印
        String strArray=Arrays.toString(array);
        System.out.println(strArray);//[1, 2, 3, 4, 5, 6]
    }
}

2. 数组的拷贝

public class ArrayCopy {
    public static void main(String[] args) {
        int[] src={1,2,3,4,5};
        int[] des=new int[src.length];
        for(int i=0; i<src.length;i++){
            des[i]=src[i];
        }
        System.out.println(Arrays.toString(des));//[1, 2, 3, 4, 5]
  }
}

也可以采用以下方式

import java.util.Arrays;

public class ArrayCopy {
    public static void main(String[] args) {
        //数组的拷贝
        int[] src={1,2,3,4,5};
            //可以采用以下方式：
        int[] array =Arrays.copyOf(src,3); 
        //从src中拷贝3个元素
        System.out.println(Arrays.toString(array)); 
        //结果：[1, 2, 3]
        int[] array1 =Arrays.copyOf(src,src.length); 
        //从src中拷贝所有元素
        System.out.println(Arrays.toString(array1));
        //结果：[1, 2, 3, 4, 5]
   }
}

3. 查找数组中指定元素

（1）顺序查找

public class FindArray {
    public static int Find(int[] array,int key){
        for(int i=0;i<array.length;i++){
            if(key==array[i]){
                return i;//找到了，返回下标
            }
        }
        return -1;//没找到，返回-1
    }

    public static void main(String[] args) {
        int[] array = {1, 4, 6, 3, 7, 9};
        System.out.println(Find(array, 5));
        //没找到，返回-1
        System.out.println(Find(array, 3)); 
        //3
    }
}

顺序查找：当有n个元素时，最差的情况下，需要比较n次，效率比较低；

（2）二分查找

前提：集合必须是有序的（升序/降序）
思路:先取中间位置的元素, 看要找的元素比中间元素大还是小. 如果小, 就在左边找; 否则在右边找；

假设  array是升序排列

public class BinarySearch {
    //二分查找：
    //前提：集合必须是有序的
    //假设array是升序排列
    public static int binarySearch(int[] array,int key){
        int left=0;
        int right=array.length-1;   //[left,right]
        while(left<=right){
            int mid=left+((right-left)>>1);
            if(key==array[mid]){
                return mid;
            }else if(key>array[mid]){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return -1;//没找到，返回-1
    }

    public static void main(String[] args) {
        int[] array={1,2,3,5,6,7,8,9};
        System.out.println(binarySearch(array,4) ); 
        //-1
        System.out.println(binarySearch(array,7) );
        //5
    }
}

随着数组元素个数的不断增多, 二分查找的优势就越大；

4 .数组逆序

需求：给定一个数组, 将里面的元素逆序排列

import java.util.Arrays;

public class ReverseArray {
    public static void  reverseArray(int[] array){
        int left=0;
        int right=array.length-1;  //[left,right]
        while(left<right){
            int tmp=array[left];
            array[left]=array[right];
            array[right]=tmp;
            left++;
            right--;
        }
    }

    public static void main(String[] args) {
        int[] array={1,4,6,8};
        reverseArray(array);
        System.out.println(Arrays.toString(array));
        //[8, 6, 4, 1]

    }
}

5.冒泡排序

需求：给定一个数组, 让数组升序 (降序) 排序
思路：假设排升序
1. 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟比较下来之后，最大元素就在该数组的末尾；
2. 依次重复上述过程，直到数组中所有的元素都排列好；

import java.util.Arrays;

public class BubbleSort {
    //冒泡排序
    public static void bubbleSort(int[] array){
        //外部循环，控制冒泡总趟数
        for(int i=0;i<array.length;i++){
            for(int j=1;j<array.length-i;j++){
                //j 表示相邻元素后一个元素的下标
                if(array[j-1]>array[j]){
                    int tmp=array[j-1];
                    array[j-1]=array[j];
                    array[j]=tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] array={1,9,3,5,6,2,7,4};
        bubbleSort(array);
        System.out.println(Arrays.toString(array)); //[1, 2, 3, 4, 5, 6, 7, 9]
    }
}

6.数组的排序

由于冒泡排序性能较低. Java 中内置了更高效的排序算法；

 Arrays.sort  进行排序

import java.util.Arrays;

public class ArraySort {
    public static void main(String[] args) {
        int[] array={1,4,2,6,8,7,9,0,3};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
        //[0, 1, 2, 3, 4, 6, 7, 8, 9]
    }
}