天天看點
傳回

黑馬程式員_集合架構（一）

——- android教育訓練、java教育訓練、期待與您交流！ ———-

一、集合架構體系概述

1、為什麼出現集合類？

面向對象語言對事物的展現都是以對象的形式，是以為了友善對多個對象的操作，就對對象進行存儲，集合就是存儲對象最常用的一種方式。

2、數組和集合類同是容器，二者有何差別？

數組雖然也可以存儲對象，但長度是固定的，集合長度是可變的。

數組中可以存儲基本資料類型，集合隻能存儲對象。

3、集合類的特點

（1）集合隻用與存儲對象

（2）集合長度是可變的

（3）集合可以存儲不同類型的對象。

4、集合架構圖

黑馬程式員_集合架構（一）
黑馬程式員_集合架構（一）

二、集合中的共性方法

1、添加

示例：

public static void main(String[] args)
    {
        //建立一個集合容器，使用collection接口的子類，Arraylist。
        ArrayList al = new ArrayList();
        //1、添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //2、擷取個數，集合長度。
        sop("size:"+al.size());
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

Add方法的參數類型是Object以便于接收任意類型的對象。

集合中存儲的都是對象的引用（位址）。

2、删除

public static void main(String[] args)
    {
        //建立一個集合容器，使用collection接口的子類，Arraylist。
        ArrayList al = new ArrayList();
        //1、添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //2、擷取個數，集合長度。
        sop("size:"+al.size());
        //列印原集合
        sop(al);
        //删除
        al.remove("java02");
        //列印改變後的集合
        sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

清空

public static void main(String[] args)
    {
        //建立一個集合容器，使用collection接口的子類，Arraylist。
        ArrayList al = new ArrayList();
        //1、添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //2、擷取個數，集合長度。
        sop("size:"+al.size());
        //列印原集合
        sop(al);
        //删除
        //al.remove("java02");
        //清空
        al.clear();

        //列印改變後的集合
        sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

3、判斷元素

示例：

public static void main(String[] args)
    {
        //建立一個集合容器，使用collection接口的子類，Arraylist。
        ArrayList al = new ArrayList();
        //1、添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //2、擷取個數，集合長度。
        sop("size:"+al.size());
        //列印原集合
        sop(al);
        //删除
        //al.remove("java02");
        //清空
        //al.clear();
        //判斷元素
        sop("java03是否存在"+al.contains("java03"));

        //列印改變後的集合
        //sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

boolean retainAll(Collection

public static void main(String[] args)
    {
        method();
    }
    public static void method()
    {
        ArrayList al1 = new ArrayList();
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");

        ArrayList al2 = new ArrayList();
        al2.add("java01");
        al2.add("java02");
        al2.add("java05");
        al2.add("java06");

        al1.retainAll(al2);//取交集。al1中隻會保留和al2中相同的部分

        sop("al1:"+al1);
        sop("al2:"+al2);
    }
    public static void base_method()
    {
        //建立一個集合容器，使用collection接口的子類，Arraylist。
        ArrayList al = new ArrayList();
        //1、添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //2、擷取個數，集合長度。
        sop("size:"+al.size());
        //列印原集合
        sop(al);
        //删除
        //al.remove("java02");
        //清空
        //al.clear();
        //判斷元素
        sop("java03是否存在"+al.contains("java03"));

        //列印改變後的集合
        //sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

4、取出元素

方法一：

public static void main(String[] args)
    {
        method_get();
    }
    public static void method_get()
    {
        ArrayList al1 = new ArrayList();
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");
        sop(al1);

    }
    public static void base_method()
    {

    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

方法二：

public static void main(String[] args)
    {
        method_get();
    }
    public static void method_get()
    {
        ArrayList al1 = new ArrayList();
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");
        //sop(al1);
        Iterator  it = al1.iterator();//擷取疊代器[疊代器其實就是集合取出元素的方式]，用于取出集合中的元素。
        while(it.hasNext())
        {
        sop(it.next());
        }

    }
    public static void base_method()
    {

    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

三、List集合

1、List集合的特點

（ 1 ）元素是有序的

（ 2 ） 元素可以重複（因為該集合體系有索引）

2、List集合的常見方法

特有方法：凡是可以操作腳标的方法都是該體系特有的方法。

（1）增： al.add(); 在指定位置添加 al.(index,”“);

示例：

public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
                sop("原集合是："+al);
        //在指定位置添加元素
        al.add(,"java09");
                sop(al);
            }

結果為：

黑馬程式員_集合架構（一）

（2）删：al.remove(index);

public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
                sop("原集合是："+al);
        //在指定位置添加元素
        al.add(,"java09");
        sop(al);
        //删除指定位置的元素
        al.remove();
                sop(al);

    }

結果為：

黑馬程式員_集合架構（一）

（3）改：a1.set(index,”“)

public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop("原集合是："+al);
        //在指定位置添加元素
        al.add(,"java09");
        sop(al);
        //删除指定位置的元素
        al.remove();
        //修改元素
        al.set(, "java07");

        sop(al);

    }

結果為：

黑馬程式員_集合架構（一）

（4）查：get(index);

subList(from,to);

public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop("原集合是："+al);
        //在指定位置添加元素
        al.add(,"java09");
        sop(al);
        //删除指定位置的元素
        //al.remove(2);
        //修改元素
        //al.set(2, "java07");
        //通過腳标擷取元素
        sop("get(1):"+al.get());
                sop(al);
            }

結果為：

黑馬程式員_集合架構（一）

擷取所有元素：

for(int x=;x<al.size();x++)  
   {        al.get(x)     }   
    第二種方式：     
    Iterator it=a1.iterator();       while(it.hasNext())     
      {             it.next();        }
           
public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop("原集合是："+al);
        //在指定位置添加元素
        al.add(,"java09");
        sop(al);
        //删除指定位置的元素
        //al.remove(2);
        //修改元素
        //al.set(2, "java07");
        //通過腳标擷取元素
        //sop("get(1):"+al.get(1));
        //擷取所有的元素。
        for(int x=;x<al.size();x++)
        {
            System.out.println("al("+x+")="+al.get(x));
        }

        //sop(al);

    }

結果為：

黑馬程式員_集合架構（一）

（5）通過indexof擷取對象的位置：

al.indexof(“字元串”);擷取清單中兩個位置之間的數：傳回List

List sub=al.subList（1,3）傳回角标1和3之間的數 在疊代集合過程中，不能對集合進行其他操作，如添加删除等，這時就需要疊代器可以對疊代器的對象進行操作，但是由于Iterator疊代器隻有 remove功能，是以建議使用其子接口ListIterator,它具備删除 remove 添加 add 修改 set 等功能，但此功能是List特有 ListIterator清單疊代器：是List集合特有的疊代器，是Iterator的子接口。可以對集合清單進行各種操作。

ListIterator it=a1.ListIterator();       
   while(it.hasNext())//正向周遊       {            
    it.next();           
     it.set();//修改        }

3、集合中的對象

（1）ArrayList：底層使用是的數組結構。

特點：查詢速度很快，但是增删稍慢。 線程不同步的

練習：

import java.util.ArrayList;
import java.util.Iterator;



//去除ArrayList中的重複元素
public class arraylisttest {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop(al);

        al = singleElement(al);
        sop(al);
    }
    public static ArrayList singleElement(ArrayList al)
    {
        //定義一個臨時容器
        ArrayList newal = new ArrayList();
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            if(!newal.contains(obj))
                newal.add(obj);
        }
        return newal;
    }

}

結果為：

黑馬程式員_集合架構（一）

（2）LinkedList：底層使用的是連結清單結構。

特點：增删速度快，但是查詢稍慢。

LinkedList()集合;

特有方法：

();往前添加

public static void main(String[] args)
    {
        LinkedList link = new LinkedList();
        link.addFirst("java01");
        link.addFirst("java02");
        link.addFirst("java03");
        link.addFirst("java04");

        sop(link);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

addlast(）;往後添加

public static void main(String[] args)
    {
        LinkedList link = new LinkedList();
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        link.addLast("java04");

        sop(link);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

getFirst();//擷取頭值，永遠是第一個值 getLast();//擷取尾值

擷取元素但不删除元素

public static void main(String[] args)
    {
        LinkedList link = new LinkedList();
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        link.addLast("java04");

        sop(link.getFirst());
        sop(link.getLast());
            }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

removeFirst();//删除并傳回頭元素 出現NuSuchElementException異常 removeLast();//删除并傳回尾元素 可以擷取元素，但是元素被删除。如果集合中沒有元素會 出現NuSuchElementException異常，在JDK1.6中出現了替代方法。

public static void main(String[] args)
    {
        LinkedList link = new LinkedList();
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        link.addLast("java04");


        sop(link.size());
        sop(link.removeFirst());
        sop(link.size());
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

結果為：

黑馬程式員_集合架構（一）

1.6中出現了替代方法: 添加 offerFirst() offerlast() 擷取 peekFirst() peekLast()

可以擷取元素，但是元素不被删除。如果集合中沒有元素會 傳回null 删除 pollfirst() polllast() LinkedList llist=new LinkedList();可以擷取元素，但是元素被删除。如果集合中沒有元素會 傳回null

練習：

堆棧：先進後出 杯子

隊列：先進先出 水管

import java.util.LinkedList;


public class duilie {
    private LinkedList link;

    duilie()
    {
          link = new LinkedList();
    }
    public void myAdd(Object obj)

    {
        link.addFirst(obj);
    }
    public Object myGet()
    {
        return link.removeLast();
    }
    public boolean isNull()
    {
        return link.isEmpty(); 
    }
    public static void main(String[] args)
    {
        duilie dl = new duilie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");

        System.out.println(dl.myGet());
    }
}

結果為：

黑馬程式員_集合架構（一）

（3）Vecctor：底層使用是的數組結構。線程同步的。被ArrayList替代了。

Vector 使用：

Vector v=new Vector（）；v.add（）；v.add();Enumeration en=new Enumeration ()while(en.hasMoreElements()){   en.nextElement();}
           
public static void main(String[] args)
        {
            Vector v = new Vector();
            v.add("java01");
            v.add("java02");
            v.add("java03");
            v.add("java04");
            Enumeration  en= v.elements();

            while(en.hasMoreElements())
            {
               System.out.println(en.nextElement());
            }
  }

結果為：

黑馬程式員_集合架構（一）
import java.util.ArrayList;
import java.util.Iterator;
//去除ArrayList中的重複元素
public class arraylisttest {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
    //在疊代時循環中next調用一次，就要用hasNext判斷一次
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            sop(it.next()+"....."+it.next());
        }

    }
    public static ArrayList singleElement(ArrayList al)
    {
        //定義一個臨時容器
        ArrayList newal = new ArrayList();
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            if(!newal.contains(obj))
                newal.add(obj);
        }
        return newal;
    }

}

枚舉是Vector特有的取出方式

枚舉和疊代是一樣的

因為枚舉的名稱以及方法的名稱都過長

枚舉郁郁而終了

java 黑馬程式員
上一篇: 黑馬程式員：Java基礎——List集合的分支1.Vector中的枚舉2.LinkedList 3.ArrayList
下一篇: 動态庫與靜态庫 動态庫與靜态庫

繼續閱讀