java集合

Posted 2020-07-13 未名胡

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

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,添加

    void  add(index,element);

    void  add(index,collection);

2,删除

    Object  remove(index);

3,修改

    Object  set(index,element);

4,获取：

    Object  get(index);

    int indexOf(object);

    int lastIndexOf(object);

    List  subList(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