java collections 集合基础学习 ArrayList，LinkedList, HashSet, TreeSet, HashMap, Stack,Queue,PriorityQueue

collections 集合基础用法

包括ArrayList，LinkedList, HashSet, TreeSet, HashMap, Stack,Queue,PriorityQueue的方法和用法。

上代码：

package com.yuxin.learn;
import java.util.*;

public class Main {

private static void display(Iterator<String> it) {
System.out.println("call display():");
// TODO Auto-generated method stub
while(it.hasNext()){
String s = it.next();
System.out.print(s+" ");
}
System.out.println();
}

public static void print(Object l){
System.out.println(l);
}

public static void main(String[] args){
/**
* 1. List Set Queue 继承自Collection
* (1).ArrayList继承自List
* 1) ArrayList的所有方法
*/

Collection<Integer> alt_Int = new ArrayList<Integer>();
alt_Int.add(0);
alt_Int.add(2);
Random rand = new Random();
for(int i=1;i<100;i++){
alt_Int.add(rand.nextInt(30));
}
System.out.println(alt_Int);

/**
* 1. List Set Queue 继承自Collection
* (1).ArrayList继承自List
* 1) ArrayList的所有方法
*/
//List<String> altString = Arrays.asList("dog","cat","pig");
print("**************** Part 1 ArrayList Method ***********");
ArrayList<String> altString = new ArrayList<String>();
altString.add("dog");
altString.add("cat");
altString.add("pig");
print("1 pets:"+ altString);
altString.add("rat");
print("2 add rat:"+ altString);
// a.contiains(b)
print("3 contains rat?:"+altString.contains("rat"));

ArrayList<pet> altObj = new ArrayList<pet>();
pet p1 = new pet("objcat");
altObj.add(p1);
pet p2 = new pet("objdog");
altObj.add(p2);

//add()
print("4 objcat indexof:"+altObj.indexOf(p1));
pet p3 = new pet("obj3");
altObj.add(p3);
pet p4 = new pet("obj4");
altObj.add(p4);
pet p5 = new pet("obj5");
altObj.add(p5);
print ("5 objArrayList:"+altObj);
//subList()
List<pet> sub = altObj.subList(2, 5);
print("6 sub Arraylist:"+sub);
//containsAll()
print("7 containsAll: "+ altObj.containsAll(sub));
Collections.shuffle(sub,rand);
print("8 shuffle sub Arraylist:"+sub);

List<pet> sub2 = new ArrayList<pet>();

//asList()
sub2=Arrays.asList(altObj.get(1),altObj.get(3));
print("9 .get sub: "+ sub2);

List<pet> temp = new ArrayList<pet>();
temp = altObj;
//a.removeAll(b)
print("10 before removeAll: "+temp);
temp.removeAll(sub2);
print("11 after removeAll in sub2:"+temp);

//a.clear()
temp.clear();
print("12 after clear:"+temp);

//a.isEmpty()
print("13 isEmpty():"+temp.isEmpty());

Object[] o = altObj.toArray();
print("14 toArray():"+o);
//iterator
Iterator<pet> it = altObj.iterator();
print("15 iterator: ");
while(it.hasNext()){
pet p = it.next();
System.out.print(p+". ");
}
print(" ");
display(altString.iterator());

print("**************** Part 2 LinkList Method ***********");
LinkedList<String> objLinkList = new LinkedList<String>(Arrays.asList("cat","rat","dot","bird","ant"));
print("1 objLinkList:"+objLinkList);
//getFirst()
print("2 getFist():"+objLinkList.getFirst());
//element()
print("3 element():"+objLinkList.element());
//peek()
print("4 peek()"+objLinkList.peek());
//remove()
//String r = objLinkList.element();
//objLinkList.remove(r);
print("5 remove()"+objLinkList.remove());
//LinkedList<String> ListTemp = objLinkList;
//removeFirst()
print("6 removeFirst():"+objLinkList.removeFirst());
print("7 after remove"+objLinkList);
//addFirst()
objLinkList.addFirst("Rat");
print("8 after addFist():"+objLinkList);
//offer()
objLinkList.offer("OfferA");
print("9 after offer():"+objLinkList);
//addLast
objLinkList.addLast("AddLastB");
print("10 after addLast:"+objLinkList);
objLinkList.removeLast();
print("10 after removeLast:"+objLinkList);

print("**************** Part 3 Stack Method ***********");
//print("Impement a Stack using LinkedList:");
Stack<String> stk = new Stack<String>();
String str = "I Love Java progaraming!";
print("store sentence \"I Love Java progaraming!\" in a stack and pop out:");
for(String s:str.split(" ")){
stk.push(s);
}
while(!stk.isEmpty()) print( stk.pop()+" ");

System.out.println();
print("**************** Part 4 Set Method ***********");
/**
* Set 不保存重复元素
* 可以选择HashSet或者TreeSet实现，专门对快速查找进行优化。
* HashSet 保存顺序没有规律（散列存储），TreeSet 红-黑树存储
* LinkedHashSet 使用了散列存储，但使用链表维护元素插入顺序。
*/
Set<String> set1 = new HashSet<String>();
//Collections.addAll()
print("Collections.addAll():");
Collections.addAll(set1, "A B C D E F G H I J K L M".split(" "));
print(set1);
set1.add("N");
//contiains
print("1 contains() H:"+set1.contains("H"));
print("2 contains() Z:"+set1.contains("Z"));
Set<String> set2 = new HashSet<String>();
Collections.addAll(set2, "G H I J".split(" "));
print("3 containsAll() set2 in set1:"+set1.containsAll(set2));
set1.remove("H");
print("4 after remove H whether contains H:"+set1.contains("H"));
print("5 after remove H,set1 containsAll set2?:"+set1.containsAll(set2));
Collections.addAll(set1, "X Y Z".split(" "));
print("6 'X Y Z'added to set1:"+set1);
print("7 TreeSet:");
//rand.nextInt
Set<Integer> altIntSort = new TreeSet<Integer>();
for(int i=1;i<100;i++){
altIntSort.add(rand.nextInt(30));
}
System.out.println(altIntSort);

System.out.println();
print("**************** Part 5 Map Method ***********");
/**
* 用Map求产生的随机数的次数 key->随机数，value->次数
* 1）获得value 用 m.get(key)方法
* 2）存入map 用 m.put(key,value)方法
*/
print("Generate 1000 integer, calculate the frequency.");
Map<Integer,Integer> map1 = new HashMap<Integer,Integer>();
for(int i=0;i<1000;i++){
int r = rand.nextInt(20);
Integer fre = map1.get(r);
map1.put(r,fre==null?1:fre+1);
}
print(map1);

print("hashmap:");
Map<String,String> petMap = new HashMap<String,String>();
petMap.put("yx", "dog");
petMap.put("hx", "cat");
petMap.put("cc", "rat");
//containsKey
print("containsKey: yx:"+petMap.containsKey("yx"));
print("containsKey: yxx:"+petMap.containsKey("yxx"));
print("containsValue: cat:"+petMap.containsValue("cat"));
//keySet
print("keySet:"+petMap.keySet());
//values
print("valueSet:"+petMap.values());
//map<person,List<pet>>;

System.out.println();
print("**************** Part 6 Queue Method ***********");
/**
* 通过将LinkedList向上转型实现Queue.(窄化了LinkedList的访问权限)
* LinkedList提供了方法支持队列的行为，可作为队列的一种实现。
*
*/
Queue<Character> queS = new LinkedList<Character>();
for(char c:"Life is beautiful~".toCharArray()){
queS.offer(c);
}
print("1 String to CharArray offer into queue: "+queS);
//element
print("2 element:"+queS.element());
//peek
print("3 peek:"+queS.peek());
//poll
print("4 poll:"+queS.poll());
print("5 after poll:"+queS);
//addLast
queS.add('*');
print("6 after addLast:"+queS);

print("PriorityQueue:");
/**
*
* 当调用offer()方法添加对象，对象会在队列中被排序
*/
List<String> str1 = Arrays.asList("I think nothing is imporsible".split(" "));
PriorityQueue<String> PriQueS = new PriorityQueue<String>(str1);
print("1 priority que:"+PriQueS);
PriorityQueue<String> PriQueS_reverse = new PriorityQueue<String>(str1.size(),Collections.reverseOrder());
PriQueS_reverse.addAll(str1);
print("2 after add all, priority que _reverse:"+PriQueS_reverse);
String str2 = "I think nothing is imporsible";
List<Character> Allch = new ArrayList<Character>();
for(char c:str2.toCharArray()){
Allch.add(c);
}
PriorityQueue<Character> PriQueAll = new PriorityQueue<Character>();
PriQueAll.addAll(Allch);
print("3 PriorityQueue all char:"+PriQueAll);
//对于字母去重复，注意使用HashSet
Set<Character> charSet = new HashSet<Character>();
for(char c:str2.toCharArray()){
charSet.add(c);
}
PriorityQueue<Character> PriQueC = new PriorityQueue<Character>(charSet);
print("4 PriorityQueue single char:"+PriQueC);
//输出环境变量
Main m =new Main();
EnvironmentVar evn = m.new EnvironmentVar();
evn.output();

print("基本异常");
//Object t1 = null;
//if(t1==null)throw new NullPointerException();
print("如果直接抛出了异常，程序就会停在这，而加入catch后，会继续运行。");
try{
Object t1 = null;
if(t1==null)throw new NullPointerException();
}catch(NullPointerException e){
print("catched a execption!");
}
print("Exception finished");//加入捕捉异常后，才会执行到这

print("**************** Part 7 String Method ***********");
String str0="We are Chinese.";
print("str0"+str0);
//length()
print("1 length:"+str0.length());
//charAt()
print("2 charAt:"+str0.charAt(4));
char[] charArr = new char[20];
for(int i=0;i<20;i++) charArr[i]='0';
//getChars
str0.getChars(3, 7,charArr,4);
for(char c:charArr)System.out.print(c);
System.out.println();
//valueOf
print("3 valueOf(change charArray into String method):"+String.valueOf(charArr));
String str3="Chinese";
print("str3:"+str3);
//equals
print("4 equals:"+str0.equals(str3));
//compareTo
print("5 compareTo:"+str0.compareTo(str3));
//contains
print("6 contains:"+str0.contains(str3));
//StringBuffer
StringBuffer sb = new StringBuffer("We are Chinese.");
//contentEquals
print("7 contentEquals:"+str0.contentEquals(sb));
//equalsIgnoreCase
print("8 equalsIgnoreCase:"+str0.equalsIgnoreCase(str3));
//regionMatches
print("9 regionMatches(区域对比):"+str0.regionMatches(7, str3, 0, 4));
//startsWith
print("10 startsWith:"+str0.startsWith("W"));
//endsWith
print("11 endsWith:"+str0.endsWith("."));
//indexOf
print("12 indexOf(i):"+str0.indexOf("i"));
print("13 indexOf(t):"+str0.indexOf("t"));
//lastIndexOf
print("14 lastIndexOf(i)从后向前搜索:"+str0.lastIndexOf("i"));
//subString
print("15 subString:"+str0.substring(3));
//concat
print("16 concat:"+str0.concat("aaaaaaa"));
//replace
print("17 replace:"+str0.replace("n", "sd"));
//toLowerCase
print("18 toLowerCase:"+str0.toLowerCase());
//toUpperCase
print("19 toUpperCase:"+str0.toUpperCase());
//trim
print("20 trim:"+str0.trim());
//valueOf
/**
* String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串
String.valueOf(char c) : 将 char 变量 c 转换成字符串
String.valueOf(char[] data) : 将 char 数组 data 转换成字符串
String.valueOf(char[] data, int offset, int count) :
将 char 数组 data 中 由 data[offset] 开始取 count 个元素 转换成字符串
String.valueOf(double d) : 将 double 变量 d 转换成字符串
String.valueOf(float f) : 将 float 变量 f 转换成字符串
String.valueOf(int i) : 将 int 变量 i 转换成字符串
String.valueOf(long l) : 将 long 变量 l 转换成字符串
String.valueOf(Object obj) : 将 obj 对象转换成 字符串, 等于 obj.toString()
*/
print("20 valueOf(转化为字符串):"+String.valueOf(354));

/**
* intern 这个方法 返回字符串对象的规范化表示形式，当调用 intern 方法时
* ，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object)
* 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并且
* 返回此 String 对象的引用。这时候c和d就是相等的。
*/
print("21 intern:判断目前的string对象是否已经存在于常量池，存在则返回存在对象的引用");
String a = "b" ;
String b = "b" ;
System.out.print( a == b);
String c = "d" ;
String d = new String( "d" ).intern() ;
System.out.println( c == d);

String s1 = "ab123" ;
String s2 = new String( "ab123" ) ;
System.out.println( s1 == s2 );
String s3 = s2.intern() ;
System.out.println( s1 == s3 ) ;

int a1=324;
print("格式化输出：");
System.out.printf("a1:%d\n",a1);
System.out.format("a1\\:%d\n",a1);

}

class EnvironmentVar {
/**
* System.getenv()返回一个Map，entrySet()产生一个有Map.Entry的元素构成的Set，
* 并且Set是一个Iterable，因此她可以用于foreach循环。
*/
//public void EnvironmentVar(){}
public void output(){
System.out.println("output environment var:");
for(Map.Entry entry:System.getenv().entrySet()){
System.out.println(entry.getKey()+":"+entry.getValue());
}
}
}

}


实现上面的代码正常运行，另外还需要一个类：

package com.yuxin.learn;

public class pet{
private String pet;
public pet(String string) {
// TODO Auto-generated constructor stub
pet=string;
}
}