【学懂Java】(三)数组

一.概述

a.数组是相同类型数据的有序集合:

• 相同类型的若干个数据,按照一定先后次序排列组合而成。
• 其中,每一个数据称作一个数组元素
• 每个数组元素可以通过一个下标来访问它们.

b.数组特点:

• 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
• 其元素必须是相同类型,不允许出现混合类型。
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型。

c.数组属引用类型:

• length, elements of the array

d.注意

• 声明一个变量就是在内存空间划出一块合适的空间,声明一个数组就是在内存空间划出一串连续的空间
• 数组只有一个名称，即标识符
• 元素下标标明了元素在数组中的位置，从0开始
• 数组中的每个元素都可以通过下标来访问
• 数组长度固定不变，避免数组越界

二.使用

1、声明数组: 告诉计算机数据类型是什么--数据类型[ ] 数组名 ;​​int[] array;​​

2、分配空间: 告诉计算机分配几个连续的空间--数据类型[ ] 数组名 = new 数据类型[大小] ;​​array = new int[5];​​

3、赋值：向分配的格空间里放数据​​array[0] = 0;​​

4、处理数据:​​array[0] = array[0] + 1;​​

（1）一维数组

1.声明并申请空间

​​int[] arr = new int[5];​​

​​int [] arr = new int[5];​​

​​int arr[] = new int[5];​​

2.声明并且赋值

​​int[] arr = new int[]{1,2,3,4,5};//这样说明数组大小为5​​

​​int[] arr = {1,2,3};​​

3.处理

​​System.out.println(arr1.length);​​打印数组长度，为申请空间的长度，不管是否赋值。

4.初始化

动态初始化

• 数组定义与为数组元素分配空间并赋值的操作分开进行

int a[] = null;
a = new int[3];
a[0] = 3;
a[1] = 2;
a[2] = 1;

静态初始化

• 除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值。
• 格式: 类型 [] 数组名 = {元素1, 元素2 ......};

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

• int: 0
• boolean:false
• String:null

5.数组范围

数组元素下标从0开始；长度为n的数组合法下标取值范围： 0 ~ n-1；

（2）数组排序*

因为数组相当于是数据结构的一种，很多数据经常要使用数组.因此需要了解：

1. 某种排序算法

1. 冒泡排序
2. 选择排序
3. 插入排序
4. 快速排序

2. 排序算法的时间复杂度，空间复杂度：

1. 衡量一个数据结构是否合适的衡量标准

3. 排序算法的稳定性：

1. 排序之后的值跟排序之前的值位置是否发生变化

冒泡排序

public static void bubbleSort(int array[]) 
{
    int t = 0;
    for (int i = 0; i < array.length - 1; i++)
    {
        for (int j = 0; j < array.length - 1 - i; j++)
        {
            if (array[j] > array[j + 1])
            {
                t = array[j];
                array[j] = array[j + 1];
                array[j + 1] = t;
            }
        }
    }
}

选择排序

public static void selectionSort(int[] array) 
{
        for (int i = 0; i < array.length; i++)
        {
            int index = i;
            for (int j = i; j < array.length; j++)
            {
                if (array[j] < array[index]) 
                    index = j; 
            }
            int temp = array[index];
            array[index] = array[i];
            array[i] = temp;
        }
    }

插入排序

public static void insertionSort(int[] array) {
        int current;
        for (int i = 0; i < array.length - 1; i++) {
            current = array[i + 1];
            int preIndex = i;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex + 1] = array[preIndex];
                preIndex--;
            }
            array[preIndex + 1] = current;
        }
    }

快速排序

public static int[] QuickSort(int[] array, int start, int end) {
        if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
        int smallIndex = partition(array, start, end);
        if (smallIndex > start)
            QuickSort(array, start, smallIndex - 1);
        if (smallIndex < end)
            QuickSort(array, smallIndex + 1, end);
        return array;
    }
 public static int partition(int[] array, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex = start - 1;
        swap(array, pivot, end);
        for (int i = start; i <= end; i++)
            if (array[i] <= array[end]) {
                smallIndex++;
                if (i > smallIndex)
                    swap(array, i, smallIndex);
            }
        return smallIndex;
    }
 public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

（3）二维数组

二维数组的使用

public class TwoArray
{
    
    public static void main(String[] args)
    {
        
        int[] arr = new int[6];
        int[][] arr2 = new int[3][];
        //创建二维数组的对象
        arr2[0] = new int[5];
        arr2[1] = new int[3];
        arr2[2] = new int[4];
        //赋值
        arr2[0][0] = 1;
        arr2[0][1] = 2;
        arr2[0][2] = 3;
        arr2[0][3] = 4;
        arr2[0][4] = 5;
        
        arr2[1][0] = 6;
        arr2[1][1] = 7;
        arr2[1][2] = 8;
        
        arr2[2][0] = 9;
        arr2[2][1] = 10;
        arr2[2][2] = 11;
        arr2[2][3] = 12;
        
        for(int i = 0;i<arr2.length;i++)
        {
            for(int j = 0;j<arr2[i].length;j++)
            {
                System.out.print(arr2[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

注意

1.二维数组举例：

​​int [][] a = {{1,2},{3,4,0,9},{5,6,7}};​​

Java中多维数组不必须是规则矩阵形式，例如

int[] arr = new int[6];
int[][] arr2 = new int[3][];
//创建二维数组的对象
arr2[0] = new int[2];
arr2[1] = new int[4];
arr2[2] = new int[3];

2.二维数组可以看成以数组为元素的数组

Java中多维数组的声明和初始化应按从高维到低维的顺序进行，例如：

3.二维数组的初始化

• 动态初始化

• ​​int [ ][ ] arr=new int [4][3]; ​​也可以理解为“4行3例”

• 静态初始化

• 数据类型 [ ][ ] 数组名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…}…};
• 举例：​​int [ ][ ] arr={{1，2，3},{1，3，4，5},{1，5，6，7，9}};​​

• 注意

• ​​int [][]arr=new int[3][]; 正确​​
• ​​int [][]arr=new int[][3]; 错误​​

• 二维数组可以不定义列数，但必须定义行数。
• 因为每行的列数可能不一样，所以这类数组的实现方法为：先创建制定行数，列数缺省的二维数组，然后对数组的每一行重新初始化

int [][]arr=new int[3][];
arr[0]=new int[7];
arr[1]=new int[4];
arr[2]=new int[5];