Java的集合框架和泛型

el psy congroo

已于 2024-03-24 14:58:50 修改

阅读量734

点赞数 26

分类专栏：数据结构文章标签： java 数据结构

于 2024-02-16 22:21:30 首次发布

本文链接：https://blog.csdn.net/2302_77179144/article/details/136108780

版权

数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

集合框架

什么是集合框架

Java 集合框架 (Java Collection Framework )，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces和其实现类 classes 。

其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储 store 、检索 retrieve 、管理 manipulate ，即平时我们俗称的增删查改 CRUD 。

类和接口总览

在这里插入图片描述

集合框架的重要性

开发中的使用

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

笔试及面试题

腾讯-Java后台开发面经

HashMap 了解不，介绍一下，如果一个对象为 key 时，hashCode 和 equals 方法的用法要注意什么？
HashSet 和 HashMap 的区别是什么？
HashMap 是线程安全的么？那需要线程安全需要用到什么？

阿里巴巴-Java后台开发面经

ArrayList 和 LinkedList 的区别是什么？
有了解过 HashMap 的具体实现么？
HashMap 和 ConcurrentHashMap 哪个效率更高？

今日头条-Java后台开发面经

编程题：判断一个链表是否是一个回文链表。
Redis 的 zset 类型对应到 java 语言中大致是什么类型？
hashCode 主要是用来做什么用的？

背后所涉及的数据结构以及算法

什么是数据结构

数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合

容器背后对应的数据结构

每个容器其实都是对某种特定数据结构的封装

实现了Iterable接口就可以使用迭代器遍历,也就可以用for-each(依靠迭代器实现)遍历
Collection：是一个接口，包含了大部分容器常用的一些方法
List：是一个接口，规范了ArrayList 和 LinkedList中要实现的方法
ArrayList：实现了List接口，底层为动态类型顺序表
LinkedList：实现了List接口，底层为双向链表
Stack：底层是栈，栈是一种特殊的顺序表
Queue：底层是队列，队列是一种特殊的顺序表
Deque：是一个接口
Set：集合，是一个接口，里面放置的是K模型
HashSet：底层为哈希桶，查询的时间复杂度为O(1)
TreeSet：底层为红黑树，查询的时间复杂度为O( $log_2N$ ),关于key有序的
Map：映射，是一个接口,里面存储的是K-V模型的键值对
HashMap：底层为哈希桶，查询时间复杂度为O(1)
TreeMap：底层为红黑树，查询的时间复杂度为O( $log_2N$ )，关于key有序

相关java知识

泛型 (Generic)
自动装箱 (autobox) 和自动拆箱 (autounbox)
Object 的 equals 方法
Comparable 和 Comparator 接口

Comparable和Comparator区别参考此文

可以把Comparable理解为内部比较器，而Comparator是外部比较器。
Comparable和Comparator都可以用来进行比较、排序。
二者各有优缺点，用Comparable 简单，实现Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。用Comparator 的好处是不需要修改源代码，而是另外实现一个比较器，当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了，并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了。
Compareble是java.lang中的接口类，可以直接使用。
Comparator是java.util 包中的泛型接口类，使用时必须导入对应的包。

什么是算法

算法(Algorithm)就是定义良好的计算过程，取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

包装类

在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

基本数据类型和对应的包装类

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

装箱和拆箱

int i = 10;
// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
Integer ii = Integer.valueOf(i);
Integer ij = new Integer(i);
// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
int j = ii.intValue();

自动装箱和自动拆箱

可以看到在使用过程中，装箱和拆箱带来不少的代码量，所以为了减少开发者的负担，java 提供了自动机制。

int i = 10;
Integer ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱

【面试题】
下列代码输出什么，为什么？

public static void main(String[] args) {
	Integer a = 127;
	Integer b = 127;
	Integer c = 128;
	Integer d = 128;
	System.out.println(a == b);
	System.out.println(c == d);
}

在这里插入图片描述
这里只进行了装箱,我们可以打开反汇编看看自动装箱调用了哪个方法

找到目录下的字节码文件(idea是在out目录中)
在上面输入cmd回车
在这里插入图片描述

查看汇编的命令：javap -c

在这里插入图片描述
问题出在Integer.valueOf()上,我们看下源码

我们发现如果参数 >=IntegerCache.low 并且 <= IntegerCache.high时
返回IntegerCache.cache这个缓存数组中的一个值
在数组中的值没有new一个对象,是一样的

泛型

什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。这种刻板的限制对代码的束缚就会很大。—— 来源《Java编程思想》对泛型的介绍。
泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

引出泛型

思路：

我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10]; String[] strs = new String[10];
所有类的父类，默认为Object类。数组是否可以创建为Object?

代码示例：

class MyArray {
    public Object[] array = new Object[10];
    public Object getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,Object val) {
        this.array[pos] = val;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setVal(0,10);//整型可以存放
        myArray.setVal(1,"汤姆猫");//字符串也可以存放
        String ret = myArray.getPos(1);//编译报错
        System.out.println(ret);
    }
}

问题：

Object任何类型数据都可以存放
1下标对应的值就是字符串，但是取出来会编译报错。必须进行强制类型转换

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类型, 而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

语法

class 泛型类名称<类型形参列表> {
	// 这里可以使用类型参数
}

class ClassName<T1, T2, ..., Tn> {
}

class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数列表 */ {
	// 这里可以使用类型参数
}

class ClassName<T1, T2, ..., Tn> extends ParentClass<T1,..., Tn> {
	// 可以只使用部分类型参数
}

上述代码进行改写如下：

class MyArray<T> {
    public T[] array = (T[])new Object[10];//1
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}
public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();//2
        myArray.setVal(0,10);
        myArray.setVal(1,12);
        int ret = myArray.getPos(1);//3
        System.out.println(ret);
        myArray.setVal(2,"灰太狼");//4:编译报错
    }
}

代码解释：

类名后的 < T > 代表占位符，表示当前类是一个泛型类

【规范】类型形参一般使用一个大写字母表示，常用的名称有：

E 表示 Element
K 表示 Key
V 表示 Value
N 表示 Number
T 表示 Type
S, U, V 等等 —— 第二、第三、第四个类型

注释1处，不能new泛型类型的数组

T[] ts = new T[5];//是不对的

因为泛型是编译时期的机制,也意味着运行的时候没有泛型的概念,JVM没有泛型的概念

注释2处，类后面加入 < Integer > 指定当前类型
注释3处，不需要进行强制类型转换
注释4处，代码编译报错，因为在注释2处指定类为Integer，此时在注释4处，编译器会在存放元素的时候帮助我们进行类型检查。

泛型类

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

示例

MyArray<Integer> list = new MyArray<Integer>()

注意：泛型的参数只能是类，所有的基本数据类型必须使用包装类！

MyArray<int> list = new MyArray<>()//是不对的

类型推导(Type Inference)

当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写

MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的类型实参为 Integer

泛型的上界(没有下界)

在定义泛型类或泛型方法时，有时需要对传入的类型做一定的约束，可以通过类型边界来约束。

语法

class 泛型类名称<类型形参 extends 类型边界> {
	...
}

示例1

public class MyArray<E extends Number> {
	...
}

只接受 Number 的子类型或者Number本身作为 E 的类型实参

MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型

在这里插入图片描述
PS:如果没有指定类型边界，可以视为 E extends Object
示例2

public class MyArray<E extends Comparable<E>> {
	...
}

E必须是实现了Comparable接口的
引用类不能直接比较,需要实现接口

class Person implements Comparable<Person>{
    @Override
    public int compareTo(Person o) {
        return 0;
    }
}
class Alg<T extends Comparable<T>> {
    public T findMaxVal(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,4,3,8,7,5};
        Alg<Integer> alg = new Alg<>();
        System.out.println(alg.findMaxVal(array));
        Alg<Person> alg2 = new Alg<>();
    }
}

类型实参T实例化为自定义类Person时,需要实现Comparable< T >或Comparator< T >接口
而Integer类本身就实现了Comparable接口,不用我们自己重写

泛型方法

语法

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }

举个栗子

class Alg {
    public<T extends Comparable<T>> T findMaxVal(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {
        Alg alg = new Alg();
        Integer[] array = {1,4,3,8,7,5};
        //不使用类型推导
        alg.<Integer>findMaxVal(array);
        //类型自动推导
        alg.findMaxVal(array);
    }
}

可以写成静态方法,这样不用实例化类对象也能使用

class Alg {
    public static <T extends Comparable<T>> T findMaxVal(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i].compareTo(max) > 0) {
                max = array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,4,3,8,7,5};
        //不使用类型推导
        Alg.<Integer>findMaxVal(array);
        //类型自动推导
        Alg.findMaxVal(array);
    }
}

裸类型(Raw Type)

裸类型是一个泛型类但没有带着类型实参

MyArray list = new MyArray();

注意： 我们不要去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制

小结

泛型是将数据类型参数化，进行传递
使用 < T > 表示当前类是一个泛型类。
泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

泛型如何编译的

擦除机制

通过命令：javap -c 查看字节码文件，所有的T都被擦除成Object

class MyArray<T> {
    public T[] array = (T[])new Object[10];
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}

在这里插入图片描述

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。
Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。
有关泛型擦除机制的文章介绍

为什么不能实例化泛型类型数组

class MyArray<T> {
    public T[] array = (T[]) new Object[10];
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos, T val) {
        this.array[pos] = val;
    }
    public T[] getArray() {
        return array;
    }
}
public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray1 = new MyArray<>();
        Integer[] arr = myArray1.getArray();
    }
}

在这里插入图片描述
将Object[]分配给Integer[]引用，程序报错的原因：

Object可以强转为Integer,因为有继承关系,是确定的,而数组是没有继承关系的,是不确定的(可能存在其他类型的元素)
返回的Object数组里面，存放的可能是其他数据类型，可能是String，可能是自定义类Person，运行的时候，直接转给Integer类型的数组，编译器认为是不安全的。

正确的方式：

import java.lang.reflect.Array;
class MyArray<T> {
    public T[] array;
    public MyArray() {
    }
    /**
     * 通过反射创建，指定类型的数组
     * @param clazz
     * @param capacity
     */
    public MyArray(Class<T> clazz, int capacity) {
        array = (T[]) Array.newInstance(clazz, capacity);
    }
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
    public T[] getArray() {
        return array;
    }
}
public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray1 = new MyArray<>(Integer.class,10);
        Integer[] integers = myArray1.getArray();
    }
}

反射我也不太会,目前还是用

class MyArray<T> {
    public Object[] array = new Object[10];
    public T getPos(int pos) {
        return (T)array[pos];
    }
    public void setVal(int pos,T val) {
        array[pos] = val;
    }
}

通配符

? 用在泛型，即为通配符

通配符解决什么问题

示例:

class Message<T> {
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class Test {
    public static void main(String[] args) {
        Message<String> message = new Message<>() ;
        message.setMessage("光头强");
        fun(message);
    }
    public static void fun(Message<String> temp){
        System.out.println(temp.getMessage());
    }
}

以上程序会带来新的问题，如果泛型的类型不是String，而是Integer.

public class Test {
    public static void main(String[] args) {
        Message<Integer> message = new Message() ;
        message.setMessage(99);
        fun(message); // 出现错误，只能接收String
    }
    public static void fun(Message<String> temp){
        System.out.println(temp.getMessage());
    }
}

解决方案：可以接收所有的泛型类型，但是又不能够让用户随意修改。这种情况就需要使用通配符"?"来处理

public class Test {
    public static void main(String[] args) {
        Message<Integer> message = new Message() ;
        message.setMessage(55);
        fun(message);
    }
    // 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
    public static void fun(Message<?> temp){
    	//temp.setMessage(100); 无法修改！
        System.out.println(temp.getMessage());
    }
}

在"?"的基础上又产生了两个子通配符：

? extends 类：设置通配符上限
? super 类：设置通配符下限

通配符上界

语法：

<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类

示例

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Banana extends Fruit {
}
class Message<T> { // 设置泛型
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class Test {
    public static void main(String[] args) {
        Message<Apple> message = new Message<>() ;
        message.setMessage(new Apple());
        fun(message);
        Message<Banana> message2 = new Message<>() ;
        message2.setMessage(new Banana());
        fun(message2);
    }
    // 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
    public static void fun(Message<? extends Fruit> temp){
        //temp.setMessage(new Banana()); //仍然无法修改！
        //temp.setMessage(new Apple()); //仍然无法修改！
        System.out.println(temp.getMessage());
        Fruit fruit = temp.getMessage();
        //Apple apple = temp.getMessage();//报错,因为不知道是哪个子类,但是父类可以接收
    }
}

无法在fun函数中对temp进行修改，因为temp接收的是Fruit和他的子类，此时存储的元素应该是哪个子类无法确定。所以会报错！但是可以获取元素。

通配符的上界，不能进行写入数据，只能进行读取数据

通配符下界

语法:

<? super 下界>
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型

示例

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Plate<T> {
    private T plate ;
    public T getPlate() {
        return plate;
    }
    public void setPlate(T plate) {
        this.plate = plate;
    }
}
public class Test {
    public static void main(String[] args) {
        Plate<Fruit> plate1 = new Plate<>();
        plate1.setPlate(new Fruit());
        fun(plate1);
        Plate<Food> plate2 = new Plate<>();
        plate2.setPlate(new Food());
        fun(plate2);
    }
    public static void fun(Plate<? super Fruit> temp){
        // 此时可以修改！！添加的是Fruit 或者Fruit的子类
        temp.setPlate(new Apple());//这个是Fruit的子类
        temp.setPlate(new Fruit());//这个是Fruit的本身
        //Fruit fruit = temp.getPlate(); 不能接收，这里无法确定是哪个父类
        System.out.println(temp.getPlate());//只能直接输出
    }
}

通配符的下界，不能进行读取数据，只能写入数据。

el psy congroo

关注

26
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
Java的集合框架和泛型

Java 集合框架，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces和其实现类 classes。其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储store、检索retrieve、管理manipulate，即平时我们俗称的增删查改CRUD。数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。
复制链接

扫一扫