java集合

时间：2016-05-27 12:19:19 阅读：307 评论：0 收藏：0 [点我收藏+]

标签：

首先先截个图来看看集合所包含的类及接口：

技术分享

Iterator接口

首先先了解Iterator迭代器接口

Collection 接口的iterator()方法返回一个 Iterator。Iterator接口方法能以迭代方式逐个访问集合中各个元素，并安全的从Collection 中除去适当的元素

方法：

boolean hasNext()：判断是否存在另一个可访问的元素

Object next()：返回要访问的下一个元素

remove()：删除对象

/**
 * 迭代器的举例
 * @author hulin
 *
 */
public class IteratorDemo {
	public static void main(String[] args){  
	   List<String> list= new ArrayList<String>();  
	   		list.add("Hello");  
	   		list.add("你好！！");  
	   		list.add("World!!!");  
	    	Iterator<String> iter = list.iterator();  
	        while(iter.hasNext()){    //判断是否有内容  
	            System.out.println(iter.next());    //输出内容  
	        }  
	    }  
}
Hello
你好！！
World!!!

Collection接口：

Collection的常见方法：

1,添加。

boolean add(Object obj);

boolean addAll(Collection coll);

2,删除。

boolean remove(object obj);

boolean remove(Collection coll);

void clear();

3,判断：

boolean contains(object obj);

boolean containsAll(Collection coll);

boolean isEmpty();判断集合中是否有元素。

4,获取：

int size();

Iterator iterator();取出元素的方式，迭代器。

该对象必须依赖于具体容器，因为每一个容器的数据结构不同。

所以该迭代器对象是在容器中进行内部实现的。

对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可。

也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

5,其他：

boolean retainAll(Collection coll);取交集。

Object[]toArray();将集合转成数组。

示例：

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

import javax.swing.text.html.HTMLDocument.Iterator;

public class IteratorDemo {

	public static void main(String[] args) {
		Collection coll=new ArrayList();
		coll.add("abc1");
		coll.add("abc2");
		coll.add("abc3");
		coll.add("abc4");
//		System.out.println(coll);
		//使用了Collection中的iterator方法。调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
		Iterator it=coll.iterator();
//		while(it.hasNext()){
//			System.out.println(it.next());
//		}
		for(Iterator it=coll.iterator();it.hasNext();){//开发写这个
			System.out.println(it.next());
		}
//		System.out.println(it.next());//abc1
//		System.out.println(it.next());//abc2
//		System.out.println(it.next());//abc3
//		System.out.println(it.next());//abc4
//		System.out.println(it.next());//java.utilNoSuchElementException

	}

}

List和Set的特点

Collection

|--List:有序（存入和取出的顺序一致），元素都有索引（角标），元素可以重复。

|--Set:元素不能重复，无序。

List集合

List 接口继承了 Collection 接口以定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理，还添加了面向位置的操作。

List:特有的常见方法：有一个共性特点就是都可以操作角标。

1,添加

voidadd(index,element);

voidadd(index,collection);

2,删除

Objectremove(index);

3,修改

Objectset(index,element);

4,获取：

Objectget(index);

int indexOf(object);

int lastIndexOf(object);

ListsubList(from,to);

list集合是可以完成对元素的增删改查。

示例：

public class ListDemo {
	public static void main(String[] args) {
		List list=new ArrayList();
		show(list);
	}
	public static void show(List list) {
		//添加元素
		list.add("abc1");
		list.add("abc2");
		list.add("abc");
		System.out.println(list);//[abc1, abc2, abc]
		//插入元素。
		list.add(1,"abc9");
		System.out.println(list);//[abc1, abc9, abc2, abc]
		//删除元素
		System.out.println("remove:"+list.remove(2));//remove:abc2
		System.out.println(list);//[abc1, abc9, abc]
		//修改元素
		System.out.println("set:"+list.set(1,"abc8"));//set:abc9
		System.out.println(list);//[abc1, abc8, abc]
		//获取元素
		System.out.println("get:"+list.get(0));//get:abc1
		//获取子列表
		System.out.println("sublist:"+list.subList(1, 2));//sublist:[abc8]

	}

}

ListIterator接口

public class ListDemo2 {

	public static void main(String[] args) {
		List list=new ArrayList();
//		show(list);
		
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		System.out.println("list:"+list);//list:[abc1, abc2, abc3]
		
		
		ListIterator it=list.listIterator();//获取列表迭代器对象
		//它可以实现在迭代过程中完成对元素的增删改查。
		//注意：只有list集合具备该迭代功能。
		while(it.hasNext()){
			Object obj=it.next();
			if(obj.equals("abc2")){
				it.add("abc9");
			}
		}
		System.out.println("list:"+list);//list:[abc1, abc2, abc9, abc3]
		
		System.out.println("hasNext:"+it.hasNext());//hasNext:false
		System.out.println("hasPrevious:"+it.hasPrevious());//hasPrevious:true
		
		while(it.hasPrevious()){
			System.out.println("previous:"+it.previous());//previous:abc3  previous:abc9 previous:abc2 previous:abc1
		}
//		public boolean add(Object obj){
			
//		}
		/*
		Iterator it=list.iterator();
		while(it.hasNext()){
			Object obj=it.next();// java.util.ConcurrentModificationException
								//在迭代器过程中，不要使用集合操作元素，容易出现异常。
								//可以使用iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。
			if(obj.equals("abc2")){
				list.add("abc9");
			}
			else
			System.out.println("it.next()"+obj);
		}
		System.out.println(list);
	*/
	}

	public static void show(List list) {
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		list.add("abc4");
		
		Iterator it=list.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		//list特有的取出元素方式之一。
		for(int x=0;x<list.size();x++)
		System.out.println("get:"+list.get(x));
	}

}

List常用子类的特点

list集合是可以完成对元素的增删改查。

（数据结构）

List:

|--Vector:内部是数组数据结构，是同步的。增删查询都很慢。

|--ArrayList:内部是数组数据结构，是不同步的，替代了Vector。查询速度快。

|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

数组和链表：

技术分享

Vector集合

内部是数组数据结构，是同步的。增删查询很慢。少用

public class VectorDemo {
	public static void main(String[] args) {
		Vector v=new Vector();
		v.addElement("abc1");
		v.addElement("abc2");
		v.addElement("abc3");
		v.addElement("abc4");
		
		Enumeration en=v.elements();
		while(en.hasMoreElements()){
			System.out.println("nextelment:"+en.nextElement());
		}
		Iterator it=v.iterator();
		while(it.hasNext()){
			System.out.println("next:"+it.next());
		}
	}

}
nextelment:abc1
nextelment:abc2
nextelment:abc3
nextelment:abc4
next:abc1
next:abc2
next:abc3
next:abc4

LinkedList集合

内部是链表结构，是不同步的，增删元素的速度很快

方法：

void addFirst(Object o)：将对象o添加到列表的开头

void addLast(Object o)：将对象o添加到列表的结尾

Object getFirst()：返回列表开头的元素

Object getLast()：返回列表结尾的元素

Object removeFirst()：删除并且返回列表开头的元素

Object removeLast()：删除并且返回列表结尾的元素

LinkedList()：构建一个空的链接列表

LinkedList(Collection c)构建一个链接列表，并且添加集合c的所有元素

public class LinkedListDemo {
	public static void main(String[] args) {
		LinkedList link=new LinkedList();
		link.addFirst("abc1");
		link.addFirst("abc2");
		link.addFirst("abc3");
		link.addFirst("abc4");
		System.out.println(link);
		
//		System.out.println(link.getFirst());//获取第一个元素但不删除
//		System.out.println(link.getFirst());
		
		System.out.println(link.removeFirst());//获取第一个元素但是会删除
		System.out.println(link.removeFirst());
		
		while(!link.isEmpty()){
			System.out.println(link.removeFirst());//[]
		}
			
			
		System.out.println(link);
		
		
//		Iterator it=link.iterator();
//		while(it.hasNext()){
//			System.out.println(it.next());
		}
	}

LinkedList集合-练习(堆栈和队列)

LinkedList:

addFirst():

addLast():

jdk1.6

offerFirst():

offerLast():

getFirst()://获取但不移除，如果链表为空，抛出NoSuchElementException

getLast():

jdk1.6

peekFirst()://获取但不移除，如果链表为空，返回null.

peekLast():

removeFirst()://获取并移除，如果链表为空，抛出NoSuchElementException

removeLast():

jdk1.6

pollFirst()://获取并移除，如果链表为空，返回null.

pollLast():

ArrayList

内部是数组数据结构，是不同步的，代替了Vector。查询速度快

方法：（由于继承的是List，所以List的方法也适用，这里不多举例）

void ensureCapacity(int minCapacity)：将ArrayList对象容量增加minCapacity

void trimToSize()：整理ArrayList对象容量为列表当前大小。程序可使用这个操作减少ArrayList对象存储空间

public class Person {
	private String name;
	private int age;
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

public class ArrayListTest {
	public static void main(String[] args) {
		Person p1=new Person("lisi1",21);
		ArrayList a1=new ArrayList();
		a1.add(p1);
		a1.add(new Person("lisi2",22));
		a1.add(new Person("lisi3",23));
		a1.add(new Person("lisi4",24));
		
		Iterator it=a1.iterator();
		while(it.hasNext()){
//			System.out.println(((Person)it.next()).getName());
			Person p=(Person) it.next();
			System.out.println(p.getName()+"----"+p.getAge());
		}
//		a1.add(5);//a1.add(new Integet(5));
//		show(6);
	}

//	public static void show(Integer num) {//Object num=new Integer(6);//当基本数据类型值 与引用数据类型时  自动装箱
		
//		int x=num+8;//拆箱
//	}

}

Set接口
Set 接口继承 Collection 接口，而且它不允许集合中存在重复项，每个具体的 Set 实现类依赖添加的对象的 equals()方法来检查独一性。
Set接口没有引入新方法，所以Set就是一个Collection，只不过其行为不同。

Hash表是一种数据结构，用来查找对象。Hash表为每个对象计算出一个整数，称为Hash Code(哈希码)。

Hash表是个链接式列表的阵列。每个列表称为一个buckets(哈希表元)。

对象位置的计算　index = HashCode % buckets (HashCode为对象哈希码，buckets为哈希表元总数)。
当你添加元素时，有时你会遇到已经填充了元素的哈希表元，这种情况称为Hash Collisions(哈希冲突)。这时，你必须判断该元素是否已经存在于该哈希表中。
如果哈希码是合理地随机分布的，并且哈希表元的数量足够大，那么哈希冲突的数量就会减少。同时，你也可以通过设定一个初始的哈希表元数量来更好地控制哈希表的运行。初始哈希表元的数量为　buckets = size * 150% + 1 (size为预期元素的数量)。
如果哈希表中的元素放得太满，就必须进行rehashing(再哈希)。再哈希使哈希表元数增倍，并将原有的对象重新导入新的哈希表元中，而原始的哈希表元被删除。load factor(加载因子)决定何时要对哈希表进行再哈希。在Java编程语言中，加载因子默认值为0.75，默认哈希表元为101。

HashSet
|-----LinkedHashSet：LinkedHashSet的迭代器按照元素的插入顺序来访问各个元素。

方法：

HashSet()：构建一个空的哈希集

HashSet(Collection c)：构建一个哈希集，并且添加集合c中所有元素

HashSet(int initialCapacity)：构建一个拥有特定容量的空哈希集

HashSet(int initialCapacity, float loadFactor)：构建一个拥有特定容量和加载因子的空哈希集。LoadFactor是0.0至1.0之间的一个数

/**
 * HashSet实例
 * @author hulin
 *
 */
public class HashSetDemo {
	  public static void main(String[] args) {  
	        HashSet<String>  has=new HashSet<String>();  
	        has.add("1");  
	        has.add("1");  
	        has.add("2");  
	        has.add("3");  
	        has.add("4");  
	        has.add("2");  
	        Iterator<String>  it=has.iterator();   
	        while (it.hasNext()) {  
	            System.out.print(it.next()+" ");     
	        }  
	    }  
}

LinkedHashSet

LinkedHashSet的迭代器按照元素的插入顺序来访问各个元素。

/**
 * LinkedHashSet的实例
 * @author hulin
 *
 */
public class LinkedHashSetDemo {
	public static void main(String[] args) {
		LinkedHashSet<Integer> set = new LinkedHashSet<Integer>();
	     set.add(2);
	     set.add(4);
	     set.add(1);	      
	     Iterator<Integer> iter = set.iterator();      
	     System.out.println(set.isEmpty());
	     System.out.println(set.size());
	     System.out.println(set.contains(2));
	     System.out.println(set.remove(2));
	     set.clear();
	}
	
}
false
3
true
true

TreeSet

树集集合

方法：

TreeSet()：构建一个空的树集

TreeSet(Collection c)：构建一个树集，并且添加集合c中所有元素

TreeSet(Comparator c)：构建一个树集，并且使用特定的比较器对其元素进行排序

/**
 * TreeSet的实例
 * @author hulin
 *
 */
public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet ts = new TreeSet(); 
		ts.add("张三");
		ts.add("李四");
		ts.add("王五");
		Iterator it=ts.iterator();
		while(it.hasNext()){
			System.out.print(it.next()+" ");
		}
	}
}
张三 李四 王五

Map接口

Map接口不是Collection接口的继承。Map接口用于维护键/值对(key/value pairs)。该接口描述了从不重复的键到值的映射。

方法：

(1) 添加、删除操作

Object put(Object key, Object value)：将互相关联的一个关键字与一个值放入该映像。如果该关键字已经存在，那么与此关键字相关的新值将取代旧值。方法返回关键字的旧值，如果关键字原先并不存在，则返回null

Object remove(Object key)：从映像中删除与key相关的映射

void putAll(Map t)：将来自特定映像的所有元素添加给该映像

void clear()：从映像中删除所有映射

(2) 查询操作

Object get(Object key): 获得与关键字key相关的值，并且返回与关键字key相关的对象，如果没有在该映像中找到该关键字，则返回null

boolean containsKey(Object key)：判断映像中是否存在关键字key

boolean containsValue(Object value)：判断映像中是否存在值value

int size()：返回当前映像中映射的数量

boolean isEmpty()：判断映像中是否有任何映射

(3) 视图操作：处理映像中键/值对组

Set keySet()：返回映像中所有关键字的视图集（因为映射中键的集合必须是唯一的，用Set支持。还可以从视图中删除元素，同时，关键字和它相关的值将从源映像中被删除，但是不能添加任何元素）

Collection values()：返回映像中所有值的视图集（“因为映射中值的集合不是唯一的，用Collection支持。还可以从视图中删除元素，同时，值和它的关键字将从源映像中被删除，但是不能添加任何元素）

Set entrySet()：返回Map.Entry对象的视图集，即映像中的关键字/值对（“因为映射是唯一的，用Set支持。还可以从视图中删除元素，同时，这些元素将从源映像中被删除，但是不能添加任何元素）

HashMap类

使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。
在Map 中插入、删除和定位元素，HashMap 是最好的选择。
但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好（下面讲到）

方法：

HashMap()：构建一个空的哈希映像

HashMap(Map m)：构建一个哈希映像，并且添加映像m的所有映射

HashMap(int initialCapacity)：构建一个拥有特定容量的空的哈希映像

HashMap(int initialCapacity, float loadFactor)：构建一个拥有特定容量和加载因子的空的哈希映像

public class HashMapDemo {
	   
	 public static void main(String[] args){  
	  HashMap<String,Object> hm=new HashMap<String,Object>();  
	  People p1=new People();  
	  People p2=new People();  
	  People p3=new People();  
	  People p4=new People();  
	  hm.put("People3", p1);  
	  hm.put("People1", p2);  
	  hm.put("People4", p3);  
	  hm.put("People2", p4);    	    
	  Iterator<String> it=hm.keySet().iterator();  
	    
	  while(it.hasNext()){  
	   System.out.println(it.next());  
	  }    
	 }  
	}  
	class People {  
	 private String name;  
	 private int age;  
	 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;  
	 }  
}
People1
People2
People3
People4

LinkedHashMap类

LinkedHashMap扩展HashMap，以插入顺序将关键字/值对添加进链接哈希映像中。象LinkedHashSet一样，LinkedHashMap内部也采用双重链接式列表。

方法：

LinkedHashMap()：构建一个空链接哈希映像

LinkedHashMap(Map m)：构建一个链接哈希映像,并且添加映像m中所有映射

LinkedHashMap(int initialCapacity)：构建一个拥有特定容量的空的链接哈希映像

LinkedHashMap(int initialCapacity, float loadFactor)：构建一个拥有特定容量和加载因子的空的链接哈希映像

LinkedHashMap(int initialCapacity, float loadFactor,boolean accessOrder)：构建一个拥有特定容量、加载因子和访问顺序排序的空的链接哈希映像

protected boolean removeEldestEntry(Map.Entry eldest)：如果你想删除最老的映射，则覆盖该方法，以便返回true。当某个映射已经添加给映像之后，便调用该方法。它的默认实现方法返回false，表示默认条件下老的映射没有被删除。但是你可以重新定义本方法，以便有选择地在最老的映射符合某个条件，或者映像超过了某个大小时，返回true。

TreeMap类

TreeMap没有调优选项，因为该树总处于平衡状态。
在Map 中插入、删除和定位元素，HashMap 是最好的选择。
但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好

方法：

TreeMap()：构建一个空的映像树

TreeMap(Map m)：构建一个映像树，并且添加映像m中所有元素

TreeMap(Comparator c)：构建一个映像树，并且使用特定的比较器对关键字进行排序

TreeMap(SortedMap s)：构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序

/**
 * TreeMap实例
 * @author hulin
 *
 */
public class TreeMapDemo {
	 public static void main(String[] args) throws Exception {

	        // 逆序
	        TreeMap<String, String> treeMap = new TreeMap<String, String>(
	                Collections.reverseOrder());
	        treeMap.put("aaa","aaa");
	        treeMap.put("bbb","bbb");
	        treeMap.put("ccc","ccc");
	        treeMap.put("ddd","ddd");
	        treeMap.put("eee","eee");
	        treeMap.put("fff","fff");
	        Iterator<String> iter = treeMap.keySet().iterator();
	        while (iter.hasNext()) {
	            Object key = iter.next();
	            Object value = treeMap.get(key);
	            System.out.print("K: " + key);
	            System.out.println("V: " + value);
	        }

	        System.out.println("======================");
	        Iterator<?> it1 = treeMap.entrySet().iterator();
	        while (it1.hasNext()) {
	            System.out.println(it1.next());
	        }
	    }
}
K: fffV: fff
K: eeeV: eee
K: dddV: ddd
K: cccV: ccc
K: bbbV: bbb
K: aaaV: aaa
======================
fff=fff
eee=eee
ddd=ddd
ccc=ccc
bbb=bbb
aaa=aaa

java集合

标签：

原文地址：http://blog.csdn.net/qq_30641447/article/details/51497135

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行