Java 链表、集合、队列

List与Set接口的跟接口为Collection，Map则为与Collection无关的另一接口

ArrayList 链表

• 有序，可重复
• vector 线程同步，安全，适合数据量大

import java.util.*;

String str1=new String("I ");
String str2=new String("Love");
ArrayList<String> str=new ArrayList<String>();
str.add(str1);

str.remove(str2);
str.remove(0);
str.add(str2);
str.set(2,"You");
for(int i=0;i<str.size();i++){	
	str2=str.get(i);
	if(str2=="Love"){
		System.out.println(str2);
		break;
	}
}

LinkedList 链表

• 双链表
• 有序，可重复

import java.util.*;

String str1=new String("Love");
String str2=new String(" You");
LinkedList<String> str=new LinkedList<String>();
str.add(str2);
str.add(1,str1);

for(int i=0;i<str.size();i++){	
    String s=str.get(i);
	if(s=="Love"){
		str.remove(s);
		break;
	}
}

HashSet 集合

• 无序，不重复（即重复则覆盖）
• 基于HashMap，key改变，值始终是PRESENT，允许NULL，非线性安全

import java.util.*;

String str1=new String("Love");
String str2=new String(" You");
HashSet<String> str=new HashSet<String>();

if(!str.isEmpty()){	
	str.clear();
}
str.add(str1);
str.add(str2);
Iterator<String> it=str.iterator();
while(it.hasNext()){	
	String s=it.next();
	if(s=="Love"){
		str.remove(s);
		System.out.println(str.size());
	}
}
if(!str.contains("You")){	
	str.add("You");
}

HashMap

• 无序，键值对
• 键唯一，值不唯一，线程非安全
• 效率高

import java.util.*;

String str1=new String("Love");
String str2=new String(" You");
Map<Integer,String> str=new HashMap<>();
if(!str.isEmpty()){	
	str.clear();
}
Map<Character,Integer> map=new HashMap<>(){	
	{
		put('1',1);
		put('2',2);
	}
};

str.put(0,str1);
str.put(1,str2);
for(int i=0;i<str.size();i++){	
	String s=str.get(i);
	if(s=="Love"){
		str.remove(i);
		break;
	}
}
if(!str.containsKey(0)){	
	str.put(0,str1);
}
if(!str.containsValue("Love")){	
	str.put(0,"Love");
}

Queue

函数	作用	异常/返回值
add	增加一个元索	如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove	移除并返回队列头部的元素	如果队列为空，则抛出一个NoSuchElementException异常
element	返回队列头部的元素	如果队列为空，则抛出一个NoSuchElementException异常
offer	添加一个元素并返回true	如果队列已满，则返回false
poll	移除并返问队列头部的元素	如果队列为空，则返回null
peek	返回队列头部的元素	如果队列为空，则返回null
put	添加一个元素	如果队列满，则阻塞
take	移除并返回队列头部的元素	如果队列为空，则阻塞

Queue<Integer> queue_b=new PriorityQueue<Integer>();
            Queue<Integer> queue_k=new PriorityQueue<Integer>();
            for(int i=0;i<n;i++){
                int a=in.nextInt();
                int b=in.nextInt();
                int k=in.nextInt();
                while(!queue_b.isEmpty()&&a>queue_b.element()){
                    m=m+queue_k.remove();
                    queue_b.remove();
                }
                if(k<=m){
                    m=m-k;
                    queue_b.add(b);
                    queue_k.add(k);
                    System.out.println("1");
                }else{
                    System.out.println("0");
                }
            }