【www.5929.com】java库中具体集合,java中具体集合

ArrayList 一种能够动态增加和削减的目录体系

1.ArrayList   能够动态拉长和削减的目录类别

1.java  Iterator 迭代器

    1.   
Java集合类库中最注重的七个接口Collection<E>和Map<K,V>,在那之中Collection接口又重新划分为
List和Set两大子接口,List中得以包含重复的要素,Set中则不可能。以下列举出一些常用的集纳完毕类,他们均分别继承自那八个接口:
    1)    ArrayList:
一种可以动态增加和收缩的目录连串(动态数组,类似于C++中的vector);
    2)    LinkedList:
一种能够在别的地方实行快捷的插入和删除操作的静止连串(类似于C++中list);
    3)    ArrayDeque:
一种用循环数组完结的双端队列(类似于C++中的deque);
    4)   
HastSet:一种没有再一次成分的冬日,冬辰聚集(C++的标准库中一向不提供hashset集合,不过Windows的VC和Linux平台下的gcc均分别提供了hashset容器);
    5)    TreeSet: 一种有序集(类似于C++中的set);
【www.5929.com】java库中具体集合,java中具体集合。    6)    EnumSet: 一种含有枚举类型值的集;
    7)    LinkedHashSet:
一种能够记住元素插入次序的集,在在那之中间由LinkedList负责掩护插入的次第,HashSet来保卫安全Hash;
    8)   
HashMap:一种存款和储蓄键值对关系的数据结构(C++的标准库中绝非提供hashmap集合,不过Windows的VC和Linux平台下的gcc均各自提供了hashmap容器);
    9)    TreeMap:一种键值有序排列的映射表(类似于C++中的map);
    10)   EnumMap:一种键值属于枚举类型的映射表;
    11)   LinkedHashMap:一种能够记住键值项插入次序的映射表;
    2.   
ArrayList:该集合的平底是由此动态数组来实现的,集合构造的时候能够钦点一个开始容积,当插入的因素过多导致已部分容积不可能包容新成分是,其底
层数组的体量将电动拉长原有体积的1.5
倍,那样会带来一定的长空浪费,但是为了幸免平常扩大而带来的性质开支,只可以是用空间换取时间了。借使在容器的中档添加也许去除1个成分都将会促成前面的成分向后或向前移动1个职位,即便成分数量较多且该操作相比频仍,将会导致系统的质量降低,不过对于容器申月素的轻易访问质量较好,以下为
ArrayList的常用示例代码:

LinkedList 一种能够在其他位置展开快捷地插入和删除操作的稳步系列

【www.5929.com】java库中具体集合,java中具体集合。2.LinkedList 方可在其它岗位火速插入和删除错左的雷打不动种类

迭代器是一种设计方式,它是三个对象,它能够遍历并选择种类中的对象,而开发人士不要求驾驭该类别的底部结构。迭代器日常被叫作“轻量级”对象,因为创立它的代价小。

  1     public static void showIterator() {
  2         ArrayList<String> list = new ArrayList<String>();
  3         list.add("Monday");
  4         list.add("Tuesdag");
  5         list.add("Wednesday");
  6         Iterator<String> iterator = null;
  7         iterator = list.iterator();
  8         //while
  9         while (iterator.hasNext()) {
 10             String element = iterator.next();
 11             System.out.println(element);
 12         }
 13         //for
 14         for (iterator = list.iterator(); iterator.hasNext();) {
 15             String element = iterator.next();
 16             System.out.println(element);
 17         }
 18         //for each
 19         for (String element : list) {
 20             System.out.println(element);
 21         }
 22     }
 23 
 24     public static void showSetAndGet() {
 25         ArrayList<String> nums = new ArrayList<String>();
 26         nums.clear();
 27         nums.add("One");
 28         nums.add("Two");
 29         nums.add("Three");
 30         System.out.println(nums);
 31         nums.set(0, "Uno");
 32         nums.set(1, "Dos");
 33         nums.set(2, "Tres");
 34         for (int i = 0; i < nums.size(); ++i)
 35             System.out.println(nums.get(i));
 36     }
 37     
 38     public static void showRemoveAndSize() {
 39         ArrayList<String> al = new ArrayList<String>();
 40         System.out.println("Initial size of al: " + al.size());
 41         al.add("C");
 42         al.add("A");
 43         al.add("E");
 44         al.add("B");
 45         al.add(1, "A2");
 46         System.out.println("Size of al after additions: " + al.size());
 47         System.out.println("Contents of al: " + al);
 48         al.remove("F");
 49         al.remove(2);
 50         System.out.println("Size of al after deletions: " + al.size());
 51         System.out.println("Contents of al: " + al);
 52         Iterator<String> it = al.iterator();
 53         //Notes:remove() must be called after next()
 54         it.next();
 55         it.remove();
 56         System.out.println("Size of al after deletions: " + al.size());
 57         System.out.println("Contents of al: " + al);        
 58     }
 59     
 60     public static void showSubListAndCopyToArray() {
 61         ArrayList<String> arrayList = new ArrayList<String>();
 62         arrayList.add("1");
 63         arrayList.add("2");
 64         arrayList.add("3");
 65         arrayList.add("4");
 66         arrayList.add("5");
 67         List<String> lst = arrayList.subList(1, 3);
 68         for (int i = 0; i < lst.size(); i++)
 69             System.out.println(lst.get(i));        
 70         // remove one element from sub list
 71         String obj = lst.remove(0);
 72         System.out.println(obj + " is removed");
 73         for (String str: arrayList)
 74             System.out.println(str);
 75         //get object array with normal method
 76         Object[] objArray = arrayList.toArray();
 77         for (Object obj1 : objArray)
 78             System.out.println(obj1);
 79         //get object array with generic method
 80         String[] strArray = arrayList.toArray(new String[0]);
 81         for (String str : strArray)
 82             System.out.println(str); 
 83     }
 84     
 85     public static void showListIterator() {
 86         ArrayList<String> aList = new ArrayList<String>();
 87         aList.add("1");
 88         aList.add("2");
 89         aList.add("3");
 90         aList.add("4");
 91         aList.add("5");
 92         
 93         ListIterator<String> listIterator = aList.listIterator();
 94         while (listIterator.hasNext()) {
 95             System.out.println(listIterator.next());
 96             System.out.println("Previous: " + listIterator.previousIndex());
 97             System.out.println("Next: " + listIterator.nextIndex());
 98         }
 99         while (listIterator.hasPrevious()) {
100             System.out.println(listIterator.previous());
101             System.out.println("Previous: " + listIterator.previousIndex());
102             System.out.println("Next: " + listIterator.nextIndex());
103         }
104         listIterator = aList.listIterator(2);
105         listIterator.next();
106         listIterator.set("100");
107         listIterator.next();
108         listIterator.remove();
109         for (String str : aList)
110             System.out.println(str);
111 
112         if (aList.contains("4"))
113             System.out.println("True");
114         else
115             System.out.println("False");
116     }
117     
118     public static void showFillAndReplace() {
119         ArrayList<String> arrayList = new ArrayList<String>();
120         arrayList.add("A");
121         arrayList.add("B");
122         arrayList.add("A");
123         arrayList.add("C");
124         arrayList.add("D");
125         Collections.replaceAll(arrayList, "A", "Replace All");
126         System.out.println(arrayList);
127         Collections.fill(arrayList, "REPLACED");
128         System.out.println(arrayList);
129     }
130 
131     public static void showCollectionOperation() {
132         List<String> colours = new ArrayList<String>();
133         colours.add("red");
134         colours.add("green");
135         colours.add("blue");
136 
137         System.out.println(colours);
138         Collections.swap(colours, 0, 2);
139         System.out.println(colours);
140 
141         Collections.reverse(colours);
142         System.out.println(colours);
143 
144         Collections.sort(colours);
145         System.out.println(Arrays.toString(colours.toArray()));
146         Collections.sort(colours, Collections.reverseOrder());
147         System.out.println(Arrays.toString(colours.toArray()));
148 
149         int index = Collections.binarySearch(colours, "green");
150         System.out.println("Element found at : " + index);
151         ArrayList<Integer> arrayList = new ArrayList<Integer>();
152         arrayList.add(new Integer("3"));
153         arrayList.add(new Integer("1"));
154         arrayList.add(new Integer("8"));
155         arrayList.add(new Integer("3"));
156         arrayList.add(new Integer("5"));
157         System.out.println(Collections.min(arrayList));
158         System.out.println(Collections.max(arrayList));
159     }
160     
161     public static void showMinMax() {
162         ArrayList<Integer> arrayList = new ArrayList<Integer>();
163         arrayList.add(new Integer("3"));
164         arrayList.add(new Integer("1"));
165         arrayList.add(new Integer("8"));
166         arrayList.add(new Integer("3"));
167         arrayList.add(new Integer("5"));
168         System.out.println(Collections.min(arrayList));
169         System.out.println(Collections.max(arrayList));
170     }
171     
172     public static void showSynchronizedList() {
173         ArrayList arrayList = new ArrayList();
174         List list = Collections.synchronizedList(arrayList);
175         //list之后的并发操作将不再需要synchronized关键字来进行同步了。
176     }

ArrayDeque  一种用循环数组达成的双端队列

3.HashSet  没有重新成分的严节聚集

  Java中的Iterator功用比较不难,并且只可以单向活动:

    3.    LinkedList:   
该集合是透过双向链表来兑现的,对于钦赐位置元素的遍历当中间做了3个小的优化,如若position大于len/2,由于个中的数据结构是双向链表,因此能够从后迈入遍历,以收缩遍历进程中节点跳转的次数。ArrayList中的超过1/2代码示例都适用于LinkedList,以下近给出
LinkedList特有的常用示例代码:

HashSet 一种没有重新成分的冬季汇集

4.TreeSet   有序集

  (1)
使用办法iterator()要求容器再次来到几个Iterator。第1遍调用Iterator的next()方法时,它回到连串的首先个因素。注意:iterator()方法是java.lang.Iterable接口,被Collection继承。

 1     public static void showNewFeatures(String[] args) {
 2         LinkedList<String> lList = new LinkedList<String>();
 3         lList.add("1");
 4         lList.add("2");
 5         lList.add("3");
 6         lList.add("4");
 7         lList.add("5");
 8         
 9         System.out.println("First element of LinkedList is : " + lList.getFirst());
10         System.out.println("Last element of LinkedList is : " + lList.getLast());
11         System.out.println(lList);
12         
13         String str = lList.removeFirst();
14         System.out.println(str + " has been removed");
15         System.out.println(lList);
16         str = lList.removeLast();
17         System.out.println(str + " has been removed");
18         System.out.println(lList);
19         
20         lList.addFirst("1");
21         System.out.println(lList);
22         lList.addLast("5");
23         System.out.println(lList);    
24     }

TreeSet 一种有序集

5.HashMap  键值对关系的数据结构

  (2)
使用next()得到体系中的下三个成分。

    4.    ArrayList和LinkedList的相同点:
    1)    都以接口List<E>的贯彻类;
    2)   
都得以通过iterator()方法重回Iterator<E>迭代器对象,并可以透过该对象遍历容器中的成分;
    3)   
就算多少个Iterator<E>实例同时引述同一个成团对象,那么当有三个正在遍历,而其余贰个修改(add/remove)了聚众对象中的
成分,对于首个迭代器再展开迭代时将会掀起ConcurrentModificationException非凡的发生。
    5.    ArrayList和LinkedList的分裂点:
    1)   
对ArrayList和LinkedList而言,在列表末尾扩大二个成分所花的付出都以固定的。对ArrayList而言,主借使在其间数组中扩张一
项,指向所拉长的要素,偶尔恐怕会造成对数组重新展开分配;而对LinkedList而言,那一个花费是统一的,分配3个里头Entry对象。
    2)   
在ArrayList的中级插入或删除一个成分意味着这么些列表中多余的因素都会被活动;而在LinkedList的中间插入或删除叁个成分的费用是定位的。
    3)    LinkedList不帮助高速的即兴元素访问。
    4)   
ArrayList的空间浪费主要呈以往在list列表的末梢预留一定的体积空间,而LinkedList的长空开销则呈以往它的每一个要素都亟待消耗一定的半空中
   
在C++的标准库中,ArrayList和LinkedList之间的采纳差别以及个别的利弊也一如既往呈现于vector和list。
    6.    HashSet:
散列表为每种对象计算出贰个整数(通过Object缺省的或类重载的hashCode域方法),称为散列码。在Java中,散列表是利用链表的数组来促成
的,每一个链表被号称3个哈希桶。假如想在哈希表中查找一个指标,则必要先总结对象的hashCode,之后对表内的桶数取余数,得到的结果就是哈希桶的索
引,此时一旦该桶为空桶,就可以直接将该指标插入到该桶中,若是已经有对象存在了,则须求各类实行相比,一旦发现该与该目的相等的目的(equals()
再次回到true),就会遗弃这次插入操作,不然将该目的插入到该桶的背后。HashSet在协会的时候提供七个参数,三个是initialCapacity
钦命了桶的数码(实际的桶数为2的initialCapacity次幂),另3个是loadFactortian(0.0–1.0,推荐值为
0.75),当桶的填充百分比达到该值后,哈希表内的哈希桶数将double,重新填写已有对象,该操作被称为rehash,rehash是很是影响作用的操作,因为为了尽恐怕幸免该事件的发出,因恐怕在布局HashSet的时候给出3个靠边的参数。以下为HashSet的常用示例代码:

LinkHashSet 一种能够记住成分插入次序的成团

6.TreeMap  键值有序排列的映射表

  (3)
使用hasNext()检查体系中是否还有成分。

 1     public static void showAddAndIterator() {
 2         HashSet<String> hs = new HashSet<String>();
 3         hs.add("B");
 4         hs.add("A");
 5         hs.add("D");
 6         hs.add("E");
 7         hs.add("C");
 8         hs.add("F");
 9         System.out.println(hs);
10         Iterator<String> it = hs.iterator();
11         while (it.hasNext())
12             System.out.println(it.next());
13     }
14     public static void showRemoveAndClearAndContains() {
15         HashSet<Integer> hSet = new HashSet<Integer>();
16         hSet.add(new Integer("1"));
17         hSet.add(new Integer("2"));
18         hSet.add(new Integer("3"));
19         System.out.println(hSet.contains(new Integer("3")));
20         System.out.println(hSet);
21         boolean blnRemoved = hSet.remove(new Integer("2"));
22         System.out.println(hSet.contains(new Integer("2")));
23         System.out.println(blnRemoved);
24         System.out.println(hSet);    
25         hSet.clear();
26         System.out.println(hSet);
27         System.out.println(hSet.isEmpty());
28     }
29     
30     public static void showToArrayListAndArray() {
31         HashSet<String> hs = new HashSet<String>();
32         hs.add("B");
33         hs.add("A");
34         hs.add("D");
35         System.out.println(hs);
36         List<String> list = new ArrayList<String>(hs);
37         Object[] objects = list.toArray();
38         for (Object obj : objects)
39             System.out.println("Object = " + obj);
40         String[] strs = list.toArray(new String[0]);
41         for (String str : strs)
42             System.out.println("String = " + str);
43     }
44 
45     public static void showToHashSetAndRemoveDuplicate() {
46         Integer[] numbers = { 7, 7, 8, 9, 10, 8, 8, 9, 6, 5, 4 };
47         List<Integer> list = Arrays.asList(numbers);
48         Set<Integer> set = new HashSet<Integer>(list);
49         for (Integer o : set)
50             System.out.print(o + ", ");
51     }
52     
53     public static void showMinMax() {
54         HashSet<Long> hashSet = new HashSet<Long>();
55         hashSet.add(new Long("9"));
56         hashSet.add(new Long("4"));
57         hashSet.add(new Long("2"));
58         hashSet.add(new Long("2"));
59         hashSet.add(new Long("3"));
60         Object objMin = Collections.min(hashSet);
61         System.out.println("Minimum Element of Java HashSet is : " + objMin);
62         Object objMax = Collections.max(hashSet);
63         System.out.println("Maximum Element of Java HashSet is : "+ objMax);
64     }
65 
66     public static void showSynchronizedSet() {
67         HashSet hashSet = new HashSet();
68         Set set = Collections.synchronizedSet(hashSet);
69         //set之后的并发操作将不再需要synchronized关键字来进行同步了。
70     }

PriorityQueue 一种能够非常的慢去除最小成分的聚合

7.  EunmMap  枚举类型的映射表

  (4)
使用remove()将迭代器新回到的因素删除。

    7.   
TreeSet:该集合为平稳聚集,数据在插入集合后便根据自定义的排序规则将插入的靶子开始展览排序,该集合首若是透过三种艺术排序插入对象的,一种是讲求
集合成分类必须是Comparable<T>的完结类,那样在插入对象的时候,集合能够依照compareTo方法的再次回到值来规定新插入对象
的岗位,此外一种方式是因此在布局该集合对象的时候,传入Comparator<T>的达成类作为参数,之后有所插入的目的都以经过
Comparator<T>的compare方法的重回值来控制新目的的任务。该集合是因而RBTree(红黑树)来兑现排序的,那一点和
C++标准库中的set和map是一致的。由于目的插入集合之后是平稳的,因而该集合的插入功用要小于HashSet的插入成效。TreeSet和
HashSet相比根本的反差来自于对象的排序规则,以上HashSet的以身作则代码均适用于TreeSet,上面只是列出目的比较的代码:

HashMap 一种存储key:value关联的炫耀

8.EnumSet   包罗枚举类型值的值

  Iterator是Java迭代器最简便易行的贯彻,为List设计的ListIterator具有越多的功力,它能够从四个趋势遍历List,也能够从List中插入和删除成分。

 1     public class Item implements Comparable<Item> {
 2         public int compareTo(Item other) {
 3             return partNumber - other.partNumber;
 4         }
 5     }
 6     public static void main(String[] args) {
 7         SortedSet<Item> parts = new TreeSet<Item>();
 8         parts.add(new Item("Toaster",1234));
 9         parts.add(new Item("Widget",4562));
10         parts.add(new Item("Modem",9912));
11         System.out.println(parts);
12         
13         SortedSet<Item> sortByDescription = new TreeSet<Item>(new Comparator<Item>() {
14             public int compare(Item a,Item b) {
15                 String descA = a.getDescription();
16                 String descB = b.getDescription();
17                 return descA.compareTo(descB);
18             }
19         });
20         sortByDescription.addAll(parts);
21         System.out.println(sortByDescription);
22     }

TreeMap 一种key有序的照耀

9.ArrayQueue  循环数组完结的双端队列

迭代器应用:

    8.    PriorityQueue(优先级对象):
该容器也是严守原地聚集,和TreeSet分裂的是,该集合只是保障当从集合的尾部取出数据的时候,总是取出队列中型小型小的(优先级最高)的因素。该集合内部是通
过”堆”的数据结构落成的,该协会只有首先个要素(尾部成分)保险为该集合中最大的或纤维的因素,别的成分没有永恒的相继,可是当集合有新的靶子从底部插
入或是从头顶取出时,集合内部的相干要素会开始展览相比较的比较最后再次决定出哪个人是最大或非常小的成分作为尾部成分。在JDK提供的classes中提姆er是
通过该数据结构实现的,从而确认保障了Timer每一次获得职务时都以最应当被调度的TimerTask,见如下代码:

LinkedHashMap 一种能够记住插入次序的映照

10.PriorityQueue  允许高效去除最小成分的汇集

 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");
 for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }
 /*迭代器用于while循环
 Iterator iter = l.iterator();
 while(iter.hasNext()){
  String str = (String) iter.next();
  System.out.println(str);
 }
 */
 1     public class TestMain {
 2         public static void main(String[] args) {
 3             PriorityQueue<String> pq = new PriorityQueue<String>();
 4             pq.add("1");
 5             pq.add("6");
 6             pq.add("4");
 7             pq.offer("5");
 8             pq.offer("3");
 9             pq.offer("2");
10             pq.offer("7");
11             //以下输出将以无序的结果输出
12             System.out.println(pq);
13             //以下输出将以有序的结果输出
14             while (pq.peek() != null) {
15                 String str = pq.poll();
16                 System.out.println(str);
17             }
18             int initCapacity = 20;
19             PriorityQueue<TestComparator> pq1 = new PriorityQueue<TestComparator>(initCapacity,
20                 new Comparator<TestComparator>() {
21                     public int compare(TestComparator t1, TestComparator t2) {
22                         return t1.getID() - t2.getID();
23                     }
24                 });
25             pq1.offer(new TestComparator(1));
26             pq1.offer(new TestComparator(6));
27             pq1.offer(new TestComparator(4));
28             pq1.offer(new TestComparator(5));
29             pq1.offer(new TestComparator(3));
30             pq1.offer(new TestComparator(2));
31             pq1.offer(new TestComparator(7));
32             System.out.println("The following is for TestComparator.");
33             System.out.println(pq1);
34             while (pq1.peek() != null) {
35                 int id = pq1.poll().getID();
36                 System.out.println(id);
37             }
38         }
39     }
40     
41     class TestComparator {
42         public TestComparator(int id) {
43             _id = id;
44         }
45         public int getID() {
46             return _id;
47         }
48         public String toString() {
49             return Integer.toString(_id);
50         }
51         private int _id;
52     }

11.LinkedHashMap  能够记住键值添加次序的映射表

 

    9.   
HashMap:其里面数据结构的逻辑类似于HashSet,只是Map存款和储蓄的都以key/value的键值映射关系,key也正是HashSet中的对
象,value只是附着于key的靶子,使用者一般都以透过key的值去HashMap中搜索,找到并重临该key以及相关联的value,其里面贯彻机
制可参照HashSet。在接口方面重要的分裂点是Map对象能够转变叁个汇集的视图(仅仅是视图,没有目的copy,视图的底部容器还是来自于原映射对
象集合,假设在其间任意视图或原集合删除和拉长数据都会即时反应与其余视图和照耀集合)。该规则一样适用于TreeMap。见之下常用代码示例:

12.WeakHashMap  能够被垃圾回收期回收的映射表

 

 1     public static void showGetAndPut() {
 2         HashMap<String, Double> hm = new HashMap<String, Double>();
 3         hm.put("A", new Double(3.34));
 4         hm.put("B", new Double(1.22));
 5         hm.put("C", new Double(1.00));
 6         hm.put("D", new Double(9.22));
 7         hm.put("E", new Double(-19.08));
 8         //随机的获取HashMap中的数据
 9         Set<Map.Entry<String, Double>> set = hm.entrySet();
10         for (Map.Entry<String, Double> me : set) {
11             System.out.print(me.getKey() + ": ");
12             System.out.println(me.getValue());
13         }
14         double balance = hm.get("A");
15         //输出1003.34
16         hm.put("A", balance + 1000);
17         System.out.println(hm.get("A"));
18     }
19     
20     public static void showContainsAndRemove() {
21         HashMap<String, String> hashMap = new HashMap<String, String>();
22         hashMap.put("1", "One");
23         hashMap.put("2", "Two");
24         hashMap.put("3", "Three");
25         System.out.println(hashMap.containsValue("Three"));
26         String str = hashMap.remove("2");
27         System.out.println("old value of 2 = " + str);
28         System.out.println(hashMap.containsValue("Two"));
29         Set<String> st = hashMap.keySet();
30         st.remove("1");
31         System.out.println("The size is equal to " + hashMap.size());
32         System.out.println(hashMap.containsKey("3"));
33     }
34     /* 结果如下
35         true
36         old value of 2 = Two
37         false 
38         The size is equal to 1 
39         true */
40         
41     public static void showIterator() {
42         String names[] = { "Mercury", "Venus", "Earth", "Mars", "Jupiter"
43             , "Saturn", "Uranus", "Neptune", "Pluto" };
44         float diameters[] = { 4800f, 12103.6f, 12756.3f, 6794f, 142984f
45             , 120536f, 51118f, 49532f, 2274f };
46         Map<String,Float> map = new HashMap<String,Float>();
47         for (int i = 0, n = names.length; i < n; i++)
48             map.put(names[i], new Float(diameters[i]));
49         Iterator<String> it = map.keySet().iterator();
50         while (it.hasNext()) {
51             String str = it.next();
52             System.out.println(str + ": " + map.get(str));
53         }
54     }
55 
56     public static void showSynchronizedMap() {
57         TreeMap<String,String> treeMap = new TreeMap<String,String>();
58         Map<String,String> map = Collections.synchronizedMap(treeMap);
59         //Map之后的并发操作将不再需要synchronized关键字来进行同步了。
60     }

13.IdentityHashMap   用==而不是equals相比键值的映射表

 

      10.   
TreeMap:TreeMap和TreeSet之间的相似性和根本出入就像是HashMap之于HashSet,见之下常用代码示例:

14.LinkedHashSet  能够记住插入次序的集合

2.java set

 1     public static void showSubMapAndHeadMapAndTailMap() {
 2         TreeMap<String, String> sortedMap = new TreeMap<String, String>();
 3         sortedMap.put("Adobe", "Mountain View, CA");
 4         sortedMap.put("IBM", "White Plains, NY");
 5         sortedMap.put("Learning Tree", "Los Angeles, CA");
 6         sortedMap.put("Microsoft", "Redmond, WA");
 7         sortedMap.put("Netscape", "Mountain View, CA");
 8         sortedMap.put("O'Reilly", "Sebastopol, CA");
 9         sortedMap.put("Sun", "Mountain View, CA");
10         System.out.println(sortedMap);
11         //firstKey and lastKey 是SortedMap中提供的方法,HashMap中没有。
12         String low = sortedMap.firstKey(), high = sortedMap.lastKey();
13         System.out.println(low);
14         System.out.println(high);
15         Iterator<String> it = sortedMap.keySet().iterator();
16         int i = 0;
17         while (it.hasNext()) {
18             if (i == 3)
19                 low = it.next();
20             if (i == 6)
21                 high = it.next();
22             else
23                 it.next();
24             i++;
25         }
26         System.out.println(low);
27         System.out.println(high);
28         //以下3个方法也是SortedMap中提供的方法,HashMap中没有。
29         System.out.println(sortedMap.subMap(low, high));
30         System.out.println(sortedMap.headMap(high));
31         System.out.println(sortedMap.tailMap(low));
32     }

在Java中应用Set,能够方便地将索要的种类以聚集类型保存在1个变量中.主要选用在体现列表.Set是多个不分包重复成分的
collection。更贴切地讲,set 不带有知足 e1.equals(e2) 的要素对 e1 和
e2,并且最多含有一个 null 成分。

    11.   
LinkedHashSet和LinkedHashMap:那七个集聚与HashSet和HashMap唯一的异样是LinkedHashSet和LinkedHashMap通过内部贯彻的双向链表保留了集合成分的插入顺序,见如下代码:

JAVA集合能够储存和操作数目不固定的一组数据。

 1     public static void main(String[] a) {
 2         Map<String, String> map = new LinkedHashMap<String, String>();
 3         map.put("1", "value1");
 4         map.put("2", "value2");
 5         map.put("3", "value3");
 6         map.put("2", "value4");
 7         for (Iterator<String> it = map.keySet().iterator(); it.hasNext();) {
 8             String key = it.next();
 9             String value = map.get(key);
10             System.out.println(value);
11         }
12     }
13     /* 结果如下:
14         value1
15         value4
16         value3 */
17 
18     //基于Values的排序后输出Keys
19     public static void main(String[] a) {
20         Map<String, String> yourMap = new HashMap<String, String>();
21         yourMap.put("1", "one");
22         yourMap.put("2", "two");
23         yourMap.put("3", "three");
24 
25         Map<String, String> map = new LinkedHashMap<String, String>();
26         List<String> keyList = new ArrayList<String>(yourMap.keySet());
27         List<String> valueList = new ArrayList<String>(yourMap.values());
28         Set<String> sortedSet = new TreeSet<String>(valueList);
29         String[] sortedArray = sortedSet.toArray(new String[0]);
30         int size = sortedArray.length;
31 
32         for (int i = 0; i < size; i++)
33             map.put(keyList.get(valueList.indexOf(sortedArray[i])), sortedArray[i]);
34 
35         Set<String> ref = map.keySet();
36         Iterator<String> it = ref.iterator();
37         while (it.hasNext()) {
38             String i = (String) it.next();
39             System.out.println(i);
40         }
41     }    

*   * 全数的JAVA集合都置身 java.util包中!
    JAVA集合只可以存放引用类型的的数量,不可能存放基本数据类型.
    JAVA集合主要分为三种类型:
    Set(集)
    List(列表)
    Map(映射)
    Collection 接口
   
Collection是最中央的聚集接口,申明了适用于JAVA集合(只蕴涵Set和List)的通用方法。
    Set 和List 都继承了Conllection,Map没有
    Collection接口的办法:
    boolean add(Object o)   :向聚集中参预一个对象的引用
    void clear()                       
:删除集合中有所的对象,即不再抱有这么些目的的引用
    boolean isEmpty()           :判断集合是还是不是为空
    boolean contains(Object o): 判断集合中是或不是享有一定指标的引用
    Iterartor iterator()              :
再次回到贰个Iterator对象,能够用来遍历集合中的成分
    boolean remove(Object o):从集合中删去2个指标的引用
    int size()                               :重回集合七月素的数目
    Object[] toArray()                
:重返3个数组,该数组中回顾集合中的全体因素
    关于:Iterator() 和toArray()
方法都用于集合的具有的因素,前者重临八个Iterator对象,后者再次来到一个暗含集合中拥有因素的数组。
    Iterator接口申明了如下方法:     hasNext(): 判断集合桐月素是或不是遍历实现,借使没有,就重返true
    next()       :重返下2个要素
    remove():从集合中删除上多少个有next()方法重返的元素。
    Set(集合):
   
Set是最简单易行的一种集合。集合中的对象不按一定的法子排序,并且没有再一次对象。
    Set接口主要达成了多个落到实处类:
    HashSet : HashSet类依据哈希算法来存取集合中的对象,存取速度比较快
    TreeSet   :
TreeSet类达成了SortedSet接口,能够对聚集中的对象开始展览排序。
    Set 的用法:     存放的是目的的引用,没有重新对象
   

    12.   
EnumSet和EnumMap,那多少个集聚能够用作是类别参数特化后的Set<E extends
Enum<E>>和Map<E extends
Enum<E>,V>,EnumSet没有显得的构造函数,而是经过一组织工作厂方法来创制了,见如下代码:

 Set set=new HashSet();
    String s1=new String("hello");
    String s2=s1;
    String s3=new String("world");
    set.add(s1);
    set.add(s2);
    set.add(s3);
    System.out.println(set.size());//打印集合中对象的数目 为 2。
 1     enum Weekdays {
 2         Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
 3     }
 4     public static void main(String[] a) {
 5         EnumSet<Weekdays> es1 = EnumSet.allOf(Weekdays.class);
 6         EnumSet<Weekdays> es2 = EnumSet.noneOf(Weekdays.class);
 7         EnumSet<Weekdays> es3 = EnumSet.range(Weekdays.Thursday, Weekdays.Sunday);
 8         EnumSet<Weekdays> es4 = EnumSet.of(Weekdays.Monday,Weekdays.Saturday);
 9         System.out.println("es1 = " + es1);
10         System.out.println("es2 = " + es2);
11         System.out.println("es3 = " + es3);
12         System.out.println("es4 = " + es4);
13     }
14     /* 结果如下:
15         es1 = [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
16         es2 = []
17         es3 = [Thursday, Friday, Saturday, Sunday]
18         es4 = [Monday, Saturday] */

    Set 的 add()方法是什么样判定指标是还是不是已经存放在集合中?

    13.   
集合视图:顾名思义,全体的联谊视图和数据库中的普通视图一样,并不存款和储蓄真实是的容器成分,而只是确立一套针对原有底层集合数据的引用机制,针对富有视图
的操作或底部集合的操作都会同时相互影响,如插入和删除等,但是对于视图而言,插入操作即便效果于其范围之外将会引发那三个。对于区别品类的视图其操作也存
在不一致的限制。
    1).    subList:获取底层集合中某一限量的要素,如List group2 =
staff.asList(10,20);
那首先个索引上的数码是被含有的,第②个目录的数额是不被含有的。就算实施了group2.clear()操作情状了视图中的数据,那么staff中那段
范围内的数据也会被连同删除。对于有序聚集和映射表(Map),能够利用排序依次而不是因素地方建立子范围,如SortedSet接口表明的
SortedSet<E> subSet(E from,E to); SortedSet<E> headSet(E
to); SortedSet<E> tailSet(E from);
注意那贰个参数的门类均不是因素的目录,而是对象自小编。SortedMap中也有近似的章程,如SortedMap<K,V>
subMap(K from,K to); SortedMap<K,V> headMap(K to);
SortedMap<K> tailMap(K
from)。在NavigableSet中提供特别丰裕的接口,如NavigableSet<E>
subSet(E from,boolean fromInclusive,E to,boolean toInclusive);
NavigableSet<E> headSet(E to,boolean toInclusive);
NavigableSet<E> tailSet(E from,boolean fromInclusive);
    2).    不可修改的视图:       
    Collections.unModifiableCollection();
    Collections.unModifiableList();        //用于ArrayList、LinkedList
    Collections.unModifiableSet();       
//用于HashSet、TreeSet、LinkedHashSet
    Collections.unModifiableSortedSet();//用于TreeSet
    Collections.unModifiableMap();       
//用于HashMap、TreeMap、LinkedHashMap
    Collections.unModifiableSortedMap();//用于TreeMap
    如List<String> staff = new LinkedList<String>();
List<String> unmodifiableList = new
Collections.unmodifiableList(staff);
那里unmodifiableList作为三个List对象,全体访问器的主意均可像一般List一样操作,不过对于更改器方法的调用将会抓住
UnsupportedOperationException分外。假如的确需求修改数据只可以通过原始集合来形成。
    3)    同步视图:
    Collections.synchronizedList();        //用于ArrayList、LinkedList
    Collections.synchronizedSet();       
//用于HashSet、TreeSet、LinkedHashSet
    Collections.synchronizedSortedMap();//用于TreeMap
    Collections.synchronizedSortedSet();//用于TreeSet
    Collections.synchronizedMap();       
//用于HashMap、TreeMap、LinkedHashMap
   
之后有所通过共同视图访问底层集合的操作都将是线程安全的,即synchronized关键字就不须求在联谊的表面添加了,但是对于底层集合的一直访问照旧是线程不安全。
    4)   
被检查视图:见之下二种情状,第1种情状将会在集聚执行(String)rawList.get()操作时抛出ClassCastException万分,第①种情状则会在rawList.add()操作时就应声抛出ClassCastException。

boolean isExists=false;
    Iterator iterator=set.iterator();
    while(it.hasNext())           {
    String oldStr=it.next();
    if(newStr.equals(oldStr)){
    isExists=true;
    }
    }
 1     public void uncheckedListTest() {
 2         ArrayList<String> strings = new ArrayList<String>();
 3         ArrayList rawList = strings;
 4         rawList.add(new Date()); //no exception is raised here.
 5         String ss = (String)rawList.get(0); //exception will be thrown here.
 6     }
 7 
 8     public void checkedListTest() {
 9         ArrayList<String> strings = new ArrayList<String>();
10         ArrayList<String> safeStrings = Collections.checkedList(strings,String.class);
11         ArrayList rawList = safeStrings;
12         rawList.add(new Date()); //exception will be thrown here.
13     }

List(列表):    
List的特点是其成分以线天性局存储,集合中得以存放重复对象。
    List接口首要完成类包罗:
    ArrayList() :
代表长度能够变更得数组。能够对成分进行任意的拜会,向ArrayList()中插入与
    与删除成分的快渐渐。
    LinkedList():
在落到实处中动用链表数据结构。插入和删除速度快,访问速度慢。
    对于List的私自走访以来,正是只随机来寻找位于特确定工作岗位位的元素。
    List 的 get(int index)
方法放回集合中由参数index内定的目录地点的对象,下标从“0” 起先。
    最大旨的两种检索集合中的全部指标的措施:     1: 用for循环和get()方法:

   
注:从集合框架的一体化统一筹划技术、扩张性、功用等地点综合相比,Java在此方面和C++的stl比较依然存在必然的差距。尤其是扩充性和成效方面,C++
的标准库定义了更加多更灵活的模参扩张。由于标准库都以因而沙盘的法门贯彻的,由此其实施作用要简明优化基于虚函数的虚指针和虚表的那种动态绑定的多态格局,其不足只是编写翻译速度有点慢罢了。
    14.    算法:
   
在C++中提供了一套泛型算法,主要包蕴排序、搜索和相比较等通用操作,由于这几个泛型算法完全遵照各个集合提供的迭代器(iterator)统一接口,因而能够高达一种中度的泛型操作,以及算法函数和汇聚之间的完全松耦合。见如下C++代码:

 for(int i=0; i<list.size();i++){
    System.out.println(list.get(i));
    }
    2: 使用 迭代器(Iterator):
    Iterator it=list.iterator();
    while(it.hashNext){
    System.out.println(it.next);
    }
 1     #include <algorithm>
 2     #include <set>
 3     #include <vector>
 4     using namespace std;
 5     int main()
 6     {
 7         vector<int> v1;
 8         for (int i = 0; i < 10; ++i)
 9             v1.push_back(i);
10         set<int> s1;
11         for (int i = 0; i < 20; ++i)
12             s1.insert(i);
13         sort(v1.begin(),v1.end());
14         binary_search(v1.begin(),v1.end(),5);
15         binary_search(s1.begin(),s1.end(),5);
16         return 0;
17     }

    Map(映射):
    Map
是一种把键对象和值对象映射的集合,它的每3个成分都包括一对键目的和值对象。
    Map没有继续于Collection接口
    从Map集合中检索元素时,只要给出键对象,就会回来对应的值对象。
    Map 的常用方法:     1 增加,删除操作:
    Object put(Object key, Object value): 向集合中加入元素
    Object remove(Object key):   删除与KEY相关的成分
    void putAll(Map t):   将来自特定影象的拥有因素添加给该影像
    void clear(): 从印象中除去全体映射
    2 询问操作:
    Object get(Object key): 获得与重大字key相关的值
   
Map集合中的键对象不容许再度,也就说,任意两个键对象通过equals()方法比较的结果都以false.
    不过足以将随意两个键独享映射到同三个值对象上。
    Conllections : 集合实用类
    Conllections提供了供JAVA集合实用的静态方法
    总结:    
JAVA集合的主导用法,都归咎了,上边这个是平凡最常用的JAVA集合,具体的别样的,还要参考JDK帮忙文书档案了,呵呵
关于 Map的行使,还有为数不少,具体就是以此,Conllections提供了很多 List /Map
实用的情势,对平庸开发非常实用。

   
在Java中千篇一律提供了如此的泛型算法,不一致的是那些算法函数都是Collections中静态方法。见如下Java代码:

boolean containsKey(Object key): 判断印象中是或不是留存珍视字key
    boolean containsValue(Object value): 判断影象中是否存在值value
    int size(): 再次来到当前印象中映射的多少
    boolean isEmpty() :判断影像中是还是不是有其余映射
   
List按指标进入的相继保存对象,不做排序或编辑操作。Set对每一个对象只接受一次,并动用自个儿之中的排序方法(常常,你只关切某些元素是或不是属于Set,而不关怀它的相继–不然应该使用List)。Map同样对各样成分保存一份,但那是依据”键”的,Map也有内置的排序,由此不关注成分添加的相继。如果添日成分的逐一对你很首要,应该利用
LinkedHashSet只怕LinkedHashMap.
    List的职能方法     实际上有二种List:
一种是骨干的ArrayList,其优点在于随机访问成分,另一种是更强大的LinkedList,它并不是为赶快随机走访布署的,而是兼具一套更通用的法子。
    List :
次序是List最要紧的风味:它保障维护成分特定的顺序。List为Collection添加了许多措施,使得能够向List中间插入与移除成分(那只推荐LinkedList使用。)二个List可以生成ListIterator,使用它能够从四个样子遍历List,也能够从List中间插入和移除成分。
    ArrayList :
由数组实现的List。允许对成分实行飞快随机访问,不过向List中间插入与移除成分的进度相当慢。ListIterator只应该用来由后迈入遍历ArrayList,而不是用来插入和移除成分。因为那比LinkedList开支要大过多。
    LinkedList :
对各类访问进行了优化,向List中间插入与删除的支付并一点都不大。随机访问则绝对较慢。(使用ArrayList代替。)还有所下列格局:addFirst(),
addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(),
那么些方法
(没有在此外接口或基类中定义过)使得LinkedList能够当作储藏室、队列和双向队列使用。
    Set的意义方法    
Set具有与Collection完全等同的接口,因此并未任何附加的功效,不像前边有七个不等的List。实际上Set正是Collection,只是表现不一致。(那是后续与多态思想的头角峥嵘应用:表现差别的行为。)Set不保留重复的要素(至于何以判定成分相同则相比较负责)
    Set :
存入Set的种种成分都必须是唯一的,因为Set不保留重复成分。参与Set的要素必须定义equals()方法以保证指标的唯一性。Set与Collection有一齐等同的接口。Set接口不保障维护成分的次序。
    HashSet :
为急忙搜索设计的Set。存入HashSet的靶子必须定义hashCode()。
    TreeSet : 保存次序的Set,
底层为树结构。使用它能够从Set中领到有序的体系。
    LinkedHashSet :
具有HashSet的询问速度,且个中使用链表维护成分的顺序(插入的主次)。于是在选取迭代器遍历Set时,结果会按要素插入的次序显示。
    Map的功力方法     方法put(Object key, Object
value)添加3个“值”(想要得东西)和与“值”相关联的“键”(key)(使用它来寻找)。方法get(Object
key)再次回到与给定“键”相关联的“值”。能够用containsKey()和containsValue()测试Map中是不是包罗有个别“键”或“值”。标准的Java类库中包罗了二种不一样的Map:HashMap,
TreeMap, LinkedHashMap, WeakHashMap,
IdentityHashMap。它们都有同等的宗旨接口Map,可是作为、功用、排序策略、保存对象的生命周期和判断“键”等价的政策等各分歧。
   
执行功能是Map的三个大题材。看看get()要做哪些事,就会精晓为什么在ArrayList中搜索“键”是非常的慢的。而那便是HashMap进步速度的地方。HashMap使用了超过常规规的值,称为“散列码”(hash
code),来替代对键的缓缓搜索。“散列码”是“相对唯一”用以代表对象的int值,它是透过将该对象的一些音信进行更换而生成的。全体Java对象都能发生散列码,因为hashCode()是概念在基类Object中的方法。
   
HashMap正是应用对象的hashCode()举行急忙查询的。此方法能够显着升高品质。
www.5929.com ,    Map : 维护“键值对”的关联性,使您能够经过“键”查找“值”
    HashMap :
Map基于散列表的贯彻。插入和查询“键值对”的费用是定位的。能够由此构造器设置体积capacity和负载因子load
factor,以调动容器的属性。
    LinkedHashMap :
类似于HashMap,但是迭代遍历它时,取得“键值对”的各类是其插入次序,只怕是多年来最少使用(LRU)的程序。只比HashMap慢一点。而在迭代走访时发而更快,因为它应用链表维护个中次序。
    TreeMap :
基于红黑树数据结构的完成。查看“键”或“键值对”时,它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的风味在于,你获得的结果是由此排序的。TreeMap是绝无仅有的涵盖subMap()方法的Map,它能够回来三个子树。
    WeakHashMao : 弱键(weak key)Map,Map中使用的对象也被允许释放:
那是为涸泽而渔卓绝难题设计的。假如没有map之外的引用指向有些“键”,则此“键”能够被垃圾收集器回收。
    IdentifyHashMap : 使用==代替equals()对“键”作相比较的hash
map。专为消除非凡难题而规划。

 1     public static void main(String[] args) {
 2         List<Integer> v1 = new ArrayList<Integer>();
 3         for (int i = 0; i < 10; ++i)
 4             v1.add(i);
 5         
 6         List<Integer> l1 = new LinkedList<Integer>();
 7         for (int i = 0; i < 20; ++i)
 8             l1.add(i);
 9         
10         Collections.sort(v1);
11         Collections.sort(l1);
12         Collections.binarySearch(v1, 5);
13         Collections.binarySearch(l1, 5);
14     }

 

Leave a Comment.