集合類整理
集合類關係圖以下：java
一，SET:數組
① EnumSet安全
package set;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Set;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 12:05
*/
public class EnumSetTest {
/**
* EnumSet提供了對枚舉的set集合操做，提供了更高效簡單的枚舉操做
* 其實使用hashset也能實現對枚舉的操做，應該是EnumSet更專一作枚舉一些吧
* EnumSet是一個抽象類，繼承於AbstractSet，AbstractSet實現Set接口
*/
public static void main(String[] args) {
System.out.println("EnumSet.noneOf");
Set<Student> set=EnumSet.noneOf(Student.class);
set.add(Student.HARRY);
set.add(Student.ROBBIE);
set.add(Student.ROBIN);
for(Student p:set){
System.out.println(p);
}
set.clear();
System.out.println();
System.out.println("EnumSet.allOf");
set=EnumSet.allOf(Student.class);
for(Student p:set){
System.out.println(p);
}
set.clear();
System.out.println();
System.out.println("EnumSet.Of one");
set=EnumSet.of(Student.ROBIN);
for(Student p:set){
System.out.println(p);
}
System.out.println();
System.out.println("EnumSet.Of two");
set=EnumSet.of(Student.ROBIN,Student.HARRY);
for(Student p:set){
System.out.println(p);
}
System.out.println();
System.out.println("hashset：");
Set<Student> set2 = new HashSet<Student>();
set2.add(Student.HARRY);
set2.add(Student.ROBBIE);
set2.add(Student.ROBIN);
for (Student student : set2){
System.out.println(student);
}
}
}
enum Student
{
ROBIN("robin"),
HARRY("harry",40),
ROBBIE("robbie");
String name;
int age;
private Student(String name)
{
this(name,0);
}
private Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String toString()
{
return name;
}
}
打印結果：ide
EnumSet.noneOf robin harry robbie EnumSet.allOf robin harry robbie EnumSet.Of one robin EnumSet.Of two robin harry hashset： robbie robin harry
② LinkedHashSetui
package set;
import java.util.LinkedHashSet;
import java.util.Set;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 14:35
*/
public class LinkedHashSetTest {
/**
* LinkedHashSet是有序的set，不容許重複，可是跟放入的前後順序有關。
* 若是已經包含這個元素，那麼add會失敗
*/
public static void main(String[] args) {
Set<Integer> set = new LinkedHashSet<Integer>();
set.add(1);
set.add(5);
set.add(2);
set.add(1);
for(Integer i : set){
System.out.println(i);
}
}
}
打印結果：
this
1 5 2
③ TreeSet.net
package set;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 12:27
*/
public class TreeSetTest {
/**
* TreeSet是類，實現NavigableSet，NavigableSet繼承SortedSet接口，SortedSet實現Set接口
* 默認升序排序，若是要改變排序規則，能夠實現Comparator的compare方法
* 其內部使用了Map
*/
public static void main(String[] args) {
Set<Integer> set = new TreeSet<Integer>(new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
set.add(2);
set.add(1);
set.add(3);
for(Integer i : set){
System.out.println(i);
}
}
}
打印結果：線程
3 2 1
二，List指針
① LinkedList對象
package list;
import java.util.LinkedList;
import java.util.List;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 15:22
*/
public class LinkedListTest {
/**
* LinkedList和ArrayList的區別
* LinkedList是基於鏈表實現的，ArrayList是基於動態數組（初始化數據長度，後期再增長長度）實現的。
* 因此對於查詢，ArrayList根據角標來查詢時要比LinkedList要快。
* 對於修改，LinkedList要比ArrayList要快，由於ArrayList是數組，數組內容在一塊存儲空間，須要移動其餘已經存儲的元素，LinkedList只須要修改先後的引用就能夠了，不涉及對象的移動
*/
public static void main(String[] args) {
List<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(2);
for(Integer i : list){
System.out.println(i);
}
}
}
打印結果：
1 2
② vector
package list;
import java.util.List;
import java.util.Vector;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 15:41
*/
public class VectorTest {
/**
* Vector類實現了List接口，他和ArrayList的區別是，他是線程安全的。
* 內部實現是數組
*
*/
public static void main(String[] args) {
List<Integer> list = new Vector<Integer>();
list.add(1);
list.add(2);
for(Integer i : list){
System.out.println(i);
}
}
}
打印結果：
1 2
三，queue
① ProrityQueue
package queue;
import java.util.Comparator;
import java.util.PriorityQueue;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 17:28
*/
public class ProrityQueueTest {
public static void main(String[] args) {
PriorityQueue<Boss> priorityQueue = new PriorityQueue<Boss>(2,new Comparator<Boss>() {
public int compare(Boss o1, Boss o2) {
return o2.getAge() - o1.getAge();
}
});
priorityQueue.add(new Boss("zhouhui",28));
priorityQueue.add(new Boss("zhangjingjing",26));
for(Boss boss : priorityQueue){
System.out.println(boss.toString());
}
}
}
class Boss{
private String name;
private Integer age;
public Boss(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Boss{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
打印結果：
Boss{name='zhouhui', age=28}
Boss{name='zhangjingjing', age=26}
四 map
① EnumMap
package map;
import java.util.EnumMap;
import java.util.Map;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 15:46
*/
public class EnumMapTest {
/**
* EnumMap的key必須是枚舉類型
*/
public static void main(String[] args) {
Map<Student,String> map = new EnumMap<Student, String>(Student.class);
map.put(Student.HARRY,Student.HARRY.toString());
map.put(Student.ROBBIE,Student.ROBBIE.toString());
map.put(Student.ROBIN,Student.ROBIN.toString());
for(Map.Entry<Student,String> entry : map.entrySet()){
System.out.println(entry.getKey().name + ":" + entry.getValue());
}
}
}
enum Student
{
ROBIN("robin"),
HARRY("harry",40),
ROBBIE("robbie");
String name;
int age;
private Student(String name)
{
this(name,0);
}
private Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String toString()
{
return name;
}
}
打印結果：
robin:robin harry:harry robbie:robbie
② hashtable
package map;
import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 16:14
*/
public class HashTableTest {
/**
* hashtable和hashmap的區別：
* 1，hashtable是線程安全的，hashmap不是
* 2，hashmap能接受key和value都是null的狀況，hashtable不行
* 3，hashmap能夠經過Collections.synchronizedMap(map)變成線程安全的
*/
public static void main(String[] args) {
Hashtable<Integer,Integer> hashtable = new Hashtable<Integer,Integer>();
for (int i = 0; i < 10; i++) {
hashtable.put(i,i);
}
//hashtable不容許null，會報空指針
//hashtable.put(null,null);
for(Map.Entry<Integer,Integer> entry : hashtable.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
Map<Integer,Integer> map = new HashMap<Integer, Integer>();
map.put(1,12);
map = Collections.synchronizedMap(map);
}
}
打印結果：
9:9 8:8 7:7 6:6 5:5 4:4 3:3 2:2 1:1 0:0
③ IdentityHashMap
package map;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Map;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 15:57
*/
public class IdentityHashMapTest {
/**
* IdentityHashMap判斷key是否重複是用對象==，而不是想HashMap這樣使用對象的toString
* 好比"1"或者String.valueOf("1")，和new String("1")是不同的，IdentityHashMap能放進去，而HashMap不能夠。
*/
public static void main(String[] args) {
Map<String,String> map = new IdentityHashMap<String,String>();
map.put("1","2");
map.put(new String("1"),"2");
for(Map.Entry<String,String> entry : map.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
System.out.println("---------------------");
map = new HashMap<String, String>();
map.put(String.valueOf("1"),"2");
map.put(new String("1"),"2");
for(Map.Entry<String,String> entry : map.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}
打印結果：
1:2 1:2 --------------------- 1:2
④ LinkedHashMap
package map;
import java.util.Map;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 16:09
*/
public class LinkedHashMapTest {
/**
* 有序的map集合。
*/
public static void main(String[] args) {
Map<Integer,Integer> map = new java.util.LinkedHashMap<Integer, Integer>();
map.put(1,3);
map.put(2,3);
map.put(3,3);
for(Map.Entry<Integer,Integer> entry : map.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}
打印結果：
1:3 2:3 3:3
⑤ properties
package map;
import java.util.Map;
import java.util.Properties;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 16:26
*/
public class PropertiesTest {
/**
* properties繼承於hashtable，其key和value都是string的，即便能夠提供put(Object,Object)的方法，那麼最後都會toString變成String，String。
*
* properties類更多的是load文件，getProperty(String key)獲取屬性值
*/
public static void main(String[] args) {
Properties properties = new Properties();
properties.put(new Boss("zhou",1),new Boss("zhang",12));
for(Map.Entry<Object,Object> entry : properties.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}
class Boss{
private String name;
private Integer age;
public Boss(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Boss{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object obj) {
return super.equals(obj);
}
}
打印結果
Boss{name='zhou', age=1}:Boss{name='zhang', age=12}
⑥ TreeMap
package map;
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 16:53
*/
public class TreeMapTest {
/**
* TreeMap是根據key有序的map
*/
public static void main(String[] args) {
Map<Integer,Integer> map = new TreeMap<Integer, Integer>(new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
map.put(1,2);
map.put(2,3);
map.put(3,1);
for(Map.Entry<Integer,Integer> entry : map.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}
打印結果：
3:1 2:3 1:2
⑦ WeakHashMap
package map;
import java.util.Map;
import java.util.WeakHashMap;
/*
* DESCRIPTION :
* USER : zhouhui
* DATE : 2017/8/18 17:03
*/
public class WeakHashMapTest {
/**
* weakhashmap和hashmap的區別是：
* weakhashmap的key若是是一個空引用，那麼會被釋放掉。
*/
public static void main(String[] args) {
String a = new String("1");
Map<String,String> map = new WeakHashMap<String, String>();
map.put(a,"2");
for(Map.Entry<String,String> entry : map.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
System.out.println("--------------------------------------");
a = null;
System.gc();
for(Map.Entry<String,String> entry : map.entrySet()){
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}
打印結果
1:2 --------------------------------------
相關文章
- 1. JAVA集合類整理
- 2. C# 集合類型（經常使用集合類型整理）
- 3. 集合整理
- 4. Java集合類層次關係整理
- 5. Https的各類協議-集合整理
- 6. 【基礎】Java集合類整理（面試）
- 7. Java集合類--超詳細整理
- 8. java集合整理
- 9. Java集合整理
- 10. 集合的整理
- 更多相關文章...
- • Scala Set(集合) - Scala教程
- • C# 集合（Collection） - C#教程
- • ☆技術問答集錦（13）Java Instrument原理
- • Kotlin學習（二）基本類型
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. JAVA集合類整理
- 2. C# 集合類型（經常使用集合類型整理）
- 3. 集合整理
- 4. Java集合類層次關係整理
- 5. Https的各類協議-集合整理
- 6. 【基礎】Java集合類整理（面試）
- 7. Java集合類--超詳細整理
- 8. java集合整理
- 9. Java集合整理
- 10. 集合的整理