数组的增删改查、排序、去重、扩容

增删改查

public class arrayOperator
{
	//准备工作，创建数组
	public static int[] arrs;
	public static int currentlength;
	

	//构造函数初始化
	private  arrayOperator(int length)
	{
		arrs=new int[length];
	}
	
	public static arrayOperator getArray(int length )
	{
		return new arrayOperator(length) ;
	}
   
	
	//1、按位插入数据
	public void insert(int index,int value)
	{
		if(index<0||index>arrs.length)
			System.out.println("下标越界异常");
		else
		{
			for(int j=currentlength;j>index;j--)
			{
				arrs[j]=arrs[j-1];
			}
			arrs[index]=value;
			currentlength++;
		}
	}
	
	//2、按值查找
	public int searchValue(int value)
	{
		int i;
		for(i=0;i<arrs.length;i++)
		{
			if(value==arrs[i])
				break;
		}
		System.out.println("下标为"+i);
		return i;
	}
	
	//3、按下标查找
	public int searchIndex(int index)
	{
		int i =0;
		if(index<0||index>arrs.length)
			System.out.println("下标越界异常");
		else {	
		for(i=0;i<arrs.length;i++)
		{
			if(index==i)
				break;
		}
		}
		System.out.println("值为："+arrs[i]);
		return arrs[i];
	}
	
	//4、删除数据
	public void delete(int index)
	{
		if(searchIndex(index)==-1)
			System.out.println("数组内无指定数据");
		else {
			for(int i=0;i<currentlength;i++)
			{
				arrs[currentlength-1]=arrs[currentlength];
			}
			currentlength--;
		}
	}
	
	//5、更新数据
	public void updata (int oldValue,int newValue)
	{
		if(searchValue(oldValue)==-1)
			System.out.println("数组内无指定数据");
		else {
		arrs[searchValue(oldValue)]=newValue;
		
		}
	}
	
	//数组遍历

		public void show() {
		for (int i = 0; i < arrs.length; i++) {
		System.out.print("数组为："+arrs[i]+" ");

		}

		System.out.println();

		}
	
		public static void main(String []args) {
			
		 arrayOperator array = arrayOperator.getArray(6);
			
			array.insert(0,2);
			array.updata(2, 3);
			array.searchIndex(0);	
			System.out.println("长度"+array.currentlength);
		
			array.show();

		}	
}

数组排序和去重

public class capacity
{//从小到大排序
	public static void sort(int[] as)
	{
		int temp=0;
		//第一次排序，每遍历一个下标，就会和第二次遍历结合，确定一个下标的值
		for(int i=0;i<as.length;i++)
		{
			//从后往前遍历。就j>i：因为i之前的值已经排好
			for(int j=as.length-1;j>i;j--)
			{
				if(as[j]<as[j-1]) {
				temp=as[j-1];
				as[j-1]=as[j];
				as[j]=temp;
				}
			}
			
		}
		for(int i=0;i<as.length;i++)
		{
			System.out.println(as[i]);
		}
	}
	public static void one(int[] as)
	{//临时数组，用来存放不重复的元素
		int[] target=new int [as.length];
		
		int i=0;
		int t=0;
		for(i=0;i<as.length;i++)
		{
			boolean isTrue = true;
			for(int j=i+1;j<as.length;j++)
			{
				if(as[j]==as[i])
				{
					isTrue=false;
					break;
				}
			}
			
			if(isTrue)
			{
				target[t]=as[i];
				t++;
				
			}
			
		}
		System.out.println(t);
		int[] newArry=new int[t];
		System.arraycopy(target, 0, newArry, 0, t);;
		
		for(int n=0;n<newArry.length;n++)
		{
			System.out.println(newArry[n]);
		}
	}
	
	public static void main(String[] args)
	{
		int[] as= {3,22,5,66,66,2,9,1};
		capacity.sort(as);
		//capacity.one(as);
		
		

	}

}

数组扩容

public class capacity
{
	public static void main(String[] args) {
	//原数组
	int[] arr1={1,3,4,6,2};
	//新数组
	int[] arr2=new int[(int) (arr1.length*1.5)];//确定新长度
	//数组的复制(原数组,复制原数组的开始下标,目标数组,粘贴的开始下标,复制数组的长度)
	System.arraycopy(arr1,0,arr2,0,arr1.length);
	//将原数组的引用指向新数组。
	arr1=arr2;
	System.out.println(Arrays.toString(arr1));
	} 
}