数组和面向对象数组

谁借莪１个温暖的怀抱￠ 2023-06-20 12:59 26阅读 0赞

##### 一、数组 #####

1.  数组的创建

//创建数组
    		int array[] = new int[3];

1.  为数组中的元素进行赋值

//为数组中的元素赋值
    		array[0] = 1;
    		array[1] = 2;
    		array[2] = 3;

1.  创建时为数组进行赋值

//创建一个数组并赋值
       	int array[] = new int[] {
        1,2,3};

1.  输出数组中的所有元素

System.out.println(Arrays.toString(目标数组));

1.  在数组后面添加新的元素

public class OpArrayTest {
            //数组元素的添加
    	public static void main(String[] args) {
        
    		
    		//创建一个数组并赋值
    		int array[] = new int[] {
        1,2,3};
    		System.out.println(Arrays.toString(array));
    		
    		//需要添加的数据
    		int dext = 4;
    		
    		//创建一个新的数组长度为原来数组的+1
    		int array1[] = new int[array.length+1];
    		
    		//将原来数组的元素赋值给新数组
    		for(int i=0;i<array.length;i++) {
        
    			array1[i] = array[i];
    		}
    		
    		//将新元素添加到新数组的最后
    		array1[array.length] = dext;
    		
    		//新数组替换原来的数组
    		array=array1;
    		System.out.println(Arrays.toString(array));
    	}

1.  删除数组中的元素

package shuzu;
    
    import java.util.Arrays;
    
    public class OpArrayTest2 {
             //数组元素的删除
    	public static void main(String[] args) {
        
    		
    		//创建一个数组并为其赋值
    		int array[] = new int[] {
        1,2,3,4,5};
    		System.out.println(Arrays.toString(array));
    		
    		//需要删除数组元素的下标
    		int dext = 2;
    		
    		//创建一个新数组长度为原理啊数组长度-1
    		int array1[] = new int[array.length-1];
    		
    		//赋值原来数组中的元素到新数组，除了需要删除的元素
    		for(int i=0;i<array1.length;i++) {
        
    			//判断
    			if(i<dext) {
        
    				array1[i] = array[i];
    			}else {
        
    				array1[i] = array[i+1];
    			}
    			
    		}
    		
    		//新数组替换原来的数组
    		array = array1;
    		System.out.println(Arrays.toString(array));
    	}
    
    }

##### 二、面向对象数组 #####

1.  创建工具类MyArray.java，封装操作数组的一些方法。

package shuzu.util;
    
    import java.util.Arrays;
    
    public class MyArray {
        
    	
    	//同于储存数据的数组
    	private int array[];
    	
    	public MyArray() {
        
    		array = new int[0];
    	}
    	
    	//获取数组的长度
    	public int size() {
        
    		return array.length;
    	}
    	
    	//打印输出数组
    	public void show() {
        
    		System.out.println(Arrays.toString(array));
    	}
    	
    	//往数组中添加元素
    	public void add(int dex) {
        
    		
    		//创建一个新数组，长度为原来数组长度+1
    		int array1[] = new int[array.length+1];
    		
    		//将原来数组中的元素复制到新数组中
    		for(int i=0;i<array.length;i++) {
        
    			array1[i] = array[i];
    		}
    		
    		//将新元素添加到新数组的后面
    		array1[array.length] = dex;
    		
    		//新数组替换原来的数组
    		array = array1;
    		
    	}
    	
    	//删除数组中的元素
    	public void delete(int dex) {
        
    		
    		//创建一个新的数组，长度为原理啊数组长度-1
    		int array1[] = new int[array.length-1];
    		
    		//将原来数组中的元素，除了要删除的元素之外都复制到新数组中
    		if(dex<0||dex>array.length-1) {
        
    			throw new RuntimeException("下标越界");
    		}
    		for(int i=0;i<array1.length;i++) {
        
    			if(i<dex) {
        
    				array1[i] = array[i];
    			}else {
        
    				array1[i] = array[i+1];
    			}
    		}
    		
    		//新数组替换原来的数组
    		array = array1;
    	}
    	
    	//插入一个元素到数组指定的位置
    	public void insert(int dex,int nex) {
            //dex:指定位置  nex:为需要插入的元素
    		
    		//创建一个新数组长度为原来数组长度+1
    		int array1[] = new int[array.length+1];
    		
    		//将原来数组中的元素复制到新数组中
    		if(dex<0||dex>array.length-1) {
        
    			throw new RuntimeException("下标越界");
    		}
    		for(int i=0;i<array.length;i++) {
        
    			//判断
    			if(i<dex) {
        
    				array1[i] = array[i];
    			}else {
        
    				array1[i+1] = array[i];
    			}
    			
    		}
    		
    		//将新元素插入
    		array1[dex]  = nex;
    		//新数组替代原来的数组
    		array = array1;
    		
    	}
    	
    	//替换指定位置的元素
    	public void set(int dex ,int nex) {
            //dex:要替换的元素下标   nex:替换的元素
    
    		//替换元素、
    		array[dex] = nex;
    		
    		
    		
    		
    	}
    
    }

1.  编写一个测试类来创建一个可变数组，并对数组进行添加，删除，替换，输出等操作。

package shuzu;
    
    import shuzu.util.MyArray;
    
    public class MyArrayTest {
        
    	public static void main(String[] args) {
        
    		
    		//创建一个可变数组
    		MyArray ma = new MyArray();
    		
    		//输出的数组
    		ma.show();
    		
    		//往数组中添加一个元素
    		ma.add(1);
    		ma.add(66);
    		ma.show();
    		
    		//删除数组中的某个元素
    		ma.add(2);
    		ma.show();
    		ma.add(3);
    		ma.add(4);
    		ma.add(5);
    		ma.show();
    		ma.delete(2);
    		ma.show();
    		
    		//在指定的位置添加元素
    		ma.insert(2, 8);
    		ma.show();
    		
    		//替换指定位置上的元素
    		ma.set(2, 11);
    		ma.show();
    	}
    
    }

1.  控制台效果如图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY0NjQ2Mw_size_16_color_FFFFFF_t_70]

##### 三、线性查找 #####

1.  创建目标数组，将目标元素和数组中的每一个元素作比较，如果相等就返回该元素的下标

package shuzu;
    
    public class SearchTest {
             //线性查找目标元素
    	public static void main(String[] ages) {
        
    		
    		//创建目标数组
    		int array[] = new int[] {
        1,3,2,9,6,8};
    		
    		//查找的目标元素
    		int dex = 8;
    		
    		//目标元素的下标
    		int nex = -1;
    		
    		for(int i=0;i<array.length;i++) {
        
    			if(array[i] == dex) {
        
    				nex = i;
    				break;
    			}
    		}
    		
    		//打印目标元素下标
    		System.out.println("目标元素的下标："+nex);
    	
    	}
    
    }

##### 四、二分查找 #####

1.  创建一个有序数组并为其赋值，记录开始，中间，结束的位置。循环每次会那中间元素和目标元素作比较，如果中间元素比目标元素大，就把结束位置变为中间元素的前一个元素的位置。如果中间元素比目标元素小，就把开始位置变为中甲元素的后一个元素的位置。

package shuzu;
    
    import java.util.Arrays;
    
    public class BinaryTest {
        
    	public static void main(String[] ages) {
        
    		
    		//创建目标数组
    		int array[] = new int[] {
        1,3,2,4,5,6,7,8,9};
    		Arrays.sort(array);
    		System.out.println(Arrays.toString(array));
    		
    		//目标元素
    		int nex = 7;
    		
    		//记录开始位置
    		int begin = 0;
    		
    		//记录结束位置
    		int end = array.length-1;
    		
    		//记录中间位置
    		int mid = (begin+end)/2;
    		
    		//记录目标位置
    		int dex = -1;
    		
    		while(true) {
        
    			//判断中间的这个元素是不是要查找的元素
    			if(array[mid] == nex) {
        
    				dex = mid;
    				break;
    			}else {
        
    				if(array[mid]>nex) {
            //中间元素大于目标元素
    					end = mid-1;        //改变结束位置为中间元素的前一位元素
    				}else {
                         //中间元素小于目标元素
    					begin = mid+1;      //改变开始元素位置为中间元素的后一位
    				}
    			}
    			mid = (begin+end)/2;        //新的中间元素
    		}
    		System.out.println("查找到目标元素的位置"+dex);
    		
    		
    	}
    	
    	//输出查找到的目标元素的位置
    	
    	
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY0NjQ2Mw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2019121015463630.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY0NjQ2Mw==,size_16,color_FFFFFF,t_70