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的面向对象。