数组小结

   数组是一种在内存中连续分布的数据结构，很方便存储和取出。

   java中一维数组定义几种格式如下：（直接赋值时就不能规定长度）

 

1.数据类型 [] 数组名 = {值,....};
2.数据类型 [] 数组名 = new 数据类型[长度];
3.数据类型 [] 数组名;
   数组名 = new 数据类型[长度];
4.数据类型 [] 数组名;
   数组名 = new 数据类型[]{值,...};

 类似的，二维数组格式如下：

1.数据类型 [][] 数组名 = {{值,....},...};
2.数据类型 [][] 数组名 = new 数据类型[行][列];
3.数据类型 [][] 数组名;
数组名 = new 数据类型[行][列];
4.数据类型 [][] 数组名;
数组名 = new 数据类型[][]{{值,...},...};

 

我们可以用一些算法对数据进行排序，常见的几种算法原理和代码如下：

	//冒泡法从小到大排列:首先将第一个元素与后面所有元素比较，
	//若第一个元素小则互换元素，这样就把最小的元素放在第一个位置，
	//后面第n个位置依次方法可获取到倒数第n小的元素
	public int [] maopao(int array[]){
		System.out.print("冒泡排序（从小到大）：  ");
		for(int i=0;i<array.length;i++){
			for(int j=i+1;j<array.length;j++){
				int temp;				
				if(array[i]>array[j]){
					//互换两位置元素
					temp=array[j];
					array[j]=array[i];
					array[i]=temp;
				}
			}
		}
		
		return array;
		
	}
	
	//选择排序从大到小排序：找出元素中的最大值与第一个元素互换，倒数第二大的元素
	//与第二个元素互换，依次下去
	public int [] xuanze(int array[]){
		System.out.print("选择排序（从大到小）：  ");
		for(int i=0;i<array.length;i++){
			int max=array[i];
			int num=i;
			for(int j=i+1;j<array.length;j++){				
				if(array[j]>max){
					max=array[j];
					num=j;
				}
			}
			array[num]=array[i];
			array[i]=max;
			
		}
			return array;
	}
	
	//插入排序：即在一个已知有序排列的数字中，依次插入每个数字
	//可以先把第一个数字和第二个数字先排成有序的，后面的数字依次插入；
	//以下方法从小到大；
	public int [] charu(int array[]){
		System.out.print("插入排序（从小到大）：  ");
		//数组长度小于2时
		if(array.length<2){
			return array;
		}
		//先将前面两个数据排好序
		else if(array[0]>array[1]){//
			int temp=array[0];
			array[0]=array[1];
			array[1]=temp;
		}
		//后面的依次插入
		for(int i=2;i<array.length;i++){
			int tem=array[i];
			//插入的数字比第一个数字小时
			if(tem<array[0]){
				for(int k=i;k>0;k--){
					 array[k]=array[k-1];
				 }
				array[0]=tem;
			}
			else {
				//插入的数字比最后一个数字大时
				if(tem>array[i-1]){			
					array[i]=tem;
				}
				else {
					////插入的数字处于中间位置
					for(int j=0;j<i;j++){				
						if(tem>=array[j]&&tem<=array[j+1]){
							//把第j+1之后的数字往后推一位
							for(int k=i;k>j+1;k--){
								 array[k]=array[k-1];
							 }
							 array[j+1]=tem;
							 break;
						}
					}
					
				}
				
			}
			
		}
		
		return array;
		
	}
	
	//希尔排序： 设定一定间距增量gap，每gap个抽出来排序,
	//然后减小gap，再按gap抽出数据排序，直到gap为1位置
	public int [] hill(int array []){
		System.out.print("希尔排序（从大到小）：  ");
		int length=array.length ;
		for(int gap=length/2;gap>0;gap=gap/2){
			int flag;
			do{//直到相应gap间距的数字已排好序，flag不为1结束
				
				flag=0;
			for(int i=0;i<length-gap;i++){
				int j=i+gap;
				int temp;
							
					if(array[j]>array[i]){
						temp=array[j];
						array[j]=array[i];
						array[i]=temp;
						flag=1;
					}
			
			}
			}while(flag==1);
		}
		return array;
	}

  

我们可i以创建一个动态数组（自定义队列），就可以弥补数组一旦定义长度固定不能改变的缺点。

其中用到了泛型，可以使动态数组只能添加指定数据类型。

以下是自定义队列接口：

//E就表示泛型，泛型实际上表示的是泛指Java中任意的一种数据类型，
//如果指定了对应的数据类型，那么就只能存储该种数据类型的数据
public interface Mylist<E> {
	public void  add(E e);
	public void  add(E e,int index);
	public boolean remove(int index);
	public boolean remove(E e);	
	public Object get(int index);
	public int size();
	
}

 

然后定义一个接口类，实现方法：

//自定义队列接口类
public class MyListImp<E> implements Mylist<E>{

	//定义一个属性，用来存储元素的总数
	private int size=0;
	//定义一个属性，用来存储数据的数组
	private Object array [];
	
	public MyListImp(){
		array = new Object[0];
	}	
		
	@Override//在动态数组后添加一个对象
	public void add(E e) {
		Object temp []=new Object[array.length +1];
		for(int i=0;i<array.length;i++){
			temp[i]=array[i];
		}
		temp[array.length]=e;
		size++;
		array=temp;
		
	}
		
	
//在指定索引位置添加对象
	public void add(E e, int index) {
		// TODO Auto-generated method stub
		
			Object [] temp = new Object [size+1];
			for(int i=0;i<index;i++){
				temp[i]=array[i];
			}
			for(int i= index;i<size;i++){
				temp[i+1]=array[i];
			}
			size++;
			temp[index]=e;
			array=temp;
	
	}

	//移除索引位置的对象
	public boolean remove(int index) {
		// TODO Auto-generated method stub
		System.out.println(size);
		Object [] temp = new Object [size-1];
		if(index<0||index>=size)
			return false;
		else {
			for(int i=0;i<index;i++){
				temp[i]=array[i];
			}
			for(int i= index+1;i<size;i++){
				temp[i-1]=array[i];
			}	
			size--;
			array=temp;
			
			return true;		
		}
		
		
			}

//移除某个对象
	public boolean remove(E e) {
		// TODO Auto-generated method stub
		for(int i=0;i<size;i++){
			if(this.get(i).equals(e)){
				//这里调用了移除索引位置方法
				this.remove(i);
				return true;				
			}
		}
		
		return false;
		
	}

	//得到索引位置所在对象
	public Object get(int index) {
		// TODO Auto-generated method stub	
		if(index<0||index>=size){
			return null;
		}
		return array[index];
	}

	//得到动态数组的元素个数，即长度
	public int size() {
		// TODO Auto-generated method stub
		size=array.length ;
		return size;
	}
	
	
	
}

 

 

 编程基础不太好，如有概念等错误欢迎指导！