数组使用及边界问题

数组的简单使用及边界问题

1.数组的理解

数组是一个装载同一类型的多个元素的容器，即为多个相同类型元素的集合，和数学上的集合有类似含义，但她还有个自己的意义，就是在计算机的内存中数组的元素是存储在一片连续的内存空间的，且空间被分割为相同大小的内容块，每个空间用来装一个元素，空间的多少由数组初始化决定。与此概念相对的是链表，她是一个类似链条的结构，内存空间不连续，但是存储的元素也要求是同一类型。数组和链表是数据结构的基础，是计算机存储复杂数据的最基本依赖。

2. 初始化

数组初始化分为三种形式：1>直接声明一定大小的数组；2>声明一个固定大小且给出每一个元素的内容；3>只声明数组，不初始化，可后初始化。

   // 形式1：指定容器长度，不存入数据。
   int [] arrayOfInt = new int[100];
   // 形式2：指定容器类型，且存入元素数据。
   String[] arrayOfString = new String[]{"陈", "思", "Tony"};
   // 形式3：只声明数组
   float [] arrayOfFloat;
    // some code ...
    arrayOfFloat = new float[10];

若初始化时没有给出元素的数据，则该数组的各元素按照声明的类型赋予不同的初始值；

类型	初始值
整数型（short, int, long）	0
浮点型（float, double）	0.0
字符型（char）	\u0000
布尔型（boolean）	false
引用型（对象）	null

3.数组使用

在数组使用中，直接用过数组的下标来获取数组中元素的值（下标可理解为容器里面对于的一个标记），数组可根据下标返回对应的地址里面的元素；此时应当注意数组地标超界时抛出异常(java.lang.ArrayIndexOutOfBoundsException)，即当前使用的下标超出数组的内存空间，无法获取到元素，在使用中注意防备；另数组只能在初始化后才能使用，否则会抛出空指异常(java.lang.NullPointerException)，因为只有数组初始化之后才能给数组分配地址空间，未初始化的数组没有对应地址空间，当使用下标获取对应其地址空间元素时就会抛出异常。数组中有一个length
属性对应当前数组的内容大小，可根据该属性循环地遍历数组

 		int[] array = {1,3,5,7,9,11};
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        // 异常java.lang.ArrayIndexOutOfBoundsException
        System.out.println(array[6]);
      	//异常java.lang.NullPointerException
        int[] arr = null;
        System.out.println("arr"+ arr[0]);
        //遍历数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

获取数组中最大值，最小值

 	System.out.println( "MAX_VALUE: " + getArraysMaxValue(array));
    System.out.println( "MAX_VALUE: " + getArraysMaxValue(new int[] { 2 }));
    System.out.println( "MAX_VALUE: " + getArraysMaxValue(null));
    System.out.println( "MIN_VALUE: " + getArraysMinValue(array));
    System.out.println( "MIN_VALUE: " + getArraysMinValue(null));
    System.out.println( "MIN_VALUE: " + getArraysMinValue(new int[]{ 2 }));
	/***
     * 获得数组中最大值
     * @param arr
     * @return
     */
    public static int getArraysMaxValue(int [] arr){
        int max = Integer.MIN_VALUE;
        if(arr == null){
            return max;
        }
        for(int i=0; i<arr.length; i++){
            if( arr[i]>max ){
                max = arr[i];
            }
        }
        return max;
    }

    /**
     * 获取数组中最小值
     * @param arr
     * @return
     */
    public static int getArraysMinValue(int[] arr){
        int min = Integer.MAX_VALUE;
        if( arr == null ){
            return min;
        }
        for (int i = 0; i < arr.length; i++) {
            if( arr[i]<min ){
                min = arr[i];
            }
        }
        return min;
    }

数组转置，或者叫反转

	System.out.println("MIN_VALUE: " + getReverseArray(array));
    System.out.println("MIN_VALUE: " + getReverseArray(null));
    System.out.println("MIN_VALUE: " + getReverseArray(new int[]{2}));
    for (int i = 0; i < array.length; i++) {
    	System.out.println(array[i]);
    }
    /**
     * 数组转置
     * @param arr
     * @return
     */
    public static int[] getReverseArray(int[] arr) {
        if(arr == null){
            return arr;
        }
        int temp;
        for (int i = 0; i < arr.length/2; i++) {
            temp = arr[i];
            arr[i] = arr[arr.length-i-1];
            arr[arr.length-i-1] = temp;
        }
        return arr;
    }