Java 容器、泛型

容器

java容器是前人为我们提供的一套用于存储数据和对象的工具，类似于c++的STL，java容器又可以称为Java Collection Framework（JCF）。里面除了存储对象的容器之外，还提供了一套用于处理和操作容器里面的对象的一套工具类，其主要包括列表（List）、集合（Set）、映射（Map）

List

类似于数组，按照插入顺序保存对象，可包含重复元素

ArrayList：数组实现，因此支持随机访问，而不适合频繁的插入与删除操作，默认大小为10，扩充1.5倍（向下取整）+1，可自动扩容

ArrayList<Integer> al =new ArrayList<>();
for (int i=2;i<=5;i++){
    al.add(i);
}
System.out.println(al);
System.out.println(al.get(2));//返回第【3】个元素
al.set(2,12);//修改第【3】个元素为12
al.remove(1);//删除第【2】个元素
System.out.println(al);
System.out.println(al.size());//返回元素个数
/*
输出：
[2, 3, 4, 5]
4
[2, 12, 5]
3
*/

LinkedList：双向链表实现，因此可以被用作队列、堆栈、双端队列；顺序访问高效，随机访问性能较差、适用于需要经常添加和删除的数据

LinkedList<Integer> li = new LinkedList<>();
for (int i=2;i<=5;i++){
    li.add(i);
}
System.out.println(li);
li.addFirst(1);//在最前方插入元素
System.out.println(li);
li.removeLast();//删除末尾元素
System.out.println(li);
System.out.println(li.getLast());//得到末尾元素
/*
输出：
[2, 3, 4, 5]
[1, 2, 3, 4, 5]
[1, 2, 3, 4]
4

*/

Vector：数组实现，默认大小为10，扩充2倍，与LinkedList类似

Vector<Integer> v = new Vector<>();
for (int i=1;i<=5;i++) v.add(i);
System.out.println(v);
v.remove(2);//删除第【3】个元素
System.out.println(v);
System.out.println(v.size());
//和前面的差不多就不多写代码了
/*
输出：
[1, 2, 3, 4, 5]
[1, 2, 4, 5]
4
*/

Set

相同的元素只会被储存一次

HashSet：Hash表实现，默认大小为16，2倍扩充，可以存null元素，储存是无序的

HashSet <Integer> ha = new HashSet<>();
for (int i=0;i<15;i++){
    ha.add(i);
}
ha.add(13);//无效语句，因为13已经被存过了
System.out.println(ha);
ha.add(null);
System.out.println(ha);
System.out.println(ha.contains(12));//查看是否含有12这个元素
ha.remove(12);//删除12
System.out.println(ha.contains(12));
System.out.println(ha);
System.out.println(ha.size());
/*
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
[0, null, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
true
false
[0, null, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14]
15
*/

TreeSet：红黑树实现，基于树结构的集和，印次支持排序，不能容纳null元素

TreeSet te = new TreeSet<>();
te.add(3);
te.add(7);
te.add(1);
te.add(12);
te.add(1);//无效插入
System.out.println(te);
Iterator<Integer> iterate = te.iterator();
System.out.print("使用迭代器输出：");
while (iterate.hasNext()){
    System.out.print(iterate.next());
    System.out.print(" ");
}
System.out.println();
te.remove(12);//删除元素12
System.out.println(te.last());//输出最后一个元素
System.out.println("此时最后一个元素为："+te.pollLast());//返回最后一个元素并将其删除
System.out.println(te);
/*
输出：
[1, 3, 7, 12]
使用迭代器输出：1 3 7 12 
7
此时最后一个元素为：7
[1, 3]

*/

Map

HashMap：数组+链表+红黑树实现，hash数组默认大小16

Hashtable：数组+链表+红黑树实现，hash数组默认大小11，若指定初值，会直接使用这个值

ConcurrentHashMap：Node数组+链表+红黑树实现

TreeMap：红黑树实现

懒得敲代码了

泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型对于输入的广泛的数据类型都可以做出反应，得出结论

在一些情况下可以自己去定义输入的数据类型要求

使用 Java 泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。

泛型方法定义规则：

所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的 <E>）。

每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。

类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。

泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）。

露一手

public class GenericMethodTest {
    public static < E > void findThirdInArray( E[] inputArray )//创建一个泛型查找数组的第三个元素
    {
        int cnt=0;
        for ( E element : inputArray ){
            cnt++;
            if (cnt==3) System.out.println(element);
        }
    }

    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
        findThirdInArray(intArray); // 传递一个整型数组
        findThirdInArray(doubleArray); // 传递一个双精度型数组
        findThirdInArray(charArray); // 传递一个字符型数组
    }
}
/*
输出：
3
3.3
L
*/

这个泛型可以对任意类型的数组都进行第三个元素的查找，那我们只想去查找数字类型的第三个元素该怎么办？

这时候就需要一个有界类型参数

敲代码时候忘了上面说的要实现找元素了，实在抱歉

public static void main(String[] args) {
        printNum(11);
        printNum(12.7F);
        printNum(11.23);
        //printNum("have a nice day") 不可使用该用法，因为"have a nice day"并不属于Number类
    }

    public static <T extends Number> void printNum (T element){
        System.out.println(element);
    }
    //使T继承Number类，创造上界

/*
输出：
11
12.7
11.23
*/

创建泛型类

public class Box <T> {
    private T t;

    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<Integer>();
        Box<String> stringBox = new Box<String>();
        integerBox.add(10);
        stringBox.add("have a nice day");
        System.out.println(integerBox.get());
        System.out.println(stringBox.get());
        //integerBox.add(13.6); 定义为int而输入为double，类型不兼容
    }

/*
输出：
10
have a nice day
*/

文章引用

java容器超详细_CoderWriter的博客-CSDN博客

Java容器及其常用方法汇总_little_fat_sheep的博客-CSDN博客

Java 泛型 | 菜鸟教程 (runoob.com)

感谢观看