javaSE基础-数组

数组

数组的简述

1、数组：是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行同一管理

2、数组的相关概念：
数组名
元素
角标、下标、索引
数组的长度：元素的个数

3、数组的特点：
数组是序排列
数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
创建数组对象会在内存开辟一块连续的空间
数组的长度一旦确定，就不可修改

4、数组的分类：
按维度：一维数组、二维数组。。。
按元素的类型：基本数据类型元素数组、引用数据类型元素数组

数组的使用

1、一维数组的初始化两种方式

int[] arr = new int[3]; //动态初始化
String[] arr2 = new String[]{"Mary", "Jerry", "Tim"}; // 静态初始化

注：数组一旦初始化，其长度不可变(arr.length)，长度确定就不可修改。

2、二维数组初始化的两种方式

int[][] arr1 = new int[][]{{1,2,3},{45,67,89}}; // 静态初始化
int[][] arr2 = new int[3][4]; //动态初始化
int[][] arr3 = new int[3][];  //动态初始化

二维数组内外层的注意事项

数组定义格式
一维数组：int[] x 或者 int x[]
二维数组：int[][] y 或者 int[] y[] 或者 int y[][]

3、遍历二维数组

int[] arr = new int[][]{{1,2,3}, {2,1}, {7,3,6}};

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();
}

4、不同类型的一维数组元素的默认初始化值

整型：0
浮点型：0.0
Boolean：false
Char：0 或 \u0000
引用类型：null

5、一维数组的内存解析

6、二维数组的内存解析

7、数组使用常见异常

• 数组角标越界：ArrayIndexOutOfBoundsException

int[] arr = new int[]{1,2,3,4};
for (int i = 0; i <= arr.length; i++) {
	System.out.println(arr[i]); //报错：ArrayIndexOutOfBoundsException
}

System.out.println(arr[-1]); //报错：ArrayIndexOutOfBoundsException

• 空指针异常：NullPointerException

//情况一
int[] arr2 = new int[]{1,2,3};
arr2 = null;
System.out.println(arr2[0]); //报错：NullPointerException

//情况二
int[][] arr3 = new int[4][];
System.out.println(arr3[0][0]); //报错：NullPointerException

//情况三
String[] arr4 = new String[]{"AA","B","C"};
arr4[0] = null;
System.out.println(arr4[0].toString()); //报错：NullPointerException

Arrays工具类的使用

java.util.Arrays类为操作数组的工具类，包含用来操作数组的各种方法

1、常用方法

示例

public class ArraysTest {
    public static void main(String[] args) {
        int[] arr1 = new int[]{1,22,33,44};
        int[] arr2 = new int[]{1,33,22,44};

        //equal()
        boolean b = Arrays.equals(arr1, arr2);
        System.out.println(b); //false

        //toString()
        System.out.println(Arrays.toString(arr1)); //[1, 22, 33, 44]

        //fill()
        Arrays.fill(arr1, 10);
        System.out.println(Arrays.toString(arr1)); //[10, 10, 10, 10]

        //sort():使用快排
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2)); //[1, 22, 33, 44]

        //binarySearch()：使用二分查找
        int index = Arrays.binarySearch(arr2, 22);
        System.out.println("22在数组arr2索引位置" + index); //1
    }
}

2、数组基本操作 - 最大值、最小值、求和、平均值、复制、反转、排序、遍历、查找

click me

public class ArrayUtil {

    //求数组的最大值
    public int getMax(int[] arr) {
        int maxValue = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maxValue) {
                maxValue = arr[i];
            }
        }
        return maxValue;
    }

    //求数组的最小值
    public int getMin(int[] arr) {
        int minValue = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (minValue > arr[i]) {
                minValue = arr[i];
            }
        }
        return minValue;
    }

    //求数组的和
    public int getSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    //求数组的平均值
    public double getAverage(int[] arr) {
        DecimalFormat df = new DecimalFormat("0.00");
        String ave = df.format(getSum(arr) / arr.length);
        return new Double(ave);
    }

    //数组的复制
    public int[] copyArray(int[] arr) {
        int[] newArr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }
        return newArr;
    }

    //反转数组
    public void reverse(int[] arr) {
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }

    //数组排序（从小到大）
    public void sortArray(int[] arr) {
        //冒泡排序
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

    }

    //数组遍历
    public void printArray(int[] arr){
        System.out.print("[");
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
            if(index == arr.length -1){
                System.out.print(arr[i]);
            }
            index++;
        }
        System.out.print("]" + "\n");
    }

    //查找指定元素
    public int getIndex(int[] arr, int dest){
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == dest){
                index = i;
                return index;
            }
        }
        return index;
    }
}

数组与算法

数据结构

1、数据间的逻辑关系：集合、一对一、一对多、多对多

2、数据的存储结构

线性表：顺序表（如：数组）、链表、栈（先进后出）、队列（先进先出）

树型结构：二叉树

图形结构

数组中常用算法

1、数组元素的赋值（杨辉三角、回形数等）

2、求数值型数组中的最大值、最小值、平均数等

3、数组的复制、反转、查找（线性查找、二分查找）

4、数组元素的排序算法

排序算法

排序算法分类

排序算法的性能比较

十大内部排序算法

• 选择排序
  • 直接选择排序、堆排序
• 交换排序
  • 冒泡排序、快速排序
• 插入排序
  • 直接插入排序、折半插入排序、Shell排序
• 归并排序
• 桶式排序
• 基数排序

示例一：冒泡排序

int[] arr = new int[]{23,4,565,23,65,-34,0,123};

for(int i=0; i<arr.length -1; i++){
    for(int j=0; j<arr.length - 1 -i; j++){ // 每一轮交换的次数：arr.length - 1 -i
        if(arr[j] > arr[j+1]){
            int tmp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = tmp;
        }
    }
}

示例二：快速排序

private static void subSort(int[] data, int start, int end){
    if(start < end){
        int base = data[start];
        int low = start;
        int high = end + 1;
        while(low < end && data[++low] - base <= 0);
        while(high > start %% data[--high] - base >= 0);
        if(low < high){
            swap(data, low, high)
        }else{
            break;
        }
    }
    swap(data, start,high);
    subSort(data, start, high-1);
    subSort(data, high+1, end);
}

private static void swap(int[] data, int i, int j){
    int tmp = data[i];
    data[i] = data[j];
    data[j] = tmp;
}