关于java的集合类,以及HashMap中Set的用法!

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");//获取指定键的值
         }
     }
}

 

JAVA提高认识Set集合之HashSet：

集合在Java里面的作用非凡，我们常用的有Set,List和Map三种，我们先熟悉一下Set，特别是HashSet的使用

 

package collection.lession2;

import java.util.HashSet;
import java.util.Set;

/**
 * 认识Set集合之HashSet。<br>
 * Set用来保存不允许重复的数据。可以是任何对象类型。<br>
 * JDK5以后，主类型可以通过autobox 放入Set里面。
 * 
 *
 */
public class Lession2 {

  public static void main(String[] args) {
    // 普通测试
    testNormal();

    // 测试HashSet的特殊性
    testForHashSet();
    testForHashSet2();
  }

  /**
   * 测试保存混合类型的数据.
   */
  public static void testNormal() {
    System.out.println("----- testNormal -----------");
    // Set有多个实现，我们先看看最常用的HashSet
    Set set = new HashSet();
    // 添加一个字符串
    set.add("字符串");
    // 添加一个整数对象
    set.add(new Integer(1));
    // 利用JDK5的特性，增加一个浮点数
    set.add(123.45);

    // 我们看看集合里对象的数量
    System.out.println(set.size());

    // 我们尝试增加一个重复的字符串
    set.add("字符串");

    // 我们再次看看集合里对象的数量
    System.out.println(set.size());

    // 我们来测试看看是否集合里包含了某个数据
    System.out.println(set.contains(123.45));

    // 我们从里面把这个浮点数删除
    set.remove(123.45);

    // 我们再次看看集合里对象的数量
    System.out.println(set.size());
  }

  /**
   * 专门针对HashSet的测试。
   */
  public static void testForHashSet() {
    System.out.println("----- testForHashSet -----------");
    HashSet<MyObject> set = new HashSet<MyObject>();

    // 增加一个null对象
    set.add(null);
    // 我们再次看看集合里对象的数量
    System.out.println(set.size());
    // 再次增加一个null看看
    set.add(null);
    // 我们再次看看集合里对象的数量
    System.out.println(set.size());

    MyObject obj = new MyObject("java2000", 2);
    set.add(obj);

    obj = new MyObject("csdn", 10);
    set.add(obj);

    // 我们再次看看集合里对象的数量
    System.out.println(set.size());

    // 判断是否包含某个对象
    System.out.println(set.contains(obj));

    obj = new MyObject("java2000_net", 2);
    set.add(obj);

    // 我们再次看看集合里对象的数量
    System.out.println(set.size());

    // 我们尝试把obj再次放入set看看
    // 并没有增加，因为是重复的
    set.add(obj);
    System.out.println(set.size());

    // 我们构造一个新的对象，内容和前面的相同
    obj = new MyObject("java2000_net", 2);
    set.add(obj);
    System.out.println(set.size());

    // 我们修改一下obj里面的年龄，再看看
    obj.setAge(3);

    // 我们再测试看看是否包含此对象。
    // 请注意，我们这个obj和前面的obj是同一个对象
  &nbs-p; // 我们仅仅修改了一下我们的年龄

    System.out.println(set.contains(obj));

    // 我们尝试把obj再次放入set看看
    // 我们又增加了长度
    set.add(obj);
    System.out.println(set.size());
  }

  /**
   * 专门针对HashSet的测试2。
   */
  public static void testForHashSet2() {
    System.out.println("----- testForHashSet2 -----------");
    HashSet<MyObject2> set = new HashSet<MyObject2>();
    MyObject2 obj = null;
    for (int i = 0; i < 3; i++) {
      obj = new MyObject2("java2000" + i, i);
      set.add(obj);
      System.out.println(set.size());
    }
  }

}

class MyObject {
  private int age;
  private String name;

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  MyObject(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public boolean equals(Object obj) {
    System.out.println("equals");
    if (obj == null || !(obj instanceof MyObject)) {
      return false;
    }
    MyObject o = (MyObject) obj;
    return this.age == o.age && this.name.equals(o.name);
  }

  public int hashCode() {
    int hashCode = name.hashCode() + String.valueOf(age).hashCode();
    return hashCode;
  }
}

class MyObject2 {
  private int age;
  private String name;

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  MyObject2(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public boolean equals(Object obj) {
    System.out.println("equals");
    if (obj == null || !(obj instanceof MyObject2)) {
      return false;
    }
    MyObject2 o = (MyObject2) obj;
    return this.age == o.age && this.name.equals(o.name);
  }

pan class="keyword">int hashCode() {
    return 1;
  }
}

class MyObject3 {
  private int age;
  private String name;

  // 采用一个变量进行控制
  // 一旦生成了hashCode,则不再变动
  private int HASHCODE = Integer.MIN_VALUE;

  public int hashCode() {
    if (HASHCODE == Integer.MIN_VALUE) {
      // 重新生成本类的hashCode
      HASHCODE = name.hashCode() + String.valueOf(age).hashCode();

    }
    return HASHCODE;
  }
}
说明,针对HashSet： 

Set不允许重复
允许 null,重复的null只算一个
判断是否存在一个数据(是否重复)，先判断其hashCode是否存在，若存在再逐个判断hashCode相同的数据是否相等
判断是否相等，除了hashCode相等外，还要判断对象引用相等(==)，或者 equals
如果一个对象的hashCode变动了，会造成找不到这个对象，也就出现了内存泄漏的危险。
hashCode 方法是HashSet里面对象的关键，它的算法影响到了数据的分散和查找效率。某个确认对象的hashCode不应该变动，避免出现内存泄漏，可以采用如下方法，来方式属性变化造成hashCode变化

class MyObject3 {
  private int age;
  private String name;

  // 采用一个变量进行控制
  // 一旦生成了hashCode,则不再变动
  private int HASHCODE = Integer.MIN_VALUE;

  public int hashCode() {
    if (HASHCODE == Integer.MIN_VALUE) {
      // 重新生成本类的hashCode
      HASHCODE = name.hashCode() + String.valueOf(age).hashCode();

    }
    return HASHCODE;
  }
}