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);
    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
倍,那样会拉动一定的上空浪费,不过为了制止平常扩大而带来的属性开支,只可以是用空间换取时间了。即便在容器的中等添加或许去除三个因素都将会招致后边的
元素向后或向前挪动二个岗位,即使成分数量较多且该操作比较频仍,将会导致系统的属性下落,然则对于容器桐月素的随机访问质量较好,以下为
ArrayList的常用示例代码:

LinkedList 一种能够在其余职责展开火速地插入和删除操作的不变系列

2.LinkedList 方可在其余地点赶快插入和删除错左的稳步系列

迭代器是一种设计情势,它是3个对象,它能够遍历并选拔系列中的对象,而开发职员不需求驾驭该体系的最底层结构。迭代器常常被叫作“轻量级”对象,因为创建它的代价小。

  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:   
该集合是透过双向链表来促成的,对于钦定位置成分的遍历其里面做了二个小的优化,假若position大于len/2,由于内部的数据结构是双向链表,因而能够从后迈入遍历,以减小遍历进度中节点跳转的次数。ArrayList中的超过四分之二代码示例都适用于LinkedList,以下近给出
LinkedList特有的常用示例代码:

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

4.TreeSet   有序集

  (1)
使用办法iterator()供给容器重临一个Iterator。第叁回调用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()获得系列中的下3个要素。

    4.    ArrayList和LinkedList的相同点:
    1)    都以接口List<E>的落实类;
    2)   
都能够透过iterator()方法重返Iterator<E>迭代器对象,并得以由此该对象遍历容器中的成分;
    3)   
要是七个Iterator<E>实例同时援引同二个聚众对象,那么当有3个正值遍历,而除此以外二个改动(add/remove)了汇集对象中的
成分,对于第2个迭代器再进行迭代时将会抓住ConcurrentModificationException很是的发出。
    5.    ArrayList和LinkedList的差别点:
    1)   
对ArrayList和LinkedList而言,在列表末尾扩充1个成分所花的开发都以定位的。对ArrayList而言,主假如在个中数组中追加一
项,指向所添加的成分,偶尔只怕会促成对数组重新进行分红;而对LinkedList而言,这些费用是联合的,分配四个里头Entry对象。
    2)   
在ArrayList的中档插入或删除一个成分意味着那个列表中剩下的因素都会被移位;而在LinkedList的中游插入或删除三个要素的费用是一贯的。
    3)    LinkedList不支持高效的肆意成分访问。
    4)   
ArrayList的上空浪费主要反映在在list列表的最终预留一定的体积空间,而LinkedList的半空中耗费则映未来它的每四个因素都亟待消耗一定的空中
   
在C++的标准库中,ArrayList和LinkedList之间的施用差别以及个别的利弊也一样呈现于vector和list。
    6.    HashSet:
散列表为各样对象计算出一个整数(通过Object缺省的或类重载的hashCode域方法),称为散列码。在Java中,散列表是利用链表的数组来贯彻
的,各类链表被誉为多个哈希桶。若是想在哈希表中找找三个对象,则须求先计算对象的hashCode,之后对表内的桶数取余数,获得的结果正是哈希桶的索
引,此时一经该桶为空桶,就足以从来将该目的插入到该桶中,假如已经有对象存在了,则须要各种举行比较,一旦发觉该与该对象相等的靶子(equals()
重临true),就会丢弃这一次插入操作,不然将该对象插入到该桶的背后。HashSet在布局的时候提供四个参数,2个是initialCapacity
钦定了桶的数量(实际的桶数为2的initialCapacity次幂),另八个是loadFactortian(0.0–1.0,推荐值为
0.75),当桶的填写百分比达到该值后,哈希表内的哈希桶数将double,重新填写已有目的,该操作被号称rehash,rehash是特别影响作用的操作,因为为了尽可能幸免该事件的产生,因只怕在协会HashSet的时候给出一个合理的参数。以下为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,上边只是列出目的相比较的代码:

发表评论

电子邮件地址不会被公开。 必填项已用*标注