Java常见集合的归纳总结

Java常见集合的归纳总结

 

 

首先来看看集合的关系：

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

 

 一、Collection接口中定义的方法

        int size():获取当前集合中的元素数量

 

        boolean isEmpty():查看当前集合中是否包含元素

                                         不包含返回true  

                                         检查当前集合是否为空集 

 

        boolean contains(Object o):

                                          查看当前集合中是否包含给定的元素

 

         void clear():清空集合

 

         boolean add(E e):向集合中添加元素

                                          当元素成功添加到集合中返回true

 

          boolean remove(Object o):从集合中删除给定的元素

 

          boolean addAll(Collection c):

                                           将给定集合中的所有元素添加到当前集合

 

           boolean removeAll(Collection c):

                                            删除当前集合中与给定集合中相同的元素

 

            Iterator iterator():

                                          获取迭代

二、List接口

        1）ArrayList

              1.ArrayList集合是有序的，可重复的集合，可以根据下表来取元素(下表从0开始)

               2.常用方法有:

                   add()   增加元素

                   set()     修改元素的值

                   remove()   删除元素

                   indexOf()   第一个对应元素的下标

                   lastIndexOf()   最后一个对应元素的下标

                   subList(int a,int b)   取子集(操作子集会影响原集合) 下标前包含后不包含[a,b)   List中的独有方法

                   toArray()   集合转化成数组(Arrays.toString(array)是显示该数组的方法)

               2.遍历集合的统一方式:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * 遍历集合的统一方式
 * 迭代器模式
 * @author admin
 *
 */
public class IteratorDemo {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("one");
		c.add("two");
		c.add("three");
		
		//java.util.Iterator
		/*
		 * Iterator不能实例化（接口）
		 * 不同的集合提供了可以遍历自身元素的迭代器实现
		 */
		Iterator it = c.iterator();
		/*
		 * 使用迭代器遍历集合的步骤
		 * 问取删
		 * 删不是必须的操作
		 */
		//问问集合是否还有元素可以遍历
		while(it.hasNext()){
			//取出这个元素
			Object element = it.next();
			//每次调用next()方法前都应先确保hasNext()为true
//			element = it.next();
			System.out.println(element);
		}
		
	}
}

 

        2）LinkedList

               1.Queue接口定义了队列存取元素的基本方法，基于LinkedList的实现原理，它非常适合队列的特性。

                   队列，遵循先进先出原则.

                   1>.Queue常用方法

                         offer()   向队列末尾追加新元素

                         poll()   获取队首元素，获取后该元素就从队列中被删除

                         peek()   获取队首元素，但不从队列中删除

                 

                  2.Deque   双端队列，两端都可以进出队但当我们约束从队列的一端进出队时，就形成了另一种存取模式

                      先进后出原则，这就是栈结构

                   1>.Deue常用方法

                         push()   压入元素

                         pop()   “弹出"栈顶元素（注意，当栈中没有元素的时候pop方法会引发异常）

                  

三、Map接口

        Map中的key不允许重复。

        1）HashMap 一个多行两列的表格存储元素以 key-value对的形式，散列算法实现的Map。

            1>常用方法：

                 put()   存放元素

                 toString()   HashMap重写了toString()，格式为{key1=value1,key2=value2,....}

                 get(key)   取对应key值的元素的值

                 boolean containsKey(Object k)   查看当前Map中是否包含给定的key

                 boolean containsValue(Object v)   查看当前Map中是否包含给定的value

       

                4>HashMap的遍历

 

public class IterateMapDemo {
	public static void main(String[] args) {
		Map<Integer,String> map 
			= new HashMap<Integer,String>();

		map.put(1, "一");
		map.put(2, "二");
		map.put(3, "三");
		map.put(4, "四");
		map.put(5, "五");
		
		/*
		 * 获取Map中所有的key
		 * Set keySet()
		 * 获取一个Set集合，该集合中存放当前Map中的所有key
		 */
		Set<Integer> keys = map.keySet();
		
		for(Integer key : keys){
			System.out.println("key:"+ key);
		}
		
		/*
		 * 遍历每组键值对
		 * Map中每组键值对，使用一个Entry实例保存的
		 * Set entrySet()
		 * 获取一个Set集合，其中每一个元素是一个Entry的
		 * 实例，而每一个Entry的实例都包含着两个内容
		 * 分别是key与value
		 */
		//java.util.Map.Entry
		Set<Entry<Integer,String>> entrySet 
									= map.entrySet();
		
		for( Entry<Integer,String> entry : entrySet ){
			
			System.out.println(
				"key:" + entry.getKey() + "," +
				"value:" + entry.getValue()
			);
			
		}
		
		/*
		 *  Collection values()
		 *  遍历所有的value，这个操作很少用
		 */
		Collection<String> values = map.values();
		for(String value : values){
			System.out.println("value:" + value);
		}
		
	}

 

 

      

            3>HashMap关于性能的几个名词

                Capacity 容量: Hashmap中数组的长度

                Initial capacity 初始容量:创建HashMap时，

                          数组的默认大小，16。

 

                 size 大小:HashMap中的元素数量

 

                  load factor 加载因子:默认值0.75

                            是一个比值 size/capacity

                    

                每当size/capacity达到加载因子时，数组扩容

                并且对原数组中的数据重新进行散列算法并存入

                扩容后的数组中

                 

四、Set集合的实现类

        1）HashSet

               使用散列算法实现的

               存放元素的顺序与元素在集合中的顺序不一致 但是元素在不改变的情况下，在集合中的顺序是一致                 的

                Set集合的不重复的集合。

                   1>.HashSet常用方法

                 add()   添加元素

                 remove()   删除元素

                         注意：a.一般循环遍历的时候删除Set集合使用用迭代器的remove()方法，不能直接调用                                             Set.remove(e)否则会报异常.                                   

                                    b:存放元素时是根据元素的hashcode()方法的返回值进行的，所以要保证equals方法                                        为ture的元素应具有相同的hashcode

                                     c:尽可能不要在元素存入集合后修改该元素的内容防止hashcode值发生变化导致不                                           能正确访问

        1）TreeSet 

               使用二叉树实现的

 

五、集合的排序

       1）ArrayList排序

            使用集合的工具类 Collections.sort(list)方法做自然排序。  

            

        2）实现Comparator接口

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/*
 * Comparable接口与Comparator接口
 */
public class ComparableDemo {
	public static void main(String[] args) {
		//实现该类后，子类是可比较的
		Comparable c;
		/*
		 * 当我们需要排序的元素自身已经实现了Comparable
		 * 接口，并且定义好了比较规则，但这种比较规则不能
		 * 满足我们对于排序的需求是，我们就需要提供一种
		 * 额外的比较规则，这时候我们就需要使用Comparator
		 */
		List<String> list = new ArrayList<String>();		
		list.add("Killer");
		list.add("adam");
		list.add("cark");
		list.add("marry");
		list.add("Boss");
		list.add("Jazz");
		list.add("jason");
		list.add("mark");
		list.add("bill");		
		System.out.println(list);		
		Collections.sort(list);		
		System.out.println(list);		
		/*
		 * 不能够满足我们的希求，我们希望字母少的在前
		 * 字母多的在后
		 */
		MyComparator comparator = new MyComparator();
		/*
		 * 使用Collections的重载sort方法
		 */
		Collections.sort(list, comparator);
		System.out.println(list);	
	}
}
/**
 * 为字符串提供额外的比较规则
 * @author admin
 *
 */
class MyComparator implements Comparator<String>{
	/**
	 * 根据字符串的长度进行比较
	 */
	public int compare(String o1, String o2) {
		return o2.length() - o1.length();
	}	
}