新手瞭解java 集合基礎知識
一、概述
集合是一種長度可變,存儲數據的數據結構多樣,存儲對象多樣的一種數據容器。Java中集合可分為:List集合、Set集合、HashMap集合,等。
Java集合體系結構:
二、collection
collection是Java中所有值存儲集合的頂級接口,因此它的所有直接或者間接實現類都有它的非私有方法,我們可以從它的方法開始瞭解這個體系的功能實現。
boolean add(E e) 確保此 collection 包含指定的元素。 boolean addAll(Collection<? extends E> c) 將指定 collection 中的所有元素都添加到此 collection 中。 void clear() 移除此 collection 中的所有元素。 boolean contains(Object o) 如果此 collection 包含指定的元素,則返回 true。 boolean containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素,則返回 true。 boolean equals(Object o) 比較此 collection 與指定對象是否相等。 int hashCode() 返回此 collection 的哈希碼值。 boolean isEmpty() 如果此 collection 不包含元素,則返回 true。 Iterator<E> iterator() 返回在此 collection 的元素上進行迭代的迭代器。 boolean remove(Object o) 從此 collection 中移除指定元素的單個實例,如果存在的話)。 boolean removeAll(Collection<?> c) 移除此 collection 中那些也包含在指定 collection 中的所有元素。 boolean retainAll(Collection<?> c) 僅保留此 collection 中那些也包含在指定 collection 的元素。 int size() 返回此 collection 中的元素數。 Object[] toArray() 返回包含此 collection 中所有元素的數組。 <T> T[] toArray(T[] a) 返回包含此 collection 中所有元素的數組;返回數組的運行時類型與指定數組的運行時類型相同。
1、List
List,是單列集合,存儲的是一組插入有序的數據,並且數據可以重復。
List集合
- LinkedList
- ArrayList
1)ArrayList
示例:
public class CollectionTest { public static void main(String[] args) { List list = new ArrayList(); //添加元素,boolean add(E e) 確保此 collection 包含指定的元素 list.add("張三"); list.add(1); list.add('A'); System.out.println(list);//[張三, 1, A] //boolean addAll(Collection<? extends E> c) // 將指定 collection 中的所有元素都添加到此 collection 中 List list1 = new ArrayList(); list.add("java"); list.add("MySQL"); list.addAll(list1); System.out.println(list);//[張三, 1, A, java, MySQL] //boolean contains(Object o) // 如果此 collection 包含指定的元素,則返回 true。 System.out.println(list.contains("java"));//true //boolean remove(Object o) // 從此 collection 中移除指定元素的單個實例,如果存在的話)。 System.out.println(list.remove("java"));//true // int size() // 返回此 collection 中的元素數。 System.out.println(list.size());//4 //set(int index, E element) // 用指定的元素替代此列表中指定位置上的元素。 //並返回被修改的值 System.out.println(list.set(1, "李四")); //get(int index) // 返回此列表中指定位置上的元素。 System.out.println(list.get(1)); // Iterator<E> iterator() // 返回在此 collection 的元素上進行迭代的迭代器。 //集合的遍歷 Iterator iterator = list.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next()); } }
說明:ArrayList底層是使用數組的形式創建集合的,因此基於數組的特性,此集合對數據的查找很快速,但是在刪除或移動大量數據操作上會顯得緩慢。它適合用於快速查找,但不適合做刪除多的操作。
2)LinkedList
LinkedList:雙向鏈表,內部沒有聲明數組,而是定義瞭Node類型的first 和last,用於記錄首末元素。同時,定義內部類Node,作為LinkedList中 保存數據的基本結構。Node除瞭保存數據,還定義瞭兩個變量:
- prev變量記錄前一個元素的位置
- next變量記錄下一個元素的位置
特點:
- 數據有序
- 底層結構為鏈表
ArrayList比較:
- LinkedList的添加元素速度比ArrayList快;
- LinkedList的查詢速度比ArrayList慢;
- 底層數據結構不同:LinkedList用的是鏈表結構,而ArrayList底層使用 的是數組結構;
說明:LinkedList一般用於添加頻繁的操作,ArrayList一般用於頻繁查詢 的操作。
示例:
public class Stack { private LinkedList data = null; public Stack(){ data = new LinkedList(); } // 添加元素 public boolean push(Object element) { data.addFirst(element); return true; } // 獲取元素 public Object pop() { return data.pollFirst(); } // 判斷集合是否為空 public boolean isEmpty() { return data.isEmpty(); } // 迭代元素 public void list() { Iterator it = data.iterator(); while(it.hasNext()){ System.out.println(it.next()); } } } public class MyStack { public static void main(String[] args) { Stack stack = new Stack(); stack.push("張三"); stack.push("李四"); stack.push("王五"); stack.list(); System.out.println("-------------"); Object pop = stack.pop(); System.out.println(pop); } }
2、set
1)HashSet
HashSet 是 Set 接口的典型實現,大多數時候使用 Set 集合時都使用 這個實現類。
- HashSet 按 Hash 算法來存儲集合中的元素,因此具有很好的存取、 查找、刪除性能。
- HashSet 具有以下特點:不能保證元素的排列順序
- HashSet 不是線程安全的
- 集合元素可以是 null
- 不能添加重復元素
- HashSet 集合判斷兩個元素相等的標準:兩個對象通過 hashCode() 方法比較相等,並且兩個對象的 equals() 方法返回值也相等。
- 對於存放在Set容器中的對象,對應的類一定要重寫equals()和 hashCode(Object obj)方法,以實現對象相等規則。即:“相等的對象必須具有相等的散列碼”。
示例:
public static void main(String[] args) { Set set = new HashSet(); // 添加 // boolean add(E e) :把指定的元素添加到集合中 set.add("hello"); set.add("world"); set.add("world"); set.add(null); System.out.println(set); // 註:Set集合中元素是無序,並且不能重復 // boolean addAll(Collection<? extends E> c) :把指定的集合添加到集合中 Set set1 = new HashSet(); set1.add("aaa"); set1.add("linux"); ; set.addAll(set1); System.out.println(set); // boolean remove(Object o) :從集合中刪除指定元素 set.remove("hello"); System.out.println(set); // boolean removeAll(Collection<?> c) :從集合中刪除指定集合中的所有元素 set1.add("aaa"); set1.add("linux"); set.removeAll(set1); System.out.println(set); // void clear() :清空集合中所有元素 set.clear(); System.out.println(set); // int size() :獲取集合的元素個數 int size = set.size(); System.out.println(size); // boolean contains(Object o) :判斷集合中是否包含指定元素,包含為true,否則為false; System.out.println(set.contains("aaa")); // boolean isEmpty() :判斷集合是否為空 System.out.println(set.isEmpty()); }
說明:在HashSet添加元素時,會首先比較兩個元素的hashCode值是不相等,如 果不相等則直接添加;如果相等再判斷兩個元素的equals的值是否相等, 如果相等則不添加,如果不相等則添加。
2)TreeSet
- TreeSet和TreeMap采用紅黑樹的存儲結構
- 特點:有序,查詢速度比List快
使用TreeSet集合是,對象必須具有可比較性。而要讓對象具有可比較性有 兩種方式:
第一種:實現Comparable
接口,並重寫compareTo()
方法:
第二種:寫一個比較器類,讓該類去實現Comparator
接口,並重寫 comare()
方法。
示例:
1.實體類
public class Student implements Comparable<Student>{ private String name; private int age; private String sex; private int height; public Student() { } public Student(String name, int age, String sex, int height) { this.name = name; this.age = age; this.sex = sex; this.height = height; } 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 String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public int getHeight() { return height; } public void setHeight(int height) { this.height = height; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return age == student.age && height == student.height && Objects.equals(name, student.name) && Objects.equals(sex, student.sex); } @Override public int hashCode() { return Objects.hash(name, age, sex, height); } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + ", sex='" + sex + '\'' + ", height=" + height + '}'; } @Override public int compareTo(Student stu) { if (stu.getAge() > this.getAge()){ return 1; } if (stu.getAge() < this.getAge()){ return -1; } return stu.getName().compareTo(this.getName()); } }
2.測試類:
public class TreeSetTest { public static void main(String[] args) { TreeSet treeSet = new TreeSet(); Student student1 = new Student("張三", 20, "男", 165); Student student2 = new Student("李四", 21, "男", 170); Student student3 = new Student("王五", 19, "女", 160); Student student4 = new Student("趙六", 18, "女", 165); Student student5 = new Student("田七", 20, "男", 175); treeSet.add(student1); treeSet.add(student2); treeSet.add(student3); treeSet.add(student4); treeSet.add(student5); System.out.println(treeSet); } }
3.實體類
public class Teacher { private String name; public Teacher(){} public Teacher(String name){ this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "Teacher{" + "name='" + name + '\'' + '}'; } }
4.測試類
public class TreeSetTest2 { public static void main(String[] args) { Teacher teacher1 = new Teacher("11"); Teacher teacher2 = new Teacher("12"); Teacher teacher3 = new Teacher("13"); Teacher teacher4 = new Teacher("14"); Teacher teacher5 = new Teacher("15"); TreeSet treeSet1 = new TreeSet(new Comparator() { @Override public int compare(Object o1, Object o2) { return o1.hashCode() - o2.hashCode(); } }); treeSet1.add(teacher1); treeSet1.add(teacher2); treeSet1.add(teacher3); treeSet1.add(teacher4); treeSet1.add(teacher5); System.out.println(treeSet1); } }
說明:HashSet
去重是依靠hashCode
和equals()
方法,而TreeSet去重則 依靠的是比較器。
三、Map
存儲的雙列元素,Key是無序的,不可重復,而Value是無序,可重復的。
1、HashMap
public class HashMapDemo { private Map map = null; public void init() { map = new HashMap(); map.put("a", "aaa"); map.put("b", "bbb"); map.put("c", "ccc"); System.out.println(map); } // 添加元素 public void testPut() { // V put(K key, V value) :把指定的key和value添加到集合中 map.put("a1", "aaa"); map.put("b1", "bbb"); map.put("c1", "ccc"); System.out.println(map); // void putAll(Map<? extends K,? extends V>m) :把指定集合添加集合中 Map map1 = new HashMap(); map1.put("e", "eee"); map1.put("f", "fff"); map.putAll(map1); System.out.println(map); // default V putIfAbsent(K key, V value) :如果key不存在就添加 map.putIfAbsent("a", "hello"); System.out.println(map); map.putIfAbsent("g", "ggg"); System.out.println(map); } // 修改元素 public void testModify() { // V put(K key, V value) :把集合中指定key的值修改為指定的值 map.put("a", "hello"); map.put("a", "world"); System.out.println(map); // 說明,當key相同時,後面的值會覆蓋前面的值。 // default V replace(K key, V value) :根據key來替換值,而不做增加操作 Object replace = map.replace("b1", "java"); System.out.println(replace); System.out.println(map); //default boolean replace(K key, V oldValue,V newValue) } // 刪除元素 public void testRemove() { // V remove(Object key) :根據指定key刪除集合中對應的值 Object c = map.remove("c"); System.out.println(c); System.out.println(map); // default boolean remove(Object key, Objectvalue) :根據key和value進行刪除 map.remove("b", "bbb1"); System.out.println(map); // void clear() :清空集合中所有元素 map.clear(); System.out.println(map); } // 判斷元素 public void testJudge() { // boolean isEmpty() :判斷集合是否為空,如果是返回true,否則返回false System.out.println(map.isEmpty()); // boolean containsKey(Object key) :判斷集合中是否包含指定的key,包含返回true,否則返回false boolean flag = map.containsKey("a"); System.out.println(flag); // true flag = map.containsKey("a1"); System.out.println(flag); // false // boolean containsValue(Object value) :判斷集合中是否包含指定的value,包含返回true,否則返回false flag = map.containsValue("aaa"); System.out.println(flag); // true flag = map.containsValue("aaa1"); System.out.println(flag); // false } // 獲取元素 public void testGet() { // int size() :返回集合的元素個數 int size = map.size(); System.out.println(size); // V get(Object key) :根據Key獲取值,如果找到就返回對應的值,否則返回null Object val = map.get("a"); System.out.println(val); val = map.get("a1"); System.out.println(val); // null // default V getOrDefault(Object key, VdefaultValue) :根據Key獲取值,如果key不存在,則返回默認值 val = map.getOrDefault("a1", "hello"); System.out.println(val); // Collection<V> values() :返回集合中所有的Value Collection values = map.values(); for (Object value : values) { System.out.println(value); } // Set<K> keySet() :返回集合中所有的Key Set set = map.keySet(); for (Object o : set) { System.out.println(o); } } // 迭代元素 public void testIterator() { // 第一種:通過key獲取值的方式 Set keySet = map.keySet(); Iterator it = keySet.iterator(); while (it.hasNext()) { Object key = it.next(); Object val = map.get(key); System.out.println(key + "=" + val); } System.out.println("------------------------ "); // 第二種:使用for循環 for (Object key : map.keySet()) { System.out.println(key + "=" + map.get(key)); } System.out.println("------------------------ "); // 第三種:使用Map接口中的內部類來完成,在框架中大量使用 Set entrySet = map.entrySet(); for (Object obj : entrySet) { Map.Entry entry = (Map.Entry) obj; System.out.println(entry.getKey() + "=" + entry.getValue()); } } }
說明:在HashMap中鍵-值允許為空,但鍵唯一,值可重復。hashMap不是線程安全的。
2、TreeMap
是一個有序的集合,默認使用的是自然排序方式。
public class Person implements Comparable { private String name; private int age; @Override public int compareTo(Object o) { if (o instanceof Person) { Person p = (Person) o; return this.age - p.age; } return 0; } public Person() {} public Person(String name, int age) { this.name = name; this.age = age; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } }
測試
public class TeeMapDemo { @Test public void testInteger() { TreeMap tm = new TreeMap(); tm.put(3, 333); tm.put(2, 222); tm.put(11, 111); tm.put(2, 222); System.out.println(tm); } @Test public void testString() { TreeMap tm = new TreeMap(); tm.put("hello", "hello"); tm.put("world", "world"); tm.put("about", ""); tm.put("abstract", ""); System.out.println(tm); } @Test public void testPerson() { TreeMap tm = new TreeMap(new Comparator(){ @Override public int compare(Object o1, Object o2) { if (o1 instanceof Person && o2 instanceof Person) { Person p1 = (Person) o1; Person p2 = (Person) o2; return p1.getAge() - p2.getAge(); } return 0; } }); tm.put(new Person("張三",18), null); tm.put(new Person("李四",17), null); System.out.println(tm); } }
說明:從上面的代碼可以發現,TreeMap的使用和TreeSet的使用非常相似,觀察HashSet集合的源代碼可以看出,當創建 HashSet集合時,其實是底層使用的是HashMap。
public HashSet() { map = new HashMap<>(); }
HashSet實際上存的是HashMap的Key。
3.ConcurrentHashMap
在Map集合中我們介紹瞭HashMap
,TreeMap
,在多線程的情況下這些集合都不是線程安全的,因此可能出現線程安全的問題。
在Java中Hashtable是一種線程安全的HashMap
,Hashtable
在方法上與HashMap
並無區別,僅僅隻是在方法使用瞭synchronized
以此來達到線程安全的目的,我們觀察Hashtable的源碼。
public synchronized V get(Object key) { Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return (V)e.value; } } return null; }
以上是Hashtable的get源碼,可以看出它僅僅隻是在方法上添加瞭鎖,這大大降低瞭線程的執行效率,以犧牲效率的形式來達到目的,這顯然不是我們在實際中想要的,因此我們需要一種既能在線程安全方面有保障,在效率上還可以的方法。
ConcurrentHashMap采用的是分段鎖的原理,我們觀察源碼。
public V put(K key, V value) { return putVal(key, value, false); } final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw new NullPointerException(); int hash = spread(key.hashCode()); int binCount = 0; for (Node<K,V>[] tab = table;;) { Node<K,V> f; int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null))) break; // no lock when adding to empty bin } else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); else { V oldVal = null; synchronized (f) { if (tabAt(tab, i) == f) { if (fh >= 0) { binCount = 1; for (Node<K,V> e = f;; ++binCount) { K ek; if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) { oldVal = e.val; if (!onlyIfAbsent) e.val = value; break; } Node<K,V> pred = e; if ((e = e.next) == null) { pred.next = new Node<K,V>(hash, key, value, null); break; } } } else if (f instanceof TreeBin) { Node<K,V> p; binCount = 2; if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) { oldVal = p.val; if (!onlyIfAbsent) p.val = value; } } } } if (binCount != 0) { if (binCount >= TREEIFY_THRESHOLD) treeifyBin(tab, i); if (oldVal != null) return oldVal; break; } } } addCount(1L, binCount); return null; }
從源碼中可以看出ConcurrentHashMap
僅僅是在當有線程去操作當前數據的時候添加瞭鎖,因此效率大大提高瞭。
在線程安全的情況下提高瞭效率。
總結
本篇文章就到這裡瞭,希望能對你有所幫助,也希望您能夠多多關註WalkonNet的更多內容!
推薦閱讀:
- Java 深入淺出掌握Collection單列集合Set
- 深入淺出講解Java集合之Collection接口
- 帶你入門Java的集合
- 一文掌握Java中List和Set接口的基本使用
- 新手初學Java集合框架