集合框架及背后的数据结构Collection，MapArrayList的使用

Posted 2021-12-28 西弗勒斯斯内普

一、类和接口总览

Java 集合框架的优点及作用

• 使用成熟的集合框架，有助于我们便捷、快速的写出高效、稳定的代码
• 学习背后的数据结构知识，有助于我们理解各个集合的优缺点及使用场景

---

二、Collection 接口

1、Collection 常用方法

• 将元素放入集合中、返回集合中的元素个数

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

public class TestDemo 
    public static void main(String[] args) 
        Collection<String> collection = new ArrayList<>();
        collection.add("hello");
        collection.add("world");
        System.out.println(collection.size()); // 2

        // 尖括号中 不能放简单的基本类型 一定是类类型
        Collection<Integer> collection1 = new ArrayList<>();
        collection1.add(10);
    

• 删除集合中的所有元素、判断集合是否没有任何元素

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

public class TestDemo 
    public static void main(String[] args) 
        Collection<String> collection = new ArrayList<>();
        collection.add("hello");
        collection.add("world");
        System.out.println(collection); // [hello, world]
        collection.clear();
        System.out.println(collection); // []

        System.out.println(collection.isEmpty()); // true
    

• 返回一个装有所有集合中元素的数组

不建议进行整体的强制类型转换

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

public class TestDemo 
    public static void main(String[] args) 
        Collection<String> collection = new ArrayList<>();
        collection.add("hello");
        collection.add("world");
        Object[] objects = collection.toArray();
        System.out.println(Arrays.toString(objects)); // [hello, world]
    

• 如果元素 e 出现在集合中，删除其中一个

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

public class TestDemo 
    public static void main(String[] args) 
        Collection<String> collection = new ArrayList<>();
        collection.add("hello");
        collection.add("world");
        collection.remove("world");
        System.out.println(collection); // [hello]
    

---

2、Map 接口

方法签名	说明
V get(Object k)	根据指定的 k 查找对应的 v
V getOrDefault(Object k, V defaultValue)	根据指定的 k 查找对应的 v，没有找到用默认值代替
V put(K key, V value)	将指定的 k-v 放入 Map
boolean containsKey(Object key)	判断是否包含 key
boolean containsValue(Object value)	判断是否包含 value
Set<Map.Entry<K, V>> entrySet()	将所有键值对返回
boolean isEmpty()	判断是否为空
int size()	返回键值对的数量

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

public class TestDemo 
    public static void main(String[] args) 
        Map<String, String> map = new HashMap<>();
        map.put("及时雨", "宋江");
        map.put("豹子头", "林冲");

        System.out.println(map.isEmpty()); // false
        System.out.println(map.size()); // 2

        String ret = map.get("及时雨");
        System.out.println(ret); // 宋江
        // 没有找到用默认值代
        System.out.println(map.getOrDefault("花和尚", "鲁智深")); // 鲁智深

        System.out.println(map.containsKey("豹子头")); // true
        System.out.println(map.containsValue("林冲")); // true

        // 不是按顺序
        System.out.println(map); // 豹子头=林冲, 及时雨=宋江

        Set<Map.Entry<String, String>> entrySet = map.entrySet(); // 把k v组装成一个整体

        for (Map.Entry<String, String> entry : entrySet) 
            System.out.println("key: "+entry.getKey()+" value:"+entry.getValue());
        
    

---

三、预备知识-泛型(Generic)

class MyArrayList<E>代表这个类是一个泛型类，此时的这个E，就是一个占位符而已

public class Test 
    public static void main(String[] args) 
        // 把类型 参数化了
        MyArrayList<String> myArrayList1 = new MyArrayList<>();
        MyArrayList<Integer> myArrayList2 = new MyArrayList<>();
        MyArrayList<Boolean> myArrayList3 = new MyArrayList<>();
    

泛型的意义：
1. 自动对类型进行检查
2. 自动对类型进行了强制类性转换

class MyArrayList<E> 
    private E[] elem;
    private int usedSize;
    public MyArrayList() 
        this.elem = (E[])new Object[10];
    
    public void add(E val) 
        this.elem[usedSize] = val;
        usedSize++;
    
    public E get(int pos) 
        return this.elem[pos];
    


public class Test 
    public static void main(String[] args) 
        MyArrayList<String> myArrayList = new MyArrayList<>();
        myArrayList.add("ABC");
        myArrayList.add("bit");
        String ret = myArrayList.get(1);
        System.out.println(ret); // bit

        MyArrayList<Integer> myArrayList1 = new MyArrayList<>();
        myArrayList1.add(11);
        myArrayList1.add(22);
        int ret2 = myArrayList1.get(1);
        System.out.println(ret2); // 22
    

• 泛型中尖括号中的内容，不参与类型的组成

关于Object[] 强制类型转换的思考

		// 前提：Object数组进行向下转换
		String[] strings = new String[10];
        Object o1 = new String[10];
        Object[] o2 = new String[10];

JAVA提高六：泛型

---

泛型是怎么编译的？

泛型是编译时期的一种机制，擦除机制（-> Object）

Creating a Generic Array in Java
使用泛型数组时的注意事项：
数组和泛型之间的一个重要区别是它们如何强制执行类型检查。 具体来说，数组在运行时存储和检查类型信息。 然而，泛型在编译时检查类型错误，并且在运行时没有类型信息。

---

四、预备知识-包装类(Wrapper Class)

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

public class TestDemo 
    public static void main(String[] args) 
        String str = "123";
        int ret = Integer.valueOf(str);
        System.out.println(ret+1); // 124
    

装箱(boxing)和拆箱(unboxing)

public class TestDemo 
    public static void main(String[] args) 
        Integer a = 123; //装箱  装包【隐式的】
        int b = a; //拆箱  拆包【隐式的】
        System.out.println(a+" " + b); // 123 123

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

        Integer a2 = Integer.valueOf(123); //显示地装包
        Integer a3 = new Integer(123); // 显示地装包

        int b2 = a2.intValue(); // 显示地拆包
        double d = a2.doubleValue(); // 显示地拆包
        int i = 10; // 显示地初始化
    

一道面试题：

public class TestDemo 
    public static void main(String[] args) 
        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b); // false
    

---

五、List

public class Test 
    public static void main(String[] args) 
        List<String> list = new ArrayList<>(20);

        ArrayList<String> list2 = new ArrayList<>();
    

1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
4. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList
5. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

---

六、ArrayList使用

1、ArrayList的构造

public class Test 
    public static void main(String[] args) 
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("bit");
        list.add("haha");
        System.out.println(list);

        // 使用另外一个ArrayList对list3进行初始化
        ArrayList<String> list3 = new ArrayList<>(list);
    

2、ArrayList的遍历

public class Test 
    public static void main(String[] args) 
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("hello");
        list2.add("bit");
        list2.add("haha");
        // 重写了ToString()
        System.out.println(list2);
        System.out.println("================");
        for(int i = 0; i < list2.size(); i++) 
            System.out.print(list2.get(i)+" ");
        
        System.out.println();
        System.out.println("==================");
        for (String s : list2) 
            System.out.print(s+" ");
        
        System.out.println();
        System.out.println("========迭代器打印==========");
        Iterator<String> it = list2.iterator();
        while (it.hasNext()) 
            System.out.print(it.next()+" ");
        

        System.out.println();
        System.out.println("========迭代器List相关打印==========");
        ListIterator<String> it2 = list2.listIterator();
        // Iterator<String> it2 = list2.listIterator();
        while (it2.hasNext()) 
            System.out.print(it2.next()+" ");
        
    

Iterator 和 ListIterator 的区别

• remove

public class Test 
    public static void main(String[] args) 
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("hello");
        list2.add("bit");
        list2.add("haha");

        Iterator<String> it = list2.iterator();
        while (itJavaEE基础（十八）/集合

 Java 集合框架概述及Collection接口中常用的方法总结
 Java 集合框架概述及Collection接口中常用的方法总结
 java集合框架和泛型
 Collection集合
 Java：集合，Collection接口框架图