1、数组简介
1.1 数组初始化
为什么要使用数组呢？
因为有了数组可以更好的存储同类型的值，并做一些操作。
那么如何定义数组呢？
- 动态初始化方式1：
数据类型 数组名[] = new 数据类型[数组长度]; - 动态初始化方式2：
数据类型 数组名[]; 数组名 = new 数据类型[数组长度];
//数据类型 数组名[] = new 数据类型[数组长度];
double scores[] = new double[6];
//或者
double score1[];
score1 = new double[5];
- 静态初始化方式：
数据类型 数组名[] = {元素1，元素2...}
double scores[] = {10,20.3,14.2,5.5};
注意：可以是数据类型[] 数组名，可以是数据类型 数组名[]。
1.2 使用注意事项
- 数组是多个相同类型数据的组合，实现对这些数据的统一管理
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
- 数组创建后，如果没有赋值，有默认值int-->0，short-->0，byte-->0，long-->0，float-->0.0，double-->0.0，char-->\u0000，boolean-->false，String-->null
- 数组的下标是从0开始的
- 数组下标必须在指定范围内使用，否则报：下标越界异常
- 数组属引用类型，数组型数据是对象(object)
案例1：求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标
public class Array02 {
public static void main(String[] args) {
//求出一个数组 int[]的最大值 {4,-1,9,25,10,23}，并得到对应的下标
int[] arr = {4,-1,9,25,10,23};
int maxLength = 0;
for (int i = 1; i < arr.length; i++) {
if (arr[i] > arr[maxLength]){
maxLength = i;
}
}
System.out.println("最大的值是" + arr[maxLength]);
System.out.println("对应的下标是" + maxLength);
}
}
2、数组的常见操作
2.1 数组拷贝
如果想拷贝数组，而且可以直接使用相互之前不影响，下面这种方式是不对的：
public class Array03 {
public static void main(String[] args) {
int[] arr1 = {1,2,3,4,5};
int[] arr2 = arr1;
System.out.println(Arrays.toString(arr2));
}
}
因为这样只拷贝了一个地址，任何一方对其进行操作都会造成对另一引用的影响，所以要逐一拷贝里面的值。
public class Array03 {
public static void main(String[] args) {
int[] arr1 = {1,2,3,4,5};
int[] arr2 = new int[arr1.length];
for (int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
arr1[1] = 3;
System.out.println(Arrays.toString(arr2));
System.out.println(Arrays.toString(arr1));
}
}
这里我们可以简单的看一下Arrays.toString()源码：
public static String toString(int[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
先判断数组的值是不是null，或者数组是不是为空，也就是"[]"这样。如果都不是，就用StringBuilder去创建一个String参数，随着i逐渐增加会接近a.length - 1，也就是数组最大下标，这样据把全部数组打印出来return回去了。
2.2 数组反转
把数组元素调换一个位置：
public class Array04 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
for (int i = 0; i < arr.length/2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - i - 1] = temp;
}
System.out.println(Arrays.toString(arr));
}
}
2.3 数组扩容
😎（难点）实例如下，好好看：
public class ArrayIncrease {
public static void main(String[] args) {
//动态添加数组的功能
Scanner scanner = new Scanner(System.in);
int[] arr = {1,2,3};
do {
int[] newArr = new int[arr.length + 1];
for (int i = 0; i < arr.length; i++) {
newArr[i] = arr[i];
}
System.out.println("输入你要添加的元素");
int addNum = scanner.nextInt();
newArr[newArr.length - 1] = addNum;
arr = newArr;
System.out.println("数组扩容后:" + Arrays.toString(arr));
System.out.println("是否继续添加元素y/n?");
char key = scanner.next().charAt(0);
if (key == 'n'){
break;
}
}while (true);
System.out.println("退出");
}
}
2.4 冒泡排序
代码如下：
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {10,20,4,8,1,30,15,9}; //8
for (int i = arr.length - 1; i > 0; i--) {
for(int j = 0;j < i;j++){
if (arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
2.5 二分法查找
二分法查找的要求：数组必须是有序的。
二分法查找就是不断通过找中间值和比较，排除一部分值，如果是顺序查找需要和所有的值进行比较，而二分法则减少了比较次数。
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1,2,4,6,9,15,26,27,29,30,40,66,104,150};
System.out.println(binarySearch(arr, 9));
}
/**
* 二分法查找方法
* @param arr 要查找的数组
* @param target 目标
* @return 返回索引下标
*/
private static int binarySearch(int[] arr,int target){
int begin = 0;
int end = arr.length - 1;
int middle;
while(begin <= end){
middle = (begin + end)/2;
if (arr[middle] == target){
return middle;
}else if(arr[middle] > target){
end = middle - 1;
}else {
begin = middle + 1;
}
}
return -1;
}
}
3、二维数组
一维数组，每个元素是一个值，而二维数组每一个元素是一个二维数组。
它的初始化也是有动态初始化和静态初始化两种方式：
- 动态初始化方式1：
int[][] a = new int[2][3]; - 动态初始化方式2：
int[][] a; a = new int[2][3]; - 静态初始化方式：
int[][] a = {1,2},{2,3},{3,4};
public class TwoDimensionArray {
public static void main(String[] args) {
//动态初始化1
int[][] arr1 = new int[10][10];
//动态初始化2
int[][] arr2;
arr2 = new int[6][6];
//静态初始化
int[][] arr3 = {{10,20},{20,30}};
//遍历
for (int i = 0; i < arr3.length; i++) {
for (int j = 0; j < arr3[i].length; j++) {
System.out.print(arr3[i][j] + " ");
}
System.out.println();
}
}
}
