java集合框架22

标签：java   集合框架   collection   

简单的

   

Set<String> set=new TreeSet<String>();
  set.add("London");
  set.add("Paris");
  set.add("New York");
  set.add("San Francisco");
  set.add("Beijing");
  set.add("New York");
 
  TreeSet<String> treeSet=new TreeSet<String>(set);
 
  System.out.println(treeSet);
  System.out.println("first():"+treeSet.first());
  System.out.println("last():"+treeSet.last());
  System.out.println("headSet():"+treeSet.headSet("New York"));  //返回之前的
  System.out.println("tailSet():"+treeSet.tailSet("New York"));  //返回之后的，包括它自身
  System.out.println("lower(\"p\"):"+treeSet.lower("P"));     //返回小于P的最大元素
  System.out.println("higher:"+treeSet.higher("P"));          //返回大于P的最小元素
  System.out.println("floor:"+treeSet.floor("P"));            //返回小于或等于P的最大元素
  System.out.println("ceiling:"+treeSet.ceiling("P"));        //返回大于或者等于P的最小元素
  System.out.println("poolFirst:"+treeSet.pollFirst());      //删除第一个并返回
  System.out.println("pollLast:"+treeSet.pollLast());	   //删除最后一个并返回
  System.out.println("new Set"+treeSet);

List<Integer> alist=new ArrayList<Integer>();
   alist.add(1);   //10
   alist.add(2);
   alist.add(3);
   alist.add(1);   //30
   alist.add(4);    //4  1  30  3  2  1  10
   alist.add(0,10);  //把下标为0的元素挤到下标为1的地方  
   alist.add(3,30);
   System.out.println(" A list of integer in array list:\n"+alist);
   
   LinkedList<Object> llist=new LinkedList<Object>(alist);
   llist.add(1,"red");
   llist.removeLast();
   llist.addFirst("green");
   
   //顺序输出
   System.out.println("Display the linked list forward:");
   ListIterator<Object> iterator=llist.listIterator();
   while(iterator.hasNext()){
    System.out.print(iterator.next()+"  ");
   }
   System.out.println();
   
   //逆序输出
   System.out.println("Display the linked list backward");
   iterator=llist.listIterator(llist.size());
   while(iterator.hasPrevious()){
    System.out.print(iterator.previous()+"  ");
   }

List<String> list=Arrays.asList("red","green","blue");
  Collections.sort(list);           //排序
  System.out.println(list);
  Collections.sort(list,Collections.reverseOrder());    //逆序输出
  System.out.println(list);
  List<Integer> list1=Arrays.asList(2,4,7,10,11,45,50,59,60,69);
  System.out.println("(1) Index:"+Collections.binarySearch(list1,7));
  System.out.println("(2) Index:"+Collections.binarySearch(list1,9));
  System.out.println("(3) Index:"+Collections.binarySearch(list,"blue"));     //-1
  System.out.println("(4) Index:"+Collections.binarySearch(list,"cyna"));
  Collections.reverse(list);           //逆序排序
  System.out.println("reverse:::::"+list);
  Collections.reverse(list);
  System.out.println("reverse2:::::"+list);
  Collections.shuffle(list,new Random(2));   //随机打乱顺序
  System.out.println("shuffle::::"+list);
  System.out.println("*********************copy()**********************");
 
  List<String> list2=Arrays.asList("yellow","red","green","blue");
  List<String> list3=Arrays.asList("white","black");
  Collections.copy(list2,list3);
  System.out.println(list2);
  List<Integer> list4=Collections.nCopies(5,5);
   /*用nCopies()方法创建的线性表是不可变的，不能在该线性表中添加删除或更新*/
  //list4.add(new Integer(6));
  System.out.println(list4);
  List<String> list5=Arrays.asList("red","green","blue");
  Collections.fill(list5,"aha~");       //全部替换成"aha~"
  System.out.println("fille():"+list5);

性能测试

public static void main(String[] args) {
 
       Collection<Integer> set1=new HashSet<Integer>();
       System.out.println("the time of HashSet  is:"+getTestTime(set1,500000)+"milliseconds");
 
       Collection<Integer> set2=new LinkedHashSet<Integer>();
       System.out.println("the time of LinkedHashSet is:"+getTestTime(set2,500000)+"milliseconds");
       Collection<Integer> set3=new TreeSet<Integer>();
       System.out.println("the time of TreeSet is:"+getTestTime(set3,500000)+"milliseconds");
 
     Collection<Integer> set4=new ArrayList<Integer>();
     System.out.println("the time of ArrayList  is:"+getTestTime(set4,500000)+"milliseconds");
     Collection<Integer> set5=new LinkedList<Integer>();
     System.out.println("the time of LinkedList is:"+getTestTime(set5,500000)+"milliseconds");
         
}
 public static long getTestTime(Collection<Integer> c , int size){
       long start=System.currentTimeMillis();
       List<Integer> list=new ArrayList<Integer>();
       for(int i=0;i<size;i++)  list.add(i);
       Collections.shuffle(list);
       for(int element: list)  c.add(element);
       Collections.shuffle(list);
       for(int element: list)   c.remove(element);
       long end=System.currentTimeMillis();
       return end-start;
 }

public static void main(String[] args) {
   Queue<String> queue=new LinkedList<String>();
   queue.offer("first");
   queue.offer("second");
   queue.offer("third");
   queue.offer("fourth");
   /**
    * poll():获取并删除队列头，队列为空返回null
    * remove():获取并删除队列头，队列为空返回异常
    * peek():获取但不删除队列头，队列为空返回null
    * element():获取但不删除队列头，队列为空返回异常
    */
   System.out.println("队头为:"+queue.element());
   System.out.println("队长为:"+queue.size());
 }

public static void main(String[] args) {
     // 默认为自然排序
  PriorityQueue<String> queue=new PriorityQueue<String>();
  queue.offer("java");
  queue.offer("net");
  queue.offer("C");
  queue.offer("python");
  while(queue.size()>0){
   System.out.print(queue.remove()+"\t");
  }
 
  System.out.println();
 
  // 修改排序方式
  PriorityQueue<String> queue2=new PriorityQueue<String>(4,Collections.reverseOrder());
  queue2.offer("java");
  queue2.offer("net");
  queue2.offer("C");
  queue2.offer("python");
  while(queue2.size()>0){
   System.out.print(queue2.remove()+"\t");
  }
 }

public static void main(String[] args) {
  Map<String,Integer> hashmap=new HashMap<String, Integer>();
  hashmap.put("chenjian", 21);
  hashmap.put("liuzhenguang", 22);
  hashmap.put("guoliangjun", 23);
  hashmap.put("qiufubi", 22);
  System.out.println(hashmap);  //随机输出
 
  //从一个散列图创建一个树形图
  Map<String,Integer> treemap=new TreeMap<String, Integer>(hashmap);
  System.out.println(treemap);  //按照键值排序输出
 
  Map<String,Integer> linkedmap=new LinkedHashMap<String, Integer>(11,0.75f,false);
  linkedmap.put("chenjian", 21);
  linkedmap.put("liuzhenguang", 22);
  linkedmap.put("guoliangjun", 23);
  linkedmap.put("qiufubi", 22);
  System.out.println(linkedmap);  //按照插入的时间顺序输出
 }

/**统计单词出现的次数
  * 在TreeMap中，键值排序
  * Have 比 a 优先级要高 大写比小写高
  */
 public static void main(String[] args) {
  String text="Hello,Chicago! Have a nice day! Baby! Have fun this day.";
  TreeMap<String, Integer> map=new TreeMap<String, Integer>();
  String[] words=text.split("[ \n\t\r.,;:!?(){]");
  for (int i = 0; i < words.length; i++) {
   String key=words[i].toLowerCase();
   if(key.length()>0){
    if(map.get(key)==null){
     map.put(key, 1);
    }else{
     int value=map.get(key).intValue();
     map.put(key, value+1);
    }
   }
  }
 
  for(Map.Entry<String, Integer> m:map.entrySet()){
   System.out.println(m.getKey()+" \t "+m.getValue());
  }
 }

public class AbsComparator implements Comparator<Object> {
 public int compare(Object o1, Object o2) {
   int v1=Math.abs(((Integer)o1).intValue());
   int v2=Math.abs(((Integer)o2).intValue());
   return v1>v2?1:(v1==v2?0:-1);
 }
}

public static void main(String[] args) {
   Random random=new Random();
   Integer[] ints=new Integer[20];
   for (int i = 0; i < ints.length; i++) {
   ints[i]=new Integer(random.nextInt(100)*(random.nextBoolean()?1:-1));
  }
  System.out.println("使用内置方法排序");
  Arrays.sort(ints);
  System.out.println(Arrays.asList(ints));
 
  System.out.println("使用自定义排序");
  Arrays.sort(ints,new AbsComparator());
  System.out.println(Arrays.asList(ints));
 }

public class Person implements Comparable<Object> {
 public int compareTo(Object o) {
  // TODO Auto-generated method stub
  return 0;
 }
}

参照书籍《Java语言程序设计·进阶篇》 下一篇是编程练习题

 2015年6月5日19:42:49  

我是菜鸟，我在路上。 

java集合框架22

标签：java   集合框架   collection   

原文地址：http://blog.csdn.net/cjvs9k/article/details/46381071