JAVA_TOJAVASE_Day05(数组 、数组排序、冒泡法和排序法)

数组的格式：

public static void main(String[] args) {
        //格式1
        /**
         * 需要一个容器，但是不明确容器的具体数据
         */
        int[] arr=new int[3];

        //元素类型[] 数组名=new 元素类型[]{元素，元素，...}
        /**
         * 需要一个容器，存储已知的具体类型。
         */
        int arr2[]=new int[] {2,3};
        int arr3[]= {2,3,4,5,6};
    }

数组的遍历：

int arr2[]=new int[] {2,3};
        int arr3[]= {2,3,4};


        /**
         * 对数组操作最基本的动作就是存和取
         * 核心思想：就是对角标的操作。
         */

        System.out.println(arr3[1]);

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

数组常见操作——最值

• 获取最大值
• 获取最小值

public static void main(String[] args) {
        /**
         * 获取数组中的最大值。 思路： 1.需要进行比较。并定义变量记录住每次比较后较大的值 2.对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
         * 如果遍历到的元素大于变量中记录的元素，就用变量记录住该大的值。 3.遍历结果，该变量记录就是最大值
         */
        int arr[] = { 2, 4, 9, 0 };
        int max = getArrayMax(arr);
        int max_jiaobiao=getArrayMax2(arr);
        System.out.println(max);
        System.out.println(arr[max_jiaobiao]);

    }
    /**
     * 用数值比较
     * @param array
     * @return
     */
    public static int getArrayMax(int array[]) {
        int temp = array[0];
        for (int i = 1; i < array.length; i++) {
            if (temp < array[i]) {
                temp = array[i];
            }

        }
        return temp;
    }
    /**
     * 用角标比较
     * @param array
     * @return
     */
    public static int getArrayMax2(int array[]) {
        int temp = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[temp] < array[i]) {
                temp = i;
            }

        }
        return temp;
    }

数组常见操作选择排序

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[] = new int[] { 23, 24, 3, 35, 29 };
        printArray(arr);
        sort(arr);
        printArray(arr);

    }
    /**
     * 选择排序 从小到大
     * @param arr
     */
    public static void sort(int arr[]) {
        for (int i = 0; i < arr.length - 1; i++) {//这里为什么减1，因为最后一个不需要比较。看如下图：

            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }


    }
    /**
     * 输出
     * @param arr
     */
    public static void printArray(int arr[]) {

        for (int k = 0; k < arr.length; k++) {
            if(k!=arr.length-1) {
                System.out.print(arr[k] + "——");
            }else {
                System.out.println(arr[k]);
            }
        }
    }

• 首先为什么外循环要减一？
  
  • 因为最后一个不需要在比较。
• y=x+1 ,为什么加一？
  
  • 随着外循环的增加一次，内循环次数减一，也就是说y的值越大了。内循环的次数也就越小了

数组常见操作冒泡排序

数组常见功能：查找

public static void main(String[] args) {
        int []arr=new  int[] {2,3,4,5};
        int []arr2=new int[9];

        int index=getIndex(arr, 2);
        System.out.println("index="+index);
    }
    /**
     * 数组常见功能:查找
     */
    public static int getIndex(int [] arr,int key) {
        for(int i=0;i<arr.length;i++) {
            if(arr[i]==key) {
                return i;
            }
        }
        return -1;
    }

数组折半查找

//数组必须是有序的。
public static int halfSearch2(int []arr,int key) {

        int  max,min,mid;
        min=0;
        max=arr.length-1;
        while(min<=max) {
            mid=(min+max)>>1;//mid=(min+max)/2
            if(key>arr[mid]) {
                min=mid+1;
            }else if (key<arr[mid]){
                max=mid-1;
            }else {
                return mid;
            }
        }

        return -1;
    }


/**
     * 折半查找，
     * @param arr 这个数组必须是有序的，从小到大或者从大到小。
     * @param key
     * @return
     */
    public static int halfSearch(int [] arr,int key) {
        int  max,min,mid;//角标，index
        min=0;
        max=arr.length-1;
        mid=(min+max)/2;

        while(arr[mid]!=key) {
            if(key>arr[mid]) {
                min=mid+1;
            }else if(key<arr[mid]) {
                max=mid-1;
            }

            if(max<mid) {
                return -1;
            }
            mid=(min+max)/2;
        }
        return mid;
    }

面试题：
给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，那么这个元素的存储的角标位如何获取。

有序并且数组查找就想到折半查找

二维数组

• 二维数组的创建

        int [][]arr2=new int [3][2];//c创建一个二维数组，该数组中有3个一维数组，每一个一维数组中有2个元素

内存图示

示例：

int [][]arr2=new int [3][2];//创建一个二维数组，该数组中有3个一维数组，每一个一维数组中有2个元素
System.out.println(arr2);//直接打印二维数组
System.out.println(arr2[0]);//直接打印二维数组中的角标0的一维数组 [I@6d06d69c @左边是实体的类型，@右边是哈希值
System.out.println(arr2[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。

打印结果：

[[I@15db9742
[I@6d06d69c
0

• 另外还有一种只定义了二维数组的长度，没有定义一维数组的长度如下：
  

代码

        int[][] arr3=new int [3][];
        System.out.println(arr3);//直接打印二维数组
        System.out.println(arr3[0]);//null
        System.out.println(arr3[0][0]);//没有指向地址

        打印结果：
        [[I@15db9742
        null
        Exception in thread "main" java.lang.NullPointerException
    at com.study.array2.Array2Demo.main(Array2Demo.java:18)

• 二维数组的另一种形式

//int [][]arr4=new int [3][2];
//      System.out.println(arr4.length);//打印二维数组的长度，其实就是一维数组的个数
//      System.out.println(arr4[1].length);//打印二维数组中角标为1的一维数组的长度。

        int [][] arr5= {{3,2,1},{4,5,6},{4,2}};

        for(int i=0;i<arr5.length;i++) {
            for(int x=0;x<arr5[i].length;x++) {
                System.out.println(arr5[i][x]);
            }
        }