集合Collection＜E＞

集合Collection

1.Collection—顶级接口
子接口：List、Set、Queue

2. List（列表）
   保证存储数据有序，可以根据下标进行操作集合元素
   实现类：ArrayList、LinkedList、Vector、Stack
   2.1 ArrayList（顺序表）
   由数组实现，内存连续，默认容量为10，可以指定容
   量,默认扩容是在原来的基础上增加一半，基于右移运
   算。查询效率较高、增删元素效率较低

案例:数组实现ArrayList
//实现ArrayList

class ListArray{
//存储数据的数组
String[] data; 
//元素个数以及数组下标 
int size=0; 
//无参构造---默认初始容量
public ListArray(){
//默认初始长度为10 
data=new String[10];
} 
//有参构造---指定初始容量 
public ListArray(int initCapcity){
data=new String[initCapcity];
} 
//数组扩容
public void grow() { 
// 判断数组原长度是否是0 
if (data.length <=1) { 
data = Arrays.copyOf(data, data.length + 1);
} else
// 在原来的基础是加上一半
data = Arrays.copyOf(data, 
data.length + (data.length >> 1));
} 
//下标是否越界
public void out(int index){
//如果下标越界就抛出异常
if(index<0||index>=size){
throw new IllegalArgumentException("Index:"+index);
}
}
//添加元素
public void add(String str){
//判断是否需要扩容
if(size>=data.length){
//对数组进行扩容 
grow(); 
} 
//往数组里添加元素
data[size++]=str;
}
//插入元素 
public void add(int index,String str){ 
//判断下标是否越界 
if(index<0||index>size){//下标和元素个数比较
throw new IllegalArgumentException("Index:"+index);
}
//判断是否需要扩容
if(size>=data.length){
grow(); 
} 
//依次把index后面的数组元素往后赋值
/*for(int i=size-1;i>=index;i--){ 
//把前面的元素赋值给后面的元素
data[i+1]=data[i]; 
}*/ 
System.arraycopy(data, index, data, index+1, size-index); 
//插这个元素 
data[index]=str; 
//元素个数 
size++;
} 
//根据下标删除(元素个数和长度相等，删除最后一个元素？) 
public void remove(int index){ 
//下标越界问题
out(index); 
//依次把index的后面的元素往前赋值
/*for(int i=index;i<size-1;i++){
// 
data[i]=data[i+1];
}*/ 
System.arraycopy 
(data, index+1, data, index, size-(index+1)); 
// 
size--; 
} 
//根据元素删除
public void remove(String str){
//返回结果值 
int index=indexOf(str); 
//判断返回值·是否·为-1 
if(index!=-1){ 
remove(index);
} 
} 
//返回元素第一次出现的下标值 
public int indexOf(String str){ 
//遍历数组依次比较 
for(int i=0;i<size;i++){//只比元素
//判断是否相等 
if(data[i]==str||
data[i]!=null&& 
data[i].equals(str)){ 
//返回下标值 
return i; 
} 
} 
//数组中没有出现 
return -1;
} 
//清空集合
public void clear(){
size=0;//没有可以遍历的元素
} 
//判断是否包含元素
public boolean contains(String str){
return indexOf(str)!=-1; 
} 
//获取元素
public String get(int index){
//越界问题
out(index); 
//返回指定元素 
return data[index]; 
}
//判断集合是否为空
public boolean isEmpty(){
return size==0;
}
//替换元素
public void set(int index,String str){
//越界问题
out(index); 
//替换 
data[index]=str;
} 
//返回元素个数
public int size(){ 
return size;
} 
//截取子列表
public ListArray subList(int fromindex,int toindex){
//越界问题 
out(fromindex); 
out(toindex); 
//判断下标大小是否正确
if(toindex<fromindex){
throw new 
IllegalArgumentException 
("FromIndex:"+fromindex+",ToIndex:"+toindex);
}
//新建列表 
//指定新列表长度 
int count=toindex-fromindex; 
ListArray list=new ListArray(count);
//数组的复制 
System.arraycopy(data, fromindex, list.data, 0, count); 
//赋值size---把复制的元素个数赋值给新列表的size 
list.size=count; 
//返回新列表 
return list; 
}
//重写toString方法 
//输出对象的时候输出是元素
@Override
public String toString() {
//创建StringBuilder的对象 
StringBuilder sb=new StringBuilder("["); 
//拼接字符串数组中的元素
for(int i=0;i<size;i++){//只遍历有元素的下标 
//拼接元素 
sb.append(data[i]).append(", ");
} 
//转成字符串 
String str=sb.toString(); 
//截取子串---后面的, 不要了 
//判断size是否大于0 
if(size>0) 
str=str.substring(0,str.length()-2); 
//返回 
return str+="]"; 
public String toString() { 
} 
}

2.2 LinkedList（链表）
底层是由节点（静态内部类）来进行存储元素的。底
层内存不连续，不需要扩容，增删元素效率较高、查
询元素效率较低

案例:实现LinkedList

class ListLinked{
	//元素个数/节点数
	int size=0;
	//头节点---表示第一个节点
	Node first;
	//尾结点--表示最后一个节点
	Node last;
	
	//节点---内部类
	class Node{
		//存储的元素
		String item;
		//上一个节点
		Node prev;
		//下一个节点
		Node next;
		//有参构造
		public Node(String item,Node prev,Node next){//元素给节点赋值
			this.item=item;
			this.prev=prev;
			this.next=next;
		}
	}
	
	//下标越界问题
	public void out(int index){
		if(index<0||index>=size){
			throw new IllegalArgumentException("index:"+index);
		}
	}
	
	//根据下标找节点
	public Node getNode(int index){
		Node no=this.first;
		for(int i=0;i<index;i++){
			no=no.next;
		}
		return no;
	}
	//添加
	public void add(String str){
		//新节点
		Node node=new Node(str, null, null);
		//判断添加元素的位置
		if(size==0){//表明添加的是第一个节点
			//头节点指向新节点
			this.first=node;
		}else{//尾部添加
			//原尾节点的下一个指向新节点
			this.last.next=node;
			//新节点的上一个指向原尾节点
			node.prev=this.last;
		}
		//尾节点指向新节点
		this.last=node;
		//节点个数加1
		size++;
	}
	
	//插入
	public void add(int index,String str){
		//判断下标是否越界
		if(index<0||index>size){
			throw new IllegalArgumentException("index:"+index);
		}
		
		//新节点
		Node node=new Node(str, null, null);
		
		//判断插入节点的位置
		//插入的节点位置是头节点且size为0
		//在尾部进行添加节点
		if(index==size){//尾部添加
			add(str);
			//结束方法
			//保证size不会添加两次
			return;
		}
		
		//判断插入头节点但是已经有了头节点
		//szie不为0
		if(index==0){
			//原头节点的上一个指向新节点
			this.first.prev=node;
			//新节点的下一个指向原头节点
			node.next=this.first;
			//头节点指向新节点
			this.first=node;
		}else{//表明在中间插入
			//获取指定下标的节点
			/*Node no=this.first;
			for(int i=0;i<index;i++){
				no=no.next;
			}*/
			Node no=getNode(index);
			//no节点的上一个节点的下一个指向新节点
			no.prev.next=node;
			//新节点的上一个指向no节点的上一个节点
			node.prev=no.prev;
			//no节点的上一个指向新节点
			no.prev=node;
			//新节点的下一个指向no
			node.next=no;
		}
		//
		size++;
	}
	
	//删除---根据下标
	public void remove(int index){
		//下标越界问题
		out(index);
		//判断删除节点的位置
		//判断是否删除的是头节点
		if(index==0){
			//原头节点的下一个节点的上一个为null
			this.first.next.prev=null;
			//头节点指向原头节点的下一个节点
			this.first=this.first.next;
		}else if(index==size-1){//尾部删除
			//原尾节点的上一个节点的下一个为null
			this.last.prev.next=null;
			//尾节点指向原尾节点的上一个节点
			this.last=this.last.prev;
		}else{//删除中间节点
			//获取指定节点
			Node no=getNode(index);
			//no节点的下一个节点的上一个指向no的上一个节点
			no.next.prev=no.prev;
			//no节点的上一个节点的下一个指向no的下一个节点
			no.prev.next=no.next;
			
		}
		//
		size--;
	}
	//根据指定元素进行删除
	public void remove(String str){
		//获取下标
		int index=indexOf(str);
		//判断是否为-1
		if(index!=-1){
			remove(index);
		}
	}
	
	//根据元素第一次出现的下标
	public int indexOf(String str){
		//遍历节点找出满足要求的节点
		Node node=this.first;
		for(int i=0;i<size;i++){
			//把每个节点的元素和参数做比较
			if(str==node.item||str!=null&&str.equals(node.item)){
				//返回下标值
				return i;
				//下一个节点
			}
			node=node.next;//下一个节点
		}
		//没有找到
		return -1;
	}
	
	
	//其他的方法补齐
	
	
	//重写toString
	@Override
	public String toString() {
		//创建对象
		StringBuilder sb=new StringBuilder("[");
		//拼接节点里的元素
		//遍历节点
		Node no=this.first;
		for(int i=0;i<size;i++){
			sb.append(no.item).append(", ");
			//下一个节点
			no=no.next;
		}
		//转换字符串
		String str=sb.toString();
		//判断元素是否为空
		if(size>0){
			str=str.substring(0, str.length()-2);
		}
		//
		return str+="]";
	}
}

如果这个场景需要用到ArrayList或者LinkedList，增删和
查询的操作概率相当，因为LinkedList—内存不连续，没有空间浪费，提高内存利用率。

2.3 Vector(向量)
第一个集合类，底层是由数组实现的，默认初始容量是
10，默认扩容增加一倍基于三目运算，线程安全的集合
调用elements方法返回古老的迭代器

public class VectorDemo {
	
	public static void main(String[] args) {
		//创建集合对象
		Vector<String> v=new Vector<>();
		
		//添加元素
		v.add("1323");
		v.add("abh");
		v.add("13");
		v.add("ah");
		v.add("1");
		v.add("abh");
		
		//调用方法返回古老的迭代器
		Enumeration<String> e=v.elements();//只有Vector有这个方法
		//迭代遍历
		//使用while循环
		while(e.hasMoreElements()){//判断是否还有元素
			//获取元素
			String s=e.nextElement();
			System.out.println(s);
			//删除元素---直接删除集合元素
			v.remove(s);
		}
		//
		System.out.println(v);
	}

}