Java重修之路（五）数组基本概念，存储方式，遍历，排序，查找，多维数组

数组遍历，排序，查找，多维数组

数组概念，定义，存储方式

数组在很多编程语言中都是比较重要的一部分，其中主要包含了数组在内存中的存储方式，以及对数组的各种操作：遍历，查找，排序等等，当然还有多维数组

- 数组的定义及内存分配特点

• 概念

数组是同一种类型的数据集合，本质就是一个容器

• 特点

自动给里面的元素编号，编号从0开始，数组里面的数据类型可以是任意的，但是同一个数组里面所有元素类型相同

• 格式

元素类型 [ ] 数组名=new 元素类型[元素个数或数组长度]
如： int[ ] num=new int[5]
元素类型 [ ] 数组名=new 元素类型[ ]{元素1，元素2······}
int[ ] num= new int[ ]{1,3,5,69};
int[ ] num= {1,3,5,69};
这里的中括号可以在元素类型后边，也可以在数组名后边：
type arrayName[ ]=new type[ arraySize];也是符合规范的

• 内存分配

  java在运行程序时一共在内存中划分5块内存区域，分别是 栈内存、堆内存、方法区、本地方法区、寄存器。这里主要先介绍栈内存和堆内存。

  

简单的说，栈内存存放基本数据类型和对象的引用，用完之后会立即释放，堆内存用于存储对象的实体和数组，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。

数组的静态赋值和输出
public class Hello {
    public static void main(String[] args) {
        int arr[] = new int[] { 1, 5, 9, 4, 7 };
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }

    }
}

注意角标越界的问题，最大只能访问到arr[arr.length-1]

遍历数组并且获取最大值
public class Hello {
    public static void main(String[] args) {
        int arr[] = new int[] { 1, 5, 9, 4, 7 };
        System.out.println(getMax(arr));
    }

    /**
     * 获取数组中最大值
     * 
     * @param arr
     * @return
     */
    private static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

}

初始化的问题

    public static void main(String[] args) {
        int arr1[] = new int[5];
        char arr2[] = new char[5];
        boolean arr3[] = new boolean[5];
        System.out.println(arr1[2]);
        System.out.println(arr2[2]);
        System.out.println(arr3[2]);

    }
输出结果为：
0   //int型默认为0
    //char型默认为空
false  //boolean型默认为false

---

- 数组排序

• 
  
• 冒泡排序（从小到大）
  

基本原理：
对于数组中的每一个元素，都会进行一次遍历，将相邻两个元素比较，最终结果是将大数字放在最后面，例如第一趟循环，将最大的数放在最后一位，第二次遍历，将第二大的数据放在倒数第二位···以此类推。

需要嵌套循环：
对于第一个数来说，需要与后边每一个数字比较一次，结果就是将此数组中最大的数放在最后。
public static void bubbleSort(int[] array) {
    int temp;
    for (int i = 0; i < array.length; i++) {// 趟数
        for (int j = 0; j < array.length - i - 1; j++) {// 比较次数
            if (array[j] > array[j + 1]) {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

---

• 选择排序

基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

/**
 * 选择排序
 * @param array
 */
public static void selectSort(int[] array) {
    int position = 0;
    for (int i = 0; i < array.length; i++) {
        int j = i + 1;
        position = i;
        int temp = array[i];
        for (; j < array.length; j++) {
            if (array[j] < temp) {
                temp = array[j];
                position = j;
            }
        }
        array[position] = array[i];
        array[i] = temp;
    }
}

• 
  
• 插入排序
  

在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序

public static void insertSort(int[] array) {
    int temp = 0;
    for (int i = 1; i < array.length; i++) {
        int j = i - 1;
        temp = array[i];
        for (; j >= 0 && temp < array[j]; j--) {
            array[j + 1] = array[j]; // 将大于temp的值整体后移一个单位
        }
        array[j + 1] = temp;
    }
}

还有希尔排序和快速排序，都是需要掌握的，这里就不贴出来了。
系统自带排序： Arrays.sort(arr);

• 数组的折半查找：

前提是该数组是有序的，否则会出错

public static int halfSearch(int[] array, int key) {
        int min, max, mid;
        min = 0;
        max = array.length - 1;
        mid = (min + max) / 2;
        while (array[mid] != key) {
            if (key > array[mid])
                min = mid + 1;
            else if (key < array[mid])
                max = mid - 1;
            mid = (max + min) / 2;
        }

        return mid;
    }

进制转换

• 十进制转换为二进制字符串

/**
 - 将十进制转换为二进制字符串返回
 - 
 - @param num
 - @return
 */
public static String toBin(int num) {
    StringBuffer sb = new StringBuffer();
    while (num != 0) {
        sb.append(num % 2);
        num /= 2;
    }
    return sb.reverse().toString();
}

• 十进制转换为十六进制：

public static String toHex(int num) {
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < 8; i++) {
        int temp = num & 15;
        if (temp > 9)
            sb.append((char) (temp - 10 + 'A'));
        else
            sb.append(temp);
        num = num >>> 4;
    }

    return sb.reverse().toString();
}

多维数组

• 定义
  int arr[ ][ ]=new int[3][4];
  定义了一个名称为arr的二维数组，里面有3个一位数组，每个一维数组里面有4个元素。
  int arr [ ] [ ]={{2,3},{3,4},{5,7}};

注意：
多维数组不允许说明静态数组 即：int[2][3];不合法
数组的维数说明必须从高维到低维，先说明高维再说明低维。
数组维数的指定只能出现在new之后。
下面是合法的说明：
int[] arr[] = new int[3][5];
int[][] arr2 = new int[3][];
int [][] arr3=new int[2][4];
下面是错误的说明：

int [2][3] arr;
int[][]=new int[][3];
int [2][]=new int[2][4];

• 多维数组遍历：

public static void main(String[] args) {
int[] arr[] = new int[][] { { 2, 6, 58, 9, 4 }, { 5, 9, 84, 8, 68 }, { 895, 35, 15, 4, 3} };
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j]+"\t");
    }
    System.out.println();
}
}

关于数组就介绍这么多，下边真正进入主题，Java的面向对象。