Java数组训练综合案例（为数组自定义方法）

Java基础知识思维导图
实时更新，有问题的地方欢迎各位指正。

数组的基本操作

功能实现:1.完成在数组中插入新值的操作
1.1 给定一个长度为5的整数数组并完成遍历操作。

public class Test1{
	public static void main(String[] args){
		int[] nums=new int[5];
		nums[0]=11;
		nums[1]=22;
		nums[2]=11;
		nums[3]=11;
		for(int i=0;i<nums.length;i++){
			System.out.print(nums[i]+"\t");
		}
	}
}

1.2 数组的遍历会使用到多次，定义一个print()函数，遍历数组。

public class Test1{
	public static void main(String[] args){
		int[] nums=new int[5];
		nums[0]=11;
		nums[1]=22;
		nums[2]=11;
		nums[3]=11;
		print();
		
	}
	public static void print(){
		for(int i=0;i<nums.length;i++){
			System.out.print(nums[i]+"\t");
		}
			System.out.println();
	}
}

但若如此写，便会出现一个问题，print函数中并没有定义nums数组，考虑到nums数组在后面定义的其他函数中也会用到，若用函数传值后面每个函数都需要传。则将nums数组定义改为全局变量。

public class Test1{
	static int[] nums=new int[5];
	public static void main(String[] args){
		nums[0]=11;
		nums[1]=22;
		nums[2]=11;
		nums[3]=11;
		print();
		
	}
	public static void print(){
		for(int i=0;i<nums.length;i++){
			System.out.print(nums[i]+"\t");
		}
			System.out.println();
	}
}

1.3在数组中插入整数，将添加的数值赋值给0；

public class Test1{
	static int[] nums=new int[5];
	public static void main(String[] args){
		nums[0]=11;
		nums[1]=22;
		nums[2]=11;
		nums[3]=11;
		print();
		insert(3);
		
	}
	public static  void insert(int value){
		for(int i=0;i<nums.length;i++){
			if(nums[i]==0){
			    nums[i]=value;
				break;
			}	
		}
	}
	public static void print(){
		for(int i=0;i<nums.length;i++){
			System.out.print(nums[i]+"\t");
		}
			System.out.println();
	}
}

1.4 但若数组中本存在0，则达不到需求。此时添加size用来记录有效数字的个数，当存入数据时便+1。同样定义为全局变量。由于插入数字不一定插入在数组的最后，可以在有效数值前插入数字，插入数值的地方的后面的数字往后移动一位，直至移动到插入的位置为止。

public class Test1{
	static int[] nums=new int[5];
	static int size=4;
	public static void main(String[] args){
		nums[0]=11;
		nums[1]=22;
		nums[2]=11;
		nums[3]=11;
		print();
		insert(2,99);
		print();
	}
	public static  void insert(int position,int value){
		for(int i=size;i>position;i--){
				nums[i]=nums[i-1];
		}
		nums[position]=value;
		size++;
	}
	public static void print(){
		for(int i=0;i<nums.length;i++){
			System.out.print(nums[i]+"\t");
		}
		System.out.println();
	}
}

1.5 插入数前考虑数组是否已经装满，插入的位置是否超过有效值范围。

public class Test1{
	static int[] nums=new int[5];
	static int size=4;
	public static void main(String[] args){
		nums[0]=11;
		nums[1]=22;
		nums[2]=11;
		nums[3]=11;
		print();
		insert(2,99);
		print();
	}
	public static  void insert(int position,int value){
		if(size==nums.length){//判断数组能否装满插入的数据
			expand();
		}
		if(position <0||position>size){//判断position有效下标，插入的位置为有效值前
			System.out.println("非法位置，请稍后重试！");
		}
		for(int i=size;i>position;i--){
				nums[i]=nums[i-1];
		}
		nums[position]=value;
		size++;
	}
	public static void expand(){
		
	}
	public static void print(){
		for(int i=0;i<nums.length;i++){
			System.out.print(nums[i]+"\t");
		}
		System.out.println();
	}
}

1.6 当数组已经装满数据后，再想添加则需要扩容。

public class Test1{
	static int[] nums=new int[5];
	static int size=4;
	public static void main(String[] args){
		nums[0]=11;
		nums[1]=22;
		nums[2]=11;
		nums[3]=11;
		print();
		insert(2,99);
		print();
	}
	public static  void insert(int position,int value){
		if(size==nums.length){//判断数组能否装满插入的数据
			expand();
		}
		if(position <0||position>size){//判断position有效下标，插入的位置为有效值前
			System.out.println("非法位置，请稍后重试！");
		}
		for(int i=size;i>position;i--){
				nums[i]=nums[i-1];
		}
		nums[position]=value;
		size++;
	}
	public static void expand(){
		int[] newsNums=new int[nums.length*2];
		System.arraycopy(nums,0,newsNums,0,nums.length);
		//替换nums中的地址，让它指向新数组()
		nums=newsNums;
	}
	public static void print(){
		for(int i=0;i<nums.length;i++){
			System.out.print(nums[i]+"\t");
		}
		System.out.println();
	}
}

1.7 将给定的数组利用insert()添加数值。注意此时的全局变量的值初始化为0。

public class Test1{
	static int[] nums=new int[5];
	static int size=0;
	public static void main(String[] args){
		insert(0,11);
		insert(1,44);
		insert(2,44);
		insert(3,44);
		print();
		insert(2,99);
		print();
	}
	public static  void insert(int position,int value){
		if(size==nums.length){//判断数组能否装满插入的数据
			expand();
		}
		if(position <0||position>size){//判断position有效下标，插入的位置为有效值前
			System.out.println("非法位置，请稍后重试！");
		}
		for(int i=size;i>position;i--){
				nums[i]=nums[i-1];
		}
		nums[position]=value;
		size++;
	}
	public static void expand(){
		int[] newsNums=new int[nums.length*2];
		System.arraycopy(nums,0,newsNums,0,nums.length);
		//替换nums中的地址，让它指向新数组()
		nums=newsNums;
	}
	public static void print(){
		for(int i=0;i<nums.length;i++){
			System.out.print(nums[i]+"\t");
		}
		System.out.println();
	}
}

1.8 判断插入的位置是否和要求，在其余方法中也会使用为此我们添加个check()函数。用boolean类型接收。

public class Test1{
	static int[] nums=new int[5];
	static int size=0;
	public static void main(String[] args){
		insert(0,11);
		insert(1,44);
		insert(2,44);
		insert(3,44);
		print();
		insert(2,99);
		print();
		insert(41,123);
		print();
	}
	public static  void insert(int position,int value){
		if(size==nums.length){//判断数组能否装满插入的数据
			expand();
		}
		Boolean flag=check(position);
		if(flag==false){
			return;
		}
		for(int i=size;i>position;i--){
				nums[i]=nums[i-1];
		}
		nums[position]=value;
		size++;
	}
	public static void expand(){
		int[] newsNums=new int[nums.length*2];
		System.arraycopy(nums,0,newsNums,0,nums.length);
		//替换nums中的地址，让它指向新数组()
		nums=newsNums;
	}
	public static void print(){
		for(int i=0;i<nums.length;i++){
			System.out.print(nums[i]+"\t");
		}
		System.out.println();
	}
	public static boolean check(int position){
		if(position <0||position>size){//判断position有效下标，插入的位置为有效值前
			System.out.println("非法位置，请稍后重试！");
			return false;
		}
			return true;
	}
}

1.9 此时的打印结果没有用到的数组空间会输出0，则将打印结果只输出有效值。

public static void print(){
		for(int i=0;i<size;i++){
			System.out.print(nums[i]+"\t");
		}
		System.out.println();
	}

2.完成删除数组中数值的功能：
2.1 需要判断删除的数值是否合理
2.2 删除的依据是将后一位向前提，从删除数据的位置开始，将后一位向前赋值，直到有效值处，但是需要-1。因为每次都是后一位向前赋值，到最后位时候，它的后为超过范围。

public static void delete(int position){
		Boolean flag=check(position);
		if(flag==true){
		for(int i=position;i<size-1;i++){
			nums[position]=nums[position+1];
		}
		size--;
		}

2.3 整合后代码为：

public class Test1{
	static int[] nums=new int[5];
	static int size=0;
	public static void main(String[] args){
		insert(0,11);
		insert(1,44);
		insert(2,44);
		insert(3,44);
		print();
		insert(2,99);
		print();
		insert(41,123);
		print();
		insert(5,123);
		print();
		delete(4);
		print();
	}
	public static  void insert(int position,int value){
		if(size==nums.length){//判断数组能否装满插入的数据
			expand();
		}
		Boolean flag=check(position);
		if(flag==false){
			return;
		}
		for(int i=size;i>position;i--){
				nums[i]=nums[i-1];
		}
		nums[position]=value;
		size++;
	}
	public static void delete(int position){
		Boolean flag=check(position);
		if(flag==true){
		for(int i=position;i<size-1;i++){
			nums[position]=nums[position+1];
		}
		size--;
		}
	}
	public static void expand(){
		int[] newsNums=new int[nums.length*2];
		System.arraycopy(nums,0,newsNums,0,nums.length);
		//替换nums中的地址，让它指向新数组()
		nums=newsNums;
	}
	public static void print(){
		for(int i=0;i<size;i++){
			System.out.print(nums[i]+"\t");
		}
		System.out.println();
	}
	public static boolean check(int position){
		if(position <0||position>size){//判断position有效下标，插入的位置为有效值前
			System.out.println("非法位置，请稍后重试！");
			return false;
		}
			return true;
	}
}

3.完成替换数组中数值的功能：

public static void replace(int position,int value){
		Boolean flag=check(position);
		nums[position]=value;
	}

4.完成数组内的数值查询功能：

public static int  search(int position){
		Boolean flag=check(position);
		return nums[position];
	}

5.整合最终代码：

public class Test1{
	static int[] nums=new int[5];
	static int size=0;
	public static void main(String[] args){
		insert(0,11);
		insert(1,44);
		insert(2,44);
		insert(3,44);
		print();
		insert(2,99);
		print();
		insert(41,123);
		print();
		insert(5,123);
		print();
		delete(4);
		print();
		replace(4,520);
		print();
		int target=search(4);
		System.out.println("您查询的下标位置，对应的值是:"+target);
		print();
	}
	public static int  search(int position){
		Boolean flag=check(position);
		return nums[position];
	}
	public static void replace(int position,int value){
		Boolean flag=check(position);
		nums[position]=value;
	}
	public static  void insert(int position,int value){
		if(size==nums.length){//判断数组能否装满插入的数据
			expand();
		}
		Boolean flag=check(position);
		if(flag==false){
			return;
		}
		for(int i=size;i>position;i--){
				nums[i]=nums[i-1];
		}
		nums[position]=value;
		size++;
	}
	public static void delete(int position){
		Boolean flag=check(position);
		if(flag==true){
		for(int i=position;i<size-1;i++){
			nums[position]=nums[position+1];
		}
		size--;
		}
	}
	public static void expand(){
		int[] newsNums=new int[nums.length*2];
		System.arraycopy(nums,0,newsNums,0,nums.length);
		//替换nums中的地址，让它指向新数组()
		nums=newsNums;
	}
	public static void print(){
		for(int i=0;i<size;i++){
			System.out.print(nums[i]+"\t");
		}
		System.out.println();
	}
	public static boolean check(int position){
		if(position <0||position>size){//判断position有效下标，插入的位置为有效值前
			System.out.println("非法位置，请稍后重试！");
			return false;
		}
			return true;
	}
}