博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
Java - Collection
阅读量：5278 次
发布时间：2019-06-14

本文共 20639 字，大约阅读时间需要 68 分钟。

Collection层次结构

 

Collection

[plain]
  1. 子接口  
  2.  Set,List  
  3. 集合中只能放置对象的引用,不能放置原生数据类型,  
  4.  我们需要使用原生数据类型的封装类才能加入到集合中  
子接口Set,List集合中只能放置对象的引用,不能放置原生数据类型,我们需要使用原生数据类型的封装类才能加入到集合中

Ordered与Sorted接口

  1. Ordered排序,按照某种由具体情况决定的顺序排序,是后天指定的  
  2. Sorted排序,按照天然顺序进行排序,是先天指定的  
Ordered排序,按照某种由具体情况决定的顺序排序,是后天指定的Sorted排序,按照天然顺序进行排序,是先天指定的

List

  1. 实现类包括  
  2.     LinkedList,Vector,ArrayList  
  3. 列表接口,继承与Collection,可以按索引的顺序访问,有索引的Collection  
  4.     具有列表的功能,元素顺序均是按添加的先后进行排列的,  
  5.     允许重复的元素,允许多个null元素  
实现类包括	LinkedList,Vector,ArrayList列表接口,继承与Collection,可以按索引的顺序访问,有索引的Collection	具有列表的功能,元素顺序均是按添加的先后进行排列的,	允许重复的元素,允许多个null元素

List常用方法

  1. package com.itlwc;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. public class Test {  
  7.     public static void main(String[] args) {  
  8.         List list = new ArrayList();  
  9.         // 向列表的尾部追加指定的元素  
  10.         list.add("lwc");  
  11.         // 在列表的指定位置插入指定元素  
  12.         list.add(1, "nxj");  
  13.         // 追加指定 collection 中的所有元素到此列表的结尾  
  14.         list.addAll(new ArrayList());  
  15.         // 从列表中移除所有元素  
  16.         list.clear();  
  17.         // 如果列表包含指定的元素,则返回true  
  18.         list.contains("nxj");  
  19.         // 如果列表包含指定 collection 的所有元素,则返回 true  
  20.         list.containsAll(new ArrayList());  
  21.         // 比较指定的对象与列表是否相等  
  22.         list.equals(new ArrayList());  
  23.         // 返回列表中指定位置的元素  
  24.         list.get(0);  
  25.         // 返回列表的哈希码值  
  26.         list.hashCode();  
  27.         // 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1  
  28.         list.indexOf("lwc");  
  29.         // 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1  
  30.         list.lastIndexOf("lwc");  
  31.         // 如果列表不包含元素,则返回 true  
  32.         list.isEmpty();  
  33.         // 移除列表中指定位置的元素  
  34.         list.remove(0);  
  35.         // 移除列表中出现的首个指定元素  
  36.         list.remove("lwc");  
  37.         // 从列表中移除指定 collection 中包含的所有元素  
  38.         list.removeAll(new ArrayList());  
  39.         // 用指定元素替换列表中指定位置的元素  
  40.         list.set(0, "lp");  
  41.         // 返回列表中的元素数  
  42.         list.size();  
  43.         // 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图  
  44.         list.subList(1, 2);  
  45.         // 返回以正确顺序包含列表中的所有元素的数组  
  46.         list.toArray();  
  47.         // 返回以正确顺序包含列表中所有元素的数组  
  48.         list.toArray(new String[] { "a", "b" });  
  49.     }  
  50. }  
package com.itlwc;import java.util.ArrayList;import java.util.List;public class Test {	public static void main(String[] args) {		List list = new ArrayList();		// 向列表的尾部追加指定的元素		list.add("lwc");		// 在列表的指定位置插入指定元素		list.add(1, "nxj");		// 追加指定 collection 中的所有元素到此列表的结尾		list.addAll(new ArrayList());		// 从列表中移除所有元素		list.clear();		// 如果列表包含指定的元素,则返回true		list.contains("nxj");		// 如果列表包含指定 collection 的所有元素,则返回 true		list.containsAll(new ArrayList());		// 比较指定的对象与列表是否相等		list.equals(new ArrayList());		// 返回列表中指定位置的元素		list.get(0);		// 返回列表的哈希码值		list.hashCode();		// 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1		list.indexOf("lwc");		// 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1		list.lastIndexOf("lwc");		// 如果列表不包含元素,则返回 true		list.isEmpty();		// 移除列表中指定位置的元素		list.remove(0);		// 移除列表中出现的首个指定元素		list.remove("lwc");		// 从列表中移除指定 collection 中包含的所有元素		list.removeAll(new ArrayList());		// 用指定元素替换列表中指定位置的元素		list.set(0, "lp");		// 返回列表中的元素数		list.size();		// 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图		list.subList(1, 2);		// 返回以正确顺序包含列表中的所有元素的数组		list.toArray();		// 返回以正确顺序包含列表中所有元素的数组		list.toArray(new String[] { "a", "b" });	}}

ArrayList

  1. 构造方法  
  2.     public ArrayList()  
  3.     public ArrayList(int initialCapacity)  
  4.     public ArrayList(Collection c)  
  5. ArrayList依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组  
  6.     当元素超过10,那么ArrayList底层会新生成一个数组,长度为原来的1.5倍+1,  
  7.     然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中,  
  8.     当新数组无法容纳增加的元素,重复该过程  
  9. ArrayList对随机访问性能很好,但进行大量插入,删除操作,性能很差,  
  10.     因为操作之后后续元素需要移动  
构造方法	public ArrayList()	public ArrayList(int initialCapacity)	public ArrayList(Collection c)ArrayList依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组	当元素超过10,那么ArrayList底层会新生成一个数组,长度为原来的1.5倍+1,	然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中,	当新数组无法容纳增加的元素,重复该过程ArrayList对随机访问性能很好,但进行大量插入,删除操作,性能很差,	因为操作之后后续元素需要移动

遍历ArrayList

  1. package com.itlwc;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Iterator;  
  5. import java.util.List;  
  6.   
  7. public class Test {  
  8.     public static void main(String[] args) {  
  9.         List<String> list = new ArrayList<String>();  
  10.         list.add("lwc");  
  11.         list.add("nxj");  
  12.         // 方法一  
  13.         Iterator<String> ite1 = list.iterator();  
  14.         while (ite1.hasNext()) {  
  15.             String str = ite1.next();  
  16.             System.out.println(str);  
  17.         }  
  18.         System.out.println("---------------------");  
  19.         // 方法二(方法一的变形)  
  20.         for (Iterator<String> ite2 = list.iterator(); ite2.hasNext();) {  
  21.             String str = ite2.next();  
  22.             System.out.println(str);  
  23.         }  
  24.         System.out.println("---------------------");  
  25.         // 方法三  
  26.         for(String s : list){  
  27.             System.out.println(s);  
  28.         }  
  29.     }  
  30. }  
  31. /* 
  32. 打印结果: 
  33.     lwc 
  34.     nxj 
  35.     --------------------- 
  36.     lwc 
  37.     nxj 
  38.     --------------------- 
  39.     lwc 
  40.     nxj 
  41. */  
package com.itlwc;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class Test {	public static void main(String[] args) {		List
    
      list = new ArrayList
     
      ();		list.add("lwc");		list.add("nxj");		// 方法一		Iterator
      
        ite1 = list.iterator();		while (ite1.hasNext()) {			String str = ite1.next();			System.out.println(str);		}		System.out.println("---------------------");		// 方法二(方法一的变形)		for (Iterator
       
         ite2 = list.iterator(); ite2.hasNext();) {			String str = ite2.next();			System.out.println(str);		}		System.out.println("---------------------");		// 方法三		for(String s : list){			System.out.println(s);		}	}}/*打印结果:	lwc	nxj	---------------------	lwc	nxj	---------------------	lwc	nxj*/

Vector

  1. 向量,历史比较悠久,Java诞生就有了,特点与ArrayList相同,  
  2.     不同的是Vector操作元素的方法是同步的,同一时刻只能有一个线程访问,没有特殊需求都使用ArrayList  
  3. 构造方法  
  4.     public Vector()  
  5.     public Vector(int initialCapacity)  
  6.     public Vector(int initialCapacity,int capacityIncrement)  
  7.         第一个参数是初始容量,第二个参数是当Vector满时的增量  
  8.     public Vector(Collection c)  
  9. Vector也是依赖数组实现的  
向量,历史比较悠久,Java诞生就有了,特点与ArrayList相同,	不同的是Vector操作元素的方法是同步的,同一时刻只能有一个线程访问,没有特殊需求都使用ArrayList构造方法	public Vector()	public Vector(int initialCapacity)	public Vector(int initialCapacity,int capacityIncrement)		第一个参数是初始容量,第二个参数是当Vector满时的增量	public Vector(Collection c)Vector也是依赖数组实现的

案例

  1. package com.itlwc;  
  2.   
  3. import java.util.Enumeration;  
  4. import java.util.Vector;  
  5.   
  6. public class Test {  
  7.     public static void main(String[] args) {  
  8.         Vector v = new Vector();  
  9.         v.add("123");  
  10.         v.add("lwc");  
  11.         v.add("你好");  
  12.         // Vector转换为枚举  
  13.         Enumeration e = v.elements();  
  14.         while (e.hasMoreElements()) {  
  15.             System.out.println(e.nextElement());  
  16.         }  
  17.     }  
  18. }  
package com.itlwc;import java.util.Enumeration;import java.util.Vector;public class Test {	public static void main(String[] args) {		Vector v = new Vector();		v.add("123");		v.add("lwc");		v.add("你好");		// Vector转换为枚举		Enumeration e = v.elements();		while (e.hasMoreElements()) {			System.out.println(e.nextElement());		}	}}

Stack

  1. Vector的子类  
Vector的子类
案例
[java]
  1. package com.itlwc;  
  2.   
  3. import java.util.Enumeration;  
  4. import java.util.Stack;  
  5.   
  6. public class Test {  
  7.     public static void main(String[] args) {  
  8.         Stack stack = new Stack();  
  9.         // 向栈里面压一个整数  
  10.         stack.push(new Integer(123));  
  11.         stack.push("lwc");  
  12.         stack.push(new Double(88.88));  
  13.         // 遍历  
  14.         Enumeration items = stack.elements();  
  15.         while (items.hasMoreElements()) {  
  16.             System.out.print(items.nextElement() + " ");  
  17.         }  
  18.         System.out.println();  
  19.         // 出栈  
  20.         while (stack.size() != 0) {  
  21.             System.out.print(stack.pop() + " ");  
  22.         }  
  23.     }  
  24. }  
  25. /* 
  26. 打印结果: 
  27.     123 lwc 88.88  
  28.     88.88 lwc 123 
  29. */  
package com.itlwc;import java.util.Enumeration;import java.util.Stack;public class Test {	public static void main(String[] args) {		Stack stack = new Stack();		// 向栈里面压一个整数		stack.push(new Integer(123));		stack.push("lwc");		stack.push(new Double(88.88));		// 遍历		Enumeration items = stack.elements();		while (items.hasMoreElements()) {			System.out.print(items.nextElement() + " ");		}		System.out.println();		// 出栈		while (stack.size() != 0) {			System.out.print(stack.pop() + " ");		}	}}/*打印结果:	123 lwc 88.88 	88.88 lwc 123*/

LinkedList

  1. LinkedList功能与ArrayList,Vector相同,内部是依赖双链表实现的,  
  2.     因此有很好的插入和删除性能,但随机访问元素的性能很差  
  3. 构造方法  
  4.     public LinkedList()  
  5.     public LinkedList(Collection c)  
  6. LinkedList类中有一个Entry内部类,Entry内部类包含3个部分向前的引用,向后的引用,数据  
  7.     header.next = header.previous = header;  
LinkedList功能与ArrayList,Vector相同,内部是依赖双链表实现的,	因此有很好的插入和删除性能,但随机访问元素的性能很差构造方法	public LinkedList()	public LinkedList(Collection c)LinkedList类中有一个Entry内部类,Entry内部类包含3个部分向前的引用,向后的引用,数据	header.next = header.previous = header;

遍历LinkedList

  1. package com.itlwc;  
  2.   
  3. import java.util.LinkedList;  
  4. import java.util.List;  
  5. import java.util.ListIterator;  
  6.   
  7. public class Test {  
  8.     public static void main(String[] args) {  
  9.         List link = new LinkedList();  
  10.         link.add(123);  
  11.         link.add("lwc");  
  12.         link.add(8.8);  
  13.         link.add("nxj");  
  14.         link.add(520);  
  15.         printList(link);  
  16.         printReversedList(link);  
  17.     }  
  18.   
  19.     private static void printList(List link) {  
  20.         System.out.println("正序链表中的元素");  
  21.         // 的到链表的迭代器,位置指向链头  
  22.         ListIterator li = link.listIterator();  
  23.         // 判断迭代器中是否有下一个元素  
  24.         while (li.hasNext()) {  
  25.             // 返回下个元素  
  26.             System.out.print(li.next() + " ");  
  27.         }  
  28.         System.out.println();  
  29.     }  
  30.   
  31.     private static void printReversedList(List link) {  
  32.         System.out.println("逆向链表中的元素");  
  33.         // 的到链表的迭代器,位置指向link.size()结尾  
  34.         ListIterator li = link.listIterator(link.size());  
  35.         // 判断迭代器中是否有前一个元素  
  36.         while (li.hasPrevious()) {  
  37.             // 返回前一个元素  
  38.             System.out.print(li.previous() + " ");  
  39.         }  
  40.         System.out.println();  
  41.     }  
  42. }  
  43. /* 
  44. 打印结果: 
  45.     正序链表中的元素 
  46.     123 lwc 8.8 nxj 520  
  47.     逆向链表中的元素 
  48.     520 nxj 8.8 lwc 123  
  49. */  
package com.itlwc;import java.util.LinkedList;import java.util.List;import java.util.ListIterator;public class Test {	public static void main(String[] args) {		List link = new LinkedList();		link.add(123);		link.add("lwc");		link.add(8.8);		link.add("nxj");		link.add(520);		printList(link);		printReversedList(link);	}	private static void printList(List link) {		System.out.println("正序链表中的元素");		// 的到链表的迭代器,位置指向链头		ListIterator li = link.listIterator();		// 判断迭代器中是否有下一个元素		while (li.hasNext()) {			// 返回下个元素			System.out.print(li.next() + " ");		}		System.out.println();	}	private static void printReversedList(List link) {		System.out.println("逆向链表中的元素");		// 的到链表的迭代器,位置指向link.size()结尾		ListIterator li = link.listIterator(link.size());		// 判断迭代器中是否有前一个元素		while (li.hasPrevious()) {			// 返回前一个元素			System.out.print(li.previous() + " ");		}		System.out.println();	}}/*打印结果:	正序链表中的元素	123 lwc 8.8 nxj 520 	逆向链表中的元素	520 nxj 8.8 lwc 123 */

自定义LinkedList结构

  1. package com.itlwc;  
  2.   
  3. class Node {  
  4.     Node previous;// 前驱  
  5.     String data;// 数据  
  6.     Node next;// 后驱  
  7.   
  8.     public Node(String data) {  
  9.         this.data = data;  
  10.     }  
  11. }  
  12.   
  13. public class Test {  
  14.     public static void main(String[] args) {  
  15.         Node node1 = new Node("node1");  
  16.         Node node2 = new Node("node2");  
  17.         Node node3 = new Node("node3");  
  18.         node1.next = node2;  
  19.         node2.previous = node1;  
  20.         node2.next = node3;  
  21.         node3.previous = node2;  
  22.         node3.next = node1;  
  23.         node1.previous = node3;  
  24.   
  25.         // 增加node4  
  26.         Node node4 = new Node("node4");  
  27.         node1.next = node4;  
  28.         node4.previous = node1;  
  29.         node4.next = node2;  
  30.         node2.previous = node4;  
  31.         // 删除node4  
  32.         node1.next = node2;  
  33.         node2.previous = node1;  
  34.         node4.previous = null;  
  35.         node4.next = null;  
  36.   
  37.     }  
  38. }  
package com.itlwc;class Node {	Node previous;// 前驱	String data;// 数据	Node next;// 后驱	public Node(String data) {		this.data = data;	}}public class Test {	public static void main(String[] args) {		Node node1 = new Node("node1");		Node node2 = new Node("node2");		Node node3 = new Node("node3");		node1.next = node2;		node2.previous = node1;		node2.next = node3;		node3.previous = node2;		node3.next = node1;		node1.previous = node3;		// 增加node4		Node node4 = new Node("node4");		node1.next = node4;		node4.previous = node1;		node4.next = node2;		node2.previous = node4;		// 删除node4		node1.next = node2;		node2.previous = node1;		node4.previous = null;		node4.next = null;	}}

依赖倒置原理

  1. 依赖应该尽量在抽象层进行,避免在具体层进行,  
  2.     在实际开发中尽量使用接口类型的引用,避免采用具体类型的引用  
依赖应该尽量在抽象层进行,避免在具体层进行,	在实际开发中尽量使用接口类型的引用,避免采用具体类型的引用

案例

[java]
  1. package com.itlwc;  
  2.   
  3. import java.util.LinkedList;  
  4. import java.util.List;  
  5.   
  6. public class Test {  
  7.     //如果我们需要传入参数是ArrayList就需要改动代码  
  8.     public void printLinkedList(LinkedList ll){  
  9.         System.out.println(ll);  
  10.     }  
  11.     //如果我们传入参数是List的子类,我们不需要改动代码,灵活性大  
  12.     public void printList(List l){  
  13.         System.out.println(l);  
  14.     }  
  15. }  
package com.itlwc;import java.util.LinkedList;import java.util.List;public class Test {	//如果我们需要传入参数是ArrayList就需要改动代码	public void printLinkedList(LinkedList ll){		System.out.println(ll);	}	//如果我们传入参数是List的子类,我们不需要改动代码,灵活性大	public void printList(List l){		System.out.println(l);	}}

将数组转换为列表

  1. package com.itlwc;  
  2.   
  3. import java.util.Arrays;  
  4. import java.util.List;  
  5.   
  6. public class Test {  
  7.     public static void main(String[] args) {  
  8.         String[] str = { "l", "w", "c" };  
  9.         //使用Java类库中java.util.Arrays类的静态方法asList()  
  10.         List l = Arrays.asList(str);  
  11.         System.out.println(str);  
  12.     }  
  13.   
  14. }  
  15. /* 
  16. 打印结果: 
  17.     [l, w, c] 
  18. */  
package com.itlwc;import java.util.Arrays;import java.util.List;public class Test {	public static void main(String[] args) {		String[] str = { "l", "w", "c" };		//使用Java类库中java.util.Arrays类的静态方法asList()		List l = Arrays.asList(str);		System.out.println(str);	}}/*打印结果:	[l, w, c]*/

ArrayList VS LinkedList

  1. ArrayList底层采用数组实现,LinkedList底层采用双链表实现  
  2. 如果为列表增加对象  
  3.     ArrayList是ArrayList底层数组维护的,LinkedList是LinkedList底层Entry对象维护的  
  4.     LinkedList底层Entry结构  
  5.         Entry{  
  6.             Entry previous;  
  7.             Object element;  
  8.             Entry next;  
  9.         }  
  10.         其中element就是我们添加的元素,最后将生成的Entry对象加入到链表中  
  11. 插入和删除操作时,采用LinkedList好,搜索时,采用ArrayList好  
ArrayList底层采用数组实现,LinkedList底层采用双链表实现如果为列表增加对象	ArrayList是ArrayList底层数组维护的,LinkedList是LinkedList底层Entry对象维护的	LinkedList底层Entry结构		Entry{			Entry previous;			Object element;			Entry next;		}		其中element就是我们添加的元素,最后将生成的Entry对象加入到链表中插入和删除操作时,采用LinkedList好,搜索时,采用ArrayList好

List<Map>遍历

  1. package com.itlwc;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.HashMap;  
  5. import java.util.Iterator;  
  6. import java.util.List;  
  7. import java.util.Map;  
  8.   
  9. public class Test {  
  10.     public static void main(String[] args) {  
  11.         Map<Integer, String> map1 = new HashMap<Integer, String>();  
  12.         map1.put(new Integer(1), "lwc");  
  13.         map1.put(new Integer(2), "nxj");  
  14.         Map<Integer, String> map2 = new HashMap<Integer, String>();  
  15.         map2.put(new Integer(3), "tom");  
  16.         map2.put(new Integer(4), "cat");  
  17.         List<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>();  
  18.         list.add(map1);  
  19.         list.add(map2);  
  20.         // 方法一  
  21.         Iterator<Map<Integer, String>> ite1 = list.iterator();  
  22.         while (ite1.hasNext()) {  
  23.             Map<Integer, String> m = ite1.next();  
  24.             System.out.println(m);  
  25.         }  
  26.         System.out.println("-----------------------------");  
  27.         // 方法二(方法一的变形)  
  28.         for (Iterator<Map<Integer, String>> ite2 = list.iterator(); ite2.hasNext();) {  
  29.             Map<Integer, String> m = ite2.next();  
  30.             System.out.println(m);  
  31.         }  
  32.         System.out.println("-----------------------------");  
  33.         // 方法三:  
  34.         for (Map<Integer, String> m : list) {  
  35.             System.out.println(m);  
  36.         }  
  37.     }  
  38. }  
  39. /*  
  40. 打印结果:  
  41.     {1=lwc, 2=nxj} 
  42.     {3=tom, 4=cat} 
  43.     ----------------------------- 
  44.     {1=lwc, 2=nxj} 
  45.     {3=tom, 4=cat} 
  46.     ----------------------------- 
  47.     {1=lwc, 2=nxj} 
  48.     {3=tom, 4=cat} 
  49. */  
package com.itlwc;import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;public class Test {	public static void main(String[] args) {		Map
     
       map1 = new HashMap
      
       ();		map1.put(new Integer(1), "lwc");		map1.put(new Integer(2), "nxj");		Map
       
         map2 = new HashMap
        
         ();		map2.put(new Integer(3), "tom");		map2.put(new Integer(4), "cat");		List
         
          
           > list = new ArrayList
           
            
             >(); list.add(map1); list.add(map2); // 方法一 Iterator
             
              
               > ite1 = list.iterator(); while (ite1.hasNext()) { Map
               
                 m = ite1.next(); System.out.println(m); } System.out.println("-----------------------------"); // 方法二(方法一的变形) for (Iterator
                
                 
                  > ite2 = list.iterator(); ite2.hasNext();) { Map
                  
                    m = ite2.next(); System.out.println(m); } System.out.println("-----------------------------"); // 方法三: for (Map
                   
                     m : list) { System.out.println(m); } }}/* 打印结果: {1=lwc, 2=nxj} {3=tom, 4=cat} ----------------------------- {1=lwc, 2=nxj} {3=tom, 4=cat} ----------------------------- {1=lwc, 2=nxj} {3=tom, 4=cat}*/

Set

  1. 实现类  
  2. HashSet,LinkedHashSet  
  3. 子接口  
  4. SortSet  
  5. 实现类  
  6. TreeSet  
  7. 不包含重复元素,最多包含一个null,元素没有顺序  
实现类	HashSet,LinkedHashSet子接口	SortSet	实现类		TreeSet不包含重复元素,最多包含一个null,元素没有顺序

HashSet

  1. HashSet不是Ordered也不是Sorted,存储对象引用时是按照哈希策略来实现的,  
  2. HashSet中是否存在一个对象是通过equals()和hashCode()协同判断  
  3. 不保证顺序  
  4. 构造方法  
  5. public HashSet()    
  6. public HashSet(int initialCapacity)    
  7. public HashSet(Collection c)  
  8. HashSet底层是使用HashMap实现的  
  9. HashSet的add()方法详解:  
  10. 判断已经存储在集合中的对象hashCode值是否与增加对象的hashCode值一致  
  11. 如果不一致,直接加进去  
  12. 如果一致,再进行equals()比较  
  13. 如果equals()返回true,对象已经存在不增加进去  
  14. 如果equals()返回false,把对象增加进去  
HashSet不是Ordered也不是Sorted,存储对象引用时是按照哈希策略来实现的,	HashSet中是否存在一个对象是通过equals()和hashCode()协同判断不保证顺序构造方法	public HashSet()  	public HashSet(int initialCapacity)  	public HashSet(Collection c)HashSet底层是使用HashMap实现的HashSet的add()方法详解:	判断已经存储在集合中的对象hashCode值是否与增加对象的hashCode值一致	如果不一致,直接加进去	如果一致,再进行equals()比较		如果equals()返回true,对象已经存在不增加进去		如果equals()返回false,把对象增加进去

LinkedHashSet

  1. LinkedHashSet是Ordered,采用双链表实现的  
  2. 有固定顺序,也就是插入顺序  
  3. LinkedHashSet底层是使用LinkedHashMap实现的  
  4. 构造方法  
  5.     public LinkedHashSet()    
  6.     public LinkedHashSet(int initialCapacity)    
  7.     public LinkedHashSet(Collection c)  
LinkedHashSet是Ordered,采用双链表实现的有固定顺序,也就是插入顺序LinkedHashSet底层是使用LinkedHashMap实现的构造方法	public LinkedHashSet()  	public LinkedHashSet(int initialCapacity)  	public LinkedHashSet(Collection c)

SortedSet接口

  1. 保证迭代器按照元素递增顺序遍历的集合,可以按照元素的自然顺序进行排序  
  2. 常用方法  
  3.     Object first()  
  4.          返回此有序集合中当前第一个(最小的)元素  
  5.     Object last()  
  6.         返回此有序集合中最后一个(最大的)元素  
  7.     SortedSet headSet(Object toElement)  
  8.         返回此有序集合的部分视图,其元素严格小于toElement  
  9.     SortedSet tailSet(Object fromElement)  
  10.         返回此有序集合的部分视图,其元素大于或等于fromElement  
  11.     SortedSet subSet(Object fromElement,Object toElement)  
  12.         返回此有序集合的部分视图,元素范围从fromElement(包括)到toElement(不包括)  
  13.     Comparator comparator()  
  14.         返回与此有序集合关联的比较器,如果使用元素的自然顺序,则返回 null  
保证迭代器按照元素递增顺序遍历的集合,可以按照元素的自然顺序进行排序常用方法	Object first()		 返回此有序集合中当前第一个(最小的)元素	Object last()		返回此有序集合中最后一个(最大的)元素	SortedSet headSet(Object toElement)		返回此有序集合的部分视图,其元素严格小于toElement	SortedSet tailSet(Object fromElement)		返回此有序集合的部分视图,其元素大于或等于fromElement	SortedSet subSet(Object fromElement,Object toElement)		返回此有序集合的部分视图,元素范围从fromElement(包括)到toElement(不包括)	Comparator comparator()		返回与此有序集合关联的比较器,如果使用元素的自然顺序,则返回 null

TreeSet

  1. TreeSet是SortedSet接口的实现,元素不论以什么元素插入,在遍历的时候,都会以天然顺序遍历  
  2. TreeSet底层是使用TreeMap实现的  
  3. 构造方法  
  4.     public TreeSet()  
  5.     public TreeSet(SortedSet s)    
  6.     public TreeSet(int initialCapacity)  
  7.     public TreeSet(Comparator<? super E>)  
  8.     public TreeSet(Collection c)  
  9. 因为TreeSet是带排序的,所以想要为TreeSet增加自定义类型,必须指定排序规则  
TreeSet是SortedSet接口的实现,元素不论以什么元素插入,在遍历的时候,都会以天然顺序遍历TreeSet底层是使用TreeMap实现的构造方法	public TreeSet()	public TreeSet(SortedSet s)  	public TreeSet(int initialCapacity)	public TreeSet(Comparator
     )	public TreeSet(Collection c)因为TreeSet是带排序的,所以想要为TreeSet增加自定义类型,必须指定排序规则

TreeSet排序规则Comparator案例

  1. package com.itlwc;  
  2.   
  3. import java.util.Comparator;  
  4. import java.util.Iterator;  
  5. import java.util.TreeSet;  
  6.   
  7. public class Test {  
  8.     public static void main(String[] args) {  
  9.         TreeSet set = new TreeSet(new PersonComparator());  
  10.         set.add(new Person("lwc", 80));  
  11.         set.add(new Person("nxj", 70));  
  12.         set.add(new Person("lp", 60));  
  13.         set.add(new Person("fy", 75));  
  14.         Iterator ite = set.iterator();  
  15.         while (ite.hasNext()) {  
  16.             Person p = (Person)ite.next();  
  17.             System.out.println(p.name);  
  18.         }  
  19.     }  
  20. }  
  21.   
  22. class Person {  
  23.     String name;  
  24.     int score;  
  25.   
  26.     public Person(String name, int score) {  
  27.         this.name = name;  
  28.         this.score = score;  
  29.     }  
  30. }  
  31.   
  32. class PersonComparator implements Comparator {  
  33.     public int compare(Object o1, Object o2) {  
  34.         Person p1 = (Person) o1;  
  35.         Person p2 = (Person) o2;  
  36.         return p1.score - p2.score;  
  37.     }  
  38. }  
package com.itlwc;import java.util.Comparator;import java.util.Iterator;import java.util.TreeSet;public class Test {	public static void main(String[] args) {		TreeSet set = new TreeSet(new PersonComparator());		set.add(new Person("lwc", 80));		set.add(new Person("nxj", 70));		set.add(new Person("lp", 60));		set.add(new Person("fy", 75));		Iterator ite = set.iterator();		while (ite.hasNext()) {			Person p = (Person)ite.next();			System.out.println(p.name);		}	}}class Person {	String name;	int score;	public Person(String name, int score) {		this.name = name;		this.score = score;	}}class PersonComparator implements Comparator {	public int compare(Object o1, Object o2) {		Person p1 = (Person) o1;		Person p2 = (Person) o2;		return p1.score - p2.score;	}}

Collections

  1. 操作Collection类的工具类,类中方法都是静态的  
操作Collection类的工具类,类中方法都是静态的

Collections常用方法

[java]
  1. package com.itlwc;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Collections;  
  5. import java.util.Comparator;  
  6.   
  7. public class Test {  
  8.     public static void main(String[] args) {  
  9.         // 将所有元素从一个列表复制到另一个列表  
  10.         Collections.copy(new ArrayList(), new ArrayList());  
  11.         // 如果两个指定collection中没有相同的元素,则返回 true  
  12.         Collections.disjoint(new ArrayList(), new ArrayList());  
  13.         // 使用指定元素替换指定列表中的所有元素  
  14.         Collections.fill(new ArrayList(), new Object());  
  15.         // 返回指定 collection 中等于指定对象的元素数  
  16.         Collections.frequency(new ArrayList(), new Object());  
  17.         // 返回指定源列表中第一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回 -1  
  18.         Collections.indexOfSubList(new ArrayList(), new ArrayList());  
  19.         // 根据元素的自然顺序，返回给定 collection 的最大元素  
  20.         Collections.max(new ArrayList());  
  21.         // //根据元素的自然顺序，返回给定 collection 的最大元素  
  22.         Collections.min(new ArrayList());  
  23.         // 使用另一个值替换列表中出现的所有某一指定值  
  24.         Collections.replaceAll(new ArrayList(), "oldVal", "newVal");  
  25.         // 反转指定列表中元素的顺序  
  26.         Collections.reverse(new ArrayList());  
  27.         // 返回一个比较器,它强行反转  
  28.         Collections.reverseOrder();  
  29.         // 返回一个比较器,它强行反转指定比较器的顺序  
  30.         Collections.reverseOrder(new Comparator() {  
  31.             @Override  
  32.             public int compare(Object o1, Object o2) {  
  33.                 return 0;  
  34.             }  
  35.         });  
  36.         // 使用默认随机源随机更改指定列表的序列  
  37.         Collections.shuffle(new ArrayList());  
  38.         // 根据元素的自然顺序对指定列表按升序进行排序  
  39.         Collections.sort(new ArrayList());  
  40.         // 根据元素的自然顺序对指定列表按降序进行排序  
  41.         Collections.sort(new ArrayList(), Collections.reverseOrder());  
  42.         // 在指定列表的指定位置处交换元素  
  43.         Collections.swap(new ArrayList(), 1, 2);  
  44.   
  45.     }  
  46. }  

转载于:https://www.cnblogs.com/wlming/p/6780617.html

你可能感兴趣的文章
字符集
查看>>
数据库设计经验
查看>>
Crossing River（1700poj）
查看>>
敏捷的最佳实践-3
查看>>
map reduce filter
查看>>
今天入住园子了
查看>>
20162319 莫礼钟 预备作业02
查看>>
数字的可视化：python画图之散点图sactter函数详解
查看>>
116. Populating Next Right Pointers in Each Node (Tree; WFS)
查看>>
uva 11991 Easy Problem from Rujia Liu
查看>>
[PhoneGap] 开篇： Web开发工程师染指手机App的利器
查看>>
140717
查看>>
划分型动态规划 之 CODE[VS] 1040 统计单词个数 2001年NOIP全国联赛提高组
查看>>
使用 PHP 验证表单数据
查看>>
内存分布
查看>>
asp.net中http接口的开发
查看>>
C#实现动态引用外部的Javascript，CSS
查看>>
XMLHttpRequest对象的属性与方法
查看>>
Pots bfs
查看>>
Python Indentation
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2024-11-26 02:26:24   当前IP: 3.144.116.195   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我