Java 中的集合

阿新 • • 發佈：2021-09-15

1、Collection集合

1.1、集合類的特點

　　提供一種儲存空間可變的儲存模型，儲存的資料容量可以隨時發生改變

集合類的體系圖

1.2、Collection集合概述和基本使用

Collection集合概述

是單例集合的頂層介面，它表示一組物件，這些物件也稱為Collection的元素

JDK 不提供此介面的任何直接實現，它提供更具體的子介面（如Set和List）實現

Collection集合基本使用

package com.itheima_01;

import java.util.ArrayList;
import java.util.Collection;

/*
    建立Collection集合的物件
        多型的方式
        ArrayList()
 */
public class CollectionDemo01 {
    public static void main(String[] args) {
        //建立Collection集合的物件
        Collection<String> c = new 
 ArrayList<String>();

        //新增元素：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");

        //輸出集合物件
        System.out.println(c);

    }
}

1.3、Collection集合的常用方法

示例程式碼

package com.itheima_01;

import java.util.ArrayList;
import java.util.Collection;

/*
    Collection集合常用方法:
        boolean add(E e):新增元素
        boolean remove(Object o):從集合中移除指定的元素
        void clear():清空集合中的元素
        boolean contains(Object o):判斷集合中是否存在指定的元素
        boolean isEmpty():判斷集合是否為空
        int size():集合的長度，也就是集合中元素的個數

    Alt+7   開啟一個視窗，能夠看到類的所有資訊
 */
public class CollectionDemo02 {
    public static void main(String[] args) {
        //建立集合物件
        Collection<String> c = new ArrayList<String>();

        //boolean add(E e):新增元素
//        System.out.println(c.add("hello"));
//        System.out.println(c.add("world"));
//        System.out.println(c.add("world"));
        c.add("hello");
        c.add("world");
        c.add("java");

        //boolean remove(Object o):從集合中移除指定的元素
//        System.out.println(c.remove("world"));
//        System.out.println(c.remove("javaee"));

        //void clear():清空集合中的元素
//        c.clear();

        //boolean contains(Object o):判斷集合中是否存在指定的元素
//        System.out.println(c.contains("world"));
//        System.out.println(c.contains("javaee"));

        //boolean isEmpty():判斷集合是否為空
//        System.out.println(c.isEmpty());

        //int size():集合的長度，也就是集合中元素的個數
        System.out.println(c.size());


        //輸出集合物件
        System.out.println(c);
    }
}

1.4、Collection集合的遍歷

迭代器的介紹

　　迭代器，集合的專用遍歷方式 Iterator iterator()：返回此集合中元素的迭代器，通過集合的iterator()方法得到

　　迭代器是通過集合的iterator()方法得到的，所以我們說它是依賴於集合而存在的

iterator中的常用的方法

　　E next():返回迭代中的下一個元素

　　booleanhasNext():如果迭代具有更多元素，則返回true

Collection集合的遍歷

package com.itheima_02;

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

/*
    Iterator：迭代器，集合的專用遍歷方式
        Iterator<E> iterator()：返回此集合中元素的迭代器，通過集合的iterator()方法得到
        迭代器是通過集合的iterator()方法得到的，所以我們說它是依賴於集合而存在的

    Iterator中的常用方法
        E next()：返回迭代中的下一個元素
        boolean hasNext()：如果迭代具有更多元素，則返回 true
 */
public class IteratorDemo {
    public static void main(String[] args) {
        //建立集合物件
        Collection<String> c = new ArrayList<String>();

        //新增元素
        c.add("hello");
        c.add("world");
        c.add("java");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通過集合的iterator()方法得到
        Iterator<String> it = c.iterator();
        /*
            public Iterator<E> iterator() {
                return new Itr();
            }

            private class Itr implements Iterator<E> {
                ...
            }
         */

        //E next()：返回迭代中的下一個元素
        /*
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next()); //NoSuchElementException:表示被請求的元素不存在
        */

        //boolean hasNext()：如果迭代具有更多元素，則返回 true
        /*
        if(it.hasNext()) {
            System.out.println(it.next());
        }

        if(it.hasNext()) {
            System.out.println(it.next());
        }

        if(it.hasNext()) {
            System.out.println(it.next());
        }

        if(it.hasNext()) {
            System.out.println(it.next());
        }
        */

        //用while迴圈改進判斷
        while (it.hasNext()) {
//            System.out.println(it.next());
            String s = it.next();
            System.out.println(s);
        }

    }
}

1.6、集合的案例-Collection集合儲存學生物件並遍歷

案例需求

　　建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合

程式碼實現

package com.itheima_03;
/*
    學生類
*/
public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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;
    }
}




// ----------------------------------------------------------------------

package com.itheima_03;

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

/*
    需求：
        建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合

    思路：
        1:定義學生類
        2:建立Collection集合物件
        3:建立學生物件
        4:把學生新增到集合
        5:遍歷集合(迭代器方式)
 */
public class CollectionDemo {
    public static void main(String[] args) {
        //建立Collection集合物件
        Collection<Student> c = new ArrayList<Student>();

        //建立學生物件
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("張曼玉", 35);
        Student s3 = new Student("王祖賢", 33);

        //把學生新增到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //遍歷集合(迭代器方式)
        Iterator<Student> it = c.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }

    }
}

2、List集合

2.1、List集合概述和特點

List集合概述

　　有序集合(也稱為序列)，使用者可以精確控制列表中每個元素的插入位置。使用者可以通過整數索引訪問元素，並搜尋列表中的元素

　　與Set集合不同，列表通常允許重複的元素

List集合特點

　　有序：儲存和取出的元素順序一致

　　可重複：儲存的元素可以重複

package com.itheima_01;

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

/*
    List集合特點
        有序：儲存和取出的元素順序一致
        可重複：儲存的元素可以重複
 */
public class ListDemo01 {
    public static void main(String[] args) {
        //建立集合物件
        List<String> list = new ArrayList<String>();

        //新增元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("world");

        //輸出集合物件
//        System.out.println(list);

        //迭代器的方式遍歷
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

    }
}

2.2、List集合的特有方法

例項程式碼

package com.itheima_01;

import java.util.ArrayList;
import java.util.List;

/*
    List集合特有方法：
        void add(int index,E element)：在此集合中的指定位置插入指定的元素
        E remove(int index)：刪除指定索引處的元素，返回被刪除的元素
        E set(int index,E element)：修改指定索引處的元素，返回被修改的元素
        E get(int index)：返回指定索引處的元素
 */
public class ListDemo02 {
    public static void main(String[] args) {
        //建立集合物件
        List<String> list = new ArrayList<String>();

        //新增元素
        list.add("hello");
        list.add("world");
        list.add("java");

        //void add(int index,E element)：在此集合中的指定位置插入指定的元素
//        list.add(1,"javaee");
        //IndexOutOfBoundsException
//        list.add(11,"javaee");

        //E remove(int index)：刪除指定索引處的元素，返回被刪除的元素
//        System.out.println(list.remove(1));
        //IndexOutOfBoundsException
//        System.out.println(list.remove(11));

        //E set(int index,E element)：修改指定索引處的元素，返回被修改的元素
//        System.out.println(list.set(1,"javaee"));
        //IndexOutOfBoundsException
//        System.out.println(list.set(11,"javaee"));

        //E get(int index)：返回指定索引處的元素
//        System.out.println(list.get(1));
        //IndexOutOfBoundsException
//        System.out.println(list.get(11));

        //輸出集合物件
//        System.out.println(list);

        //遍歷集合
//        System.out.println(list.get(0));
//        System.out.println(list.get(1));
//        System.out.println(list.get(2));

        //用for迴圈改進遍歷
        for (int i=0; i<list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
    }
}

2.3集合的案例-List集合儲存學生物件並遍歷

案例需求

　　建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合

程式碼實現

package com.itheima_02;
/*
    學生類
*/

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {


        this.name = name;
        this.age = age;
    }

    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;
    }
}


// -----------------------------------------------------------------------

package com.itheima_02;

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

/*
    需求：
        建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合

    思路：
        1:定義學生類
        2:建立List集合物件
        3:建立學生物件
        4:把學生新增到集合
        5:遍歷集合(迭代器方式，for迴圈方式)
 */
public class ListDemo {
    public static void main(String[] args) {
        //建立List集合物件
        List<Student> list = new ArrayList<Student>();

        //建立學生物件
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("張曼玉", 35);
        Student s3 = new Student("王祖賢", 33);

        //把學生新增到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //迭代器方式
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");

        //for迴圈方式
        for(int i=0; i<list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }

    }
}

2.4、併發修改異常

出現的原因

　　迭代器遍歷的過程中，通過集合物件修改了集合中的元素，造成了迭代器獲取元素中判斷預期修改值和實際

　　修改值不一致，則會出現：ConcurrentModiﬁcationException

解決的方案

　　用for迴圈遍歷，然後用集合物件做對應的操作即可

示例程式碼

package com.itheima_03;

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

/*
    需求：
        我有一個集合：List<String> list = new ArrayList<String>();
        裡面有三個元素：list.add("hello");list.add("world");list.add("java");
        遍歷集合，得到每一個元素，看有沒有"world"這個元素，如果有，我就新增一個"javaee"元素，請寫程式碼實現

    ConcurrentModificationException:當不允許這樣的修改時，可以通過檢測到物件的併發修改的方法來丟擲此異常
 */
public class ListDemo {
    public static void main(String[] args) {
        //建立集合物件
        List<String> list = new ArrayList<String>();

        //新增元素
        list.add("hello");
        list.add("world");
        list.add("java");

        //遍歷集合，得到每一個元素，看有沒有"world"這個元素，如果有，我就新增一個"javaee"元素，請寫程式碼實現
//        Iterator<String> it = list.iterator();
//        while (it.hasNext()) {
//            String s = it.next();
//            if(s.equals("world")) {
//                list.add("javaee");
//            }
//        }

        for(int i=0; i<list.size(); i++) {
            String s = list.get(i);
            if(s.equals("world")) {
                list.add("javaee");
            }
        }

        //輸出集合物件
        System.out.println(list);
    }
}

2.5、列表迭代器

ListIterator介紹

　　通過List集合的listIterator()方法得到，所以說它是List集合特有的迭代器

　　用於允許程式設計師沿任一方向遍歷的列表迭代器，在迭代期間修改列表，並獲取列表中迭代器的當前位置

示例程式碼

package com.itheima_04;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

/*
    ListIterator：列表迭代器
        通過List集合的listIterator()方法得到，所以說它是List集合特有的迭代器
        用於允許程式設計師沿任一方向遍歷列表的列表的迭代器，在迭代期間修改列表，並獲取列表中迭代器的當前位置

    ListIterator中的常用方法
        E next()：返回迭代中的下一個元素
        boolean hasNext()：如果迭代具有更多元素，則返回 true
        E previous()：返回列表中的上一個元素
        boolean hasPrevious()：如果此列表迭代器在相反方向遍歷列表時具有更多元素，則返回 true
        void add(E e)：將指定的元素插入列表
 */
public class ListIteratorDemo {
    public static void main(String[] args) {
        //建立集合物件
        List<String> list = new ArrayList<String>();

        //新增元素
        list.add("hello");
        list.add("world");
        list.add("java");

        //通過List集合的listIterator()方法得到
//        ListIterator<String> lit = list.listIterator();
//        while (lit.hasNext()) {
//            String s = lit.next();
//            System.out.println(s);
//        }
//        System.out.println("--------");
//
//        while (lit.hasPrevious()) {
//            String s = lit.previous();
//            System.out.println(s);
//        }

        //獲取列表迭代器
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            if(s.equals("world")) {
                lit.add("javaee");
            }
        }

        System.out.println(list);

    }
}

2.6、增強for迴圈

定義格式

示例程式碼

package com.itheima_05;

import java.util.ArrayList;
import java.util.List;

/*
    增強for：簡化陣列和Collection集合的遍歷
        實現Iterable介面的類允許其物件成為增強型 for語句的目標
        它是JDK5之後出現的，其內部原理是一個Iterator迭代器

    格式：
        for(元素資料型別 變數名 : 陣列或者Collection集合) {
            //在此處使用變數即可，該變數就是元素
        }
 */
public class ForDemo {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for(int i : arr) {
            System.out.println(i);
        }
        System.out.println("--------");

        String[] strArray = {"hello","world","java"};
        for(String s : strArray) {
            System.out.println(s);
        }
        System.out.println("--------");

        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");

        for(String s : list) {
            System.out.println(s);
        }
        System.out.println("--------");

        //內部原理是一個Iterator迭代器
        /*
        for(String s : list) {
            if(s.equals("world")) {
                list.add("javaee"); //ConcurrentModificationException
            }
        }
        */
    }
}

2.7、集合的案例-List集合儲存學生物件三種方式遍歷

案例需求

　　建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合

程式碼實現

/*
    學生類
*/


package com.itheima_06;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {


        this.name = name;
        this.age = age;
    }

    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;
    }
}

// ---------------------------------------------------------------------

package com.itheima_06;

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

/*
    需求：
        建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合

    思路：
        1:定義學生類
        2:建立List集合物件
        3:建立學生物件
        4:把學生新增到集合
        5:遍歷集合
            迭代器：集合特有的遍歷方式
            普通for：帶有索引的遍歷方式
            增強for：最方便的遍歷方式
 */
public class ListDemo {
    public static void main(String[] args) {
        //建立List集合物件
        List<Student> list = new ArrayList<Student>();

        //建立學生物件
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("張曼玉", 35);
        Student s3 = new Student("王祖賢", 33);

        //把學生新增到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //迭代器：集合特有的遍歷方式
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }

        System.out.println("--------");

        //普通for：帶有索引的遍歷方式
        for(int i=0; i<list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("--------");

        //增強for：最方便的遍歷方式
        for(Student s : list) {
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

3、資料結構

　　資料結構是計算機儲存、組織資料的方式。是指互相之間存在一種或多種特定關係的資料元素的集合通常情況下，

　　精心選擇的資料結構可以帶來更高的執行或者儲存效率

3.1、資料結構之棧和佇列

　　棧結構先進後出

　　佇列結構先進先出

3.2、資料結構之陣列和連結串列

　　陣列結構查詢快、增刪慢

　　佇列結構查詢慢、增刪快

4、List集合的實現類

4.1、List集合子類的特點

ArrayList集合

　　底層是陣列結構實現，查詢快、增刪慢

LinkedList集合

　　底層是連結串列結構實現，查詢慢、增刪快

package com.itheima_07;

import java.util.ArrayList;
import java.util.LinkedList;

/*
    List集合常用子類：ArrayList，LinkedList
        ArrayList：底層資料結構是陣列，查詢快，增刪慢
        LinkedList：底層資料結構是連結串列，查詢慢，增刪快

    練習：
        分別使用ArrayList和LinkedList完成儲存字串並遍歷
 */
public class ListDemo {
    public static void main(String[] args) {
        //建立集合物件
        ArrayList<String> array = new ArrayList<String>();

        array.add("hello");
        array.add("world");
        array.add("java");

        //遍歷
        for (String s : array) {
            System.out.println(s);
        }
        //剩下兩種遍歷方式大家補齊

        System.out.println("------------------------------");

        Iterator<String> list = array.iterator();
        while (list.hasNext()){
            String s = list.next();
            System.out.println(s);
        }

        System.out.println("------------------------------");

        for(int i = 0;i<array.size();i++){
            String s = array.get(i);
            System.out.println(s);

        }




        System.out.println("--------");



        LinkedList<String> linkedList = new LinkedList<String>();

        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");

        for(String s : linkedList) {
            System.out.println(s);
        }
        //剩下兩種遍歷方式大家補齊
        

        Iterator<String> list = linkedList.iterator();
        while (list.hasNext()){
            String s = list.next();
            System.out.println(s);
        }

        System.out.println("------------------------------");

        for(int i = 0;i<list.size();i++){
            String s = list.get(i);
            System.out.println(s);

        }

    }
}

4.2、集合的案例-ArrayList集合儲存學生物件三種方式遍歷

案例需求

　　建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合

程式碼實現

/*
    學生類
*/

package com.itheima_08;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {


        this.name = name;
        this.age = age;
    }

    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;
    }
}


// -------------------------------------------------------------------------------


package com.itheima_08;

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

/*
    需求：
        建立一個儲存學生物件的集合，儲存3個學生物件，使用程式實現在控制檯遍歷該集合

    思路：
        1:定義學生類
        2:建立ArrayList集合物件
        3:建立學生物件
        4:把學生新增到集合
        5:遍歷集合
            迭代器：集合特有的遍歷方式
            普通for：帶有索引的遍歷方式
            增強for：最方便的遍歷方式
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        //建立ArrayList集合物件
        ArrayList<Student> array = new ArrayList<Student>();

        //建立學生物件
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("張曼玉", 35);
        Student s3 = new Student("王祖賢", 33);

        //把學生新增到集合
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //迭代器：集合特有的遍歷方式
        Iterator<Student> it = array.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");

        //普通for：帶有索引的遍歷方式
        for(int i=0; i<array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");

        //增強for：最方便的遍歷方式
        for(Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

4.3、LinkedList集合的特有功能

特有方法

程式碼例項

package com.itheima_09;

import java.util.LinkedList;

/*
    LinkedList集合的特有功能：
        public void addFirst(E e)：在該列表開頭插入指定的元素
        public void addLast(E e)：將指定的元素追加到此列表的末尾

        public E getFirst()：返回此列表中的第一個元素
        public E getLast()：返回此列表中的最後一個元素

        public E removeFirst()：從此列表中刪除並返回第一個元素
        public E removeLast()：從此列表中刪除並返回最後一個元素
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        //建立集合物件
        LinkedList<String> linkedList = new LinkedList<String>();

        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");

//        public void addFirst(E e)：在該列表開頭插入指定的元素
//        public void addLast(E e)：將指定的元素追加到此列表的末尾
//        linkedList.addFirst("javase");
//        linkedList.addLast("javaee");

//        public E getFirst()：返回此列表中的第一個元素
//        public E getLast()：返回此列表中的最後一個元素
//        System.out.println(linkedList.getFirst());
//        System.out.println(linkedList.getLast());

//        public E removeFirst()：從此列表中刪除並返回第一個元素
//        public E removeLast()：從此列表中刪除並返回最後一個元素
//        System.out.println(linkedList.removeFirst());
//        System.out.println(linkedList.removeLast());

        System.out.println(linkedList);
    }
}

Java中集合基礎相關知識

1.集合基礎 1.1 集合概述程式設計的時候如果需要儲存多個數據使用長度固定的資料儲存，適應不了元素個數變化的需求，這時候我們就需要用集合。

Java中集合和陣列的區別

一、基本介紹 1、總的來說區別：陣列特點：大小固定，只能儲存相同資料型別的資料

java中的常用集合類整理

一、Set集合其主要實現類有HashSet、TreeSet存放物件的引用，不允許有重複物件。

6種方法初始化JAVA中的list集合

List 是 Java 開發中經常會使用的集合，你們知道有哪些方式可以初始化一個 List 嗎？這其中不缺乏一些坑，今天棧長我給大家一一普及一下。

Java中的不可變集合，我們換個方式理解！！！

不可變集合例： public static final ImmutableSet<String> COLOR_NAMES = ImmutableSet.of( "red",

在java中獲取List集合中最大的日期時間操作

取List集合中最大的日期,可以用Date max = Collections.max(dateList);,傳入一個日期集合,就可以獲取,工作中有這個需求,就查詢到這個,

一分鐘瞭解Java中List集合與set集合的多種遍歷方式

List集合與set集合的多種遍歷方式方法有： 1. for迴圈遍歷 2. foreach增強迴圈遍歷

Java List集合返回值去掉中括號('[ ]')的操作

如下所示：呼叫StringUtils工具類的strip()方法去掉中括號\"[ ]\"： StringUtils.strip(word.toString(),\"[]\") //第一個引數放集合，第二個引數去掉中括號\"[]\"

Java中操作字串的工具類-判空、擷取、格式化、轉換駝峰、轉集合和list、是否包含

場景某些常用的對字串進行處理的方法抽離出來成工具類，方便在多處應用。

Java中List集合物件去重及按屬性去重的8種方法

最近在寫一些關於java基礎的文章，但是我又不想按照教科書的方式去寫知識點的文章，因為意義不大。基礎知識太多了，如何將這些知識歸納總結，總結出優缺點或者是使用場景才是對知識的昇華。所以我更想把java相關的基

【Java】Java中的集合框架、泛型

集合框架、泛型 1).Collection 集合:一類特殊的物件(用於儲存多個物件的物件) Collection：元素必須是引用型別，在遍歷時需要for each方式（因為資料沒有下標）

java中超級重要的map集合之概述

序今天我們來說一說java中超級重要的map集合. 1、map集合概述 publicinterfaceMap<K,V>

淺談Java中的集合儲存資料後,輸出資料的有序和無序問題

HashSet,TreeSet,無序是指儲存資料的順序和取出資料的順序不一致；但是TreeSet 是按照指定的順序排個序出來；

Java中Map集合中的Entry物件用法

Entry: 鍵值對物件。在Map類設計是，提供了一個巢狀介面（static修飾的介面）：Entry。Entry將鍵值對的對應關係封裝成了物件，即鍵值對物件，這樣我們在遍歷Map集合時，就可以從每一個鍵值對（Entry）物件中獲取對

Java中的List集合

集合概述為了在程式中儲存數目不確定的物件，JDK中提供了一系列的特殊類，這些類可以儲存任意型別的物件，並且長度可變，在Java中這些類被統稱為集合。集合類都位於java.util包中。

Java中的Set集合

Set介面簡介 Set介面和List介面一樣，同樣繼承自Collection介面，它與Collection介面中的方法基本一致，並沒有對Collection介面進行功能上的擴充，它是比Collection介面更加嚴格了。與List介面不同的是，Set介面元素

萬字長文深入理解java中的集合-附PDF下載

目錄1. 前言2. List2.1fail-safe fail-fast知多少2.1.1 Fail-fast Iterator2.1.2 Fail-fast 的原理2.1.3 Fail-safe Iterator2.2 Iterator to list的三種方法2.2.1 使用while2.2.2 使用ForEachRemaining2.2.3 使用str

Java中的Set集合簡單彙總解析

Set介面簡介 Set介面和List介面一樣，同樣繼承自Collection介面，它與Collection介面中的方法基本一致，並沒有對Collection介面進行功能上的擴充，它是比Collection介面更加嚴格了。與List介面不同的是，Set介面元

Java中的Map集合簡單彙總解析

Map介面簡介 Map介面是一種雙列集合，它的每個元素都包含一個鍵物件Key和值物件Value，鍵和值物件之間存在一種對應關係，稱為對映。從Map集合中訪問元素時，只要指定了Key，就能找到對應的Value，

Java中常用的集合工具類

Map大佬是和Collection一個元老級別的，不是List、set一級的 1.1 Collection介面 Collection是所有單列集合的父介面，因此在Collection中定義了單列集合(List和Set)通用的一些方法，這些方法可用於操作所有的單列

Java 中的集合

目錄

1、Collection集合

1.1、集合類的特點

1.2、Collection集合概述和基本使用

1.3、Collection集合的常用方法

1.4、Collection集合的遍歷

1.6、集合的案例-Collection集合儲存學生物件並遍歷

2、List集合

2.1、List集合概述和特點

2.2、List集合的特有方法

2.3集合的案例-List集合儲存學生物件並遍歷

2.4、併發修改異常

2.5、列表迭代器

2.6、增強for迴圈

2.7、集合的案例-List集合儲存學生物件三種方式遍歷

3、資料結構

3.1、資料結構之棧和佇列

3.2、資料結構之陣列和連結串列

4、List集合的實現類

4.1、List集合子類的特點

4.2、集合的案例-ArrayList集合儲存學生物件三種方式遍歷

4.3、LinkedList集合的特有功能

相關推薦