当前位置：首页 > article >正文

图灵日记--MapSet字符串常量池反射枚举Lambda表达式泛型

article 2024/12/22 13:07:10

搜索树
- 概念
- 实现
- 性能分析
- 和 java 类集的关系
搜索
- 概念及场景
- 模型
Map的使用
- Map常用方法
Set的说明
- 常见方法说明
哈希表
- 冲突-避免-负载因子调节
- - 冲突-解决-闭散列
  - 冲突-解决-开散列/哈希桶
  - 冲突严重时的解决办法
- 实现
- 和 java 类集的关系
字符串常量池
- String对象创建
- - intern方法
反射
枚举
Lambda表达式
泛型

搜索树

概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

实现


public class BinarySearchTree {
    static class TreeNode {
        TreeNode left;
        TreeNode right;
        int val;
        public TreeNode(int val) {
            this.val = val;
        }
    }

    public TreeNode root;

    public boolean insert(int val) {
        TreeNode newNode = new TreeNode(val);
        if(root==null) {
            root = newNode;
            return true;
        }
        TreeNode prevNode = null;
        TreeNode curNode = root;
        while (curNode!=null) {
            prevNode = curNode;
            if(val>curNode.val) {
                curNode = curNode.right;
            } else if (val<curNode.val) {
                curNode = curNode.left;
            }
        }
        if(val > prevNode.val) {
            prevNode.right = newNode;
        } else {
            prevNode.left = newNode;
        }
        return false;
    }

    public boolean search(int key) {
        TreeNode cur = root;
        while (cur!=null) {
            if(cur.val==key) {
                return true;
            } else if (cur.val<key) {
                cur = cur.right;
            } else {
                cur = cur.left;
            }
        }
        return false;
    }

    public boolean remove(int val) {
        if(!search(val)) {
            System.out.println("该值不存在,无法删除");
            return false;
        }
        if(root.val==val&&root.left==null) {
            root = root.right;
            if(!search(val)) {
                System.out.println("删除成功");
                return true;
            }else {
                System.out.println("删除失败");
                return false;
            }
        }
        if(root.val==val&&root.right==null) {
            root = root.right;
            if(!search(val)) {
                System.out.println("删除成功");
                return true;
            }else {
                System.out.println("删除失败");
                return false;
            }
        }
        if (root.val==val) {
            TreeNode tmpNode = root.right;
            root = root.left;
            TreeNode node = root;
            while (node.right!=null) {
                node = node.right;
            }
            node.right = tmpNode;
            if(!search(val)) {
                System.out.println("删除成功");
                return true;
            }else {
                System.out.println("删除失败");
                return false;
            }
        }
        TreeNode curNode = root;
        TreeNode prevNode = null;
        while (curNode!=null) {
            if(val>curNode.val) {
                prevNode = curNode;
                curNode = curNode.right;
            } else if (val<curNode.val) {
                prevNode = curNode;
                curNode = curNode.left;
            } else {
                removeNode(curNode,prevNode);
                if(!search(val)) {
                    System.out.println("删除成功");
                }else {
                    System.out.println("删除失败");
                }
                return true;
            }
        }


        return true;
    }

    private void removeNode(TreeNode curNode, TreeNode prevNode) {
        if(curNode.val>prevNode.val) {
            if(curNode.left==null&&curNode.right==null) {
                prevNode.right = null;
            }
            if(curNode.left==null&&curNode.right!=null) {
                prevNode.right = curNode.right;
            }
            if(curNode.left!=null&&curNode.right==null) {
                prevNode.right = curNode.left;
            }
            if(curNode.left!=null&&curNode.right!=null) {
                prevNode.right = curNode.left;
                TreeNode tmpNode = curNode.left;
                while (tmpNode.right!=null) {
                    tmpNode = tmpNode.right;
                }
                tmpNode.right = curNode.right;
            }

        } else if (curNode.val<prevNode.val) {
            if(curNode.left==null&&curNode.right==null) {
                prevNode.left = null;
            }
            if(curNode.left!=null&&curNode.right==null) {
                prevNode.left = curNode.left;
            }
            if(curNode.left==null&&curNode.right!=null) {
                prevNode.left = curNode.right;
            }
            if(curNode.left!=null&&curNode.right!=null) {
                prevNode.left = curNode.left;
                TreeNode tmpNode = curNode.left;
                while (tmpNode.right!=null) {
                    tmpNode = tmpNode.right;
                }
                tmpNode.right = curNode.right;
            }
        }


    }
}

性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
最优情况下，二叉搜索树为完全二叉树
最差情况下，二叉搜索树退化为单支树

和 java 类集的关系

TreeMap 和 TreeSet 即 java 中利用搜索树实现的 Map 和 Set；实际上用的是红黑树，而红黑树是一棵近似平衡的二叉搜索树，即在二叉搜索树的基础之上 + 颜色以及红黑树性质验证

搜索

概念及场景

Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关

模型

一般把搜索的数据称为关键字（Key），和关键字对应的称为值（Value），将其称之为Key-value的键值对，所以模型会有两种：

纯 key 模型，比如：
有一个英文词典，快速查找一个单词是否在词典中
快速查找某个名字在不在通讯录中
Key-Value 模型，比如：
统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>
梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号
而Map中存储的就是key-value的键值对，Set中只存储了Key。

Map的使用

Map是一个接口类，该类没有继承自Collection，该类中存储的是<K,V>结构的键值对，并且K一定是唯一的，不能重复。

Map常用方法

方法解释
V get(Object key) 返回 key 对应的 value
V getOrDefault(Object key, V defaultValue) 返回 key 对应的 value，key 不存在，返回默认值
V put(K key, V value) 设置 key 对应的 value
V remove(Object key) 删除 key 对应的映射关系
Set keySet() 返回所有 key 的不重复集合
Collection values() 返回所有 value 的可重复集合
Set<Map.Entry<K, V>> entrySet() 返回所有的 key-value 映射关系
boolean containsKey(Object key) 判断是否包含 key
boolean containsValue(Object value) 判断是否包含 value

注意:

Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap
Map中存放键值对的Key是唯一的，value是可以重复的
在TreeMap中插入键值对时，key不能为空，否则就会抛NullPointerException异常，value可以为空。但
是HashMap的key和value都可以为空。
Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。
Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。
Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行
重新插入。

Map底层结构 TreeMap HashMap
底层结构红黑树哈希桶
是否有序关于Key有序无序
线程安全不安全不安全
插入/删除/查找区别需要进行元素比较通过哈希函数计算哈希地址

Set的说明

Set与Map主要的不同有两点:Set是继承Collection的接口类,Set中只存储了Key

常见方法说明

方法解释
boolean add(E e) 添加元素，但重复元素不会被添加成功
void clear() 清空集合
boolean contains(Object o) 判断 o 是否在集合中
Iterator iterator() 返回迭代器
boolean remove(Object o) 删除集合中的 o
int size() 返回set中元素的个数
boolean isEmpty() 检测set是否为空，空返回true，否则返回false
Object[] toArray() 将set中的元素转换为数组返回
boolean containsAll(Collection<?> c)
集合c中的元素是否在set中全部存在，是返回true，否则返回false
boolean addAll(Collection<? extends E> c)
将集合c中的元素添加到set中，可以达到去重的效果

**注意: **

Set是继承自Collection的一个接口类
Set中只存储了key，并且要求key一定要唯一
TreeSet的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的
Set最大的功能就是对集合中的元素进行去重
实现Set接口的常用类有TreeSet和HashSet，还有一个LinkedHashSet，LinkedHashSet是在HashSet的基础上维护了一个双向链表来记录元素的插入次序。
Set中的Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入
TreeSet中不能插入null的key，HashSet可以。

不管你实例化一个什么类型的treemap,value都是一个Object对象

哈希表

5.1 概念
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN )，搜索的效率取决于搜索过程中
元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash
Table)(或者称散列表)

哈希冲突: 不同的关键字key,通过相同的哈希函数,得到相同的值
对于两个数据元素的关键字和 (i != j)，有 != ，但有：Hash( ) == Hash( )，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”

首先，我们需要明确一点，由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。哈希函数设计原则：
哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
哈希函数计算出来的地址能均匀分布在整个空间中
哈希函数应该比较简单

冲突-避免-负载因子调节

所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。
已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

解决哈希冲突两种常见的方法是：闭散列和开散列

冲突-解决-闭散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个”空位置中去。

线性探测
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
插入:
通过哈希函数获取待插入元素在哈希表中的位置
如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到
下一个空位置，插入新元素
二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： = ( + )% m, 或者：= ( - )% m。其中：i = 1,2,3…，是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。
研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。
因此：比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

冲突-解决-开散列/哈希桶

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

开散列，可以认为是把一个在大集合中的搜索问题转化为在小集合中做搜索了
插入元素的时候,JDK1.7以前采用头插法,从1.8开始采用尾插法

数组+链表+红黑树(当数组长度>=64&&链表长度>=8以后,链表变成红黑树)

冲突严重时的解决办法

刚才我们提到了，哈希桶其实可以看作将大集合的搜索问题转化为小集合的搜索问题了，那如果冲突严重，就意味着小集合的搜索性能其实也时不佳的，这个时候我们就可以将这个所谓的小集合搜索问题继续进行转化，例如：

每个桶的背后是另一个哈希表
每个桶的背后是一棵搜索树

实现


public class HashBuck {
    static class Node {
        public int key;
        public int val;
        public Node next;

        public Node(int key, int val) {
            this.key = key;
            this.val = val;
        }
    }

    public Node[] arr;
    public int usedSize;
    //负载因子
    public static final float DEFAULT_LOAD_FACTOR = 0.75f;
    public HashBuck(Node[] arr, int usedSize) {
        arr = new Node[10];
    }
    public void put(int key, int val) {
        //根据key和哈希函数来确定在数组中的下标
        int index = key % (arr.length);
        Node cur = arr[index];
        //查看之前是否存在key值,存在的话,更新val,不存在,进行头插法
        while (cur!=null) {
            if(cur.key==key) {
                cur.val = val;
                return;
            }
            cur = cur.next;
        }
        //不存在key值进行头插法
        Node newNode = new Node(key,val);
        newNode.next = arr[index];
        arr[index] = newNode;
        usedSize++;
        if(doLoadFactor()>=DEFAULT_LOAD_FACTOR) {
            //扩容
            //重新哈希
            //因为长度变了
            //原来位置冲突的元素可能放在新的数组的其他位置
            resize();
        }
    }

    private void resize() {
        Node[] newArray = new Node[arr.length*2];
        //遍历数组每个下标的链表,重新放到新数组
        for (int i = 0; i < arr.length; i++) {
            Node cur = arr[i];
            //遍历链表,重新哈希
            while (cur!=null) {
                //后面的步骤cur.next会被修改,所以在传向
                //链表的下一个结点时会出错,所以要提前记录下来
                Node tmpNode = cur.next;
                //确定在新数组中的下标
                int newIndex = cur.key%(newArray.length);
                //重新在新的数组中插入
                cur.next = newArray[newIndex];
                newArray[newIndex] = cur;
                cur = tmpNode;
            }
        }
        arr = newArray;
    }


    private float doLoadFactor() {
        return usedSize*1.0f / arr.length;
    }

    public int get(int key) {
        //获取下标
        int index = key%arr.length;
        Node cur = arr[index];
        while (cur!=null) {
            //找到返回val值
            if(cur.key==key) {
                return cur.val;
            }
            //遍历链表
            cur = cur.next;
        }
        return -1;
    }
}

和 java 类集的关系

java中利用哈希表实现Map和Set
java中使用的是哈希桶方式解决冲突的
java会在冲突链表大于一定阈值后,将链表转化为搜索树(红黑树)
java中计算哈希值实际上是调用的类的hashCode方法,进行key的相等性比较是调用key的equals方法,所以如果要用自定义类作为HashMap的key或者HashSet值,必须覆写hashCode和equals方法,而且要做到equals相等的对象,hashCode一定是一致的

实现

public class HashBuck2<K,V> {
    static class Node<K,V> {
        public K key;
        public V val;
        public Node<K,V> next;
        public Node(K key, V val) {
            this.key = key;
            this.val = val;
        }
    }

    public Node<K,V>[] array;
    public int usedSize;
    public static final float DEFAULT_LOAD_FACTOR = 0.75f;

    public HashBuck2() {
        array = (Node<K,V>[])new Node[10];
    }
    public void put(K key, V val){
        int hash = key.hashCode();
        int index = hash% array.length;
        Node<K,V> cur = array[index];
        //查看之前是否存在key值,存在的话,更新val,不存在,进行头插法
        while (cur!=null) {
            if(cur.key==key) {
                cur.val = val;
                return;
            }
            cur = cur.next;
        }
        //不存在key值进行头插法
        Node<K,V> newNode = new Node(key,val);
        newNode.next = array[index];
        array[index] = newNode;
        usedSize++;
    }

    public V get(K key) {
        int hash = key.hashCode();
        int index = hash% array.length;
        Node<K,V> cur = array[index];
        //查看之前是否存在key值,存在的话,更新val,不存在,进行头插法
        while (cur!=null) {
            if(cur.key.equals(key)) {
                return cur.val;
            }
            cur = cur.next;
        }
        return null;
    }
}

字符串常量池

        String str1 = "a";
        String str2 = "a";
        String str3 = new String("a");
        String str4  = new String("a");
        System.out.println(str1==str2);
        System.out.println(str1==str3);
        System.out.println(str3==str4);

在这里插入图片描述
创建String对象的方式类似,可以str1和str2引用的是同一个对象,但是str3和str4不是

因为常量在程序中要被频繁使用,为了节省内存,提升速度,在Java中,为8钟基本类型和String类型提供了常量池

字符串常量在JVM中是StringTable类,实际是一个固定大小的HashTable(一种高效查找的数据结构)

String对象创建

只要是双引号引起来的都会存放在常量池当中
String对象的创建方式
直接使用字符串常量进行赋值
通过new创建String类对象

如何放在常量池里呢?

创建对象,根据对象求得对应的数组下标,对应数组下标对应链表,放入链表的结点,链表结点放的是String类型的引用,

        String str1 = "a";

在这里插入图片描述

遇到双引号,先去常量池查找是否存在当前这个字符串
存在则指向对象,不存在就重新创立

在这里插入图片描述

创建str3对象

"a"在常量池存在创建新的String对象中value的引用就是字符数组的引用,如下

结论:只要是new的对象就是唯一的
使用常量串创建String类型对象的效率更高一些,更省空间,用户也可以通过创建字符串对象通过intern方式添加到常量池中

intern方法

        char[] ch = new char[]{'a','b','c'};
        String s1 = new String(ch);
        String s2 = "abc";
        System.out.println(s1==s2);//结果:false

在这里插入图片描述
String类型传入字符数组时,复制传入的数组并返回数组引用,如下

当前常量池没有任何数据,在s2未实例化之前,没有出现双引号引起的值

实例化s2,出现双引号,先去常量池看有没有引号里面的东西,没有就创建

在这里插入图片描述

        char[] ch = new char[]{'a','b','c'};
        String s1 = new String(ch);
        s1.intern();
        String s2 = "abc";
        System.out.println(s1==s2);//结果是true

intern让s1所指向的对象入池,如果存在于常量池则不入

反射

知道类的路径,用forName来获取对象
在这里插入图片描述
获取Student对象

发生报错,看一下forName方法长什么样

发现我们需要捕获异常,返回值为Class<?>接收一下

    public static void main(String[] args) {
        Class<?> c1 = null;
        try {
            c1 = Class.forName("Demo01.Student");
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

编译前就确定要操作的类

        Class<?> c2 = Student.class;

使用类对象的getClass方法

		Student s = new Student();
        Class<?> c3 = s.getClass();

验证这三个是不是同一个对象
在这里插入图片描述
发现一样,那么就说明Class对象只有一个

那么如何进行反射呢?
以下是我们要反射的类

class Student {
    //私有属性name
    private String name = "zhangsan";
    //公有属性age
    public int age = 18;

    //不带参数的构造方法
    public Student() {
        System.out.println("Student()");
    }

    private Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student(String,name)");
    }

    private void eat() {
        System.out.println("i am eat");
    }

    public void sleep() {
        System.out.println("i am pig");
    }

    private void function(String str) {
        System.out.println(str);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

先获取Class对象

在这里插入图片描述
拿到一个Student对象

在这里插入图片描述
发生报错,看一下newInstance方法

要捕获异常并且T会被擦除成Object,要进行向下转型

在这里插入图片描述
打印对象来验证一下,调用刚才设计的方法,代码如下

    public static void reflectStudent() {
        Class<?> studentClass;
        try {
            studentClass = Class.forName("Demo01.Student");
            Student student = (Student) studentClass.newInstance();
            System.out.println(student);
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        reflectStudent();
    }

在这里插入图片描述
虽然并没有new Student,但是确实创建了一个Student对象

那我们调用隐藏程度高的方法试一下
在这里插入图片描述

public static void reflectConstructor() {
        Class<?> c = null;
        try {
            c = Class.forName("Demo01.Student");
            //获得构造方法
            Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class);

            Student student = (Student) constructor.newInstance("zhangsan",11);
            System.out.println(student);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        reflectConstructor();
    }

在这里插入图片描述

发生报错
因为你调用的方法被private修饰,为了强调他的私密性,需要你调用方法再确定一下以保证安全性

在这里插入图片描述
成功调用未报错

反射私有属性

public static void reflectPrivateField() {
        Class<?> c = null;
        try {
            c = Class.forName("Demo01.Student");
            Field field = c.getDeclaredField("name");
            Student student = (Student) c.newInstance();
            field.setAccessible(true);
            field.set(student,"lisi");
            System.out.println(student);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args) {
        reflectPrivateField();
    }

在这里插入图片描述

在这里插入图片描述
反射私有方法

在这里插入图片描述

枚举

public enum TestEnum {
    RED,BLACK,WHITE,GREEN;

    public static void main(String[] args) {
        TestEnum color = RED;

        switch (color) {
            case RED:
                System.out.println("RED");
                break;
            case BLACK:
                System.out.println("BLACK");
                break;
            default:
                System.out.println("error");
                break;
        }
    }
}

在这里插入图片描述

public enum TestEnum {
    RED,BLACK,WHITE,GREEN;

    public static void main(String[] args) {
        //values(): 以数组的形式返回枚举成员
        TestEnum[] testEnums = TestEnum.values();
        for (int i = 0; i < testEnums.length; i++) {
            System.out.println(testEnums[i]);
        }
        for (int i = 0; i < testEnums.length; i++) {
            //ordinal() :返回对应枚举成员的索引值
            System.out.println(testEnums[i].ordinal());
        }
        //把字符串转化为枚举实例
        TestEnum color = TestEnum.valueOf("RED");
        System.out.println(color);
        //比较两个枚举在定义时的顺序
        System.out.println(RED.compareTo(BLACK));
    }
}

尝试对枚举类型进行反射
创建的枚举类型如下:

在这里插入图片描述

在这里插入图片描述
发生报错

枚举类型默认继承于Enum类,该类的构造方法如下:
在这里插入图片描述
在刚才调用枚举类型默认先调用Enum类的构造方法

依旧报错

在这里插入图片描述

在这里插入图片描述
通过反射无法创建枚举类型
结论:

枚举类型非常安全,即便反射也无法创建一个枚举对象

Lambda表达式

在这里插入图片描述

使用Lambda表达式
在这里插入图片描述
无返回值,一个参数

无返回值,多个参数

无参有返回值

泛型

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());
    }
}

如果我们要使用fun方法接收的类型不止Message类型,或者Message类型等,<>里的类型不固定,这时我们要使用**通配符?**来解决这样的问题

在这里插入图片描述

在这里插入图片描述
通配符的上界


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<Banana> message1 = new Message<>();
        fun(message);
        fun(message1);

    }

    public static void fun(Message<? extends Fruit> temp){
        System.out.println(temp.getMessage());
    }
}