哈希表--想彻底了解哈希表,看这一篇文章就可以了

为了一次存储便能得到所查记录，在记录的存储位置和它的关键字之间建立一个确定的对应关系H，已H（key)作为关键字为key的记录在表中的位置，这个对应关系H为哈希（Hash）函数， 按这个思路建立的表为哈希表。

哈希表也叫散列表。从根本上来说，一个哈希表包含一个数组，通过特殊的关键码(也就是key)来访问数组中的元素。

哈希表的主要思想：
（1）存放Value的时候，通过一个哈希函数，通过关键码（key）进行哈希运算得到哈希值，然后得到映射的位置， 去寻找存放值的地方 ，

（2）读取Value的时候，也是通过同一个哈希函数，通过关键码（key）进行哈希运算得到哈希值，然后得到 映射的位置，从那个位置去读取。

哈希函数

哈希表的组成取决于哈希算法，也就是哈希函数的构成。哈希函数计算过程会将键转化为数组的索引。

一个好的哈希函数至少具有两个特征：
（1）计算要足够快；
（2）最小化碰撞，即输出的哈希值尽可能不会重复。

那接下来我们就来看下几个常见的哈希函数：

直接定址法

  • 取关键字或关键字的某个线性函数值为散列地址。
  • 即 f(key) = key 或 f(key) = a*key + b，其中a和b为常数。

除留余数法

将整数散列最常用方法是除留余数法。除留余数法的算法实用得最多。

我们选择大小为m的数组，对于任意正整数k，计算k除以m的余数，即f(key)=k%m,f(key)<m。这个函数的计算非常容易（在Java中为k% M）并能够有效地将键散布在0到M-1的范围内。

数字分析法

  • 当关键字的位数大于地址的位数，对关键字的各位分布进行分析，选出分布均匀的任意几位作为散列地址。
  • 仅适用于所有关键字都已知的情况下，根据实际应用确定要选取的部分，尽量避免发生冲突。

平方取中法

  • 先计算出关键字值的平方，然后取平方值中间几位作为散列地址。
  • 随机分布的关键字，得到的散列地址也是随机分布的。

随机数法

  • 选择一个随机函数，把关键字的随机函数值作为它的哈希值。
  • 通常当关键字的长度不等时用这种方法。

每种数据类型都需要相应的散列函数.

例如，Interge的哈希函数就是直接获取它的值：

public static int hashCode(int value) {
    return value;
}

对于字符串类型则是使用了s[0]*31^(n-1) + s[1]*31^(n-2) + … + s[n-1]的算法：

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        hash = h = isLatin1() ? StringLatin1.hashCode(value)
                              : StringUTF16.hashCode(value);
    }
    return h;
}

public static int hashCode(byte[] value) {
    int h = 0;
    for (byte v : value) {
        h = 31 * h + (v & 0xff);
    }
    return h;
}
public static int hashCode(byte[] value) {
    int h = 0;
    int length = value.length >> 1;
    for (int i = 0; i < length; i++) {
        h = 31 * h + getChar(value, i);
    }
    return h;
}

double类型则是使用位运算的方式进行哈希计算:

public int hashCode() {
    long bits = doubleToLongBits(value);
    return (int)(bits ^ (bits >>> 32));
}
public static long doubleToLongBits(double value) {
    long result = doubleToRawLongBits(value);
    if ( ((result & DoubleConsts.EXP_BIT_MASK) == DoubleConsts.EXP_BIT_MASK)
    &&
   (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
        result = 0x7ff8000000000000L;
    return result;
}

于是Java让所有数据类型都继承了超类Object类，并实现hashCode()方法。接下来我们看下Object.hashcode方法。Object类中的hashcode方法是一个native方法。

 public native int hashCode();

hashCode 方法的实现依赖于jvm，不同的jvm有不同的实现，我们看下主流的hotspot虚拟机的实现。hotspot 定hashCode方法在src/share/vm/prims/jvm.cpp中，源码如下：

JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
  JVMWrapper("JVM_IHashCode");
  return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;
JVM_END

接下来我们看下ObjectSynchronizer::FastHashCode 方法是如何返回hashcode的，ObjectSynchronizer::FastHashCode 在synchronized.hpp文件中，

intptr_t ObjectSynchronizer::identity_hash_value_for(Handle obj) {
  return FastHashCode (Thread::current(), obj()) ;
}

intptr_t ObjectSynchronizer::FastHashCode (Thread * Self, oop obj) {
  if (UseBiasedLocking) {
   
    if (obj->mark()->has_bias_pattern()) {
      // Box and unbox the raw reference just in case we cause a STW safepoint.
      Handle hobj (Self, obj) ;
      // Relaxing assertion for bug 6320749.
      assert (Universe::verify_in_progress() ||
              !SafepointSynchronize::is_at_safepoint(),
             "biases should not be seen by VM thread here");
      BiasedLocking::revoke_and_rebias(hobj, false, JavaThread::current());
      obj = hobj() ;
      assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
    }
  }


  ObjectMonitor* monitor = NULL;
  markOop temp, test;
  intptr_t hash;
  // 获取调用hashCode（) 方法的对象的对象头中的mark word 
  markOop mark = ReadStableMark (obj);

  // object should remain ineligible for biased locking
  assert (!mark->has_bias_pattern(), "invariant") ;

  if (mark->is_neutral()) {  //普通对象
    hash = mark->hash();              // this is a normal header
    //如果mark word 中已经保存哈希值，那么就直接返回该哈希值
    if (hash) {                       // if it has hash, just return it
      return hash;
    }
    // 如果mark word 中还不存在哈希值，那就调用get_next_hash(Self, obj)方法计算该对象的哈希值
    hash = get_next_hash(Self, obj);  // allocate a new hash code
   // 将计算的哈希值CAS保存到对象头的mark word中对应的bit位，成功则返回，失败的话可能有几下几种情形：
   //(1)、其他线程也在install the hash并且先于当前线程成功，进入下一轮while获取哈希即可
   //（2）、有可能当前对象作为监视器升级成了轻量级锁或重量级锁，进入下一轮while走其他case；
    temp = mark->copy_set_hash(hash); // merge the hash code into header
    // use (machine word version) atomic operation to install the hash
    test = (markOop) Atomic::cmpxchg_ptr(temp, obj->mark_addr(), mark);
    if (test == mark) {
      return hash;
    }
    // If atomic operation failed, we must inflate the header
    // into heavy weight monitor. We could add more code here
    // for fast path, but it does not worth the complexity.
  } else if (mark->has_monitor()) { //重量级锁
  // 果对象是一个重量级锁monitor，那对象头中的mark word保存的是指向ObjectMonitor的指针，
  //此时对象非加锁状态下的mark word保存在ObjectMonitor中，到ObjectMonitor中去拿对象的默认哈希值：
    monitor = mark->monitor();
    temp = monitor->header();
    assert (temp->is_neutral(), "invariant") ;
    hash = temp->hash();
  //(1)如果已经有默认哈希值，则直接返回；
    if (hash) {
      return hash;
    }
    // Skip to the following code to reduce code size
  } else if (Self->is_lock_owned((address)mark->locker())) {  //轻量级锁锁
  //如果对象是轻量级锁状态并且当前线程持有锁，那就从当前线程栈中取出mark word：
 
    temp = mark->displaced_mark_helper(); // this is a lightweight monitor owned
    assert (temp->is_neutral(), "invariant") ;
    hash = temp->hash();              // by current thread, check if the displaced
     //（1）如果已经有默认哈希值，则直接返回；
    if (hash) {                       // header contains hash code
      return hash;
    }
   
  }

  // Inflate the monitor to set hash code
  monitor = ObjectSynchronizer::inflate(Self, obj);
  // Load displaced header and check it has hash code
  mark = monitor->header();
  assert (mark->is_neutral(), "invariant") ;
  hash = mark->hash();
  //计算默认哈希值并保存到mark word中后再返回
  if (hash == 0) {
    hash = get_next_hash(Self, obj);
    temp = mark->copy_set_hash(hash); // merge hash code into header
    assert (temp->is_neutral(), "invariant") ;
    test = (markOop) Atomic::cmpxchg_ptr(temp, monitor, mark);
    if (test != mark) {
     
      hash = test->hash();
      assert (test->is_neutral(), "invariant") ;
      assert (hash != 0, "Trivial unexpected object/monitor header usage.");
    }
  }
  // We finally get the hash
  return hash;
}

关于对象头、java内置锁的内容请阅读《高并发核心编程：卷2》。

ObjectSynchronizer :: FastHashCode（）也是通过调用identity_hash_value_for方法返回值的. 调用了get_next_hash()方法生成hash值，源码如下：

static inline intptr_t get_next_hash(Thread * Self, oop obj) {
  intptr_t value = 0 ;
  if (hashCode == 0) { //随机数 openjdk6、openjdk7 采用的是这种方式
     // This form uses an unguarded global Park-Miller RNG,
     // so it's possible for two threads to race and generate the same RNG.
     // On MP system we'll have lots of RW access to a global, so the
     // mechanism induces lots of coherency traffic.
     value = os::random() ;
  } else
  if (hashCode == 1) { //基于对象内存地址的函数
     // This variation has the property of being stable (idempotent)
     // between STW operations.  This can be useful in some of the 1-0
     // synchronization schemes.
     intptr_t addrBits = cast_from_oop<intptr_t>(obj) >> 3 ;
     value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom ;
  } else
  if (hashCode == 2) { //恒等于1（用于敏感性测试）
     value = 1 ;            // for sensitivity testing
  } else
  if (hashCode == 3) { //自增序列
     value = ++GVars.hcSequence ;
  } else
  if (hashCode == 4) {  //将对象的内存地址强转为int
     value = cast_from_oop<intptr_t>(obj) ;
  } else { 
    //生成hash值的方式六： Marsaglia's xor-shift scheme with thread-specific state
  //（基于线程具体状态的Marsaglias的异或移位方案） openjdk8之后采用的就是这种方式
     // Marsaglia's xor-shift scheme with thread-specific state
     // This is probably the best overall implementation -- we'll
     // likely make this the default in future releases.
     unsigned t = Self->_hashStateX ;
     t ^= (t << 11) ;
     Self->_hashStateX = Self->_hashStateY ;
     Self->_hashStateY = Self->_hashStateZ ;
     Self->_hashStateZ = Self->_hashStateW ;
     unsigned v = Self->_hashStateW ;
     v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ;
     Self->_hashStateW = v ;
     value = v ;
  }

  value &= markOopDesc::hash_mask;
  if (value == 0) value = 0xBAD ;
  assert (value != markOopDesc::no_hash, "invariant") ;
  TEVENT (hashCode: GENERATE) ;
  return value;
}

到底用的哪一种计算方式，和参数hashCode有关系，在src/share/vm/runtime/globals.hpp中配置了默认：
openjdk6：

  product(intx, hashCode, 0,                                       \
  "(Unstable) select hashCode generation algorithm")                \

openkjdk8:

  product(intx, hashCode, 5,                                       \
  "(Unstable) select hashCode generation algorithm")                \

也可以通过虚拟机启动参数-XX:hashCode=n来做修改。

到这里你知道hash值是如何生成的了吧。

哈希表因为其本身结构使得查找对应的值变得方便快捷，但是也带来了一些问题，问题就是无论使用哪种方式生成hash值，总有产生相同值的时候。接下来我们就来看下如何解决hash值相同的问题。

hash 碰撞（哈希冲突）

对于两个不同的数据元素通过相同哈希函数计算出来相同的哈希地址（即两不同元素通过哈希函数取模得到了同样的模值），这种现象称为哈希冲突或哈希碰撞。

一般来说，哈希冲突是无法避免的。如果要完全避免的话，那么就只能一个字典对应一个值的地址，这样一来， 空间就会增大，甚至内存溢出。减少哈希冲突的原因是Hash碰撞的概率就越小，map的存取效率就会越高。 常见的哈希冲突的解决方法有开放地址法和链地址法：

开放地址法

开放地址法又叫开放寻址法、开放定址法，当冲突发生时，使用某种探测算法在散列表中寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到。开放地址法需要的表长度要大于等于所需要存放的元素。

按照探测序列的方法，可以细分为线性探查法、平法探查法、双哈希函数探查法等。

这里为了更好的展示三种方法的效果，我们用例子来看看：设关键词序列为{47,7,29,11,9,84,54,20,30}，哈希表长度为13,装载因子=9/13=0.69,哈希函数为f(key)=key%p=key%11

关键词（key）4772911984542030
散列地址k（key）3770971098

（1）线性探测法

当我们的所需要存放值的位置被占了，我们就往后面一直加1并对m取模直到存在一个空余的地址供我们存放值，取模是为了保证找到的位置在0~m-1的有效空间之中。

公式：fi=(f(key)+i) ％ m ，0 ≤ i ≤ m-1i会逐渐递增加1）

具体做法： 探查时从地址d开始，首先探查T[d],然后依次探查T[d+1]…直到T[m-1],然后又循环到T[0]、T[1],…直到探查到有空余的地址或者直到T[d-1]为止。

用线性探测法处理冲突得到的哈希表如下

缺点：需要不断处理冲突，无论是存入还是査找效率都会大大降低。

（2）平方探查法

当我们的所需要存放值的位置被占了，会前后寻找而不是单独方向的寻找。

公式：fi=(f(key)+di) ％ m，0 ≤ i ≤ m-1

具体操作：探查时从地址 d 开始，首先探查 T[d]，然后依次探查 T[d+di]，di 为增量序列12、-12，22、-22， ……，q2、-q2 且q≤1/2 (m-1) ,直到探查到 有空余地址或者到 T[d-1]为止。

用平方探查法处理冲突得到的哈希表如下
在这里插入图片描述

（3）双哈希函数探查法
公式：fi=(f(key)+i*g(key)) % m (i=1，2，……，m-1)
其中f（key） 和g（key） 是两个不同的哈希函数，m为哈希表的长度。

具体步骤：
双哈希函数探测法，先用第一个函数f(key)对关键码计算哈希地址，一旦产生地址冲突，再用第二个函数 g(key)确定移动的步长因子，最后通过步长因子序列由探测函数寻找空的哈希地址。

开发地址法，通过持续的探测，最终找到空的位置。为了解决这个问题，引入了链地址法。

链地址法

在哈希表每一个单元中设置链表，某个数据项对的关键字还是像通常一样映射到哈希表的单元中，而数据项本身插入到单元的链表中.

链地址法简单理解如下：
在这里插入图片描述

来一个相同的数据，就将它插入到单元对应的链表中，在来一个相同的，继续给链表中插入。

链地址法解决哈希冲突的例子如下：
（1）采用除留余数法构造哈希函数，而 冲突解决的方法为 链地址法。
（2）具体的关键字列表为（19,14,23,01,68,20,84,27,55,11,10,79），则哈希函数为f（key）=key MOD 13。则采用除留余数法和链地址法后得到的预想结果应该为：
在这里插入图片描述

哈希造表完成后，进行查找时，首先是根据哈希函数找到关键字的位置链，然后在该链中进行搜索，如果存在和关键字值相同的值，则查找成功，否则若到链表尾部仍未找到，则该关键字不存在。

哈希表作为一个非常常用的查找数据结构，它能够在O(1)的时间复杂度下进行数据查找,时间主要花在计算hash值上。在Java中，典型的Hash数据结构的类是HashMap。

然而也有一些极端的情况，最坏的就是hash值全都映射在同一个地址上，这样哈希表就会退化成链表，例如下面的图片：
在这里插入图片描述

当hash表变成图2的情况时，查找元素的时间复杂度会变为O(n)，效率瞬间低下，

所以，设计一个好的哈希表尤其重要，如HashMap在jdk1.8后引入的红黑树结构就很好的解决了这种情况。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

创建可引导的 macOS 安装器（可启动U盘）

创建可引导的 macOS 安装器（可启动U盘）

Apple官网下载的macOS镜像&#xff0c;只是一个安装包&#xff0c;不带引导不能直接安装到空白mac机器的。 1、首先&#xff0c;你必须要有台能正常运行macOS的mac pc。 2、下载macOS Sierra 10.12 El Capitan 10.11 Yosemite 10.10 Mountain Lion 10.8 Lion 10.7 点按以…
阅读更多...
Ada Tutorial（2）SPARK Examiner + SPARK Prover

Ada Tutorial（2）SPARK Examiner + SPARK Prover

文章目录 代码 Task1.adb代码 task3.adbtask4.adb 在Ada和SPARK中&#xff0c;SPARK_Mode是一个编译指示&#xff0c;它表示随后的代码将使用SPARK语言规则进行编译和分析。 在with SPARK_Mode > On的影响下&#xff0c;编译器会在编译过程中应用SPARK语言规则&#xff0c;它…
阅读更多...
C语言之数组详解（1）（更新前面数组博客的不足）

C语言之数组详解（1）（更新前面数组博客的不足）

目录 一、一维数组 1.一维数组的创建和初始化 (1).数组的创建 (2).数组的初始化 2.一维数组的使用 3.一维数组在内存中的存储 二、二维数组 1.二维数组的创建和初始化 (1).二维数组的创建 (2).二维数组的初始化 2.二维数组的使用 3.二维数组在内存中的存储 三、数组作为函数参…
阅读更多...
微软发布自己的 Linux 发行版：Azure Linux

微软发布自己的 Linux 发行版：Azure Linux

导读在内部使用两年并自 2022 年 10 月起以公共预览版运行后&#xff0c;微软终于在日前正式公开发布了其 Azure Linux 的发行版。 在内部使用两年并自 2022 年 10 月起以公共预览版运行后&#xff0c;微软终于在日前正式公开发布了其 Azure Linux 的发行版。 微软 Azure Lin…
阅读更多...
DSDP140B 57160001-ACX

DSDP140B 57160001-ACX

​ DSDP140B 57160001-ACX DSDP140B 57160001-ACX 单相漏电保护器可以接在三相四线制电路中使用 单相漏电维护器不可以接在三相四线制电路中使用。术有专攻&#xff0c;单相漏电开关在漏电维护器内部装置的零序电流互感器检测的是一根相线&#xff08;前方&#xff09;和一…
阅读更多...
完型填空技巧

完型填空技巧

完形中分值最高的是逻辑关系题&#xff0c;逻辑关系分为两种&#xff0c;一种是选项就是逻辑关系的&#xff0c;例: Given the advantages of electronic money, you might thinkthat we would move quickly to the cashless society in which allpayments are made electronic…
阅读更多...
【C++】红黑树的模拟实现

【C++】红黑树的模拟实现

文章目录 一、红黑树的概念二、红黑树的性质三、红黑树节点的定义四、红黑树结构五、红黑树的插入操作六、红黑树的调整1.叔叔存在且为红2.叔叔不存在或者存在且为黑3.插入完整代码4.总结 七、红黑树的验证八、红黑树的删除九、红黑树与AVL树的比较十、红黑树的应用十一、红黑树…
阅读更多...
LVS+Keepalived 高可用群集实战部署

LVS+Keepalived 高可用群集实战部署

LVSKeepalived 高可用群集实战部署 一、LVSKeepalived 高可用群集1.LVS2、Keepalived工作原理和作用3、Keepalived体系主要模块及其作用4、Keepalived实现原理剖析5、VRRP &#xff08;虚拟路由冗余协议&#xff09; LVSKeepalived 高可用群集部署&#xff08;抢占模式&#xf…
阅读更多...
[nlp] OPT与GPT-2的差异

[nlp] OPT与GPT-2的差异

Meta AI 开源1750亿参数大模型- OPT，FlagAI一键调用！ - 知乎简介Meta AI 开源 OPT系列模型，其中最大模型1750 亿参数（需申请访问权限）媲美 GPT-3。OPT系列模型包括了多组不同参数规模的模型权重，如图： OPT开源了一系列大模型，但是实际调用这些模型有很高的技术门槛。为…
阅读更多...
PortSwigger web缓存中毒（Cache Poisoning）

PortSwigger web缓存中毒（Cache Poisoning）

一、什么web缓存中毒&#xff1f; Web缓存中毒&#xff08;Web Cache Poisoning&#xff09;是一种攻击技术&#xff0c;攻击者通过操纵Web应用程序的缓存系统&#xff0c;将恶意或欺骗性内容注入到合法的缓存中&#xff0c;以欺骗用户或绕过安全控制。 Web缓存中毒的原理是利用…
阅读更多...
scala

scala

面向对象 Scala 的面向对象思想和Java 的面向对象思想和概念是一致的。 Scala 中语法和 Java 不同&#xff0c;补充了更多的功能。 6.1类和对象详解 6.1.1组成结构 构造函数: 在创建对象的时候给属性赋值 成员变量: 成员方法(函数) 局部变量 代码块 6.1.2构造器 每个…
阅读更多...
【宝塔建站】Ubuntu下使用宝塔面板一键搭建Z-Blog个人博客

【宝塔建站】Ubuntu下使用宝塔面板一键搭建Z-Blog个人博客

文章目录 1.前言2.网站搭建2.1. 网页下载和安装2.2.网页测试2.3.cpolar的安装和注册 3.本地网页发布3.1.Cpolar临时数据隧道3.2.Cpolar稳定隧道&#xff08;云端设置&#xff09;3.3.Cpolar稳定隧道&#xff08;本地设置&#xff09; 4.公网访问测试5.结语 1.前言 Ubuntu系统作…
阅读更多...
【深度学习】pytorch pth模型转为onnx模型后出现冗余节点“identity”，onnx模型的冗余节点“identity”

【深度学习】pytorch pth模型转为onnx模型后出现冗余节点“identity”，onnx模型的冗余节点“identity”

情況描述 onnx模型的冗余节点“identity”如下图。 解决方式 首先&#xff0c;确保您已经安装了onnx-simplifier库&#xff1a; pip install onnx-simplifier然后&#xff0c;您可以按照以下方式使用onnx-simplifier库&#xff1a; import onnx from onnxsim import simp…
阅读更多...
STM32F407软件模拟I2C实现MPU6050通讯（CUBEIDE）

STM32F407软件模拟I2C实现MPU6050通讯（CUBEIDE）

STM32F407软件模拟I2C实现MPU6050通讯&#xff08;CUBEIDE&#xff09; 文章目录 STM32F407软件模拟I2C实现MPU6050通讯&#xff08;CUBEIDE&#xff09;模拟I2C读写的实现mpu6050_iic.cmpu6050_iic.h代码分析 复位&#xff0c;读取温度&#xff0c;角度等函数封装mpu6050.cmpu…
阅读更多...
QT学习07：五种按钮控件

QT学习07：五种按钮控件

文章首发于我的个人博客&#xff1a;欢迎大佬们来逛逛 文章目录 抽象类&#xff1a;QAbstractButtonQPushButtonQToolButtonQCommandLinkButtonQRadioButtonQCheckBoxQButtonGroup 抽象类&#xff1a;QAbstractButton 是所有按钮类的祖先。 QAbstractButton的信号&#xff1a…
阅读更多...
深入理解CSS字符转义行为

深入理解CSS字符转义行为

深入理解CSS字符转义行为 深入理解CSS字符转义行为 前言为什么要转义&#xff1f;CSS 转义什么是合法css的表达式 左半部分右半部分 练习参考链接 前言 在日常的开发中&#xff0c;我们经常写css。比如常见的按钮: <button class"btn"></button>&am…
阅读更多...
【MySQL】 IS NOT NULL 和 != NULL 的区别？

【MySQL】 IS NOT NULL 和 != NULL 的区别？

背景 最近在开发小伙伴的需求&#xff0c;遇到了一个数据库统计的问题&#xff0c; is not null 结果正确 &#xff01;null 结果就不对&#xff0c;然后就激发了获取真理的想法&#xff0c;那必须的查查 咋回事嘞&#xff1f; 开整 在用MySQL的过程中&#xff0c;你是否存…
阅读更多...
大学物理（上）-期末知识点结合习题复习（4）——质点运动学-动能定理 力做功 保守力与非保守力 势能 机械能守恒定律 完全弹性碰撞

大学物理（上）-期末知识点结合习题复习（4）——质点运动学-动能定理 力做功 保守力与非保守力 势能 机械能守恒定律 完全弹性碰撞

目录 1.力做功 恒力作用下的功 变力的功 2.动能定理 3.保守力与非保守力 4.势能 引力的功与弹力的功 引力势能与弹性势能 5.保守力做功与势能的关系 6.机械能守恒定律 7.完全弹性碰撞 题1 题目描述 题解 题2 题目描述 题解 1.力做功 物体在力作用下移动做功…
阅读更多...
AWS CodeWhisperer 简单介绍

AWS CodeWhisperer 简单介绍

一、何为AWS CodeWhisperer Amazon CodeWhisperer能够理解以自然语言&#xff08;英语&#xff09;编写的注释&#xff0c;并能实时生成多条代码建议&#xff0c; 以此提高开发人员生产力。 二、主要功能 Amazon CodeWhisperer 的主要功能&#xff0c;包括代码生成、引用追踪…
阅读更多...
36.SpringBoot实用篇—运维

36.SpringBoot实用篇—运维

目录 一、实用篇—运维。 &#xff08;1&#xff09;程序打包与运行&#xff08;Windows版&#xff09;。 &#xff08;2&#xff09;spring-boot-maven-plugin插件作用。 &#xff08;3&#xff09;程序打包与运行&#xff08;Linux版&#xff09;。 &#xff08;4&#…
阅读更多...
最新文章

Copyright @ 2022~2023