Java集合(簡單介紹)

集合

• 集合
  • 1.集合的作用
  • 2.集合類的分類
• Collection
  • Collection方法分類
    • 首先看一下添加操作與批量添加操作
    • 集合洗掉資料
  • ArrayList
  • LinkedList
  • ArrayList與LinkedList的區別
  • HashMap
  • LinkedHashMap
  • TreeMap(二叉樹映射)
  • HashSet(哈希集合)
  • LInkedHashSet(鏈式哈希集合)
  • TreeSet(二叉樹集合)
  • 快速失敗(fail-fast)機制
  • ConcurrentHashMap

1.集合的作用

		在java中我們可以使用陣列來保存多個物件，但是陣列的長度不可變，如果需要保存數量變化的資料，資料就不太合適了，為了保存數量不確定的資料，以及保存具有映射關系的資料（也被稱為關聯陣列），Java 提供了集合類，**集合類主要負責保存、盛裝其他資料，因此集合類也被稱為容器類**

2.集合類的分類

? java集合型別分為Collection和Map,它們是 Java 集合的根介面，這兩個介面又包含了一些子介面或實作類.

下圖為collection介面基本結構

下圖為Map介面基本結構

Collection

Collection方法分類

1.修改操作

2.查詢操作

3.批量操作

首先看一下添加操作與批量添加操作

定義一個Fruit類，一個Apple類，以及一個Banana類

public class Fruit {
    private String name;

    public Fruit(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return name;
    }
}

public class Apple extends Fruit{
    public Apple(String name) {
        super(name);
    }
}

public class Banana extends Fruit{
    public Banana(String name) {
        super(name);
    }
}

然后在主方法中寫一個集合，并向這個集合中國添加資料

public class Demo01 {
    //首先看一下添加操作boolean add(),添加成功回傳True，失敗回傳False
    public static void main(String[] args) {
        List<Fruit> fruits = new ArrayList<>();
        System.out.println(fruits.add(new Apple("紅富士蘋果")));
        System.out.println(fruits.add(new Apple("青蘋果")));
        System.out.println(fruits.add(new Fruit("蛇果")));
        for (Fruit fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

輸出：

true
true
true
紅富士蘋果
青蘋果
蛇果 

List fruits = new ArrayList<>();

因為集合中定義的是Fruit，說明該集合只能存盤Fruit物件或者Fruit的子類物件

再看一下addall()方法，添加成功回傳true，否則回傳false

首先定義兩個集合，分別為蘋果集合和香蕉集合，并向集合中添加資料

public class Demo01 {
    //首先看一下添加操作boolean add(),添加成功回傳True，失敗回傳False
    public static void main(String[] args) {
        List<Apple> apples = new ArrayList<>();
            apples.add(new Apple("紅富士"));
            apples.add(new Apple("青蘋果"));
            apples.add(new Apple("蛇果"));
        List<Banana> bananas = new ArrayList<>();
        bananas.add(new Banana("帝皇蕉"));
        apples.add(new Apple("海南香蕉"));
        List<Fruit> fruits = new ArrayList<>();
        System.out.println(fruits.addAll(apples));
        System.out.println(fruits.addAll(bananas));
        for (Fruit fruit : fruits) {
            System.out.println(fruit);
        }

    }
    }

集合洗掉資料

remove()洗掉單個資料，洗掉批量資料removeAll，洗掉符合添加條件的資料，removeIF，洗掉所有資料clear，即清空資料！

首先先看單個洗掉操作如何操作的

public class Demo02 {
    public static void main(String[] args) {
        //定義一個數字集合
        List<Integer> numbers = new ArrayList<>();
                numbers.add(1);
                numbers.add(2);
                numbers.add(3);
                numbers.add(4);
                numbers.add(5);
        for (Integer number : numbers) {
            System.out.print(number+" ");
        }
        System.out.println();
        System.out.println("====分===割===線=====");
              numbers.remove(2);
              numbers.remove(3);
        for (Integer number : numbers) {
            System.out.print(number+" ");
        }
    }
}

輸出：

1 2 3 4 5 
====分===割===線=====
1 2 4 

可以看到，洗掉我們列印輸出的是1，2，4，可以看到他是先洗掉的下標為2的數字，然后，后面的數字往前進一個，集合中現在的長度為4，我們再取下標3的數，也就是最后一個數5，列印剩下的數就是1.2.4.

1.removeAll()方法

洗掉要洗掉資料中的集合，只要有符合的就執行洗掉操作

代碼示例：

public class Demo03 {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        List<Integer> num=new ArrayList<>();
        num.add(2);
        num.add(3);
        num.add(5);
        num.add(6);
        numbers.removeAll(num);
        for (Integer number : numbers) {
            System.out.print(number+" ");
        }
    }

}

輸出：

1  4

2.retainAll()方法,指定要保留的資料集合

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

        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        List<Integer> nums = new ArrayList<>();
        nums.add(2);
        nums.add(4);
        nums.add(6);
        numbers.retainAll(nums);
        System.out.println(numbers);
    }
}

輸出:

[2, 4]

可以看到，我們把要保留的數放在第二個集合中，當在需要操作的集合中能找到相應的資料，就將其保留！

3.removeIf()方法

public class Demo05 {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        //指定規則洗掉集合中的資料
        //Predicate介面主要用來判斷一個引數是否符合要求
         boolean result=numbers.removeIf(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                //洗掉所有偶數
                return integer%2==0;
            }
        });
         //看是否洗掉成功
        System.out.println(result);
        //遍歷集合
        for (Integer number : numbers) {
            System.out.print(number+" ");
        }
    }

}

輸出：

true
1 3 5 

4.clear()方法，清空集合

public class Demo06 {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        System.out.println(numbers);
        numbers.clear();
        System.out.println(numbers);
    }
}

輸出：

[1, 2, 3, 4, 5]
[]

一些常見的其他方法

public class Demo07 {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        //集合的元素數
        System.out.println(numbers.size());
        //集合是否為空
        System.out.println(numbers.isEmpty());
        //集合中是否有元素2
        System.out.println(numbers.contains(2));
    }
}

輸出：

5
false
true

更多方法，具體的可以查看一下jdk的幫助檔案

ArrayList

? ArrayLisy不但擁有Collection中的方法，還擁有List中的所有方法

特點：

1. 有序
2. 可重復
3. 資料可為null

優點：查詢快

缺點：增刪慢

1.ArrayList中的構造方法

? ArrayList中有三種構造方法

• public ArrayList() 構造一個初始容量為十的空串列，

• public ArrayList(Collection<? extends E> c) 構造一個包含指定集合的元素的串列，按照它們由集合的迭代器回傳的順序，

• public ArrayList(int initialCapacity) 構造具有指定初始容量的空串列，

2.ArrayList中的常用方法

LinkedList

? 擁有Collection里面的所有方法，List中的所有方法，Queue中的所有方法，Deque中的所有方法

1.LinkedList中的構造方法

• LinkedList() 構造一個空串列，

• LinkedList(Collection<? extends E> c) 構造一個包含指定集合的元素的串列，按照它們由集合的迭代器回傳的順序，

特點：

1. 有序
2. 可重復
3. 可為null

優點:增刪塊

缺點：查詢慢

2.LinkedList的常用方法：

ArrayList與LinkedList的區別

HashMap

特點：

? 1.無序

? 2.key可以為null，哈希值為0

? 3.key不可以重復，重復的key，新值會覆寫舊值

優點：增刪改查快

缺點：無序

1.HashMap的構造方法：

2.HashMap中常用的方法：

其中put與get方法在hashmap中用的最為頻繁，在實際開發中，hashmap多用于快取資料

LinkedHashMap

特點：

1. 有序
2. key唯一
3. key為null

優點：有序

LInkedHashMap中常用的方法：

TreeMap(二叉樹映射)

特點：

1. 對key有序
2. 無序
3. key不可為null
4. key唯一

優點：對key有序

缺點：無序

keymap的常用方法：

HashSet(哈希集合)

特點：

1. 無序
2. 值唯一
3. 值可為null

優點：增刪改查快

缺點：無序

1.HashSet的構造方法：

2.HashSet的常用方法

3.HashSet與HashMap的區別

LInkedHashSet(鏈式哈希集合)

特點：

1. 有序
2. 值唯一
3. 值可位null

優點:有序，增刪快

缺點：查詢慢

1.LinkedHashSet的常用方法

2.LinkedHahsSet與LinkedHashMap的區別

TreeSet(二叉樹集合)

特點：

1. 無序
2. 對值排序
3. 值不可為null
4. 值唯一

優點：對值排序

缺點：無序

1.TreeSet的常用方法：

2.HashSet與TreeSet的對比

快速失敗(fail-fast)機制

? 一種容器保護機制，防止多個執行緒并發修改同一個容器的內容，如果發生了并發修改的情況就會觸發快速失敗機制，也就是拋出ConcurrentModificationException(并發修改例外)

eg：

當你在迭代遍歷某個容器的程序中國，另一個執行緒介入其中，并且插入或洗掉此容器中的某個元素，那么就會出現問題，單執行緒和多執行緒同理！

我們看一下代碼：

可以看出，我們在下面迭代遍歷的同時，進行插入操作

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

public class FailFast {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Iterator<String> iterator = list.iterator();
        list.add("1");
        list.add("2");
        while (iterator.hasNext()){
            System.out.println(iterator.next());}
    }
    }

輸出：

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at com.gather.map.FailFast.main(FailFast.java:14)

那么為了防止這類問題出現，java容器類采用了快速失敗機制，主要用與監視容器的變化

那么如何避免上述問題：我們只需要采用執行緒安全的容器即可

代碼示例：

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

public class FailFast2 {
    public static void main(String[] args) {
        //創建一個支持并發的集合
        CopyOnWriteArrayList list=new CopyOnWriteArrayList();
        //另一個執行緒修改器
        new Thread(new Runnable() {
            @Override
            public void run() {
                list.add("一個簡單的多執行緒");
                list.add("lingstar");
            }
        }).start();
         //獲取迭代器
        Iterator<String> iterator = list.iterator();
        //遍歷集合
        while (iterator.hasNext()){
            //獲取元素
            System.out.println(iterator.next());
        }
    }
}

輸出：

一個簡單的多執行緒
lingstar

ConcurrentHashMap

特點：

1. 無序
2. key唯一
3. key、value不可為null
4. 執行緒安全

優點：增刪改查快

缺點：無序

1.ConcurrentHashMap的常用方法

2.ConcurrentHashMap與HashMap的區別

本文來自博客園，作者：星余明，轉載請注明原文鏈接：https://www.cnblogs.com/lingstar/p/16499093.html

標籤：其他

上一篇：如何定義一個泛型類呢？

下一篇：如何定義一個泛型介面呢？