一.概述
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）数组排序*
因为数组相当于是数据结构的一种，很多数据经常要使用数组.因此需要了解：
- 某种排序算法
- 冒泡排序
- 选择排序
- 插入排序
- 快速排序
- 排序算法的时间复杂度，空间复杂度：
- 衡量一个数据结构是否合适的衡量标准
- 排序算法的稳定性：
- 排序之后的值跟排序之前的值位置是否发生变化
冒泡排序
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];
