JAVA对象头的指针压缩

最新推荐文章于 2024-04-06 16:04:36 发布
最新推荐文章于 2024-04-06 16:04:36 发布
阅读量1.3k 收藏 4
点赞数
分类专栏： # JVM JAVA 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43820556/article/details/131067907
版权
JAVA 同时被 2 个专栏收录
56 篇文章 0 订阅
订阅专栏
JVM
6 篇文章 0 订阅
订阅专栏

JAVA对象头的指针压缩

文章目录

对象在JVM中的内存布局

在 Hotspot 虚拟机中,对象的内存布局主要由 3 部分组成：

  1. 对象头（Header）:包含了对象运行时数据Mark Word，Klass Pointer、数组长度（数组对象才会有）。

    • Mark Word：包含对象运行时的信息，包括哈希码、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。
    • 类型指针（Klass Pointer）：即对象指向它的类型元数据的指针。通过直接指针访问对象才需要在对象上存储类型指针，通过句柄访问对象时不需要此指针。Hotspot采用的是直接指针访问对象的方式，所以这类虚拟机中的对象上存储了类型指针。
    • 数组长度：数组对象才会有。
      在这里插入图片描述
      在这里插入图片描述

  2. 实例数据（Instance Data）：对象存储的真正有效数据，即当前类型的字段和父类继承的字段

  3. 对应填充（Padding）：不一定存在，主要用于占位符。虚拟机中任何对象的大小都是8字节的整数倍，如果对象所占空间不是8字节的整数倍，会进行补充对齐。

对象的访问定位

在对象创建之后，JAVA程序会通过JAVA栈上的reference数据来操作堆上的具体对象。对象的访问方式主要由虚拟机自主实现，主流的有两种方式：

  • 通过句柄访问对象

    JAVA堆中会有一块内存作为句柄池，reference中存储的是对象的句柄地址，在句柄中包含了对象的实例数据和对象的类型数据的地址。

    优势：reference中存储的是稳定的句柄地址，在对象发生移动的时候（比如在垃圾回收的时候会移动对象），只改变了句柄中对象实例数据的地址，而reference不需要修改。

    // 访问图解

  • 通过直接直接访问对象

    JAVA堆中的对象实例数据中存储着对象类型数据的地址，reference中存储的是对象的地址。

    优势：访问速度快，在访问对象的时候比句柄方式少一次指针定位的时间开销，由于对象访问比较频繁，那这个节约的开销积累下来就很可观了。

    // 访问图解

压缩实验

实验步骤

  • 使用的是64位OS

  • 引入查看对象头布局的工具

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.17</version>
</dependency>

package org.donny;

import org.openjdk.jol.info.ClassLayout;

/**
 * @author 1792998761@qq.com
 * @description 借助openjdk的jol工具, 查看对象内存的占用情况
 * oop(ordinary object pointer)--对象指针
 * -XX:+UseCompressedOops 默认开启
 * -XX:+UseCompressedClassPointers  默认开启对象头里面的类型指针压缩
 * @date 2023/6/5
 */
public class TestObjectHeader {
    public static void main(String[] args) {

        System.out.println("============Object对象===========");
        ClassLayout layout = ClassLayout.parseInstance(new Object());
        System.out.println(layout.toPrintable());

        System.out.println("============int类型数组对象===========");
        ClassLayout layout1 = ClassLayout.parseInstance(new int[]{});
        System.out.println(layout1.toPrintable());

        System.out.println("============复合类型对象===========");
        ClassLayout layout2 = ClassLayout.parseInstance(new CompositeObjectsTest());
        System.out.println(layout2.toPrintable());
    }

    public static class CompositeObjectsTest {
        //8B mark word
        //4B Klass Pointer   如果关闭压缩-XX:-UseCompressedClassPointers或-XX:-UseCompressedOops，则占用8B
        int id;        //4B
        String name;   //4B  如果关闭压缩-XX:-UseCompressedOops，则占用8B
        byte b;        //1B
        Object o;      //4B  如果关闭压缩-XX:-UseCompressedOops，则占用8B
    }
}

在这里插入图片描述

压缩策略组合

VM的配置项

  • UseCompressedOops：压缩当前对象实例数据中的 Klass Pointer 指针
  • UseCompressedClassPointers：压缩当前对象的对象头中 Klass Pointer 指针

对象指针压缩+对象头的类型指针压缩

JDK1.8之后默认开启这两个压缩

VM options: -XX:+UseCompressedOops -XX:+UseCompressedClassPointers

============Object对象===========
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

============int类型对象===========
[I object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   4        (object header: class)    0xf800016d
 12   4        (array length)            0
 16   0    int [I.<elements>             N/A
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

============复合类型对象===========
org.donny.TestObjectHeader$CompositeObjectsTest object internals:
OFF  SZ               TYPE DESCRIPTION                 VALUE
  0   8                    (object header: mark)       0x0000000000000005 (biasable; age: 0)
  8   4                    (object header: class)      0xf800f161
 12   4                int CompositeObjectsTest.id     0
 16   1               byte CompositeObjectsTest.b      0
 17   3                    (alignment/padding gap)     
 20   4   java.lang.String CompositeObjectsTest.name   null
 24   4   java.lang.Object CompositeObjectsTest.o      null
 28   4                    (object alignment gap)      
Instance size: 32 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total

对象指针不压缩+对象头的类型指针压缩

VM options：-XX:-UseCompressedOops -XX:+UseCompressedClassPointers

============Object对象===========
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   8        (object header: class)    0x0000012a6a481c00
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

============int类型对象===========
[I object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   8        (object header: class)    0x0000012a6a480b68
 16   4        (array length)            0
 20   4        (alignment/padding gap)   
 24   0    int [I.<elements>             N/A
Instance size: 24 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total

============复合类型对象===========
org.donny.TestObjectHeader$CompositeObjectsTest object internals:
OFF  SZ               TYPE DESCRIPTION                 VALUE
  0   8                    (object header: mark)       0x0000000000000005 (biasable; age: 0)
  8   8                    (object header: class)      0x0000012a6aae3210
 16   4                int CompositeObjectsTest.id     0
 20   1               byte CompositeObjectsTest.b      0
 21   3                    (alignment/padding gap)     
 24   8   java.lang.String CompositeObjectsTest.name   null
 32   8   java.lang.Object CompositeObjectsTest.o      null
Instance size: 40 bytes
Space losses: 3 bytes internal + 0 bytes external = 3 bytes total

对象指针压缩+对象头的类型指针不压缩

VM options: -XX:+UseCompressedOops -XX:-UseCompressedClassPointers

============Object对象===========
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   8        (object header: class)    0x000002d380801c00
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

============int类型对象===========
[I object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   8        (object header: class)    0x000002d380800b68
 16   4        (array length)            0
 20   4        (alignment/padding gap)   
 24   0    int [I.<elements>             N/A
Instance size: 24 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total

============复合类型对象===========
org.donny.TestObjectHeader$CompositeObjectsTest object internals:
OFF  SZ               TYPE DESCRIPTION                 VALUE
  0   8                    (object header: mark)       0x0000000000000005 (biasable; age: 0)
  8   8                    (object header: class)      0x000002d380e63210
 16   4                int CompositeObjectsTest.id     0
 20   1               byte CompositeObjectsTest.b      0
 21   3                    (alignment/padding gap)     
 24   4   java.lang.String CompositeObjectsTest.name   null
 28   4   java.lang.Object CompositeObjectsTest.o      null
Instance size: 32 bytes
Space losses: 3 bytes internal + 0 bytes external = 3 bytes total

对象指针不压缩+对象头的类型指针不压缩

VM options: -XX:-UseCompressedOops -XX:-UseCompressedClassPointers

============Object对象===========
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   8        (object header: class)    0x00000234d96d1c00
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

============int类型对象===========
[I object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   8        (object header: class)    0x00000234d96d0b68
 16   4        (array length)            0
 20   4        (alignment/padding gap)   
 24   0    int [I.<elements>             N/A
Instance size: 24 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total

============复合类型对象===========
org.donny.TestObjectHeader$CompositeObjectsTest object internals:
OFF  SZ               TYPE DESCRIPTION                 VALUE
  0   8                    (object header: mark)       0x0000000000000001 (non-biasable; age: 0)
  8   8                    (object header: class)      0x00000234d9d33210
 16   4                int CompositeObjectsTest.id     0
 20   1               byte CompositeObjectsTest.b      0
 21   3                    (alignment/padding gap)     
 24   8   java.lang.String CompositeObjectsTest.name   null
 32   8   java.lang.Object CompositeObjectsTest.o      null
Instance size: 40 bytes
Space losses: 3 bytes internal + 0 bytes external = 3 bytes total

结果集解释

OFF代表offset
SZ代表size
VALUE代表的十六进制的表示值
alignment/padding gap代表不足8字节的整数倍，填充补齐项
类型开启指针压缩不开启指针压缩
Object16字节16字节
int数组16字节24字节
复合对象32字节40字节
压缩内容

可以发现通过指针压缩可以对以下数据进行压缩：

  1. 对象头信息:64位平台下，原生对象头大小为16字节，压缩后为12字节
  2. 对象的引用类型:64位平台下，引用类型本身大小为8字节，压缩后为4字节
  3. 对象数组类型:64位平台下，数组类型本身大小为24字节，压缩后16字节

主要是对象头里面的kclass指针，即指向方法区的类信息的指针，由8字节变为4字节。 还有就是引用类型指针也由8字节变为4字节。

压缩后的影响

压缩后的好处：

  1. 减缓GC的压力: 即每个对象的大小都变小了，就不需要那么频繁的GC了。
  2. 增加CPU缓存的对象指针数量，同时降低CPU缓存的命中率。即CPU缓存本身的大小就小的多，如果采用八字节，CPU能缓存的oop（普通对象指针）肯定比四字节少。
指针压缩的实现

地址总线的根数决定了最大可用内存空间容量。每一个字节（B）的内存空间被视为一个地址单元，整个内存可以看作很多个地址单元组成的数组，每个地址单元有唯一确定的地址来标定，来区分不同的地址单元。地址总线的数量会变化，数据不一定准确可以查询服务器硬件参数确认。

地址总线数目内存上限
32位操作系统32 2 32 2^{32} 232=4GB
64位操作系统36或者46 2 36 2^{36} 236=64GB或者 2 46 2^{46} 246=64TB

一种理解：

当开启指针压缩后，KlassPointer的寻址极限是4 byte × 8 bit=32 bit，即KlassPointer可以存放2^32（=4G）个内存单元地址。

因为每个对象的长度一定是8的整数倍，所以KlassPointer每一数位存放的一定是8的整数倍的地址，即0/8/16/24/32/40/48/64……，也就是4G × 8 = 32G。当分配给JVM的内存空间大于32G时，KlassPointer将无法寻找大于32G的内存地址，因此设置的压缩指针将失效。

第二种理解：

JVM的实现方式是

不再保存所有引用，而是每隔8个字节保存一个引用。例如，原来保存每个引用0、1、2…，现在只保存0、8、16…。因此，指针压缩后，并不是所有引用都保存在堆中，而是以8个字节为间隔保存引用。

在实现上，堆中的引用其实还是按照0x0、0x1、0x2…进行存储。只不过当引用被存入64位的寄存器时，JVM将其左移3位（相当于末尾添加3个0），例如0x0、0x1、0x2…分别被转换为0x0、0x8、0x10。而当从寄存器读出时，JVM又可以右移3位，丢弃末尾的0。（oop在堆中是32位，在寄存器中是35位，2的35次方=32G。也就是说，使用32位，来达到35位oop所能引用的堆内存空间）

JVM内存关键大小

  • 当堆内存小于4G时，不需要启用指针压缩，jvm会直接去除高32位地址
  • 当堆内存大于32G时，压缩指针会失效，会强制使用64位(即8字节)来对java对象寻址， 那这样的话内存占用较大，会增加GC压力等等

参考文章
https://www.cnblogs.com/xiaomaomao/p/17350075.html
https://blog.51cto.com/u_87851/6326662
https://artisan.blog.csdn.net/article/details/106958768
https://blog.csdn.net/lioncatch/article/details/105919666

顧棟
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
10Java对象的内存布局1
08-04
通过压缩，原本64位的对象指针和类型指针被压缩为32位，从而将对象头的大小减少到12字节。这大大减少了内存消耗，尤其是在32GB以下堆内存的场景中。 压缩指针的原理可以类比为停车场的例子：假设每个停车位代表64位...
Java对文件的随机读写以及压缩处理操作
09-03
本文将深入探讨Java如何进行文件的随机读写以及压缩处理。 **一、Java文件的随机读写** Java.io包中的`RandomAccessFile`类是用于进行随机读写操作的关键工具。它允许程序直接跳转到文件的任意位置进行读写，而...
【Java对象】一文读懂 Java 对象庐山真面目及指针压缩
Lorin 洛林的后端技术小站
11-04 342
一个 Java 对象由三部分组成：对象头、实例数据、对齐数据，其中对象头分为 mark word 标记字和 class point 类元数据指针。
Java对象内存模型
weixin_42619556的博客
08-20 247
java对象在内存中包含三部分：对象头、实例数据、对齐填充。
常见面试-JVM-指针压缩
最新发布
LLLIN6699的博客
04-06 1022
了解指针压缩前，首先需要了解（哈希码、GC 分代年龄、锁状态标志等等），即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。其实还有一个对象是数组的情况下，才有这部分数据。对象不是数组，则没有这部分数据，不会为其分配空间。，也是在程序中所定义的各种类型的字段内容。对象里的非静态属性占用的空间（包括父类的所有属性，不区分修饰类型），不包括方法，注意：是非静态属性，属于对象的属性，静态属性是属于类的不在对象上分配空间。
jvm指针压缩
wwzzh1989的博客
01-02 249
jvm指针压缩
【指针压缩】简单聊一聊UseCompressedOops UseCompressedClassPointers这两个JVM参数
z69183787的专栏
09-19 1730
jdk6之后默认开启，jdk7下 xmx小于32g默认开启。 https://docs.oracle.com/javase/7/docs/technotes/guides/vm/performance-enhancements-7.html UseCompressedOops：普通对象指针压缩，oops:ordinary object pointer UseCompressedClassPointers：类指针压缩 这两者有什么作用呢？ 拿新建一个对象来说： Object o = new Ob.
【JUC】Java对象内存布局和对象头
Decade_Faiz的博客
05-22 1196
默认配置：启动了压缩指针，对象头是12个字节，实例数据2个字节，那么这个对象大小就是 12 + 2 + 2(对齐填充) = 16字节。手动配置：关闭了压缩指针，对象头是16个字节，实例数据2个字节，那么这个对象大小就是 16 + 2 + 6(对齐填充) = 24字节。存放类的属性(Field)数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐。对象，对象头16个字节，实例数据5个字节，所以对象头+实例数据=21个字节。都占8个字节，所以对象头的大小为16个字节。
JDK1.6对synchronized锁的优化
自律使我自由
07-03 2217
在JDK1.6之前synchronized关键属于一种重量级的锁，性能能略显不足，从JDK1.6开始对synchronized做了一些优化，感觉主要就是针对到底要不要加锁，加什么锁做了一些判断，下面一起来看一下吧。 1、锁消除 最大程度的优化就是没有锁，那么如何判断能不能消除synchronized呢？在编译期间有一种优化叫做逃逸分析。 如果证明一个对象不会逃逸到方法外或者线程外，则可针对此变量进行优化，JVM判断对象是否逃逸的依据有： 1、对象被赋值给堆中对象的字段和类的静态变量。 2、对象被传进了不确定
深入理解java对象，包括对象创建和内存分配
01-13
描述对象的创建过程，对象的内存布局，jvm指针压缩，对象访问
Java 对象(数组)占多大空间(几个字节) 手把手做实验
12-21
废话不多说，一起开干 1 前置知识 本次实验基于jdk8 64位以及以上版本。本机环境为jdk11 先查看一下jvm启动的默认参数，里面有...UseCompressedOops：普通对象指针压缩（oop是ordinary object pointer的缩写), UseComp
Jvm对象内存分配理解
11-24
指针压缩可以将 64 位的指针压缩到 32 位，从而减少内存的占用。但是，堆内存小于 4g 时，不需要启动指针压缩，Jvm 会直接去除高额 32 位地址，即使用低虚拟机地址空间。堆内存大于 32g 时，压缩指针会失效，会强制...
JVM OOP-Klass体系吐血总结
qq_40622253的博客
09-06 797
学JVM的时候，一直对OOP-Klass体系不是很理解，在这里总结了一下，望大家指正 前言 HotSpot是基于c++实现，而c++是一门面向对象的语言，本身具备面向对象基本特征，所以Java中的对象表示，最简单的做法是为每个Java类生成一个c++类与之对应。但HotSpot JVM并没有这么做，而是设计了一个OOP-Klass Model 这里的 OOP 指的是 Ordinary Object Pointer （普通对象指针），它用来表示对象的实例信息，看起来像个指针，实际上是藏在指针里的对象（是.
七、JVM内存分配机制超详细解析
weixin_40181736的博客
08-01 1835
那么什么是逃逸分析呢？要知道逃逸分析，先要知道什么是逃逸？我们来看一个例子user.setName("张三");}user.setName("李四");}}Test类里面有两个方法，test1()方法user对象，并且返回了user，返回回去的对象肯定是要被外部使用的。这种情况就是user对象的逃逸出了test1()方法。而test2（）方法也是构建了user对象，但是这个对象仅仅是在test2()方法的内部有效，不会再方法外部使用，这种就是user对象没有逃逸。标量替换。...
java 压缩指针原理
qq_31514235的博客
10-27 465
说明：此文件只是笔记供以后参考，有需要的随便瞅瞅。 为什么64位的jdk内存不建议超过32G？ 因为内存在32G一下，jdk会开启指针压缩，减少内存空间占用。 何为指针压缩，先来说一下内存,为何32位的内存只有4G？ 如果按照常规计算 2的32次方算出来的只有512M，其实 机器内存是通过一个个小格子来存储的，一个小格子为1bit（位）,但是它把8个小格子即8bit（1byte）作为寻址地址的最小单位，所以 2的32次方 即 2的32次方的byte 然后 乘 8bit，即得出4G的内存。 jav
java对象指针压缩
qq_41473090的博客
03-12 652
java对象指针压缩 对于64位的JVM，开启压缩指针优化后，64位的CPU寄存器只需要使用其中的32位进行内存寻址，就可以访问到最多32G的堆内存，这是怎么做到的？32位寻址不是只能访问到最多4G的内存吗？ 做法：CPU将32位的值进行左移3位，变成35位，利用这35位进行寻址，由2的35次方可知确实能访问到最多32G的堆内存。 若32位的值为0x00000000，左移后变成了0x00000...
一文带你解锁什么是指针压缩
weixin_42258418的博客
06-16 405
指针压缩，了解过jvm的都知道，可以节约内存，8bit对齐，在32位下可以放32g，那么它到底怎么实现的呢？ class oopDesc { friend class VMStructs; public: //这个就是我们熟知的对象头 volatile markOop _mark; //这个联合体就是指针压缩的关键 union _metadata { //关闭指针压缩时 klass pointer采用的是_klass 指针占 8b Klass* _klass; //开
JVM之压缩指针——Compressed oops
热门推荐
赶路人儿
06-14 1万+
1、32位 vs. 64位 32位与64位的对比是在2000年以后兴起的。然而64位CPU早就在超级计算机领域中得到应用了，只是最近几年64位CPU才在PC上成为主流配置。从32位到64位的转变，绝对不是一件简单的工作，因为几乎所有的东西，从硬件到操作系统都必须要发生改变。Java也是在这个改革的趋势中引入了64位的虚拟机。 在32位到64位的转变中，人们最大的...
java压缩对象_Java 对象指针压缩
weixin_33044131的博客
02-21 225
很久之前就看到过 Java 对象指针压缩这个技术，只是一直没具体想为什么要偏移 3 位，好吧，最近才知道原因是因为大多数 JVM 实现都是采用 8 位对齐，所以二进制位中的后三位都是 0。Let’s talk a bit about Ordinary Object Pointers (OOPs) and Compressed OOPs (Coops). OOPs are the handles/p...
java字符串压缩变短
09-10
在Java中，可以使用压缩算法对字符串进行压缩以减少其长度。常见的压缩算法包括Gzip、Deflate和Bzip2等。通过对字符串进行压缩，可以减少字符串占用的内存空间，并在网络传输或存储时节省带宽和存储空间。压缩字符串的方法可以是通过统计连续出现的相同字符的次数来实现。首先，定义两个指针i和j，其中i指向字符串的首个字符，j向前遍历直到访问到不同的字符时停止。此时，j - i便是首个字符的连续出现次数。然后，从下个字符开始，重复以上操作，直到遍历完成。最后，将字符以及出现的次数添加到新的字符串对象中。将压缩后的字符串与原始字符串进行比较，返回长度较短的那个。在Java中，可以使用StringBuilder来创建新的字符串对象，使用charAt()方法获取字符串中的字符，通过append()方法将字符和出现次数添加到新的字符串中。最终，通过调用toString()方法将StringBuilder对象转换为字符串。例如： ```java public String compressString(String S) { int i = 0, j = 0, ls = S.length(); StringBuilder res = new StringBuilder(); while (i < ls) { while (j < ls && S.charAt(i) == S.charAt(j)) { j++; } res.append(S.charAt(i)).append(j - i); i = j; } return res.length() < ls ? res.toString() : S; } ``` 以上是一个示例代码，可以通过调用compressString()方法来对字符串进行压缩。其中，参数S是待压缩的字符串，返回值是压缩后的字符串。在这个示例中，我们使用Gzip压缩算法对字符串进行压缩，得到压缩后的字节数组。然后，我们输出压缩前后的字符串长度，以便比较压缩效果。最后，我们使用Gzip压缩算法对压缩后的字节数组进行解压缩，得到解压缩后的字符串，并检查解压缩后的字符串是否与原始字符串一致。通过对字符串进行压缩，可以将字符串的长度变短。<span class="em">1</span><span class="em">2</span><span class="em">3</span>

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

顧棟

若对你有帮助，望对作者鼓励一下

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值