java學習日記集合框架

時間 2019-12-05

標籤 java 學習日記集合框架欄目 Java 简体版

原文原文鏈接

集合框架 java

有兩大接口一個是 Collection （類集）與Map （映射）；數組

collection 下有兩大接口一個是List （列表）另外一個是Set（集合）框架

List （列表）：ArrayList 基於數組實現的動態列表動態數組；ide

　　　　　　　LinkedList 基於鏈表實現的列表雙向循環鏈表性能

　　　　　　Vector 向量 ------》stack棧與線程相關；spa

Set （集合）：TreeSet 經過樹實現的集合有序集合線程

　　　　　　HashSet 經過hash桶實現的集合無序集合 ----->LinkedHashSet 基於鏈式存儲結構的無序集合；指針

Map （映射） Hashtable hash表code

　　　　　　HashMap 經過hash桶實現的映射無序映射對象

　　　　　　TreeMap 經過樹實現的映射有序映射

Map （映射）就是將任意個對象起一個別名

HashMap數據的特徵有名無序：每個數據存儲在hash桶中有他們的名字可是順序不肯定，即放入map數據和輸出時的順序可能不同；

經過右邊的圖片不難看出，內部存儲是無序的。　　　　　　　　　　　　　　

關於<string，string >的含義：就是泛型；給數據一個約定你們都往裏邊存string

類型的數據，後邊的<>是能夠省略不用寫的，默認和前邊的同樣。

在代碼中，你們也看到了咱們用put方法放入數據。方法裏兩個參數：第一個爲key 用來給數據起個名字，特有的由於重名就會被覆蓋他表明的數據。第二個爲value，表明對象（數據）。他倆在一塊兒叫作鍵值對

咱們能夠經過key值獲取對應的value值；get（key）方法；

　　　　　　　　獲取map中數據的多少用 size（）方法　

　　　　　　　　清空map內數據，可是map保留的用的方法是 clear（）；　

map是能夠合併的

根據上圖咱們能夠看出相應的用法；

private static void maptest1()
	{
		Map<String,String> map=new HashMap<>();
		map.put("name", "王徽");
		map.put("id", "110");
		map.put("class", "no.1");
		map.put("number", "250");
		Map<String,String> map2=new HashMap<>();
		map2.put("1", "123");
		map2.put("2", "250");
		System.out.println("map"+map);
		System.out.println("map2"+map2);
		int size=map.size();
		System.out.println("size :"+size);
		String id=map.get("id").toString();
		System.out.println("id :"+id);
		map.putAll(map2);
		System.out.println("map合併map2後 "+map);
		
	}

　　刪除用的方法 remove（key）；在java1.7以前key不存在會報錯，如今不會了

　　替換的方法 put；

影響hashMap性能的因素：

一個是：初始內存（初始16）

另外一個數：加載因子（初始0.75）這個是從時間和空間上決定的，不作修改

hashmap的機制是內部存儲提及。他是有hash桶進行存儲，初始化16個當到達12（16*0.75）個時，在加就要hash內部重構進行擴容。容量翻倍增加。

因此機智的咱們這樣調用構造子的時候進行初始化他的初始內存數咱們須要的/0.75+1 這樣就減小了內存虛耗；

List列表；

列表的建立和元素的添加與獲取基礎方法演示；、

咱們能夠看到數據無名有序；

元素插入 add（）方法有兩個，一個是順序插入add（value）一個參數表明數據，另外一個時指定插入兩個參數add（index，value），index即是要插入的下標，注意當插到末尾的時候適合add（value）同樣的效果；

元素替換的方法 set（index，value）；index要替換的下標，value替換後的內容；

列表空判斷方法 isEmpty（）返回的是Boolean值；

獲取長度的方法是 size（）；

元素的刪除 remove（）方法這個有兩個，一個是內容，一個是索引，按照這兩個刪除，可是當列表是int類型時，內容和索引都是int java就以索引優先進行刪除。

List轉換成數組：

、

	private static void listtest1()
	{
		List<Integer> date=new ArrayList<>();
		System.out.println(date);
		date.add(1);
		date.add(2);
		date.add(3);
		date.add(4);
		System.out.println(date);
		int a=date.get(2);
		System.out.println(a);
		date.set(2, 100);
		System.out.println(date);
		date.remove(2);
		System.out.println(date);
		Integer arr[]=new Integer[date.size()];
		date.toArray(arr);
		for(Integer b:arr)
		{
			System.out.println(b);
		}
	}

迭代器（迭代接口）

private static void iteratorTest()
    {
        List<Integer> date=new ArrayList<>();
        System.out.println(date);
        date.add(1);
        date.add(2);
        date.add(3);
        date.add(4);
        date.add(5);
        date.add(6);
        date.add(7);
        int size=date.size();
        /**
         * 獲取迭代器
         * hasNext();判斷是否含有數據；返回的是boolean值，
         * Next() 獲取當前值，
         */
        Iterator<Integer> iter=date.iterator();
        while(iter.hasNext())
        {
            System.out.println(iter.next());
        }
        
    }

迭代器

存在List專用迭代器；

private static void listIteratorTest()
    {
        List<Integer> date=new ArrayList<>();
        System.out.println(date);
        date.add(1);
        date.add(2);
        date.add(3);
        date.add(4);
        date.add(5);
        date.add(4);
        date.add(4);
        int size=date.size();
        ListIterator<Integer> iter=date.listIterator();
        System.out.println("----正序迭代------");
        while(iter.hasNext())
        {
            System.out.println(iter.nextIndex()+":"+iter.next());
        }
        /**
         * 元素修改set
         * 和刪除remove;
         * 注意remove刪除後 迭代就斷了 ，咱們去最後驗證刪除
         */
        date.set(3, 100);
        System.out.println("----倒序迭代------");
        while(iter.hasPrevious())
        {
            System.out.println(iter.previousIndex()+":"+iter.previous());
        }
        /**
         * 從指定位置index截斷開始迭代，注意階段後只能正序迭代一次 ，而後就恢復啦
         * 據我瞭解應該是至關於一個指針在走，你走到頭就走不動啦，連續迭代兩次統一方向，第二次沒結果
         * 而後從截斷開始迭代到頭，而後再往反方向走，就又能夠所有走一遍並走到頭。
         */
        ListIterator<Integer> iter2=date.listIterator(3);
        System.out.println("----正序迭代------");
        while(iter2.hasNext())
        {
            System.out.println(iter2.nextIndex()+":"+iter2.next());
        }
        System.out.println("----倒序迭代------");
        while(iter2.hasPrevious())
        {
            System.out.println(iter2.previousIndex()+":"+iter2.previous());
        }
        while(iter.hasNext())
        {
            if(iter.next()==4)
                iter.remove();
        }
        /**
         * 刪除後 咱們只能打印date，由於listiterator被破壞了、
         * 打印出來後咱們發現是4的都被刪除啦；
         */
        System.out.println(date);
    }