数据结构之数组(泛型,动态)

java中数组的创建
数组最大的优点 :快速查询

package 第二章数组;
/**
 *
 * @author thinkpad
 *
 */

public class Main {
	
	public static void main(String[] args) {
		int[] arr = new int[10];
		for(int i =0;i<arr.length;i++) {
			arr[i]=i;
		}
		int[] scores = new int[] {100,99,66};
		for(int i=0;i<scores.length;i++) {
			System.out.println(scores[i]);
		}
		
		for(int score:scores) {
			System.out.println(score);
		}
		
		scores[0]=98;
		for(int i =0;i<scores.length;i++) {
			System.out.println(scores[i]);
		}
	}

}

增加 删除

package 第二章数组;

public class Array{
	
	private int[] data;
	private int size;
	//构造函数,传入数组的容量capacity的构造Array
	public Array(int capacity) {
		data = new int[capacity];
		size=0;
	}
	//无参数的构造函数,默认数组的容量capacity=10
	public Array() {
		this(10);
		
	}
	//获取数组中的元素的个数
	public int getSize() {
		return size;
	}
	//获取数组的容量
	public int getCapacity() {
		return data.length;
	} 
	//返回数组是否为空
	public boolean isEmpty() {
		return size ==0;
	}
	//向所有元素后添加一个新的元素
	public void addLast(int e) {
//		if(size==data.length) {
//			throw new IllegalArgumentException("AddLast failed.Array is full");
//		}
//		data[size]=e;
//		size++;
		add(size,e);
	}
	public void addFirst(int e) {
		add(0,e);
	}
	//在第index个位置插入一个新的元素e
	public void add(int index,int e) {
		if(size==data.length) {
			throw new IllegalArgumentException("Add failed.Array is full");
		}
		if(index<0||index>size) {
			throw new IllegalArgumentException("Add failed.Require index>=0 and index<=size");
			
		}
		for(int i =size-1;i>=index;i--) {
			data[i+1]=data[i];
		}
		data[index]=e;
		size++;
	}
	//获取index索引位置的元素
	int get(int index) {
		if(index <0|| index >=size) {
			throw new IllegalArgumentException("Get failed.Index is illegal.");
		}
		return data[index];
	}
	//修改index索引位置的元素为e
	void set(int index,int e) {
		if(index <0|| index >=size) {
			throw new IllegalArgumentException("Set failed.Index is illegal.");
		}
		data[index] =e;
	}
	//查找数组中是否有元素e
	public boolean contains(int e) {
		for(int i=0;i<size;i++) {
			if(data[i]==e)
				return true;
		}
		return false;
	}
	//查找数组中元素e所在的索引,如果不存在元素e,则返回-1
	public int find(int e) {
		for(int i =0;i<size;i++) {
			if(data[i]==e) {
				return i;
			}
			
		}
		return -1;
	}
	//从数组中删除index位置的元素,返回删除的元素
	public int remove(int index) {
		if(index <0|| index >=size) {
			throw new IllegalArgumentException("Remove failed.Index is illegal.");
		}
		int ret = data[index];
		for(int i=index +1;i<size;i++) {
			data[i-1]=data[i];
		}
		size --;
		return ret;
	}
	//从数组中删除第一个元素,返回删除的元素
	public int removeFirst() {
		return remove(0);
	}
	//从数组中删除最后一个元素,返回删除的元素
	public int removeLast() {
		return remove(size - 1);
	}
	//从数组中删除元素e
	public void removeElement(int e) {
		int index =find(e);
		if(index !=-1)
			remove(index);
	}
	@Override
	public String toString() {
		StringBuilder res = new StringBuilder();
		res.append(String.format("Array: size =%d, capacity =%d\n",size,data.length ));
	    res.append('[');
	    for(int i=0;i<size;i++) {
	    	res.append(data[i]);
	    	if(i!=size-1)
	    		res.append(",");
	    }
	    res.append(']');
	    return res.toString();
	}
}

测试类

package 第二章数组;

public class MainTest {

	public static void main(String[] args) {
		Array arr= new Array(20);
		for(int i=0;i<10;i++) {
			arr.addLast(i);
		}
		System.out.println(arr);
		
		arr.add(1, 100);
		System.out.println(arr);
        arr.addFirst(-1);
        System.out.println(arr);
        
        arr.remove(2);
        System.out.println(arr);
        arr.removeElement(4);
        System.out.println(arr);
        arr.removeFirst();
        System.out.println(arr);
	}

}

使用泛型

package 第二章数组;

public class Array1<E> {


		
		private E[] data;
		private int size;
		//构造函数,传入数组的容量capacity的构造Array
		public Array1(int capacity) {
			data =(E[]) new Object[capacity];
			size=0;
		}
		//无参数的构造函数,默认数组的容量capacity=10
		public Array1() {
			this(10);
			
		}
		//获取数组中的元素的个数
		public int getSize() {
			return size;
		}
		//获取数组的容量
		public int getCapacity() {
			return data.length;
		} 
		//返回数组是否为空
		public boolean isEmpty() {
			return size ==0;
		}
		//向所有元素后添加一个新的元素
		public void addLast(E e) {
//			if(size==data.length) {
//				throw new IllegalArgumentException("AddLast failed.Array is full");
//			}
//			data[size]=e;
//			size++;
			add(size,e);
		}
		public void addFirst(E e) {
			add(0,e);
		}
		//在第index个位置插入一个新的元素e
		public void add(int index,E e) {
			if(size==data.length) {
				throw new IllegalArgumentException("Add failed.Array is full");
			}
			if(index<0||index>size) {
				throw new IllegalArgumentException("Add failed.Require index>=0 and index<=size");
				
			}
			for(int i =size-1;i>=index;i--) {
				data[i+1]=data[i];
			}
			data[index]=e;
			size++;
		}
		//获取index索引位置的元素
		public E get(int index) {
			if(index <0|| index >=size) {
				throw new IllegalArgumentException("Get failed.Index is illegal.");
			}
			return data[index];
		}
		//修改index索引位置的元素为e
		public void set(int index, E e) {
			if(index <0|| index >=size) {
				throw new IllegalArgumentException("Set failed.Index is illegal.");
			}
			data[index] =e;
		}
		//查找数组中是否有元素e
		public boolean contains(E e) {
			for(int i=0;i<size;i++) {
				if(data[i].equals(e))
					return true;
			}
			return false;
		}
		//查找数组中元素e所在的索引,如果不存在元素e,则返回-1
		public int find(E e) {
			for(int i =0;i<size;i++) {
				if(data[i].equals(e)) {
					return i;
				}
				
			}
			return -1;
		}
		//从数组中删除index位置的元素,返回删除的元素
		public E remove(int index) {
			if(index <0|| index >=size) {
				throw new IllegalArgumentException("Remove failed.Index is illegal.");
			}
			E ret = data[index];
			for(int i=index +1;i<size;i++) {
				data[i-1]=data[i];
			}
			size --;
			data[size]=null;
			return ret;
		}
		//从数组中删除第一个元素,返回删除的元素
		public E removeFirst() {
			return remove(0);
		}
		//从数组中删除最后一个元素,返回删除的元素
		public E removeLast() {
			return remove(size - 1);
		}
		//从数组中删除元素e
		public void removeElement(E e) {
			int index =find(e);
			if(index !=-1)
				remove(index);
		}
		@Override
		public String toString() {
			StringBuilder res = new StringBuilder();
			res.append(String.format("Array: size =%d, capacity =%d\n",size,data.length ));
		    res.append('[');
		    for(int i=0;i<size;i++) {
		    	res.append(data[i]);
		    	if(i!=size-1)
		    		res.append(",");
		    }
		    res.append(']');
		    return res.toString();
		}
	}

测试类

package 第二章数组;

public class MainTest1 {

	public static void main(String[] args) {
	Array1<Integer> arr = new Array1<>(20);
	for(int i=0;i<10;i++) {
		arr.addLast(i);
	}
	System.out.println(arr);
	
	arr.add(1, 100);
	System.out.println(arr);
    arr.addFirst(-1);
    System.out.println(arr);
    
    arr.remove(2);
    System.out.println(arr);
    arr.removeElement(4);
    System.out.println(arr);
    arr.removeFirst();
    System.out.println(arr);
	}

}

package 第二章数组;

public class Student {
private String name;
private int score;

public Student(String studentName,int studentScore) {
	name = studentName;
	score = studentScore;
	
}
@Override
public String toString() {
	return String.format("Student(name: %s,score:%d)", name,score);
}
public static void main(String[] args) {
	Array1<Student> arr = new Array1<>();
	arr.addLast(new Student("Leo",100));
	arr.addLast(new Student("Bob",99));
	arr.addLast(new Student("Mike",10));
	System.out.println(arr);
	
}
}

动态数组,用户再也不用担心数组不够用

package 第二章数组;
//动态数组,用户在也不用担心数组不够用;

public class Array1<E> {


		
		private E[] data;
		private int size;
		//构造函数,传入数组的容量capacity的构造Array
		public Array1(int capacity) {
			data =(E[]) new Object[capacity];
			size=0;
		}
		//无参数的构造函数,默认数组的容量capacity=10
		public Array1() {
			this(10);
			
		}
		//获取数组中的元素的个数
		public int getSize() {
			return size;
		}
		//获取数组的容量
		public int getCapacity() {
			return data.length;
		} 
		//返回数组是否为空
		public boolean isEmpty() {
			return size ==0;
		}
		//向所有元素后添加一个新的元素
		public void addLast(E e) {
//			if(size==data.length) {
//				throw new IllegalArgumentException("AddLast failed.Array is full");
//			}
//			data[size]=e;
//			size++;
			add(size,e);
		}
		public void addFirst(E e) {
			add(0,e);
		}
		//在第index个位置插入一个新的元素e
		public void add(int index,E e) {
			
			if(index<0||index>size) {
				throw new IllegalArgumentException("Add failed.Require index>=0 and index<=size");
				
			}
			if(size==data.length) {
				resize(2*data.length);
			}
			for(int i =size-1;i>=index;i--) {
				data[i+1]=data[i];
			}
			data[index]=e;
			size++;
		}
		
		//获取index索引位置的元素
		public E get(int index) {
			if(index <0|| index >=size) {
				throw new IllegalArgumentException("Get failed.Index is illegal.");
			}
			return data[index];
		}
		//修改index索引位置的元素为e
		public void set(int index, E e) {
			if(index <0|| index >=size) {
				throw new IllegalArgumentException("Set failed.Index is illegal.");
			}
			data[index] =e;
		}
		//查找数组中是否有元素e
		public boolean contains(E e) {
			for(int i=0;i<size;i++) {
				if(data[i].equals(e))
					return true;
			}
			return false;
		}
		//查找数组中元素e所在的索引,如果不存在元素e,则返回-1
		public int find(E e) {
			for(int i =0;i<size;i++) {
				if(data[i].equals(e)) {
					return i;
				}
				
			}
			return -1;
		}
		//从数组中删除index位置的元素,返回删除的元素
		public E remove(int index) {
			if(index <0|| index >=size) {
				throw new IllegalArgumentException("Remove failed.Index is illegal.");
			}
			E ret = data[index];
			for(int i=index +1;i<size;i++) {
				data[i-1]=data[i];
			}
			size --;
			data[size]=null;
			return ret;
		}
		//从数组中删除第一个元素,返回删除的元素
		public E removeFirst() {
			return remove(0);
		}
		//从数组中删除最后一个元素,返回删除的元素
		public E removeLast() {
			return remove(size - 1);
		}
		//从数组中删除元素e
		public void removeElement(E e) {
			int index =find(e);
			if(index !=-1)
				remove(index);
		}
		@Override
		public String toString() {
			StringBuilder res = new StringBuilder();
			res.append(String.format("Array: size =%d, capacity =%d\n",size,data.length ));
		    res.append('[');
		    for(int i=0;i<size;i++) {
		    	res.append(data[i]);
		    	if(i!=size-1)
		    		res.append(",");
		    }
		    res.append(']');
		    return res.toString();
		}
		private void resize(int newCapacity) {
			E[] newData = (E[]) new Object[newCapacity];
			for(int i =0;i<size;i++) {
				newData[i]=data[i];
				
			}
			data= newData;
			
		}
	}

测试动态数组

package 第二章数组;

public class MainTest1 {

	public static void main(String[] args) {
	Array1<Integer> arr = new Array1<>();
	for(int i=0;i<10;i++) {
		arr.addLast(i);
	}
	System.out.println(arr);
	
	arr.add(1, 100);
	System.out.println(arr);
    arr.addFirst(-1);
    System.out.println(arr);
    
    
//    arr.remove(2);
//    System.out.println(arr);
//    arr.removeElement(4);
//    System.out.println(arr);
//    arr.removeFirst();
//    System.out.println(arr);
	}

}

运行结果

完整版动态数组
可以扩容和缩容

package 第二章数组;
//动态数组,用户在也不用担心数组不够用;

public class Array1<E> {


		
		private E[] data;
		private int size;
		//构造函数,传入数组的容量capacity的构造Array
		public Array1(int capacity) {
			data =(E[]) new Object[capacity];
			size=0;
		}
		//无参数的构造函数,默认数组的容量capacity=10
		public Array1() {
			this(10);
			
		}
		//获取数组中的元素的个数
		public int getSize() {
			return size;
		}
		//获取数组的容量
		public int getCapacity() {
			return data.length;
		} 
		//返回数组是否为空
		public boolean isEmpty() {
			return size ==0;
		}
		//向所有元素后添加一个新的元素
		public void addLast(E e) {
//			if(size==data.length) {
//				throw new IllegalArgumentException("AddLast failed.Array is full");
//			}
//			data[size]=e;
//			size++;
			add(size,e);
		}
		public void addFirst(E e) {
			add(0,e);
		}
		//在第index个位置插入一个新的元素e
		public void add(int index,E e) {
			
			if(index<0||index>size) {
				throw new IllegalArgumentException("Add failed.Require index>=0 and index<=size");
				
			}
			if(size==data.length) {
				resize(2*data.length);
			}
			for(int i =size-1;i>=index;i--) {
				data[i+1]=data[i];
			}
			data[index]=e;
			size++;
		}
		
		//获取index索引位置的元素
		public E get(int index) {
			if(index <0|| index >=size) {
				throw new IllegalArgumentException("Get failed.Index is illegal.");
			}
			return data[index];
		}
		//修改index索引位置的元素为e
		public void set(int index, E e) {
			if(index <0|| index >=size) {
				throw new IllegalArgumentException("Set failed.Index is illegal.");
			}
			data[index] =e;
		}
		//查找数组中是否有元素e
		public boolean contains(E e) {
			for(int i=0;i<size;i++) {
				if(data[i].equals(e))
					return true;
			}
			return false;
		}
		//查找数组中元素e所在的索引,如果不存在元素e,则返回-1
		public int find(E e) {
			for(int i =0;i<size;i++) {
				if(data[i].equals(e)) {
					return i;
				}
				
			}
			return -1;
		}
		//从数组中删除index位置的元素,返回删除的元素
		public E remove(int index) {
			if(index <0|| index >=size) {
				throw new IllegalArgumentException("Remove failed.Index is illegal.");
			}
			E ret = data[index];
			for(int i=index +1;i<size;i++) {
				data[i-1]=data[i];
			}
			size --;
			data[size]=null;
		if(size == data.length/2) {
				resize(data.length/2);
			}
			return ret;
		}
		//从数组中删除第一个元素,返回删除的元素
		public E removeFirst() {
			return remove(0);
		}
		//从数组中删除最后一个元素,返回删除的元素
		public E removeLast() {
			return remove(size - 1);
		}
		//从数组中删除元素e
		public void removeElement(E e) {
			int index =find(e);
			if(index !=-1)
				remove(index);
		}
		@Override
		public String toString() {
			StringBuilder res = new StringBuilder();
			res.append(String.format("Array: size =%d, capacity =%d\n",size,data.length ));
		    res.append('[');
		    for(int i=0;i<size;i++) {
		    	res.append(data[i]);
		    	if(i!=size-1)
		    		res.append(",");
		    }
		    res.append(']');
		    return res.toString();
		}
		private void resize(int newCapacity) {
			E[] newData = (E[]) new Object[newCapacity];
			for(int i =0;i<size;i++) {
				newData[i]=data[i];
				
			}
			data= newData;
			
		}
	}

测试代码

package 第二章数组;

public class MainTest1 {

	public static void main(String[] args) {
	Array1<Integer> arr = new Array1<>();
	for(int i=0;i<10;i++) {
		arr.addLast(i);
	}
	System.out.println(arr);
	
	arr.add(1, 100);
	System.out.println(arr);
    arr.addFirst(-1);
    System.out.println(arr);
    
    
    arr.remove(2);
    System.out.println(arr);
    arr.removeElement(4);
    System.out.println(arr);
    arr.removeFirst();
    System.out.println(arr);
	}

}

测试结果


解决方案是

喜欢我的可以关注我,我们可以一起交流学习

微信公众号:

让我爱上它Computer

qq群:473989408