Java基础之基本数据类型封装类的缓存

已于 2022-03-28 12:04:34 修改
阅读量952 收藏 2
点赞数
文章标签： java
于 2022-03-28 11:27:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hnjcxy/article/details/123787209
版权

1、Java中基本数据类型byte、short、char、int、long、float、double、boolean有对应的封装类型：Byte、Short、Character、Integer、long、Float、Double，Boolean其中Byte、Short、Character、Integer、Long、Boolean都实现了常量池缓存。Byte、Short、Character、Integer、Long通过静态内部Cache类来实现一定范围（下面列出缓存范围）内的数据缓存，而Boolean通过两个静态常量TRUE、FALSE来实现数据缓存。

  • Byte类缓存范围：[-128,127] 共256个值。
  • Short类缓存范围：[-128,127] 共256个值。
  • Character类缓存范围：[0,127] 共128个值。
  • Integer类默认缓存范围：[-128,127] 共256个值，可以通过修改VM参数-XX:AutoBoxCacheMax=200 即可修改缓存上限到200
  • Long类缓存范围：[-128,127] 共256个值。
  • Boolean类就缓存两个值：true、false。
2、装箱和拆箱过程：
装箱：调用封装类 valueOf(x) 方法；
拆箱：调用封装类的 xxValue() 方法。

3、测试
测试前说明：
==对于基本数据类型和对象的比较含义是不同的。对于基本数据类型：“==” 比较的是基本数据类型的数值；对于对象：“==” 比较的是对象在内存中的内存地址。
byte、short、char类型计算后会自动转成整型类型int。

（1）Byte


    static void testByte(){
        System.out.println("Byte类型：");
        Byte i1 = 127;
        Byte i2 = 127;
        Byte i3 = 0;
        Byte i4 = new Byte("127");
        Byte i5 = new Byte("127");
        Byte i6 = new Byte("0");

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为数值在[-128,127]的范围内，使用常量池缓存中的127

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池Byte对象127，i4指向堆中Byte对象127

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型byte做加法运算，
        //计算结果是整型的127，所以最终是基本数据类型的值作比较;（byte、short、char类型计算后会自动转成整型类型int）
        System.out.println("127=i5+i6 " + (127 == i5 + i6)); //true
        System.out.println("byte计算后，转换类型为："+ myGetType(i5 + i6));  // int

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型byte做加法运算，计算结果是整型的127；
        // i1与基本数据类型127比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); //true

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型byte做加法运算，计算结果是整型的127；
        // i4与基本数据类型127比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); //true

        /* Byte类中有缓存静态内部类ByteCache；缓存范围：-128~127，共256（cache.length）个值
        private static class ByteCache {
            private ByteCache(){}

            static final Byte cache[] = new Byte[-(-128) + 127 + 1];

            static {
                for(int i = 0; i < cache.length; i++)
                    cache[i] = new Byte((byte)(i - 128));
            }
        }
         */
    }

（2）Short


    static void testShort(){
        System.out.println("Short类型：");
        Short i1 = 127;
        Short i2 = 127;
        Short i3 = 0;
        Short i4 = new Short("127");
        Short i5 = new Short("127");
        Short i6 = new Short("0");
        Short i1New = 128;
        Short i2New = 128;

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为数值在[-128,127]的范围内，使用常量池缓存中的127

        System.out.println("i1New=i2New " + (i1New == i2New));  //false 超过缓存范围，创建新对象了

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池对象127，i4指向堆中对象127

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型short做加法运算，
        //计算结果是整型的127，所以最终是基本数据类型的值作比较;（byte、short、char类型计算后会自动转成整型类型int）
        System.out.println("127=i5+i6 " + (127 == i5 + i6)); //true
        System.out.println("short计算后，转换类型为："+ myGetType(i5 + i6));  // int

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型short做加法运算，计算结果是整型的127；
        // i1与基本数据类型127比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); //true

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型short做加法运算，计算结果是整型的127；
        // i4与基本数据类型127比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); //true

        /* Short类中有缓存静态内部类ShortCache；缓存范围：-128~127，共256（cache.length）个值
        private static class ShortCache {
            private ShortCache(){}

            static final Short cache[] = new Short[-(-128) + 127 + 1];

            static {
                for(int i = 0; i < cache.length; i++)
                    cache[i] = new Short((short)(i - 128));
            }
        }
         */
    }

（3）Character


    static void testChar(){
        System.out.println("Character类型：");
        Character i1New72 = 72;
        Character i1 = 40; //表示字符'('
        Character i2 = 40;
        Character i3 = 32;
        Character i4 = new Character('(');//字符'('的十进制码点值是40
        Character i4New72 = new Character('H');//字符'H'的十进制码点值是72
        Character i5 = new Character('(');
        Character i6 = new Character(' '); //空格的十进制码点值是32
        Character i1New = 128;
        Character i2New = 128;
        Character i1New1 = 127;
        Character i2New2 = 127;

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为数值在[0,127]的范围内，使用常量池缓存中的40

        System.out.println("i1New=i2New " + (i1New == i2New));  //false 超过缓存范围，创建新对象了

        System.out.println("i1New1=i2New2 " + (i1New1 == i2New2));  //true 没有超过缓存范围，使用常量池缓存中的值

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池Character对象40，i4指向堆中Character对象40

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型char做加法运算，
        //计算结果是整型的72，所以最终是基本数据类型的值作比较;（byte、short、char类型计算后会自动转成整型类型int）
        System.out.println("72=i5+i6 " + (72 == i5 + i6) +" 因为：i5+i6= " + (i5 + i6)); //true
        System.out.println("char计算后，转换类型为："+ myGetType(i5 + i6));  // int

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型char做加法运算，计算结果是整型的72；
        // i1New72与基本数据类型72比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i1New72=i2+i3 " + (i1New72 == i1 + i3)); //true
        System.out.println("i4New72=i5+i6 " + (i4New72 == i5 + i6)); //true

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型char做加法运算，计算结果是整型的72；
        // i4New72与基本数据类型72比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i4=i5+i6 " + (i4New72 == i5 + i6) +" 因为：i5+i6= " + (i5 + i6)); //true

        Character c = '(';
        System.out.println("字符‘(’的码点值：" + (int)c); //40

        /* Caracter类中有缓存静态内部类CharacterCache；缓存范围：0~127，共128（cache.length）个值
        private static class CharacterCache {
            private CharacterCache(){}

            static final Character cache[] = new Character[127 + 1];

            static {
                for (int i = 0; i < cache.length; i++)
                    cache[i] = new Character((char)i);
            }
        }
         */
    }

（4）Integer


    static void testInt(){
        System.out.println("Boolean类型：");
        Integer i1 = 127;
        Integer i2 = 127;
        Integer i3 = 0;
        Integer i4 = new Integer(127);
        Integer i5 = new Integer(127);
        Integer i6 = new Integer(0);
        Integer i1New = 128;
        Integer i2New = 128;

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为数值在[-128,127]的范围内，使用常量池缓存中的127

        System.out.println("i1New=i2New " + (i1New == i2New));  //false 超过缓存范围，创建新对象了

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池对象127，i4指向堆中对象127

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型int，所以最终是基本数据类型的值作比较
        System.out.println("127=i5+i6 " + (127 == i5 + i6)); //true

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型int；i1与基本数据类型比较的时候也会自动拆箱
        System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); //true

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型int；
        //i4与i5+i6的基本数据类型int结果比较时，i4也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); //true

        /* Integer类中有缓存静态内部类IntegerCache；默认缓存范围：-128~127，共256（cache.length）个值；
            但是可通过 java.lang.Integer.IntegerCache.high 修改高位值,例如：设置vm参数 -XX:AutoBoxCacheMax=200 即
            可修改缓存上限为200
        private static class IntegerCache {
            static final int low = -128;
            static final int high;
            static final Integer cache[];

            static {
                // high value may be configured by property
                int h = 127;
                String integerCacheHighPropValue =
                    sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
                if (integerCacheHighPropValue != null) {
                    try {
                        int i = parseInt(integerCacheHighPropValue);
                        i = Math.max(i, 127);
                        // Maximum array size is Integer.MAX_VALUE
                        h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                    } catch( NumberFormatException nfe) {
                        // If the property cannot be parsed into an int, ignore it.
                    }
                }
                high = h;

                cache = new Integer[(high - low) + 1];
                int j = low;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);

                // range [-128, 127] must be interned (JLS7 5.1.7)
                assert IntegerCache.high >= 127;
            }

            private IntegerCache() {}
        }
         */
    }

Idea2021通过配置VM options修改Integer缓存上限，具体配置参考：

Idea2021.3.2 设置项目运行参数配置_hnjcxy的博客-CSDN博客Idea2021.3.2 设置运行参数配置:Program arguments 、 Environment variables 和 VM options。1、点击Run -> Edit Configurations2、在打开的窗口可以设置 Program arguments 和 Environment variables 参数，如果需要设置VM参数，请看第三步设置VM参数。设置Program arguments参数时，多个参数中间用空格分开，如："22" "33" "44"。.https://blog.csdn.net/hnjcxy/article/details/123791208

（5）Long


    static void testLong(){
        System.out.println("Long类型：");
        Long i1 = 127L;
        Long i2 = 127L;
        Long i3 = 0L;
        Long i4 = new Long(127L);
        Long i5 = new Long(127L);
        Long i6 = new Long(0);
        Long i1New = 128L;
        Long i2New = 128L;

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为数值在[-128,127]的范围内，使用常量池缓存中的127L

        System.out.println("i1New=i2New " + (i1New == i2New));  //false 超过缓存范围，创建新对象了

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池对象127L，i4指向堆中对象127L

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型long，所以最终是基本数据类型的值作比较
        System.out.println("127L=i5+i6 " + (127L == i5 + i6)); //true

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型long；i1与基本数据类型比较的时候也会自动拆箱
        System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); //true

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型long；
        //i4与i5+i6的基本数据类型long结果比较时，i4也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); //true

        /* long类中有缓存静态内部类ByteCache；缓存范围：-128~127，共256（cache.length）个值
        private static class LongCache {
            private LongCache(){}

            static final Long cache[] = new Long[-(-128) + 127 + 1];

            static {
                for(int i = 0; i < cache.length; i++)
                    cache[i] = new Long(i - 128);
            }
        }
         */

    }

（6）Boolean


    static void testBool(){
        System.out.println("Boolean类型：");
        Boolean i1 = true;
        Boolean i2 = true;
        Boolean i4 = new Boolean("true");
        Boolean i5 = new Boolean("true");

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为i1、i2使用常量池缓存中的true

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池对象true，i4指向堆中对象true，所以两个对象地址不同

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象，比较的是两个对象地址

        //因为 i5 与常量true比较时，会自动拆箱为基本数据类型boolean，所以最终比较的是值，不是对象地址
        System.out.println("true=i5+i6 " + (true == i5)); //true

    }

（7）Double 和 Float 没有缓存


    static void testDouble(){
        System.out.println("Double类型：");
        Double i1 = 127.0;
        Double i2 = 127.0;
        Double i3 = 0.0;
        Double i4 = new Double(127.0);
        Double i5 = new Double(127.0);
        Double i6 = new Double(0);

        System.out.println("i1=i2 " + (i1 == i2));  //false 没有缓存，是两个不同的Double类型对象

        //因为 i2+i3 做算术运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本类型double数值127.0，i1与基本数据类型比较时，
        // 也需要拆箱成基本数据类型，最后比较两个基本数据类型127.0的值是否相等
        System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); //true

        System.out.println("i1=i4 " + (i1 == i4)); //false 没有缓存，是两个不同的Double类型对象

        System.out.println("i4=i5 " + (i4 == i5)); //false 没有缓存，是两个不同的Double类型对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是基本数据类型double;最后比较两个基本数据类型127.0的值是否相等
        System.out.println("127.0=i5+i6 " + (127.0 == i5 + i6)); //true
        System.out.println("Double计算后，类型为："+ myGetType(i5 + i6));  // int

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是基本数据类型double；i4与i5+i6的基本数据类型结果比较时，
        // i4也会自动拆箱成基本数据类型double，最后是比较基本数据类型的值，而不是比较封装类对象地址
        System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); //true


    }
测试中用到的判断基本数据类型的方法：
//判断类型
    public static String myGetType(Object o) {
        String type = o.getClass().getSimpleName();
        if ("Integer".equals(type)) {
            return String.valueOf(Integer.TYPE);
        } else if ("Long".equals(type)) {
            return String.valueOf(Long.TYPE);
        } else if ("Float".equals(type)) {
            return String.valueOf(Float.TYPE);
        } else if ("Double".equals(type)) {
            return String.valueOf(Double.TYPE);
        } else if ("Short".equals(type)) {
            return String.valueOf(Short.TYPE);
        } else if ("Byte".equals(type)) {
            return String.valueOf(Byte.TYPE);
        } else if ("Character".equals(type)) {
            return String.valueOf(Character.TYPE);
        } else if ("Boolean".equals(type)) {
            return String.valueOf(Boolean.TYPE);
        }
        return "非基本数据类型！";
    }

hnjcxy
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hutool JAVA基础工具包 v4.5.8
10-01
Hutool是一个Java基础工具类，对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装，组成各种Util工具类，同时提供以下组件：布隆过滤缓存克隆接口类型转换日期处理数据
Java基本数据类型包装类的高速缓冲区
生命的意义在于创造和毁灭
08-10 515
Java的基本数据类型包装类解决基本数据类型的一些无法应用场景，拆箱装箱机制也让Java更具了魅力，但是Java的基本数据类型包装类的“坑”你了解吗？
Java-基本数据类型、包装类、缓存机制、BigDecimal
weixin_46711536的博客
03-19 766
在-128至127之间的赋值，Integer对象是在IntegerCache.cache产生，会复用已有对象，这个区间内的Integer值可以直接使用==进行判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用已有对象，这是一个大坑，推荐使用equals方法进行判断。我们知道计算机是二进制的，而且计算机在表示一个数字时，宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。如果超出对应范围仍然会去创建新的对象，缓存的范围区间的大小只是在性能和资源之间的权衡。
java integer 缓存_Java基本数据类型和Integer缓存机制
weixin_30158793的博客
02-24 334
一、8种基本数据类型(4整,2浮,1符,1布)​ 整型：byte(最小的数据类型)、short(短整型)、int(整型)、long(长整型)；​ 浮点型：float(浮点型)、double(双精度浮点型)；​ 字符型：char(字符型)；​ 布尔型：boolean(布尔型)。二、取值范围数据类型名称占用字节默认值最小值最大值对应包装类整数类型byte10-128(-2^7)~ 127(2^7-1)...
java学习笔记 21/9/8 java数据类型缓存池
Flying_Ape的博客
09-08 161
package com.example.rookie.demo; /** * @author * @date 2021/9/8 9:57 */ public class IntergerDemo { public static void main(String[] args) { Integer x = new Integer(18); Integer y = new Integer(18); System.out.println(x ==.
java long_java封装数据类型——Long
weixin_36168780的博客
02-12 831
Long 是长整型 long 的封装数据类型。我们知道 long 相对于 int 的差异就是数据表示的范围扩大了，其它大部分特性都是一样的。所以 Long 跟 Integer 大部分方法都是相同的。下面列出一些有差异的特性：1. 缓存机制跟 Integer 类型一样，Long 也提供了缓存机制。那么是不是如 long 比 int 范围大，Long 比 Integer 缓存范围也要大呢？其实没有。而...
包装类（整型,Char）的缓存问题
一步一脚印的博客
07-20 249
public class Test { public static void main(String[] args) { Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150; System.out.println(f1 == f2); System.out.println(f3 == f4); ...
java基本数据类型取值范围
u012758488的博客
03-06 4563
java基本数据类型取值范围
JAVA之字节流和字符流
weixin_64771061的博客
08-03 1147
列，它与外部设备中的字节存在着一一对应的关系，不存在字符的转换，被读写字节的个数与外部设备。题目：用户在键盘依次输入若干个数字，每输入一个数字都需要按回车键确认，最后在键盘输入一个非。读取一系列字符并存储到一个数组中，返回实际读取的字符数，如果读到输入。如果源文件不存在，则显示相应的错误信息。如果源文件不存在，则显示相应的错误信息。刷新缓冲区，将缓冲区中的数据全部送出到目标地，然后清空缓冲区。读取一系列字节并存储到一个数组，返回实际读取的。型的参数对应要写入的字节，后两个方法的参数与。...
Integer类的缓存机制
12-21
存在下述例子，判断其输出结果。 public class Main{ public static void main(String[] agrs){ Integer a = 110;...我们知道，在Java中存在基本数据类型和引用数据类型，而Integer作为int的封装类，Integer
Java 中常用缓存Cache机制的实现
11-08
Java 中常用缓存Cache机制的实现
Java操作Redis详细介绍
08-28
主要介绍了Java操作Redis详细介绍，涉及对key的操作，string数据类型，list数据类型等相关内容，具有一定参考价值，需要的朋友可以了解下。
【Java面试+Java学习指南】 一份涵盖大部分Java程序员所需要掌握的核心知识
最新发布
03-26
Java基本数据类型 string和包装类 final关键字特性 Java类和包 抽象类和接口 代码块和代码执行顺序 Java自动拆箱装箱里隐藏的秘密 Java中的Class类和Object类 Java异常 解读Java中的回调 反射 泛型 枚举类 Java注解...
JAVA上百实例源码以及开源项目
01-03
　Java数据压缩与传输实例，可以学习一下实例化套按字、得到文件输入流、压缩输入流、文件输出流、实例化缓冲区、写入数据到文件、关闭输入流、关闭套接字关闭输出流、输出错误信息等Java编程小技巧。 Java数组倒置...
Redis数据库-Java语言实现
01-25
Redis-Java是一款由Java语言实现的高性能缓存中间件，基于TCP实现客户端与服务端双向通信。 基本功能 客户端、服务端收发字节流 服务端解析字节流，执行命令 五大数据类型的命令、通用命令支持 RDB、AOF持久化机制...
Java 常用类（二）
weixin_44886816的博客
05-08 1326
Java 常用类： String 类 常用构造器: String()：初始化一个新创建的 String 对象，使其表示一个空字符序列。 String str1=new String(); String(byte[] bytes)：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新 的 String。 byte[] bytes=new byte[] {-24,-65,-103,-26,-104,-81,-28,-72,-83,-26,-106,-121}; //默认UTF-8 String
Java中Byte接收数据缓存解析方法
fhl13017599952的专栏
06-15 808
byte数据解析
java中 byte[] b = new byte[1024
热门推荐
shen609738067b的专栏
12-21 1万+
如果要调用子类独有的方法的时候，直接用父类是没办法进行调用的， 必须转换《讲animal（父）类型的再转换为cat（子类型） ，如下   /* 猫 ，狗，动物之间的关系 */ abstract class Animal {  public abstract void eat(); } class Cat extends Animal {  public void eat(
Spark k-v结构转换，Spark 数据缓存，spark数据封装逻辑，spark日期处理机制的知识点
05-31
好的，我分别回答您提出的四个问题： 1. Spark k-v结构转换 在Spark中，我们可以使用 `map()`、`flatMap()`、`filter()` 等操作对RDD进行转换。如果我们的数据结构是k-v结构，我们可以使用 `mapValues()`、`flatMapValues()`、`keys()`、`values()` 等操作对key和value进行单独的转换，而不影响另一部分。 例如，我们有一个k-v结构的RDD，其中key是字符串类型，value是整数类型。我们可以使用以下代码将value加1： ``` val rdd: RDD[(String, Int)] = ??? val result: RDD[(String, Int)] = rdd.mapValues(_ + 1) ``` 2. Spark 数据缓存 当我们在Spark中进行复杂计算时，通常会对中间结果进行缓存，以避免重复计算。Spark提供了两种缓存级别，即内存缓存和磁盘缓存。 我们可以使用 `cache()` 或 `persist()` 方法对RDD进行缓存。默认情况下，Spark将RDD缓存在内存中，但如果内存空间不足，则会将部分数据缓存在磁盘上。我们可以使用 `unpersist()` 方法将缓存的RDD从内存或磁盘中删除。 例如，我们有一个RDD需要进行多次计算，我们可以使用以下代码对其进行缓存： ``` val rdd: RDD[Int] = ??? rdd.cache() val result1 = rdd.reduce(_ + _) val result2 = rdd.map(_ * 2).reduce(_ + _) rdd.unpersist() ``` 3. Spark数据封装逻辑 在Spark中，我们可以使用case class来定义数据封装的逻辑。case class是Scala中的一种特殊类，它自动生成了一些方法，包括无参构造函数、getter和setter方法等。 例如，我们有一个存储用户信息的RDD，每个用户包含id、name和age三个属性，我们可以使用以下代码定义一个case class： ``` case class User(id: Int, name: String, age: Int) ``` 然后，我们可以使用 `map()` 方法将RDD中的元素转换为User对象： ``` val rdd: RDD[(Int, String, Int)] = ??? val result: RDD[User] = rdd.map { case (id, name, age) => User(id, name, age) } ``` 4. Spark日期处理机制 在Spark中，我们可以使用Java的日期时间类库或者第三方库（如Joda-Time）来处理日期时间。Spark本身提供了一些日期时间处理函数，如 `current_timestamp()`、`date_add()`、`datediff()` 等。 例如，我们有一个存储订单信息的RDD，每个订单包含id、date和price三个属性，其中date是一个字符串类型表示日期。我们可以使用以下代码将date转换为日期类型，并计算出每个订单距离今天的天数： ``` import java.time.LocalDate val rdd: RDD[(Int, String, Double)] = ??? val today = LocalDate.now() val result = rdd.map { case (id, dateStr, price) => val date = LocalDate.parse(dateStr) val days = java.time.temporal.ChronoUnit.DAYS.between(date, today) (id, days, price) } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值