JAVA API学习笔记——Collections Framework

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一、集合框架的提出：

Java中的集合，又叫容器。它是一个对象。用来存储并管理一组其他对象，存储在集合内的对象称为元素。简单地说，集合对象用来存储、检索、操作和统计一组元素。
在Java SE API中的java.util包设计了一组接口和类，用来实现以不同形式存放对象的存储结构。这样的设计结构被称为Java集合框架（JCF）。

Collection接口：
根据数据结构的不同，一些collection允许有重复的元素，而另一些则不允许。一些collection是有序的，而另一些则是无序的。

二、ArrayList:

1.:常用方法:

1.void add(int index, Element e)
增加指定元素到链表指定位置.

2.boolean add(Element e)
增加指定元素到链表尾部.

3.void clear()
从链表中删除所有元素.

    @Test
    public void ArrayListB(){
     
    ArrayList arrayListB = new ArrayList();
    arrayListB.add("super carry");
    arrayListB.add(111);
    arrayListB.add(1,"doinb");
    arrayListB.add(true);
        System.out.println(arrayListB);
    arrayListB.clear();
        System.out.println(arrayListB);
    }
输出：
[super carry, doinb, 111, true]
[]

4.E remove(int index)
删除链表中指定位置的元素.

5.E get(int index)
获取链表中指定位置处的元素.

6.E set(int index, E element)
将链表中指定位置上的元素替换成新元素。

@Test
    public void ArrayListC(){
     
    ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("super");
    arrayList.add("carry");
    arrayList.add("doinb");
    arrayList.add("kimodi");
        System.out.println(arrayList);
        System.out.println(arrayList.get(2));
        arrayList.set(2,"lwx");
        System.out.println(arrayList);
        System.out.println(arrayList.get(2));
        arrayList.remove(2);
        System.out.println(arrayList);
        System.out.println(arrayList.get(2));
    }
输出：
[super, carry, doinb, kimodi]
doinb
[super, carry, lwx, kimodi]
lwx
[super, carry, kimodi]
kimodi

7.Object[] toArray()
获取一个数组，数组中所有元素是链表中的元素.（即将链表转换为一个数组）

8.boolean contains(Object o)
如果链表包含指定元素，返回true.

9.int size()
返回链表长度（链表包含元素的个数）.

10.boolean isEmpty()
返回true表示链表中没有任何元素.

  @Test
    public void ArrayListD(){
     
        ArrayList<Integer> arrayList = new ArrayList();
        arrayList.add(7777);
        arrayList.add(5117);
        arrayList.add(8888);
        arrayList.add(1573);
        Object[] array = arrayList.toArray();
        System.out.println("数组长度为："+ arrayList.size());
        for (int i = 0; i <array.length ; i++) {
     
            System.out.println(array[i]);
        }
        System.out.println(arrayList.contains(5117));
        System.out.println(arrayList.isEmpty());
    }
输出：
数组长度为：4
7777
5117
8888
1573
true
false

三、Linked:

ArrayList与LinkedList
本LinkedList类是包含相同类型的多个对象，就像一个集合ArrayList。

本LinkedList类具有所有的相同方法的ArrayList类，因为它们都实现了List接口。这意味着您可以以相同的方式添加项目，更改项目，删除项目并清除列表。

但是，尽管ArrayList类和LinkedList类可以以相同的方式使用，但它们的构建却大不相同。

ArrayList如何工作
在ArrayList类内部具有规则排列。添加元素后，会将其放置到数组中。如果阵列不够大，则会创建一个更大的新阵列来替换旧阵列，并删除旧阵列。

LinkedList如何工作
该LinkedList商店的物品的“容器”。该列表具有指向第一个容器的链接，每个容器具有指向列表中的下一个容器的链接。要将元素添加到列表中，请将元素放入新容器中，并将该容器链接到列表中的其他容器之一。

addFirst():
Adds an item to the beginning of the list.

removeFirst():
Remove an item from the beginning of the list.

getFirst():
Get the item at the beginning of the list

public void LinkedListA(){
     
        LinkedList linkedList = new LinkedList();
        linkedList.add("super");
        linkedList.add("carry");
        linkedList.add("doinb");
        System.out.println(linkedList);
        linkedList.addFirst("kimodi");
        System.out.println(linkedList);
        linkedList.removeFirst();
        System.out.println(linkedList);
        System.out.println(linkedList.getFirst());
    }
输出：
[super, carry, doinb]
[kimodi, super, carry, doinb]
[super, carry, doinb]
super

四、Iterator:

AnIterator是可用于遍历集合的对象，例如ArrayList 和HashSet。之所以称为“迭代器”，是因为“迭代”是循环的技术术语。

1.要遍历一个集合，请使用的hasNext()和next()方法Iterator：

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

2.迭代器旨在轻松更改其循环通过的集合。该remove()方法可以在循环时从集合中删除项目。

public class IteratorTest {
     

    @Test
    public void iteratorTest(){
     
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("super");
        arrayList.add("carry");
        arrayList.add("doinb");

        Iterator<String> iteratorB= arrayList.iterator();
        while(iteratorB.hasNext()){
     
            String value = iteratorB.next();
            if(value.equals("doinb"))
                iteratorB.remove();
        }
        Iterator iteratorA= arrayList.iterator();
        while(iteratorA.hasNext()){
     
            Object value = iteratorA.next();
            System.out.println(value);
        }
    }
}
输出：
super
carry

五、Set&Hashset:

HashSet是项目的集合，其中每个项目都是唯一的，并且可以在java.util 包中找到：

1.add():

HashSet类有许多有用的方法。例如，要向其中添加项目，请使用add()方法：

2.contain():

要检查HashSet中是否存在某项，请使用以下contains()方法：

3.clear():

要删除所有项目，请使用以下clear()方法：

public class HashsetTest {
     
    @Test
    public void hashsetTest(){
     
//        HashSet为无序哈希表(value不允许重复)
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("super");
        hashSet.add("carry");
        hashSet.add("doinb");
        hashSet.add("carry");
        for (String value:hashSet) {
     
            System.out.println(value);
        }
        System.out.println(hashSet.contains("doinb"));
        hashSet.clear();

//        LinkedHashSet为有序哈希表
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet();
        linkedHashSet.add("1111");
        linkedHashSet.add("2222");
        linkedHashSet.add("3333");
        linkedHashSet.add("4444");
        linkedHashSet.add("5555");
        for (String value:linkedHashSet) {
     
            System.out.println(value);
        }
    }
}
输出：
super
doinb
carry
true
1111
2222
3333
4444
5555

六、Map&Hashmap:

在ArrayList本章中，您了解了数组将项目存储为有序集合，并且您必须使用索引号（int类型）来访问它们。一HashMap但在“商店物品键/值”对，你可以通过另一种类型的指数（例如访问它们String）。
一个对象用作另一个对象（值）的键（索引）。它可以存储不同的类型：String键和Integer值，也可以存储相同的类型，例如：String键和String值:

1.put()&get():

要向其中添加项目，请使用put()方法：
要访问中的值HashMap，请使用get()方法并引用其键：

2.remove()&&replace():

replace​(K key, V value)
仅当当前映射到key的某个值时，才替换指定键的条目。
replace​(K key, V oldValue, V newValue)
仅当当前映射到key以及value的指定值时，才替换指定键的条目。

3.containKey()&&containValue():

要检查HashMap中是否存在某项，请使用以下contains()方法：

4.clear()&&size():

要找出有多少项，请使用size()方法：
要删除所有项目，请使用以下clear()方法：

4.entryset():

这个方法返回一个Set，这个Set是HashMap的视图，对Map的操作会在Set上反映出来，反过来也是。

public class HashMapTest {
     
    @Test
    public void hashMapTest() {
     
        HashMap<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1,"super");
        hashMap.put(2,"carry");
        hashMap.put(3,"doinb");

        Set<Integer> setKey = hashMap.keySet();
        System.out.println(setKey);

        for (String value:hashMap.values()) {
     
            System.out.println(value);
        }
        Set<Map.Entry<Integer,String>> entrySet = hashMap.entrySet();
        System.out.println(entrySet);
        ArrayList<String> arrayList = new ArrayList<>();


        Iterator<Map.Entry<Integer,String>> iterator = entrySet.iterator();
        while(iterator.hasNext()){
     
            String value =iterator.next().getValue();
            if(value.equals("doinb"))
                arrayList.add(value);
        }

        System.out.println(arrayList);

}
}

输出：
[1, 2, 3]
super
carry
doinb
[1=super, 2=carry, 3=doinb]
[doinb]