数组是多个相同类型数据的组合，实现对这些数据的统一管理
数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量
一维数组声明：
type var[] 或 type[] var；
例如：
int a[];
int[] a;
double b[];
Mydate[] c; //对象数组
数组初始化：
1.动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
//一维数组动态初始化 int[] arr = new int[3]; arr[0] = 3; arr[1] = 9; arr[2] = 8; //一维对象数组动态初始化 MyDate dates[]; dates = new MyDate[4]; dates[0] = new MyDate(1990, 12, 12); dates[1] = new MyDate(1991, 2, 12); dates[2] = new MyDate(1999, 1, 14); dates[3] = new MyDate(2000, 3, 5); int[][] arrs; //二维数组动态初始化一 arrs= new int[3][5];//3行5列 //二维数组动态初始化二 arrs= new int[3][]; //动态赋值 arrs[0] = new arrs[3]; arrs[1] = new arrs[2]; arrs[2] = new arrs[4]; arrs[1][0] = 12;
2.静态初始化：在定义数组的同时就为数组元素分配空间并赋值。
//一维数组静态初始化
int a[] = new int[]{ 3, 9, 8};
int[] a = {3,9,8};
//一维对象数组静态初始化
MyDate dates[] = {
new MyDate(1990, 12, 12),
new MyDate(1991, 2, 12),
new MyDate(1999, 1, 14),
new MyDate(2000, 3, 5)
}
// 二维数组静态初始化
int sources[][] = new int[][]{{1,2,3},{3,4,5},{6}};
i[1][0] = 90;
i[2][1] = 100;注：不管是动态还是静态初始化数组，一定在创建的时候，就指明了数组的长度！
数组元素的默认初始值：
1)byte short int long 而言：0
2)float double 而言：0.0
3)char而言：空格
4)boolean而言：false
5)引用类型变量而言:null
数组的内存结构
一维数组的内存结构：
二维数组内存结构:
数组遍历：
//一维数组遍历
for(int i = 0;i < arr.length;i++){
System.out.println(scores1[i]);
}
//二维数组遍历
for(int m = 0;m < sources.length;m++){//控制行数
for(int n = 0;n < sources[m].length;n++){
System.out.print(names[m][n] + " ");
}
}数组的常见异常：
//1.数组下标越界的异常:java.lang.ArrayIndexOutOfBoundsException
//数组的角标从0开始
int[] i = new int[10];
i[0] = 90;
i[10] = 99;
for(int m = 0;m <= i.length;m++){
System.out.println(i[m]);
}
//2.空指针的异常：NullPointerException
//第一种：
boolean[] b = new boolean[3];
b = null;
System.out.println(b[0]);
//第二种：
//String[] str = new String[4];
//str[3] = new String("AA");//str[3] = "AA";
//System.out.println(str[3].toString());
//第三种：
int[][] j = new int[3][];
j[2][0] = 12;数组常见操作
1.冒泡排序
相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其它的数进行类似操作。
// 使用冒泡排序使数组元素从小到大排列
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;
}
}
}2.直接排序
//使用直接选择排序使数组元素从小到大排列
for(int i = 0; i < arr.length - 1; i++){
int t = i;//默认i处是最小的
for(int j = i;j < arr.length;j++){
//一旦在i后发现存在比其小的元素，就记录那个元素的下角标
if(arr[t] > arr[j]){
t = j;
}
}
if(t != i){
int temp = arr[t];
arr[t] = arr[i];
arr[i] = temp;
}
}3.折半查找（二分法）
/*
为了提高查找效率，可使用折半查找的方式，注意：这种查找只对有序的数组有效。
这种方式也成为二分查找法。
*/
public static int halfSeach(int[] arr,int key)
{
int min,mid,max;
min = 0;
max = arr.length-1;
mid = (max+min)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
if(min>max)
return -1;
mid = (max+min)/2;
}
return mid;
}4.数组翻转
/*
反转其实就是头角标和尾角标的元素进行位置的置换，
然后在让头角标自增。尾角标自减。
当头角标<尾角标时，可以进行置换的动作。
*/
public static void reverseArray(int[] arr)
{
for(int start=0,end=arr.length-1; start<end; start++,end--)
{
swap(arr,start,end);
}
}
//对数组的元素进行位置的置换。
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
