java的一维数组（数组的复制、扩容、删除）数组的参数

数组

一维数组

1、概念：一组数据的容器（数组可以存放多个数据）

​ 注意：
​ 1.数组是引用数据类型
​ 2.数组中的数据又叫做元素
​ 3.每个元素都有编号叫做下标/索引
​ 4.下标从0开始
​ 5.数组初始化后，会在内存中开辟一连串连续的空间
​ 6.数组一旦初始化后长度不可以改变（数组没有扩容和删除）
​ 7.数组的操作：添加、修改、查询
​

​ 数组的声明：数据类型[] 数组名;

public class Test09{

	public static void main(String[] args){
		/**
		静态初始化1
		String[] names = new String[]{"aaa","bbb","ccc","ddd","eee"};
		
		静态初始化2
		String[] names;
		names = new String[]{"aaa","bbb","ccc","ddd","eee"};
		静态初始化3
		*/
		String[] names = {"aaa","bbb","ccc","ddd","eee"};
		
		//设置指定下标上的元素
		names[3] = "fff";
		
		//获取指定下标上的元素
		String n = names[3];
		System.out.println("获取指定下标上的元素：" + n);//fff
		
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//System.out.println(names[100]);
		
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		
		System.out.println("-----------");
		
		//遍历 - for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		
		System.out.println("-----------");
		
		//遍历 - foreach(增强for循环)
		for(String str:names){//遍历数组，依次把元素赋值给str
			System.out.println(str);
		}
		
		/**
			遍历时要使用到下标，就用for循环遍历
			遍历时要不使用到下标，就用foreach遍历	
		*/
	}
}

2、数组的初始化：

​ 静态初始化：数据由程序员指定，长度由系统分配
​ 动态初始化：长度由程序员指定，数据由系统分配(默认值)
​ 整数类型：0
​ 浮点类型：0.0
​ 字符类型：’ ’
​ 布尔类型：false
​ 引用类型：null(空)
​

​ 静态初始化 vs 动态初始化
​ 一开始就知道数据：静态初始化
​ 一开始就知道长度：动态初始化

public class Test10{
	
	public static void main(String[] args){
		
		//动态初始化1
		String[] names = new String[5];//5->5个长度
		
		//设置指定下标上的元素
	
		names[1] = "aaa";

		//获取指定下标上的元素
		String n = names[1];
		System.out.println("获取指定下标上的元素：" + n);//aaa
		
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		
		System.out.println("-----------");
		
		//遍历 - for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		
		System.out.println("-----------");
		
		//遍历 - foreach(增强for循环)
		for(String str:names){//遍历数组，依次把元素赋值给str
			System.out.println(str);
		}

	}
}

案例：

public class Test11{
	/**
		
		需求：定义一个10个长度的int数组，获取最大值
	*/
	public static void main(String[] args){
		
		int[] is = {3,2,4,35,34,5,25,34,32,18};
		
		int max = is[0];//假设数组中第0个下标位置的元素为最大值
		
		for(int i = 1;i<is.length;i++){
			if(max < is[i]){
				max = is[i];
			}
		}
		
		System.out.println("最大值为：" + max);
		
	}
}

3、数组的复制

方案一：

public class Test03{
	
	/**
		缺点：修改源数组，新数组的数据也随之改变
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"aaa","bbb","ccc","eee"};
		
		//新数组
		String[] newNames = names;
		
		//修改源数组
		names[0] = "ttt";
		
		//遍历新数组
		for(String name : newNames){
			System.out.println(name);
		}
	}
}

方案二：

public class Test04{
	
	/**
		知识点：数组的复制2
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"aaa","bbb","ccc","ddd"};
		
		//新数组
		String[] newNames = new String[names.length];
		
		//将源数组中数据依次赋值给新数组
		for(int i = 0;i<names.length;i++){
			newNames[i] = names[i];
		}
	
		//修改源数组
		names[0] = "ttt";
		
		//遍历新数组
		for(String name : newNames){
			System.out.println(name);
		}
	}
}

4、数组的扩容

public class Test05{
	
	/**
		知识点：数组的扩容
		
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"aaa","bbb","ccc","ddd"};
		
		//新数组
		int capacity = names.length + (names.length>>1);//新容量：是源数组长度的1.5倍
		String[] newNames = new String[capacity];
		
		//把源数组所有的数据迁移到新数组中
		for(int i = 0;i<names.length;i++){
			newNames[i] = names[i];
		}
		
		//将新数组的地址赋值给源数组
		names = newNames;
		
		//遍历源数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

5、数组的删除

方案一：

5、public class Test06{
	
	/**
		
		缺点：数组原本是存放数据的，删除元素后，数组长度变短
		
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"aaa","bbb","ccc","ddd"};
		
		//新数组
		String[] newNames = new String[names.length-1];
		
		//将源数组的数据迁移到新数组中，要删除的元素(bbb)除外
		int index = 0;//新数组的下标
		for(String name:names){
			if(!name.equals("bbb")){
				newNames[index] = name;
				index++;
			}
		}
		
		//将新数组的地址赋值给源数组
		names = newNames;
		
		//遍历源数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

方案二：

public class Test07{
	
	/**
		知识点：数组的删除2
		
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"aaa","bbb","ccc","ddd"};
		
		//数据的迁移（进行覆盖）
        //bbb<-ccc   ccc<-ddd   ddd<-null
		for(int i = 1;i<names.length-1;i++){//从第二个开始
			names[i] = names[i+1];
		}
		names[names.length-1] = null;
		
		//遍历源数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

6、数组的参数和返回值

public class Test08{
	
	/**
		知识点：数组的参数和返回值
		
		需求：设计一个方法，传入数组，返回最大值和最小值
	*/
	public static void main(String[] args){
		
		int[] is = {1,2,3,4,5,6};
		
		int[] newArr = method(is);
		System.out.println("最大值为：" + newArr[0]);
		System.out.println("最小值为：" + newArr[1]);
	}
	
	public static int[] method(int[] is){
		int max = is[0];
		int min = is[0];
		for(int i = 1;i<is.length;i++){
			if(max < is[i]){
				max = is[i];
			}
			if(min > is[i]){
				min = is[i];
			}
		}
		
		return new int[]{max,min};
	}
}

7、可变参数

public class Test09{
	
	/**
		知识点：可变参数
		注意：可变参数底层就是数组
		
		需求：设计一个方法，传入五个int值，求和
	*/
	public static void main(String[] args){
		
		int sum = add(1,2,3,4,5,6,7);//实参作为元素，压入到数组中
		System.out.println(sum);
	}
	
	//is就是数组
	public static int add(int... is){
		int sum = 0;
		for(int num : is){
			sum += num;
		}
		return sum;
	}
	
	//注意：可变参数后不能接其他参数
	public static void method(int a,String... ss){}
}