数组的相关基础知识

一、数组的说明及初始化

1.含义

存储多个数据的集合

2.相关概念：

元素：数组里的数据

下标/索引：每个数据对应的编号，从0开始

3.初始化

静态初始化：

初始化数组时，元素由程序员指定，长度由系统根据元素个数开辟内存空间

动态初始化：

初始化数组时，长度有程序员指定，元素由系统根据元素类型默认初始化数据

​ 整数类型：0
​ 浮点类型：0.0
​ 字符类型：’ ’
​ 布尔类型：false
​ 引用类型：null - 空

注意：

1.不管数组里存的是什么类型，数组都是引用数据类型

2.数组一旦初始化后，数组在内存中开辟的空间就决定了（数组长度不能改变-不能扩容、不能删除）

3.下标超出了界限，会报数组下标越界异常 - ArrayIndexOutOfBoundsException

4.names叫做引用，该引用存的是数组在堆内存中开辟空间的地址

5.new关键字指的是在堆内存中开辟空间

静态初始化 vs 动态初始化

​ 静态初始化:一开始就知道数据
​ 动态初始化:一开始不知道数据，只知道长度

静态初始化1：

//String[] names = new String[]{"小明","小红","阿华","阿花","小黄"};

静态初始化2：先声明，再初始化

String[] names;
names = new String[]{"小明","小红","阿华","阿花","小黄"};

静态初始化3：

String[] names = {"小明","小红","阿华","阿花","小黄"};

静态初始化案例：

		String[] names = {"小明","小红","阿华","阿花","小黄"};
		//设置指定下标上的元素
		names[2] = "阿豪";
		//获取指定下标上的元素
		System.out.println(names[2]);
		System.out.println("获取数组元素的个数：" + names.length);//5
		System.out.println("-----------------");
		//遍历 - for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		System.out.println("-----------------");
		//遍历 - 增强for循环 foreach
		for(String str : names){//循环，依次取出数组中的元素，并赋值给str变量
			System.out.println(str);
		}
		/**
			for vs foreach
			
			如果要是用到下标，就是用for循环
			如果不用到下标，就是用foreach
		*/
	}

数组求和，取最大值的案例实现：

int[] is = new int[]{1,2,3,4,5,6,7,8,9};
		int max = is[0];
		int sum = max;
		for(int i = 1;i<is.length;i++){
			if(max < is[i]){
				max = is[i];
			}
			sum += is[i];
		}
		System.out.println("最大值为：" + max);
		System.out.println("总和为：" + sum);
	}

动态初始化1

String[] names = new String[5];//5-代表长度

动态初始化2

String[] names;
names = new String[5];//5-代表长度

动态初始化案例：

String[] names;
names = new String[5];//5-代表长度
		//设置指定下标上的元素
		names[0] = "啊亮";
		names[1] = "啊洲";
		names[2] = "阿豪";
		names[3] = "啊江";
		names[4] = "啊军";
		//获取指定下标上的元素
		System.out.println(names[2]);
		System.out.println("获取数组元素的个数：" + names.length);//5
		System.out.println("-----------------");
		//遍历 - for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		System.out.println("-----------------");
		//遍历 - 增强for循环 foreach
		for(String str : names){//循环，依次取出数组中的元素，并赋值给str变量
			System.out.println(str);
		}

二、数组的排序

1.冒泡排序

代码实现：

int[] is = {8,21,15,81,69,4};
		//冒泡排序部分
		for(int i = 0;i<is.length-1;i++){
			for(int j = 0;j<is.length-1-i;j++){
				if(is[j] > is[j+1]){
					int temp = is[j];
					is[j] = is[j+1];
					is[j+1] = temp;
				}
			}
		}
		//打印输出
		for(int num:is){
			System.out.println(num);
		}

2.Arrays.sort()导包排序

三、数组的查找

1.顺序查找

案例：

int[] is = {8,21,15,81,69,4};
		int num = 21;
for(int i = 0;i<is.length;i++){
					if(is[i] == num){
						System.out.println("找到该数值了");
						break;
					}
				}

2.二分法查找

注意：使用二分法的前提是必须排序

案例代码：

int[] is = {8,21,15,81,69,4};
		int num = 85;
		Arrays.sort(is);//排序: 4 8 15 21 69 81
		int start = 0;
		int end = is.length-1;
		while(start <= end){
			int mid = (start + end)/2;
			if(is[mid] < num){
				start = mid+1;
			}else if(is[mid] > num){
				end = mid-1;
			}else{
				System.out.println("找到该数值了");
				break;
			}	
		}

四、数组的复制

方法1.

	String[] ss1 = {"啊希","啊空","啊玲"};
		String[] ss2 = ss1;
		ss1[1] = "阿豪";
		for(String name : ss2){
			System.out.println(name);
		}	

可以看到，在重新给ss1数组赋值后，输出的ss2数组也发生了改变，影响了ss2，故复制数组一般不用此方法。

方法2：

String[] ss1 = {"小李","小杨","小玲"};
String[] ss2 = new String[ss1.length];
		for(int i = 0;i<ss1.length;i++){
			ss2[i] = ss1[i];
		}
		ss1[1] = "阿豪";
		for(String name : ss2){
			System.out.println(name);
		}

运行该案例后，可以看到，ss1数组的赋值，并不会影响复制后的ss2数组。

五、数组的扩容

扩容代码实现：

String[] ss1 = {"麻生","椎名","北岛"};
		//null null null null null null
		String[] ss2 = new String[ss1.length*2];//原来数组长度的两倍
		//数据的复制
		//"麻生"	"椎名"	"北岛" null null null
		for(int i = 0;i<ss1.length;i++){
			ss2[i] = ss1[i];
		}
	   //引用赋值
		ss1 = ss2;
		for(String name:ss1){
			System.out.println(name);
		}

扩容后，由于该案例扩容了2倍，后面的3位内存中值位null。

六、数组的删除

案例，删除数组的阿伟

String[] ss1 = {"阿豪","阿伟","麻生","椎名","北岛"};
		
		String[] ss2 = new String[ss1.length-1];
		
		int index = 0;
		for(String name:ss1){
			if(!name.equals("阿伟")){
				ss2[index++] = name;
			}
		}
		
		ss1 = ss2;
			
		for(String name : ss1){
			System.out.println(name);
		}

方法2实现代码如下：

String[] ss1 = {"阿豪","阿伟","麻生","椎名","北岛"};
		for(int i = 1;i<ss1.length-1;i++){
			ss1[i] = ss1[i+1];
		}
		ss1[ss1.length-1] = null;
		for(String name : ss1){
			System.out.println(name);
		}
	}
}

删除时，将要删除的数组数据删除后，直接将后面的所有代码前移，故删除一个后，最后一个内存用null补位。

七、数组参数和返回值

数组的参数示例

public static void method1(int[] is){
	}

数组的返回值

代码示例

public static int[] method02(){
		int[] is = {1,2,3};
		return is;
	} 

八、可变参数

注意：

可变参数的本质是数组

可变参数后不能加其他参数

应用示例：

public static void main(String[] args){
	int num = add(1,2,3,4,5,6,7,8,9);//把数据压入到数组中
		System.out.println(num);
	}
public static int add(int... is){//int... is --> 可变参数
		int sum = 0;
		for(int i = 0;i<is.length;i++){
			sum += is[i];
		}
		return sum;
	}

九、main参数的问题

public static void main(String[] args){
    for(String str : args){
			System.out.println(str);
		}
	}

该代码没有输出结果

但是在运行时 java Test13 小红 小绿 小黄
把这3个字符串压入到args的数组中

可以在运行结果中看到输出了3个输入的字符串

十、Arrays工具类

Arrays工具类：操作数组的类

工具类：该类里的方法都是静态的，直接用类名调用

int[] is = {8,21,15,81,69,4};
		//排序
		Arrays.sort(is);
		//Arrays.sort(is,1,4);//(目标数组,开始下标-包含,结束下标-不包含)
		//查找(查找之前一定要排序)
		//返回值：搜索键的索引，如果它包含在数组中; 否则， (-(插入点) - 1) 。 
		int index = Arrays.binarySearch(is,20);
		System.out.println("下标为：" + index);
		//替换
		Arrays.fill(is,888);
		Arrays.fill(is,1,4,666);//(目标数组,开始下标-包含,结束下标-不包含,替换的数据)
		//把数组转换为字符串
		System.out.println(Arrays.toString(is));
		//拷贝数组(目标数组,新的长度)
		int[] newIs1 = Arrays.copyOf(is,10);
		System.out.println(Arrays.toString(newIs1));
		//拷贝数组(目标数组,开始下标-包含,结束下标-不包含)
		int[] newIs2 = Arrays.copyOfRange(is,1,4);
		System.out.println(Arrays.toString(newIs2));