数组

数组

数组中包含的变量必须是相同类型的

创建数组

静态初始化

数据类型[] 数组名 = {初始化数据};

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

动态初始化

数据类型[] 数组名 = new 数据类型{初始化数据};

例：int[] arr = new int{1,2,3};

给定数组长度但不初始化

数据类型[] 数组名 = new 数据类型[数组长度];

例：int[] arr = new int[10];//定义了一个长度为10的数组

数组的使用

获取数组长度

数组名.length;

下标越界（超出数组长度）

int[] arr = {1,2,3};
System.out.println(arr[5]);

//出现
java.lang.ArrayIndexOutOfBoundsException

遍历数组（将数组中的元素全部访问一遍）

for方法

    int[] arr = {1,2,3};
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }

for-each方法

    int[] arr = {1,2,3};
    for (int a:arr) {
        System.out.println(a);
    }

使用工具类（将数组转为字符串输出）

法一
    int[] arr = {1,2,3};
    String str = Arrays.toString(arr);
    System.out.println(str);

法二
    int[] arr = {1,2,3};
    System.out.println(Arrays.toString(arr));

将无序数组变为有序的（升序）

public static void main(String[] args) {
    int[] arr = {5,8,6,7,3,2};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
}

填充数组Arrays.fill()

Arrays.fill(array, fromIndex, toIndex, val);
array:要填充的数组名
fromIndex:从几号下标开始
toIndex:到几号下标结束
val ;要填充的值

    int[] a = new int[10];
    Arrays.fill(a,2,5,99);
    System.out.println(Arrays.toString(a));
    //结果为
    [0, 0, 99, 99, 99, 0, 0, 0, 0, 0]

引用数组的空引用

	int[] arr = null;//代表arr不指向任何对象
	System.out.println(arr[0]);//出现异常
	System.out.println(arr.length);//出现异常

	int[] arr1 = {};
	System.out.println(arr1[0]);//出现异常
	System.out.println(arr1.length);//结果为0
			
	int[] arr2 = new int[5];
	System.out.println(Arrays.toString(arr2));//结果为[0,0,0,0,0]
	System.out.println(arr2.length);//结果为5

数组转字符串

public static String myToString(int[] arr){
    if (arr == null){
        return "";
    }
    if (arr.length == 0){
        return "[]";
    }
    String ret = "[";
    for (int i = 0; i < arr.length; i++) {
        ret += arr[i];
        if( i != arr.length-1){
            ret += ", ";
        }
    }
    ret += "]";
    return ret;
}

数组的拷贝

for循环拷贝

public static int[] copy(int[] arr){
 	int[] copy_arr = new int[arr.length];
 	for (int i = 0; i < arr.length; i++) {
   	 	copy_arr[i] = arr [i];
	}
	return copy_arr;
}

使用Arrays.copyOf（）方法

Arrays.copyOf ( int[] 要拷贝的数组,int 要拷贝的长度 );

public static int[] copy(int[] arr){
 	int[] copy_arr = Arrays.copyOf(arr,arr.length);
	return copy_arr;
}

使用Arrays.copyOfRange（）方法

Arrays.copyOfRange( 要拷贝的数组 , 从几号下标开始拷贝 , 到几号下标结束);

public static int[] copy(int[] arr){
	int[] copy_arr = Arrays.copyOfRange(arr,1,5);
	return copy_arr;
}

使用clone（）方法

public static int[] copy(int[] arr){
	int[] copy_arr = arr.clone();
	return copy_arr;
}

使用native方法

public static native void arraycopy(Object src,int srcPos,Object dest,int desPos,int length);
src:要拷贝的数组
srcPos:要拷贝的数组的位置
dest：目的地数组
desPos：目的地数组的位置
length：拷贝的长度

int[] arr = {1,2,3};
int[] copy = new int[arr.length];
System.arraycopy(arr,0,copy,0,arr.length);
System.out.println(Arrays.toString(copy));

数组的应用

找出数组的最大值

public static int maxArray(int[] arr){
	if(arr == null || arr.length == 0){
		return -1;
	}
	int max = arr[0];
	for(int i = 1; i <arr.length; i++){
		if(arr[i] > max){
			max = arr[i];
		}
	}
	return max;
}

求数组的平均值

public static int avgeArray(int[] arr){
	int sum= 0;
	for(int i = 0; i <arr.length; i++){
		sum+=arr[i];
	}
	double num = sum*1.0/arr.length;
	return num;
}

查找数组中的指定元素

顺序查找

piblic static int num(int[] arr,int key){
	for(int i = 0; i <arr.length; i++){
		if(arr[i] == key){
			return i;
		}
	}
	return -1;
}

二分查找

public static int binarySearch(int[] arr,int key){
	int left = 0;
	int right = arr.length-1;
	while(left<right){
		int mid = (left+right)/2;
		if(arr[mid] > key){
			right = mid -1;
		} else if(arr[mid] < key){
			left = mid +1;
		}else{
			return mid;
		}
	}
	return -1;
}

检查数组的有序性

public static boolean isSorted(int[] arr){
	for(int i =0 ; i < arr.length-1 ; i++){
		if(arr[i] > arr[i+1]){
			return false;}
		}
	}
	return true;
}

数组排序（冒泡排序）

public static void bubbleSort(int[] arr){
	boolean flg = false;//检查第i趟是否发生交换
	//i是趟数
	for(int i = 0; i < arr.length-1 ; i++){
		flg = false;//每一趟都有可能发生交换
		for(int j = 0; j < arr.length-1-i ; j++){
			if(arr[j] > arr[j+1]){
				int tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
				flg = true;//发生交换
			}
		}
		if(flg == false){
			break;
		}
	}
}

数组逆序

public static void reverse(int[] arr){
	int left = 0;
	int right = arr.length-1;
	while(left < right){
		int tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
		left++;
		right--;
	}
}

数组元素所有偶数在奇数之前

public static void func(int[] arr){
    int left = 0;
    int right = arr.length-1;
    while(left < right){
        while( left < right && arr[left] % 2 ==0){
            left++;
        }
        while(right > left && arr[right] % 2 != 0){
            right--;
        }
        if(left <right){
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
        }
    }
}

二维数组

创建二维数组

二维数组的定义
数据类型[][] 数组名称 = new 数据类型[行数][列数]{初始化数据};

int[][] array1 = {{1,2,3},{4,5,6}};
int[][] array2 = new int[][]{[1,2,3},{4,5,6}};
int[][] array3 = new int[3][];
int[][] array4 = new int[3][3];

float f[][] = new float[6][];
float []f[] = new float[6][];
float [][]f = new float[6][];

注意：定义二维数组时，行不能丢，列可以丢

int[][] array = new int[2][];
System.out.println(array[0]);//不指向任何引用，结果为null
array[0] = new int[3];//第0行有3列
array[1] = new int[4];//第1行有4列

二维数组的使用

获取数组的长度

二维数组的行数：array.length;
二维数组的列数：array[i].length;//i是指第几行

遍历二维数组

    int[][] array1 = {{1,2,3},{4,5,6}};
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array1[i].length; j++) {
            System.out.print(array1[i][j] +" ");
        }
        System.out.println();
    }