2. 程式人生 > >集合框架(List和Set)

集合框架(List和Set)

阿新 • • 發佈：2018-02-16
null tla sheet 1.2 rfi table name blog runtime

一、概述

集合是一種可變數據項的容器，具有統一的父類接口Collection<E>（Map並沒有繼承之），與其子集合的關系例如以下 圖。集合的特點是長度可變，能夠存儲多種類型的對象（不加泛型時）。這也是與數組的兩點最大的不同。

技術分享圖片
java集合類關系圖

Collection最為根接口，List、Set、Queue接口均直接繼承自它，Map接口盡管不是直接繼承自Collection，可是接口中使用到了Collection，即Map的數據也是使用Collection

存儲的。
研究集合不可缺少的是先研究Collection接口的內容，先從接口名字定義開始說起public interface Collection<E> extends Iterable<E>，這是集合的根接口。<E>是JDK1.5開始的泛型，其功能是提高安全性，增強針對性，詳細介紹後面再說。Iterable<E>接口是叠代器。以下有詳細介紹。

Collection接口提供了一些集合的共性方法，如：

  • boolean add(E e)加入一條數據。

  • boolean addAll(Collection<?

    extends E> c)加入還有一個集合內的元素。

  • void clear()清除全部數據。

  • boolean contains(Object o)是否包括指定數據。

  • Iterator<E> iterator()返回叠代器。
  • boolean remove(Object o)刪除指定數據。
  • <T>T[] toArray(T[] a)返回數據的數組形式等等。
  • boolean retainAll(Collection<?> c)取與集合c的交集。
  • boolean removeAll(Collection<?> c)取與集合c的差集。

二、叠代器

一種集合的取出方式，用於集合的數據的遍歷等。

不同容器的數據結構不同，所以取出的動作實現不同，詳細的取出動作定義在每一個容器的內部，這樣取出方式就能夠直接訪問集合內部元素。取出方式就被定義成了內部類。可是都有共性內容推斷和取出，共性抽取便形成了Iterator

接口（叠代器）。
叠代器的使用演示樣例（暫時不考慮泛型）：

ArrayList alist = new ArrayList();
alist.add("java01");
alist.add("java02");
alist.add("java03");
alist.add("java04");
for(Iterator it = alist.iterator(); it.hasNext(); ) {
    System.out.println(it.next());
}

三、List

List為Collection的常見子接口之中的一個，元素有序。能夠反復，有索引。
List有些特有的方法，和下標相關的一些方法。如：
- 增：add(index, element)指定位置加入元素，addAll(index, Collection)指定位置加入一個集合的元素。


- 刪：remove(index)刪除指定為的元素。
- 改：set(index, element)改動指定位置的元素。
- 查：get(index)獲取指定位置的元素。subList(from, to)獲取[from, to)段的子List，listIterator()獲取List特有的叠代器，indexOf(E)獲取對象的位置。

ListIterator

ListIterator是Iterator的子接口，在叠代時不能夠通過集合的操作對集合進行操作，會發生並發改動異常，可是Iterator的操作是有限的，假設想對元素進行加入和改動等，就須要用到其子接口ListIterator，該接口僅僅能通過List的listIterator()方法獲取，演示樣例代碼例如以下：

ArrayList alist = new ArrayList();
alist.add("java01");
alist.add("java02");
alist.add("java03");
alist.add("java04");
for(ListIterator it = alist.listIterator(); it.hasNext(); ) {
    System.out.println(it.next());
    it.add("java");
}
System.out.println(alist);

//輸出結果是
java01
java02
java03
java04
[java01, java, java02, java, java03, java, java04, java]

通過上面能夠看到，ListIterator在獲取之後其遍歷的內容就已經確定下來了。 ListIterator還有逆向遍歷功能。

ArrayList alist = new ArrayList();
alist.add("java01");
alist.add("java02");
alist.add("java03");
alist.add("java04");
ListIterator it = alist.listIterator();
while(it.hasNext()) {
    System.out.println(it.next());
}
while(it.hasPrevious()) {
    System.out.println(it.previous());
}
// 輸出的結果是
java01
java02
java03
java04
java04
java03
java02
java01

List中詳細對象特點

List有三個詳細的子類，各自是ArrayList、LinkedList和Vector。

三者的特點與不同例如以下：

  • ArrayList：底層數據結構為數組結構，線程非同步。查詢速度快，增刪速度慢，效率比Vector高，最早出如今JDK1.2版本號。初始長度默覺得10。空間不足時50%延長。
  • LinkedList：底層數據結構為鏈表結構，線程非同步，查詢速度慢，增刪速度快，最早出如今JDK1.2版本號。

  • Vector：底層數據結構是數組結構，線程同步，與ArrayList有同樣的功能。已被ArrayList取代，最早出如今JDK1.0版本號。

    默認長度為10，空間不足時100%延長。

Vector的特點

Vector的特有的一點就是，Vector的枚舉（Vector的特有取出方式），和叠代器相似，名為Enumeration，ArrayList中沒有此功能。可是由於方法名過長，且沒有移除功能，已被Iterator取代，所以一般優先考慮使用Iterator。演示樣例代碼例如以下：

Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
Enumeration en = v.elements();
while(en.hasMoreElements()) {
    System.out.println(en.nextElement());
}
// 輸出結果為
java01
java02
java03

LinkedList

LinkedList的特有方法：addFirst(E e)、addLast(E e)加入到頭部或者尾部、getFirst()、getLast()獲取頭部元素或者尾部元素、removeFirst()、removeLast()刪除頭部元素或者尾部元素，並返回刪除的元素，沒有會報NoSuchElementException，這些是LinkedList所特有的方法。JDK1.6版本號名稱發生了變化，分別變成了offerFirst(E e)，offerLast(E e)，peekFirst()，peekLast()。pollFirst()。pollLast()。沒有會返回null。
LinkedList練習，模擬隊列進行加入和取出動作。演示樣例代碼例如以下：

import java.util.*;
class MyQueue {
    private LinkedList link;
    MyQueue() {
        link = new LinkedList();
    }

    public void myAdd(Object obj) {
        link.addFirst(obj);
    }

    public Object myGet() {
        return link.removeFirst();
    }

    public boolean isNull() {
        return link.isEmpty();
    }
}

class LinkedListTest {
    public static void main(String[] args) {
        MyQueue q = new MyQueue();
        q.myAdd("java01");
        q.myAdd("java02");
        q.myAdd("java03");
        q.myAdd("java04");

        while(!q.isNull()) {
            System.out.println(q.myGet());
        }
    }
}

ArrayList

ArrayList練習，去除ArrayList中的反復項。

代碼示比例如以下：

import java.util.*;
class ArrayListTest {

    public static void main(String[] args) {
        ArrayList list = new ArrayList();

        list.add("java01");
        list.add("java02");
        list.add("java01");
        list.add("java02");
        list.add("java01");
        list.add("java03");

        // 去除反復前
        System.out.println(list);
        list = singleElement(list);
        // 去除反復後
        System.out.println(list);
    }

    public static ArrayList singleElement(ArrayList list) {
        //定義一個暫時容器。
        ArrayList newList = new ArrayList();
        // 獲取叠代器
        Iterator it = list.iterator();
        while(it.hasNext()) {
            Object obj = it.next();
            if(!newList.contains(obj)) {
                newList.add(obj);
            }
        }
        return newList;
    }
}

ArrayList練習。自己定義類加入至ArrayList，須要覆蓋自己定義類的equals方法。

import java.util.*;
class Person {
    private String name;
    private int age;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 覆蓋equals方法
    public boolean equals(Object obj) {

        if(!(obj instanceof Person))
            return false;

        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String toString() {
        return "Name:" + this.name + " Age:" + this.age;
    }
}

class ArrayListTest {

    public static void main(String[] args) {
        ArrayList list= new ArrayList();
        list.add(new Person("lisi01",30));
        list.add(new Person("lisi02",32));
        list.add(new Person("lisi02",32));
        list.add(new Person("lisi04",35));
        list.add(new Person("lisi03",33));
        list.add(new Person("lisi04",35));

        System.out.println(list);
        list = singleElement(list);
        System.out.println(list);
    }

    public static ArrayList singleElement(ArrayList al) {
        // 定義一個暫時容器。
        ArrayList newList = new ArrayList();
        // 取出叠代器
        Iterator it = al.iterator();
        while(it.hasNext()) {
            Object obj = it.next();
            if(!newList.contains(obj))
                newList.add(obj);
        }
        return newList;
    }
}

四、Set

元素無序（存入與取出的順序不一致），元素不可反復。

有兩個主要子類：HashSet和TreeSet。

  • HashSet：底層數據結構為哈希表。

  • TreeSet：底層數據結構為二叉樹。

HashSet

依據hashCode()和equals()方法進行存儲。add時。假設是第一次加入返回true（加入成功），否則返回false（加入失敗）。演示樣例代碼例如以下：

import java.util.*;
class HashSetDemo { 
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        // 第一次加入java01返回true
        System.out.println(hs.add("java01"));
        // 第二次加入java01返回false
        System.out.println(hs.add("java01"));
        hs.add("java02");
        hs.add("java03");
        hs.add("java03");
        hs.add("java04");
        // 遍歷集合
        Iterator it = hs.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

HashSet存儲自己定義對象，自己定義對象須要覆蓋hashCode和equals方法。當hashCode值同樣、equals返回真時，覺得是同一個對象。加入時。當hashCode值不同一時候，不會調用equals比較，當hashCode的值同樣時，才會調用equals方法比較兩個對象。

演示樣例代碼例如以下：

import java.util.*;
/**
 *姓名和年齡同樣覺得是同一個人
 */
class Person {
    private String name;
    private int age;
    Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public int hashCode() {
        System.out.println(this.name+"....hashCode");
        return name.hashCode() + age*37;
    }

    public boolean equals(Object obj) {
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        System.out.println(this.name+"...equals.."+p.name);
        return this.name.equals(p.name) && this.age == p.age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

class HashSetTest {
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        // 加入一個同樣的人
        hs.add(new Person("a2",12));
        hs.add(new Person("a4",14));

        // 遍歷集合中的人
        Iterator it = hs.iterator();
        while(it.hasNext()) {
            Person p = (Person)it.next();
            System.out.println(p.getName()+"::"+p.getAge());
        }
    }
}
// 執行結果為
a1....hashCode
a2....hashCode
a3....hashCode
a2....hashCode
a2...equals..a2
a4....hashCode
a3::13
a1::11
a4::14
a2::12

從上面代碼執行的結果能夠看出，當加入new Person("a2",12)時。由於集合中已經有這個人了。所以hashCode的返回值已經存在。因此便會調用equals方法推斷，終於結果還是此人已存在，所以最總集合中僅僅有4個人。
HashSet的推斷和刪除依據，能夠看到判讀元素是否存在和刪除元素都是首先依據hashCode值，然後再通過equals推斷是否同樣。

import java.util.*;
/**
 *姓名和年齡同樣覺得是同一個人
 */
class Person {
    private String name;
    private int age;
    Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    /**
     *統一返回1作為哈希值
     */
    public int hashCode() {
        System.out.println("hashCode");
        return 1;
    }

    /**
     * 姓名和年齡同樣覺得是同一個人
     */
    public boolean equals(Object obj) {
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        System.out.println(this.name+"...equals.."+p.name);
        return this.name.equals(p.name) && this.age == p.age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

class HashSetTest {
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        // 加入一個同樣的人
        hs.add(new Person("a2",12));
        hs.add(new Person("a4",14));
        System.out.println("--------");

        // 推斷是否存在元素
        hs.contains(new Person("a4", 14));
        System.out.println("--------");

        // 刪除指定元素
        hs.remove(new Person("a1", 11));
    }
}
// 執行結果為
hashCode
hashCode
a2...equals..a1
hashCode
a3...equals..a1
a3...equals..a2
hashCode
a2...equals..a1
a2...equals..a2
hashCode
a4...equals..a1
a4...equals..a2
a4...equals..a3
--------
hashCode
a4...equals..a1
a4...equals..a2
a4...equals..a3
a4...equals..a4
--------
hashCode
a1...equals..a1

TreeSet

能夠對集合中的元素進行排序。

底層數據結構為二叉樹。中序遍歷便是TreeSet的順序。

演示樣例代碼例如以下：

import java.util.*;
class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet();
        ts.add("asdas");
        ts.add("abc");
        ts.add("beds");
        ts.add("abd");
        Iterator it = ts.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
// 執行結果為
abc
abd
asdas
beds

對於自己定義對象的排序，一般有兩種做法，一是自己定義對象自己實現Comparable接口。二是集合提供比較器(Comparator接口)。


自己定義對象實現Comparable接口，演示樣例代碼例如以下：

import java.util.*;

class Student implements Comparable {
    private String name;
    private int age;

    Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    /**
     *比較結果又三種。負數表示小於，0表示等於，正數表示大於
     */
    public int compareTo(Object obj) {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是學生對象");
        Student s = (Student)obj;
        System.out.println(this.name+"....compareto....."+s.name);
        if(this.age>s.age)
            return 1;
        if(this.age==s.age) {
            // String類已經實現了Comparable接口
            return this.name.compareTo(s.name);
        }
        return -1;
    }

    public String getName() {
        return name;

    }

    public int getAge() {
        return age;
    }
}

class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet();
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi08",19));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi01",40));

        // 遍歷集合
        Iterator it = ts.iterator();
        while(it.hasNext()) {
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}

集合提供比較器(Comparator接口)的比較方式。用於元素不具備比較性或者具備的比較性不是用戶所須要的時。演示樣例代碼例如以下：

import java.util.*;
class Student implements Comparable {
    private String name;
    private int age;

    Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    /**
     *比較結果又三種，負數表示小於，0表示等於，正數表示大於
     */
    public int compareTo(Object obj) {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是學生對象");
        Student s = (Student)obj;
        System.out.println(this.name+"....compareto....."+s.name);
        if(this.age>s.age)
            return 1;
        if(this.age==s.age) {
            return this.name.compareTo(s.name);
        }
        return -1;
    }

    public String getName() {
        return name;

    }

    public int getAge() {
        return age;
    }
}

class TreeSetDemo2 {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet(new MyCompare());

        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi02",21));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi06",18));
        ts.add(new Student("lisi06",18));
        ts.add(new Student("lisi007",29));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi01",40));

        Iterator it = ts.iterator();
        while(it.hasNext()) {
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}

class MyCompare implements Comparator {
    public int compare(Object o1,Object o2) {
        Student s1 = (Student)o1;
        Student s2 = (Student)o2;
        // 姓名比較優先
        int num = s1.getName().compareTo(s2.getName());
        if(num==0) {
            // 姓名同樣時，年齡小的在前
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
        }

        return num;
    }
}

五、泛型

泛型的出現攻克了類型不同的安全問題，JDK1.5版本號開始出現的。詳細做法就是在集合定義時指明數據類型。如ArrayList<String> list= new ArrayList<String>()，這樣一來假設向list中加入非String類型對象時。就會在編譯時期提示ClassCastException異常。演示樣例代碼例如以下：

import java.util.*;
class GenericDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("abc01");
        list.add("abc0991");
        list.add("abc014");

        // Iterator也有相應的泛型
        Iterator<String> it = al.iterator();
        while(it.hasNext()) {
            System.out.println(s+":"+s.length());
        }
    }
}

自己定義類中使用泛型的概念。試用於用數據類型不確定時，演示樣例代碼例如以下：

class Worker {

}
class Student {

}

/**
 *泛型類，使用與引用數據類型不確定時。
 */
class Utils<Q> {
    private Q q;
    public void setObject(Q q) {
        this.q = q;
    }

    public Q getObject() {
        return q;
    }
}
class  GenericDemo3 {
    public static void main(String[] args) {
        Utils<Worker> u = new Utils<Worker>();
        u.setObject(new Worker());
        Worker w = u.getObject();;
    }
}

泛型定義在方法上，演示樣例代碼例如以下：

class Demo {
    public <T> void show(T t) {
        System.out.println("show:"+t);
    }

    public <Q> void print(Q q) {
        System.out.println("print:"+q);
    }

    /**
     * 靜態方法不能夠訪問類上的泛型。可使用靜態泛型方法。註意：泛型標識<E>需放在返回值前。

     */
    public static <E> void printf(E e) {
        System.out.println("printf:"+e);
    }
}
class GenericDemo4 {
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.show("Hi");
        demo.print("Hello");
        Demo.printf(5);
    }
}
//執行結果為
show:Hi
print:Hello
show:5

泛型限定

一般有三種情況。

  • <?

    >：?為通配符。

  • <? extends E>：E和E的子類。稱為上限。

  • <? super E>：E和E的父類。稱為下限。

如對全部類型的ArrayList進行遍歷輸出，演示樣例代碼例如以下：

public static void print(ArrayList<?> list) {
    Iterator<?> it = list.iterator();
    while(it.hasNext()) {
        System.out.println(it.next().toString());
    }
}

對Person或者Person的子類Student進行遍歷並輸出，演示樣例代碼例如以下：

public static void print(ArrayList<? extends Person> list) {
    Iterator<? extends Person> it = list.iterator();
    while(it.hasNext()) {
        System.out.println(it.next().getName());
    }
}

對於<?

super E>並不經常使用。舉一個TreeSet裏的樣例，TreeSet(Comparator<?

super E> comparator)，使用父類的比較器進行子類的比較。演示樣例代碼例如以下：

import java.util.*;
class Person {
    private String name;
    Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public String toString() {
        return "Person :"+name;
    }
}

class Student extends Person {
    Student(String name) {
        super(name);
    }
}

class Worker extends Person {
    Worker(String name) {
        super(name);
    }
}

/**
 * 定義使用與Person的比較器
 */
class Comp implements Comparator<Person> {
    public int compare(Person p1,Person p2) {
        // 倒序
        return p2.getName().compareTo(p1.getName());
    }
}

class GenericDemo {
    public static void main(String[] args) {

        // 使用使用父類的比較器進行比較
        TreeSet<Student> ts = new TreeSet<Student>(new Comp());
        ts.add(new Student("abc03"));
        ts.add(new Student("abc02"));
        ts.add(new Student("abc06"));
        ts.add(new Student("abc01"));
        Iterator<Student> it = ts.iterator();
        while(it.hasNext()) {
            System.out.println(it.next().getName());
        }

        // 使用使用父類的比較器進行比較
        TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
        ts1.add(new Worker("wabc--03"));
        ts1.add(new Worker("wabc--02"));
        ts1.add(new Worker("wabc--06"));
        ts1.add(new Worker("wabc--01"));
        Iterator<Worker> it1 = ts1.iterator();
        while(it1.hasNext()) {
            System.out.println(it1.next().getName());
        }
    }
}
// 執行結果為
abc06
abc03
abc02
abc01
wabc--06
wabc--03
wabc--02
wabc--01

集合框架(List和Set)

相關推薦

集合框架(List和Set)

null tla sheet 1.2 rfi table name blog runtime 一、概述 集合是一種可變數據項的容器，具有統一的父類接口Collect

集合框架-List與Set

所有的集合框架並不存放真正的物件，而是持有物件的引用 List與Set都繼承自Collection List的實現類：ArrayList,LinkList,Vector Set的實現類：HashSet,LinkedHashSet,SortSet（介面）,T

Java中的集合（List和Set）

Java容器類主要是為了“儲存物件”，並將其劃分為兩個不同的概念：Collection，獨立元素的集合，這些元素都服從一條或多條規則，如List必須按照插入順序儲存元素，Set不能有重複元素，Queue按照排隊規則來確定物件的順序。Map形成一組“鍵值對”物件，允許你使用鍵

Java 知識點整理-11.Java集合框架 Set+HashSet+LinkedHashSet+TreeSet+List和Set迭代方式的區別

目錄 Set HashSet LinkedHashSet TreeSet List和Set迭代方式的區別： Set 1、Set集合概述及特點： public interface Set<E> extends Collection<E>

【夯實基礎】JAVA集合框架總結(list和set的區別等等)

幾個面試常見問題： 1.Q:ArrayList和Vector有什麼區別？HashMap和HashTable有什麼區別？   A:Vector和HashTable是執行緒同步的（synchronized）。效能上，ArrayList和HashMap分別比Vector和Hashtable要好。 2.Q:大致講解j

Java集合：List、Set和Map的區別，ArrayList和LinkedList有何區別..........

一、陣列和集合的區別： 　　陣列是大小固定的，並且同一個陣列只能存放型別一樣的資料（基本型別/引用型別）； 　　集合可以儲存和操作數目不固定的一組資料。 所有的JAVA集合都位於 java.util包中！ JAVA集合只能存放引用型別的的資料，不能存放基本資料型別。 　　陣列和集合相比唯一的有點就是速度

java中迴圈遍歷刪除List和Set集合中元素的方

1.異常java一邊遍歷一邊刪除集合中的元素會報異常ConcurrentModificationException 2.正確的做法如下:   package list; import java.util.*; public class Demo { public

java集合類，List和Set比較，各自的子類比較（ArrayList，Vector，LinkedList；HashSet，TreeSet），Map集合比較

ArrayList，LinkedList，Vector都屬於ListList：元素是有順序的，元素可以重複因為每個元素有自己的角標（索引）|-- ArrayList:底層是陣列結構，特點是：查詢很快，增刪稍微慢點，執行緒不同步：A執行緒將元素放在索引0位置，CPU排程執行緒A停止，B執行，也將元素放在索引0位

集合類：List和Set比較，各自的子類比較（ArrayList，Vector，LinkedList；HashSet，TreeSet）

ArrayList，LinkedList，Vector都屬於List List：元素是有順序的，元素可以重複因為每個元素有自己的角標（索引）   |-- ArrayList:底層的資料結構是陣列結構，特點是：查詢很快，增 刪 稍微慢點，執行緒不同步   |-- Linke

Java集合List和Set的原理

        集合是一種可以儲存物件的容器，當然這個容器也是一個物件。和陣列相比，集合的優勢在於他的長度是可以變化，另外集合可以儲存多個型別的物件，而陣列的長度是固定的，只能儲存一個型別的元素；

Java集合框架List，Map，Set， Queue介紹

Java Collections Framework是Java提供的對集合進行定義，操作，和管理的包含一組介面，類的體系結構。 Collection介面     Collection是最基本的集合介面，一個Collection代表一組Object的集合，這些Objec

Java集合面試題(02) Java中List和Set之間區別

本文為本博主翻譯，未經允許，嚴禁轉載！ 簡介 Java中List和Set之間有什麼區別是一個非常流行的Java集合面試問題，也是在Java中使用Collection類時要記住的一個重要的基本概念。 List和Set都是Java程式最重要的Collection類中的兩個，以及

Java集合框架List+Set+Map基本操作

一、List集合 　List的特徵是其元素以線性方式儲存，集合中可以存放重複物件。 　List介面主要實現類包括： 　　ArrayList : 代表長度可以改變得陣列。可以對元素進行隨機的訪問，向

Spring中集合（List，Set，Map）的配置和簡單使用（一）

1、首先寫一個實體類 package com.listtest.test; import java.util.List; import java.util.Map; import java.util.Set; public class Collect {

List和set集合：交集、差集、合集的區別retainAll，removeAll、addAll

set 、list集合的交集（retainAll）、差集(removeAll)是沒有區別的都是一樣的. set 、list集合的合集addAll是有區別的：set可以去重複；list不去重複 pub

java--利用集合List和Set實現簡易版學生選課系統

 //建立學生類 import java.util.HashSet; import java.util.Set; public class student {  String id;        //學號  String sname;     //學生姓名  pu

JDK 1.8集合框架 Map、Set、List、Queue、Stack比較

JDK 1.8集合框架基本架構圖 比較 元件 比較 Map 1、Map是鍵值對，使用雜湊對映，鍵不能重複,值可以重複。 2、TreeMap可以排列順序，HashMa

list和set、map的差別叠代器讀取數據

lin style tor shm obj span col ring value package collectiondemo; import java.util.ArrayList; import java.util.LinkedList; import java.

集合（List、Set）

特性 完成 index cas ren mil public 決定 void 第19天 集合 第1章 List接口 我們掌握了Collection接口的使用後，再來看看Collection接口中的子類，他們都具備那些特性呢？ 接下來，我們一起學習Collection中的常用

集合區別(list和linkedlist的區別)？

img 集合 linked 分享 move span 原因 指針 技術分享 1.list和linkedlist都是有序可重復，為什麽還要用linkedlist呢？ 數組和數組列表都有一個重大的缺陷，這就是從數組的中間位置刪除一個元素需要付出很大的代價，其原因是數組中處於被刪