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

目录

  • 搜索树
    • 概念
    • 实现
    • 性能分析
    • 和 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的键值对,所以模型会有两种:

  1. 纯 key 模型,比如:
    有一个英文词典,快速查找一个单词是否在词典中
    快速查找某个名字在不在通讯录中
  2. 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

注意:

  1. Map是一个接口,不能直接实例化对象,如果要实例化对象只能实例化其实现类TreeMap或者HashMap
  2. Map中存放键值对的Key是唯一的,value是可以重复的
  3. 在TreeMap中插入键值对时,key不能为空,否则就会抛NullPointerException异常,value可以为空。但
    是HashMap的key和value都可以为空。
  4. Map中的Key可以全部分离出来,存储到Set中来进行访问(因为Key不能重复)。
  5. Map中的value可以全部分离出来,存储在Collection的任何一个子集合中(value可能有重复)。
  6. 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中,可以达到去重的效果

**注意: **

  1. Set是继承自Collection的一个接口类
  2. Set中只存储了key,并且要求key一定要唯一
  3. TreeSet的底层是使用Map来实现的,其使用key与Object的一个默认对象作为键值对插入到Map中的
  4. Set最大的功能就是对集合中的元素进行去重
  5. 实现Set接口的常用类有TreeSet和HashSet,还有一个LinkedHashSet,LinkedHashSet是在HashSet的基础上维护了一个双向链表来记录元素的插入次序。
  6. Set中的Key不能修改,如果要修改,先将原来的删除掉,然后再重新插入
  7. 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存放到冲突位置中的“下一个”空位置中去。

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

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

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

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

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

冲突严重时的解决办法

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

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

实现


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 类集的关系

  1. java中利用哈希表实现Map和Set
  2. java中使用的是哈希桶方式解决冲突的
  3. java会在冲突链表大于一定阈值后,将链表转化为搜索树(红黑树)
  4. 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 {//私有属性nameprivate String name = "zhangsan";//公有属性agepublic 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);}@Overridepublic 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());}
}

在这里插入图片描述

通配符的下界

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/679201.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

深入理解Go的垃圾回收机制

导语 如果你是一位Golang的开发者&#xff0c;你一定对于语言特性和详细结构有所了解。但是&#xff0c;你是否曾经停下来深入研究过Golang背后复杂而强大的垃圾回收&#xff08;GC&#xff09;机制&#xff1f;在这篇文章中&#xff0c;我们将具体深入探讨Golang垃圾回收机制…

机器学习系列——(十五)随机森林回归

引言 在机器学习的众多算法中&#xff0c;随机森林以其出色的准确率、对高维数据的处理能力以及对训练数据集的异常值的鲁棒性而广受欢迎。它是一种集成学习方法&#xff0c;通过构建多个决策树来进行预测和分类。本文将重点介绍随机森林在回归问题中的应用&#xff0c;即随机…

DP读书:《openEuler操作系统》(九)从IPC到网卡到卡驱动程序

DP读书&#xff1a;《openEuler操作系统》从IPC到网卡到卡驱动程序&#xff09; 上章回顾_SPI上节回顾_TCP 网卡驱动程序简介1.设备驱动2.总线与设备3.网卡及其抽象 驱动程序的注册与注销1. 注册2. 注销 设备初始化1. 硬件初始化2. 软件初始化 设备的打开与关闭1. 设备的打开2.…

微软和苏黎世联邦理工学院开源SliceGPT创新压缩技术节省大量部署资源;OpenAI成立儿童安全团队,防AI误用

&#x1f989; AI新闻 &#x1f680; 微软和苏黎世联邦理工学院开源SliceGPT创新压缩技术节省大量部署资源 摘要&#xff1a;微软和苏黎世联邦理工学院研究人员开源了SliceGPT&#xff0c;通过对大模型的权重矩阵进行压缩切片&#xff0c;实现了模型紧缩&#xff0c;节省了部…

Spring Boot 笔记 002 整合mybatis做数据库读取

概念 MyBatis 是一款优秀的持久层框架&#xff0c;它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO&#xff08;Plain Old Java Objec…

书生谱语-大语言模型测试demo

课程内容简介 1.作业 demo1 demo2 demo3 demo4

【leetcode】206. 反转链表(简单)题解学习

题目描述&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]示例 …

【十五】【C++】list的简单实现

list 的迭代器解引用探究 /*list的迭代器解引用探究*/ #if 1 #include <list> #include <vector> #include <iostream> #include <algorithm> using namespace std;class Date {private:int _year;int _month;int _day;public:Date(): _year(2024), _m…

【CC++】内存管理2:new + delete

前言 今天继续来学new和delete operator new 与operator delete函数 new和delete是用户进行动态内存申请和释放的操作符&#xff0c;operator new 和operator delete是系统提供的全局函数&#xff0c;new在底层调用operator new全局函数来申请空间&#xff0c;delete在底层通…

【开源】基于JAVA+Vue+SpringBoot的二手车交易系统

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 数据中心模块2.2 二手车档案管理模块2.3 车辆预约管理模块2.4 车辆预定管理模块2.5 车辆留言板管理模块2.6 车辆资讯管理模块 三、系统设计3.1 E-R图设计3.2 可行性分析3.2.1 技术可行性分析3.2.2 操作可行性3.2.3 经济…

Java核心设计模式:代理设计模式

一、生活中常见的代理案例 房地产中介&#xff1a;客户手里没有房源信息&#xff0c;找一个中介帮忙商品代购&#xff1a;代理者一般有好的资源渠道&#xff0c;降低购物成本&#xff08;如海外代购&#xff0c;自己不用为了买东西出国&#xff09; 二、为什么要使用代理 对…

AI修复历史人物 图像转真人 绝密档案

修复李白 开启control 不要点爆炸小按钮 权重建议&#xff1a;0.7-1.2 采样&#xff1a;DPM SDE Karras 如果人眼不好&#xff0c;开启高清修复&#xff0c;进行2次尝试 高难度 修复张居正 softhed 1 lineart_真实 1 适当调整lineart进入值。 如果效果不好&#xff…

CentOS安装MySQL

下载安装MySQL 官网下载MySQL ① 下载&#xff1a;访问链接&#xff1a;MySQL下载 ② 安装&#xff1a;将安装包上传并解压&#xff0c;解压&#xff1a; tar -zxvf mysql-x.x.xx-xxx.tar.gzyum安装MySQL ① 更新yum&#xff1a;sudo yum update ② 下载MySQL的rpm包&#…

【大厂AI课学习笔记】【1.6 人工智能基础知识】(2)机器学习

目录 必须理解的知识点&#xff1a; 举一个草莓的例子&#xff1a; 机器学习的三个类别&#xff1a; 监督学习&#xff1a; 无监督学习&#xff1a; 强化学习&#xff1a; 更多知识背景&#xff1a; 机器学习的诞生需求 监督学习的关键技术与实现步骤 无监督学习的关…

ubuntu篇---ubuntu安装python3.9

ubuntu篇—ubuntu安装python3.9 在ubuntu上安装Python有两种方法:在线安装和源码编译安装。 方法1&#xff1a;使用apt在线安装 1.更新软件包列表并安装必备组件&#xff1a; $ sudo apt update $ sudo apt install software-properties-common2.将Deadsnakes PPA添加到系统…

Keil : Error-Flash Download failed Cortex-M4错误

1.打开魔术棒 2.点击Debug设置 3.查看是否有你使用的板子型号的flash 4.如果没有的话就添加以下

【Python 千题 —— 基础篇】查找年龄

Python 千题持续更新中 …… 脑图地址 👉:⭐https://twilight-fanyi.gitee.io/mind-map/Python千题.html⭐ 题目描述 题目描述 班级中有 Tom、Alan、Bob、Candy、Sandy 五个人,他们组成字典 {Tom: 23, Alan: 24, Bob: 21, Candy: 22, Sandy: 21},字典的键是姓名,字典的…

详细讲解ES6箭头函数语法(附Demo)

目录 前言1. 传统函数2. 箭头函数3. 差异比较彩蛋 前言 讲述箭头函数之前&#xff0c;先了解传统函数的格式&#xff0c;方便做一个对比 1. 传统函数 函数声明&#xff1a; function greet() {console.log("Hello!"); } greet();函数表达式&#xff1a; const s…

Java实现教学资源共享平台 JAVA+Vue+SpringBoot+MySQL

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 数据中心模块2.2 课程档案模块2.3 课程资源模块2.4 课程作业模块2.5 课程评价模块 三、系统设计3.1 用例设计3.2 类图设计3.3 数据库设计3.3.1 课程档案表3.3.2 课程资源表3.3.3 课程作业表3.3.4 课程评价表 四、系统展…

【通讯录案例-偏好设置 Objective-C语言】

一、刚才,我们plist存储,讲完了,这个plist,我直接,右键,打开 打开 不用xcode,我就用文本文档打开,打开方式:其他 选择:文本编辑 打开 好,这个里边儿啊,就是我们刚才存的一个Key:Value 它本质上,是一个xml 这是一种文件的格式, 等你们讲到网络的时候,实际上,…