数组和面向对象数组

一、数组

1. 数组的创建

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

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

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

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

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

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

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

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

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));
	}

6. 删除数组中的元素

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;
		
		
		
		
	}

}

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

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();
	}

}

3. 控制台效果如图：
   

三、线性查找

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);
		
		
	}
	
	//输出查找到的目标元素的位置
	
	

}