java基础

关于java的集合类,以及HashMap中Set的用法!2007-08-07 16:17关于java的集合类,以及HashMap中Set的用法!  
 
2005-10-22 14:47:43 Sat | 阅读（547）次  
 
 
package com.tiantian;

import java.util.*;

public class JAVAContainer {

     public static void main(String[] args) throws Exception {
         //     ArrayList
         {
             ArrayList arraylist = new ArrayList();
             arraylist.add(0, "end");//指定索引加入值
             //     需注意的是，如果现有2个值，我加入索引为5的那么就会出现异常
             for (int i = 0; i < 2; i++) {
                 arraylist.add(i, String.valueOf(i));
             }
             System.out.println("ArrayList:");
             for (int i = 0; i < arraylist.size(); i++) {
                 System.out.print(arraylist.get(i) + ";");
             }
             arraylist.add("0");//直接加入值到ArrayList的最后
             arraylist.add("0");
             System.out.print(" ArrayList's lastIndexOf("0") is "
                     + arraylist.lastIndexOf("0"));
         }
         //     Arrays
         {
             String[] array = new String[] { "a", "b", "c" };
             List list = Arrays.asList(array);
             System.out.println(" Arrays:");
             for (int i = 0; i < list.size(); i++) {
                 System.out.print(list.get(i) + ";");
             }
             System.out.print(" Arrays's length is " + array.length);//打印数组的长度
         }
         //     Collections
         {
             String[] array = new String[] { "a", "b", "c" };
             List list = Arrays.asList(array);
             Collections.fill(list, "Fill");//用Fill填充全部元素
             System.out.println(" Collections:");
             for (int i = 0; i < list.size(); i++) {
                 System.out.print(list.get(i) + ";");
             }
             array = new String[] { "1", "2", "3" };
             List list2 = Arrays.asList(array);
             Collections.copy(list, list2);//拷贝list2的数据进list
             System.out.println(" " + list);
             Collections.swap(list, 2, 1);//调换索引为1和2的元素的位置
             System.out.println(list);
         }
         //     EventObject
         {
             String s = "hello";
             String s2 = s;
             EventObject eventobject = new EventObject(s);//一个准容器类型，确切的归类它不是容器
             System.out.println("EventObject:");
             System.out.println(eventobject.getSource());
             System.out.println(eventobject.equals(s2));
         }
         //     HashMap
         {
             HashMap hashmap = new HashMap();//一个速度最快的容器
             hashmap.put("0", "c");
             hashmap.put("1", "a");
             hashmap.put("2", "b");
             hashmap.put("3", "a");
             System.out.println("HashMap:");
             System.out.println(hashmap);//该容器有其内部的排序方式
             Set set = hashmap.keySet();//获取全部键
             Iterator iterator = set.iterator();
             while (iterator.hasNext()) {
                 System.out.print(hashmap.get(iterator.next()) + ";");
             }
         }
         //     HashSet
         {
             HashSet hashset = new HashSet();//一个绝对不能重复的类型
             hashset.add("c");
             hashset.add("b");
             hashset.add("a");
             hashset.add("a");
             hashset.add("b");
             System.out.println(" HashSet:");
             System.out.println(hashset);
             Iterator iterator = hashset.iterator();//取出元素
             while (iterator.hasNext()) {
                 System.out.print(iterator.next() + ";");
             }
         }
         //     Hashtable
         {
             Hashtable hashtable = new Hashtable();//一个完全可以由其他容器替换的老容器类型
             hashtable.put("0", "c");
             hashtable.put("1", "a");
             hashtable.put("3", "c");
             hashtable.put("2", "b");
             System.out.println(" Hashtable:");
             Enumeration enumeration = hashtable.elements();//获取元素，Enumeration已经不是主流，Iterator是它的下一代替代品
             while (enumeration.hasMoreElements()) {
                 System.out.print(enumeration.nextElement() + ";");
             }
         }
         //     IdentityHashMap
         {
             IdentityHashMap identityhashmap = new IdentityHashMap();
             identityhashmap.put("0", "c");
             identityhashmap.put("1", "a");
             identityhashmap.put("3", "b");
             identityhashmap.put("2", "a");
             System.out.println(" IdentityHashMap:");
             System.out.println(identityhashmap);
             System.out.println(identityhashmap.containsKey("3"));//是否包含这个键
             System.out.println(identityhashmap.containsValue("a"));//是否包含值
             Set set = identityhashmap.entrySet();//传为Set类型
             System.out.println(set);
             set = identityhashmap.keySet();//全部键
             System.out.println(set);
         }
         //     LinkedHashMap
         {
             LinkedHashMap linkedhashmap = new LinkedHashMap();
             linkedhashmap.put("0", "b");
             linkedhashmap.put("2", "a");
             linkedhashmap.put("1", "c");
             linkedhashmap.put("3", "b");
             System.out.println("LinkedHashMap:");
             System.out.println(linkedhashmap);
             System.out.println(linkedhashmap.containsKey("2"));//是否包含这个键
             System.out.println(linkedhashmap.containsValue("c"));//是否包含值
             Set set = linkedhashmap.keySet();
             Iterator iterator = set.iterator();
             while (iterator.hasNext()) {
                 System.out.print(linkedhashmap.get(iterator.next()) + ";");
             }
         }
         //     LinkedHashSet
         {
             LinkedHashSet linkedhashset = new LinkedHashSet();//它包含了几种Set的属性但却没有自己的特色
             linkedhashset.add("c");
             linkedhashset.add("a");
             linkedhashset.add("a");
             linkedhashset.add("b");
             System.out.println(" LinkedHashSet:");
             System.out.println(linkedhashset);
             System.out.println(linkedhashset.contains("a"));//是否包含对象
             Iterator iterator = linkedhashset.iterator();
             while (iterator.hasNext()) {
                 System.out.print(iterator.next() + ";");
             }
         }
         //     LinkedList
         {
             LinkedList linkedlist = new LinkedList();//自由使用是它的特色
             linkedlist.add("a");
             linkedlist.add(1, "c");
             linkedlist.addLast("b");
             linkedlist.addFirst("d");
             System.out.println(" LinkedList:");
             System.out.println(linkedlist);
             //     linkedlist.clear();//该方法清空容器
             //     linkedlist.remove(0);//删除索引为0的元素
             //     linkedlist.remove("d");//删除值为d的元素
             //     linkedlist.removeFirst();//删除第一个元素
             //     linkedlist.removeLast();//删除最后一个元素
             for (int i = 0; i < linkedlist.size(); i++) {
                 System.out.print(linkedlist.get(i) + ";");
             }
         }
         //     Stack
         {
             Stack stack = new Stack();//堆栈
             stack.add("b");
             stack.add(0, "c");
             stack.push("d");
             stack.add("e");
             stack.push("a");
             Enumeration enumeration = stack.elements();
             System.out.println(" Stack:");
             while (enumeration.hasMoreElements()) {
                 System.out.print(enumeration.nextElement() + ";");
             }
             //     后进先出
             System.out.println(" " + stack.peek());
             System.out.println(stack.pop());
             System.out.println(stack.contains("d") + ";" + stack.contains("a"));//是否包含该元素,有趣的事情发生了
             System.out.println(stack.search("c"));//非常有用的属性，检索，但是由后向前的排列
         }
         //     TreeMap
         {
             TreeMap treemap = new TreeMap();
             treemap.put("0", "d");
             treemap.put("2", "a");
             treemap.put("1", "b");
             treemap.put("3", "c");
             System.out.println(" TreeMap:");//可以对键排序
             System.out.println(treemap);
             System.out.println(treemap.firstKey());//返回第一个键
             Set set = treemap.keySet();
             Iterator iterator = set.iterator();
             while (iterator.hasNext()) {
                 System.out.print(treemap.get(iterator.next()) + ";");
             }
         }
         //     TreeSet
         {
             TreeSet treeset = new TreeSet();//自动排序内容
             treeset.add("b");
             treeset.add("a");
             treeset.add("c");
             treeset.add("d");
             System.out.println(" TreeSet:");
             System.out.println(treeset);
             System.out.println(treeset.first());//返回第一个元素
             Iterator iterator = treeset.iterator();
             while (iterator.hasNext()) {
                 System.out.print(iterator.next() + ";");
             }
         }
         //     Vector
         {
             Vector vector = new Vector();
             vector.add(0, "b");
             vector.add("a");
             vector.addElement("d");
             vector.add("c");
             System.out.println(" Vector:");
             System.out.println(vector);
             vector.set(2, "h");//替换掉指定索引的元素
             System.out.println(vector);
             Object[] str = vector.toArray();
             for (int i = 0; i < str.length; i++) {
                 System.out.print(str[i] + ";");
             }
             vector.setSize(2);//重新设置大小为2
             System.out.println(" " + vector);
         }
         //     WeakHashMap
         {
             WeakHashMap weakhashmap = new WeakHashMap();
             weakhashmap.put("1", "b");
             weakhashmap.put("2", "c");
             weakhashmap.put("0", "d");
             weakhashmap.put("3", "a");
             System.out.println(" WeakHashMap:");
             System.out.println(weakhashmap);
             System.out.println(weakhashmap.containsKey("3"));//是否包含键
             System.out.println(weakhashmap.containsValue("d"));//是否包含值
             Set set = weakhashmap.entrySet();
             Iterator iterator = set.iterator();
             while (iterator.hasNext()) {
                 System.out.print(iterator.next() + ";");
             }
             //     weakhashmap.remove("2");//删除该键对应的值
             //     weakhashmap.get("1");//获取指定键的值
         }
     }
 
 
 

posted on 2008-01-25 08:45 youngturk 阅读(271) 评论(0)  编辑  收藏 所属分类: 新认识笔记


只有注册用户登录后才能发表评论。
网站导航:
 
<2008年1月>
日一二三四五六
303112345
6789101112
13141516171819
20212223242526
272829303112
3456789

导航

统计

公告

this year :
1 jQuery
2 freemarker
3 框架结构
4 口语英语

常用链接

留言簿(6)

随笔分类

随笔档案

文章分类

文章档案

相册

EJB学习

Flex学习

learn English

oracle

spring MVC web service

SQL

Struts

生活保健

解析文件

搜索

最新评论

阅读排行榜

评论排行榜