java中集合类HashSet、ArrayList、LinkedList总结以及例子

【HashSet】   

        1. HashSet存储不能够存储相同的元素，元素是否相同的判断：重写元素的equals方法。equals方法和hashCode方法必须兼容，如：equals方法判断的是用户的名字name，那么hashCode的返回的hashcode必须是name。hashcode（）；

        2. HashSet存储是无序的，保存的顺序与添加的顺序是不一致的，它不是线性结构，而是散列结构，（通过散列表：散列单元指向链表）。因此，HashSet的查询效率相对比较高。

        3. HashSet不是线程安全的，不是线程同步的。这需要自己实现线程同步：Collections.synchronizedCollection()，方法实现。

 代码：

@Test
public void HashSetTest(){
Set hashset=new HashSet<String>();   //
Scanner in=new Scanner(System.in);
System.out.println("请输入三个string类型字符串：");
for(int i=0;i<5;i++){
String nuwstring=in.next();   //输入三个字符串，并添加到hashset中
hashset.add(nuwstring);
}
System.out.println("有以下的存储数据");
Iterator<String> it = hashset.iterator();     //用迭代器迭代出来。
while (it.hasNext()) {  
 String str = it.next();  
 System.out.println(str);  
}  
}

测试结果：

分析：（1）存储的顺序是无序的，因此查询出来顺序是随机的。证明了它不是线性结构，而是散列结构

（2）当输入重复值amy的时候，发现并没有存储成功，因此证明了：hashset遇到相同的值的时候不会存储进去。

（3）并且存储是散列的，不会排序。需要排序的话用treeset

【ArrayList】

         1.  不是线程安全的，不是线程同步的。

         2.ArrayList是通过可变大小的数组实现的，允许null在内的所有元素。

         3.ArrayList中存放顺序和添加顺序是一致的。并且可重复元素。

         4.ArrayList适合通过位子来读取元素。

 @Test
public void ArrayListTest(){
List list=new ArrayList<String>();
Scanner in=new Scanner(System.in);
System.out.println("ArrayListTest请输入string类型字符串：");
for(int i=0;i<5;i++){
String nuwstring=in.next();
list.add(nuwstring);
}
System.out.println("ArrayListTest有以下的存储数据");
Iterator<String> it = list.iterator();  
while (it.hasNext()) {  
 String str = it.next();  
 System.out.println(str);  
}  
}

运行结果：

遍历出来的顺序和输入顺序一样，证明了：是有序的，存放顺序和添加顺序是一致的。并且可重复元素

【LinkedList】

         1.不是线程安全的，不是线程同步的。

         2.LinkedList是通过双向循环链表来实现的。

         3.存放顺序和添加顺序是一致的。可添加重复元素。

         4.适合链表头尾操作和插入指定位置元素的操作。

ArrayList和LinkedList之间的数据传递可通过toArray（）方法。

 

【HashMap】

          1.非线程安全，不是线程同步。

          2.添加顺序和保存的顺序是不一致的。

          3.必须重写key的equals方法和hashCode方法。

          4.HashMap的实际容量=容量*因子，默认为16*0.75=12.所以考虑到HashMap的添加的效率问题，根据实际情况来设计它的开始的默认的容量。

           的操作方法根据api来查找。

          5.添加的值中是允许有null的值存在的。

 @Test
public void HashMapTest(){
Map hashmap=new HashMap<String,String>();
Scanner in=new Scanner(System.in);
System.out.println("HashMapTest请输入string类型字符串：");
for(int i=0;i<5;i++){
System.out.print("请分别输入key和value值：");
String key=in.next();
String value=in.next();
hashmap.put(key, value);
}
System.out.println();  
 System.out.println("--------------------遍历整个HashMap----------------------");  
 //Collection 类是Map和Set接口的父类  
 Collection objs = hashmap.entrySet();  
 for (Iterator iterator=objs.iterator(); iterator.hasNext();){  
  Object obj = iterator.next();  
  System.out.println(obj);  
 }       
 System.out.println();  
 System.out.println("--------------------遍历HashMap的key----------------------");  
 Collection keys = hashmap.keySet();  
 for (Iterator iterator=keys.iterator(); iterator.hasNext();){  
  Object key = iterator.next();  
  System.out.println(key);  
 }       
 System.out.println();  
 System.out.println("--------------------遍历HashMap的value----------------------");  
 Collection values = hashmap.values();  
 for (Iterator iterator=values.iterator(); iterator.hasNext();){  
  Object value = iterator.next();  
  System.out.println(value);  
 }   

}

运行结果：

【Hashtable】

          1.是线程安全的，是线程同步的，在实现线程同步的时候是不需要手动来实现线程同步的。因此相对效率低。

          2.添加的顺序和保存的顺序是不一致的。

          3.添加的值中是不允许有null值存在的。

 

【TreeMap】

          1.非线程安全，不是线程同步的。在必要的情况下必手动实现线程同步。

          2.在元素的添加，删除和定位映射中效率相对hashMap较低。但是在排序方面TreeMap比较实用。

          3.添加的值中允许有null值，但是在输出的时候会报空指针异常。

为了实现添加，删除效率提高同时实现排序的功能，则可以同时实用HashMap和TreeMap。现在HashMap对象hmap中添加和删除，然后在TreeMap对象map.putAll（hmap）来实现排序。部分代码如下：

@Test
public void TreeMapTest(){
Map<Integer, String> map = new HashMap<Integer, String>();
Scanner in=new Scanner(System.in);
System.out.println("TreeMapTest请输入string类型字符串：");
for(int i=0;i<5;i++){
System.out.print("请分别输入key和value值：");
Integer key=in.nextInt();
String value=in.next();
map.put(key, value);
}
System.out.println("由TreeMap类实现的Map集合，键对象降序：");
TreeMap<Integer, String> treeMap2 = new TreeMap<Integer, String>(
Collections.reverseOrder());// 初始化为反转排序
treeMap2.putAll(map);
 Collection objs = treeMap2.entrySet();  
 for (Iterator iterator=objs.iterator(); iterator.hasNext();){  
  Object obj = iterator.next();  
  System.out.println(obj);  
 }  
}

运行结果如下：