黑马程序员——Java练习笔记——数组

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
1.数组的定义：是一个容器，同一种类型的数据的集合。
示例1：需要一个容器，但不知道容器的具体数据。
int[] arr = new int[5];
示例2：需要一个容器，存储已知的具体数据。
int[] arr = new int[]{1,4,6,7};或int[] arr = {1,4,6,7};
2.数组操作常见问题：
2-1.数组脚标越界异常(ArrayIndexOutOfBoundsException)：访问到了数组中的不存在的脚标时发生
示例：
结果：

2-2.空指针异常(NullPointerException)：当引用型变量没有指向任何实体时，用其操作实体，就会发生该异常。
示例：class ArrayDemo2
{
public static void main(String[] args)
{
int[] arr =null;
System.out.println(arr[0]);
}
}

结果：

3.数组常见操作
3-1.遍历并打印数组元素

class ArrayDemo3 
{
    public static void main(String[] args) 
    {
        int[] arr = {33,564,12,4,56};
        for (int i=0;i<arr.length ;i++ )
        {
            System.out.println("arr["+arr[i]+"]");
        }
    }
}

结果：

3-2.获取最值
示例1：通过定义变量记录较大的值的方式实现。

class ArrayDemo4 
{
    public static void main(String[] args) 
    {
        int[] arr ={2,5,67,1,66};
        int max = arr[0];
        for (int x=0;x<arr.length ;x++ )
        {
            if (arr[x]>max)
            {
                max=arr[x];
            }
        }
        System.out.println("max:"+max);
    }
}

结果：

示例2：通过定义变量记录较大的值的索引方式实现。

class ArrayDemo5 
{
    public static void main(String[] args) 
    {
        int[] arr  = new int[]{2,5,67,1,66};
        int max = 0;
        for (int i=1;i<arr.length ;i++ )
        {
            if (arr[i]>arr[max])
            {
                max=i;
            }
        }
        System.out.println("max:"+arr[max]);
    }
}

结果：

3-3.排序（选择排序，冒泡排序）
示例1：选择排序
思路：
1、首先拿数组第一个元素依次与除其自身外的其他每个元素顺序比较，如果第一个元素大于剩下的某个元素，就互换内容。
2、经过第一轮比较之后，此时第一个元素就是数组中最小的元素。然后再拿第二个元素与除第一个元素和其自身的元素进行比较，如果第二个元素大于剩下的某个元素，就互换内容。
3、依次类推，直到最后一个元素。
代码：

class ArrayDemo6 
{
    public static void main(String[] args) 
    {
        int[] arr = {23,44,21,42,136,999,11};
        System.out.println("打印原数组：");
        printArray(arr);
        System.out.println();
        System.out.println("打印排序后数组：");
        //对数组选择排序
        sortArray(arr);
        printArray(arr);
    }
    private static void sortArray(int[] arr)
    {
        for (int x=0;x<arr.length-1 ;x++ )
        {
            for (int y=x+1;y<arr.length ;y++ )
            {
                if (arr[x]>arr[y])
                {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }
    private static void printArray(int[] arr)
    {
        System.out.print("[");
        for (int i=0;i<arr.length ;i++ )
        {
            if (i!=arr.length-1)
            {
                System.out.print(arr[i]+",");
            }
            else
                System.out.print(arr[i]+"]");
        }
    }

}

结果：

示例2:冒泡排序
思路：
1、首先在第一轮排序中，数组从第一个元素到倒数第二个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
2、经过第一轮比较，最大的元素就已经存储到数组最右边的结点中了。
3、第二轮排序则是从第一个元素到倒数第三个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
4、依照此方式，一直到只有第一和第二个元素互相比较而结束。
代码：

class ArrayDemo7 
{
    public static void main(String[] args) 
    {
        int[] arr = {23,44,21,42,136,999,11};
        System.out.println("打印原数组：");
        printArray(arr);
        System.out.println();
        System.out.println("打印排序后数组：");
        //对数组冒泡排序
        bubbleArray(arr);
        printArray(arr);
    }
    private static void bubbleArray(int[] arr)
    {
        for (int x=0;x<arr.length-1 ;x++ )
        {
            for (int y=0;y<arr.length-1-x ; y++)
            {
                if(arr[y]>arr[y+1])
                {
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }

            }
        }
    }

        private static void printArray(int[] arr)
    {
        System.out.print("[");
        for (int i=0;i<arr.length ;i++ )
        {
            if (i!=arr.length-1)
            {
                System.out.print(arr[i]+",");
            }
            else
                System.out.print(arr[i]+"]");
        }
    }

}

结果：

3-4.折半查找(二分查找)
注意：
如果一个数组是无序的，那么可以通过简单遍历查找的方式查找到某个元素所在的角标。
但是如果一个数组是有序的，那么就可以通过一种更高效的方式达到相同的目的，也就是二分查找。
思路：
1、设置三个变量记录角标：min、max、mid。min初始值为0，max为数组最大角标，mid为（max+min）/2。
2、查看mid角标的元素是否与待查找的值相等，如果相等，则直接返回角标值，程序终止执行。
3、如果待查找的值小于角标为mid的元素值，那么说明待查找的元素的位置可能在min与mid角标之间。设置max = mid - 1，mid = (max + min)/2，重复第1、2步的操作。
4、如果待查找的值大于角标为mid的元素值，那么说明待查找的元素的位置可能在mid与max角标之间。设置min = mid + 1，mid = (max + min)/2，重复第1、2步的操作。
5、如果数组中不存在待查找的元素，那么按照如上流程，最终min角标值会大于max角标值，此时返回-1。

代码：

class ArrayDemo8 
{
    public static void main(String[] args) 
    {
        int[] arr = {1,3,5,7,8,12,43,78,90};
        int index = binarySearch(arr,12);
        System.out.println("index:"+index);

    }
    private static int binarySearch(int[] arr,int key)
    {
        int max,min,mid;
        min =0;
        max = arr.length-1;

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

结果：

4.JDK提供的API的一些方法
排序：Arrays.sort(arr);
二分查找：Arrays.binarySearch(arr,key);