数组

一维数组

 

1、数组是一个变量，用来在内存中存储元素地址连续的，类型相同且整体长度不可变的一组数据。

2、数组四要素：名称、元素、下标（从0开始）、类型，通过下标访问数组的元素。

3、Java中定义数组的方式：

        数组的类型：int[]：代表一个一维的，元素类型为int型的数组

        数组属于引用数据类型，所以数组是new出来的

    1）定义静态数组：数组中元素的内容已经指定的数组

//定义静态数组
int[] array1 = new int[] {0,1,2,3,4,5,6,7,8,9};

注意：在静态数组中，元素是指定的，使用{}包裹所有的元素，元素和元素之间使用逗号进行分隔

    2）定义动态数组：仅指定数组的长度，不给定具体元素内容

//定义动态数组
int[] array2 = new int[10];

注意：在Java中定义数组的时候，数组的长度和内容只能择其一而指定，不能即给定长度，又给定内容；也不能不给定长度也不给定内容

 

4、数组元素最大下标：

//数组的最大下标
System.out.println(array1[array1.length-1]);

注意：数组元素最大下标和数组长度之间的关系：MAX(index) = length-1

如果访问的数组元素下标为负数，或者超过数组元素的最大下标，将会导致数组下标越界异常

5、数组的长度及循环访问

for(int i=0; i<intArray.length; i++){
   int a = intArray[i];
}

加强for循环的使用：

 

//通过加强for循环（foreach）遍历数组
for(int a : array1) {  
	//将array1这个数组中的元素一个一个的取出来，存放在临时变量a当中，我们使用的时候，直接用临时变量a就代表了当前的数组元素
    System.out.println(a);
}

注意：加强for循环中的临时变量，只能够取得数组中的值，不能反向向数组中赋值，所以通过加强for循环不能直接改变数组中元素的值

6、数组元素的修改

int[] scores = {60,80,90,77,85};
scores[1] = 100; //将第二个学生的成绩修改为满分

7、数组的长度是在声明时就已经确定的，如果想增加或减少数据的容量，需要新建一个数组，然后一个个元素赋值。

int[] scores = {60,80,90,77,85};
int[] newScores = new int[scores.length + 1];
for(int i=0;i<scores.length;i++){
   newScores[i] = scores[i];
}
newScores[newScores.length-1] = 55;//新的分数

 

上面的循环赋值，也可以用Arrays工具类的copyOf方法来代替。

 

8、数组的元素默认值：

int[] array1 = new int[10];
System.out.println(array1[1]);  //整型数组：0
boolean[] array2 = new boolean[10];
System.out.println(array2[1]);  //真值数组：false
double[] array3 = new double[10];
System.out.println(array3[1]);  //浮点型数组：0.0
char[] array4 = new char[10];
System.out.println(array4[1]);  //字符型数组：ASCII0
String[] array5 = new String[10];
System.out.println(array5[1]);  //引用数据类型数组：null

 

多维数组

   

本质：内存中最多只有一维数组，二维数组（多维数组）本质上是数组的数组

 

二维数组的创建：

//创建二维数组
public void createBinaryArray() {
    //[1]创建静态二维数组
    int[][] array = new int[][] {
        {1,2,3},
        {4,5,6},
        {7,8,9,0}
    };  //array[3][4]
    //[2]创建动态二维数组
    int[][] array2 = new int[4][3];
    /*
         * 0,0,0
         * 0,0,0
         * 0,0,0
         * 0,0,0
         */
}

二维数组的遍历：

//遍历二维数组
public void queryBinaryArray() {
    int[][] array = new int[][] {
        {1,2,3},
        {4,5,6},
        {7,8,9,0}  //二维数组中每一行的长度不一定相等
    };  //array[3][4]
    for(int i = 0; i < array.length; i++) {  //i控制行
        for(int j = 0; j < array[i].length; j++) {  //j控制列
            System.out.print(array[i][j] + ",");
        }
        System.out.println();
    }
}

 

注意：二维数组中，每一行元素的数量是可以不相同的

 

 

数组的基本算法

一、排序

1、java.util.Arrays（API文档）是一个工具类，具有一些静态方法可以直接调用，其中sort方法可用来给数组升序排序。
例如：

import java.util.Arrays; //注意这句用来导入工具类
...
int[] arr = {3,1,2,5,10};
Arrays.sort(arr)
System.out.println(Arrays.toString(arr));

 

    2、冒泡排序

原理：相邻位比较，反序则互换

// 冒泡排序
	public static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
	}

     3、插入排序

	// 插入排序
	public static void insertSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			int t = arr[i];
			int j = 0;
			for (j = i - 1; j >= 0; j--) {
				if (arr[j] > t) {
					arr[j + 1] = arr[j];
				} else {
					break;
				}
			}
			arr[j + 1] = t;
		}
	}

      4、选择排序

     //选择排序
    public int[] selectionSort(int[] array) {
        int tmp = -1;
        for(int i = 0; i < array.length-1; i++) {  
        //外层循环：控制比较轮次，同时也使用i指向数组中的标准位
            for(int j = i+1; j < array.length; j++) {  
            //内层循环：控制比较位的移动，相当于array[i]和array[j]进行比较
                if(array[i] > array[j]) {  //反序
                    tmp = array[i];
                    array[i] = array[j];
                    array[j] = tmp;
                }
            }
        } 
    }

 

二、查找

 

 

1、二分搜索：

原理：将搜索的范围降为原始范围的一半，直到找到目标元素或者确定目标元素不存在为止

前提条件：被搜索序列必须是有序序列

 

循环：循环的次数是不明确的，使用while循环

退出条件：array[middle] == target || start > end

执行条件：array[middle] != target && start <= end

 

 // 二分搜索
    public void binarySearch() {
        int[] array = new int[] {12, 23, 35, 41, 56, 62, 77, 89, 95};
        int target = 36;      
        int start = 0;
        int end = array.length-1;
        int middle = -1;
        int result = -1;  //保存最终结果的变量
        do {
            //[1]计算middle的值
            middle = (start + end) / 2;
            //[2]比较array[middle]和target之间的关系
            if(target < array[middle]) {  //说明target在middle左边
                end = middle - 1;
            }
            if(target > array[middle]) {  //说明target在middle右边
                start = middle + 1;
            }
            if(target == array[middle]) {  //target找到了
                result = middle;
            }
        }while(array[middle] != target && start <= end);
        System.out.println("目标元素下标：" + result);
    }