精华内容
下载资源
问答
  • 小型件自动装箱系统设计.zip机械设计毕业设计
  • 根据自动装箱控制系统的机械结构和工作原理,利用STM32F103系列单片机和伺服电机,设计了控制系统硬件电路原理图,完成了对自动装箱系统码垛机械手的控制,实现了自动装箱系统对小型电器产品包装盒的抓取、运送、...
  • 随着我国的经济的不断发展,啤酒被广大的消费者...本文设计的课题就是基于PLC的啤酒自动装箱控制系统设计,对本设计的各个内容将进行具体的描述,本文设计的内容包括各个方案的选择,以及所涉及到元器件的性能和措施等。 
  • #资源达人分享计划#
  • 基于单片机的自动计数与装箱控制系统设计说明.doc
  • 自动化岸边集装箱起重机模拟操作系统设计.pdf
  • #资源达人分享计划#
  • 铁路集装箱站场装卸自动化远程智能控制系统设计研究.pdf
  • 自动化集装箱堆场结构与排水系统优化设计.pdf
  • 自动化码头岸边集装箱起重机工控系统信息网络安全防护设计.pdf
  • #资源达人分享计划#
  • 一种新型全自动集装箱焊接系统,赵裕聪,何至源,文中根据波纹板焊缝密集,焊缝的轨迹复杂等特点,设计了一套专用设备,确定了最佳的焊接工位,并提出了直线阶段自动跟踪焊接与拐
  • 自动化集装箱码头GPS接收机设计.pdf
  • #资源达人分享计划#
  • java自动装箱与拆箱

    2020-07-06 22:25:17
    java自动装箱与拆箱技术产生背景装箱装箱定义拆箱拆箱定义 装箱是指,将基本数据类型转换成其包装类。 拆箱是指将包装类转换成基本数据类型。 技术产生背景 java中万物皆对象,即存在把大数据类型的封装类。并且各大...

    java自动装箱与拆箱


    装箱是指,将基本数据类型转换成其包装类。
    拆箱是指将包装类转换成基本数据类型。

    技术产生背景

    java中万物皆对象,即存在把大数据类型的封装类。并且各大基本数据类型在编程中是非常常见的,而相对于面向过程编程中直接对基本数据类型进行存储操作,面向对象中对对象的操作所花费的系统资源大。为了结合使用面向过程的优势,java中保留了八大基本数据类型。

    装箱

       

    Integer i = 5;
    
    

    上面这行代码中,创建对象i并没有使用new,但实际上系统会自动将上述语句转为下述语句。

    Integer i = new Integer(5);
    

    这一转换过程称为自动装箱。值得注意的是在java se5之前,java是没有自动装箱的,要想实现上述功能,则需要程序员手动编写。

    拆箱

    Integer i = 5;	//自动装箱
    int j = i;	//自动拆箱
    

    上面两行代码中涉及到了自动装箱与拆箱,拆箱就是将包装类转换成基本数据类型。
    在早期要想实现包装类转基本数据类型则需要程序员按以下代码实现

    Integer i = new Integer(5);
    int j = i.value();
    

    总结

    自动装拆箱其实在技术上没有多深,是java为了方便程序员而进行设计的一个机制。

    展开全文
  • 针对目前尚不完善的集装箱堆场管理现状,将RFID(射频识别)技术应用在...介绍了基于RFID技术的堆场管理系统系统包括有集装箱号码识别、进出车辆自动识别、数字化视频监控、自动排定叉车作业、EDI报文发送和接收等功能.
  • JavA的自动装箱和拆箱

    2014-03-16 16:00:11
    自动装箱和拆箱是JDK1.5提供的新特性,大致是由编译器自动帮助完成基本类型和基本类型的包装类之间的转换。   基本类型以及包装类的概念: 两者有什么差别,包装类是类,是对象,而基本类型是有值的“变量”,再细化...

    自动装箱和拆箱是JDK1.5提供的新特性,大致是由编译器自动帮助完成基本类型和基本类型的包装类之间的转换。

     

    基本类型以及包装类的概念:

    两者有什么差别,包装类是类,是对象,而基本类型是有值的“变量”,再细化一点,就是包装类的实例(对象)创建在堆上,而基本类型创建在栈上,这是JAVA为了程序的速度考虑做出的优化,那么既然是创建在栈上,所以基本类型都有大小的规定(每种基本类型所占的字节是一定的)。

    另外,包装类都实现了Comparable接口,可以实现对象之间的比较,所以包装类之间的比较尽量用compareTo,而不是><=这些运算符。切记。

    在JDK1.5之前,我们要实现基本类型和包装类之间的转换,大多是通过包装类提供的方法,Integer i = Integer.valueOf(5)或者int j = i.intValue()来做互相转换的。JDK1.5之后,编译器会在我们做赋值操作(这里所说的赋值操作不包括构造函数,我们后面会讲)的时候帮我们自动完成基本类型和包装类之间的相互转换。

    上面我们所说的赋值操作,基本上可以分为两种情况,一种是显式赋值,另一种是隐式赋值:

    显式赋值,我们可以理解为有赋值符号出现的情况,比如,Integer i = 11;这里编译器会自动的帮你完成把11这个int的基本类型装箱成包装类实例的工作,这样就不用我们再手动的转换了。

    隐式赋值,就是没有复制符号出现的情况,这点我们很多人经常忽略,比如方法调用时候的参数传递,比如我们有一个接受Integer类型参数的方法(void method(Integer i)),我们在调用的时候可以直接传递一个基本类型的实参进去(method(5)),这时候编译器会自动的将我们传递进去的实参装箱成包装类,从而完成 对方法的调用。很简单的一个过程,里面的原理却不简单,这是因为,方法调用的时候,在内存中的栈上,首先会为方法的形参创建内存区域,然后将我们传递进去的实参赋值给形参,看到没,就是在这时,发生了赋值操作,才会让编译器完成装箱操作。当然,方法执行完后,栈上有关形参的内存区域会被回收。

    还有我们要记住一点,就是编译器的:

    装箱/拆箱原则,就是基本类型可以先加宽(比如int转换为long),再转变成宽类型的包装类(Long),但是不能转变成宽类型的包装类型。

    比如我们有个方法 void method(long l),我们通过method(5)是可以调用该方法的,因为int类型的5被加宽成了long类型;但是如果这个方法变成void method(Long l),我们通过method(5)就不能调用它了,因为int类型的5是不能直接转换成Long包装类的。切记。

    最后还有一个值得注意的地方,就是上面我们提到的显示赋值的情况下,比如Integer i = 11的情况,实际上在源码中是调用到了Integer的静态方法valueOf(),在这一块,java的设计者采用了cache pool的设计模式,在Integer这个类里面有一个长度为256的静态Integer数组,里面存储了从-128到127的Integer对象,当我 们传递进去的参数在这个范围之内时,这个方法会返回该数据中实现保存的Integer对象实例,只有超过该范围时,才会返回new出来的Integer对 象实例。

    享元模式(flyweight):有很多个小的对象,有很多属性相同,把他们变成一个对象,不同的属性变成方法的参数,称之为外部状态,相同的称之为内部状态

     

    装箱:形如--->Integer num1 = 2;

    一般我们要创建一个类的对象的时候,我们会这样:

     Class a = newClass(parameter);

     当我们创建一个Integer对象时,却可以这样:

     Integer i = 100; (注意:不是 int i = 100; )

    实际上,执行上面那句代码的时候,系统为我们执行了:Integer i = new Integer(100); 此即基本数据类型的自动装箱功能。

     

             拆箱:形如--->System.out.println(num1+ 3);也就是将对象中的基本数据从对象中自动取出

             基本数据类型对象缓存:

                       Integernum1 = 12;

                       Integernum2 = 12;

                       System.out.println(num1== num2);        true

     

                       Integernum3 = 129;

                       Integernum4 = 129;

                       System.out.println(num3== num4);        false          (-128~127)

     

                       Integernum5 = Integer.valueOf(12);

                       Integernum6 = Integer.valueOf(12);

                       System.out.println(num5== num6);        true

     

                       Integernum7 = Integer.valueOf(129);

                       Integernum8 = Integer.valueOf(129);

                       System.out.println(num7== num8);        false

    注意:

    equals() 比较的是两个对象的值(内容)是否相同。

    "==" 比较的是两个对象的引用(内存地址)是否相同,也用来比较两个基本数据类型的变量值是否相等。

    在自动装箱时对于值从–128到127之间的值,它们被装箱为Integer对象后,会存在内存中被重用,

    所以范例中,num1 与 num2实际上参考至同一个对象。

    如果超过了从–128到127之间的值,被装箱后的Integer对象并不会被重用,

    即相当于每次装箱时都新建一个 Integer对象,所以范例中,num7与num8参考的是不同的对象。

    另外,当不使用自动装箱功能的时候,情况与普通类对象一样

     

    例如String的自动拆装箱

    例子一:

    String str1 = "abc";

    String str2 = "abc";

    System.out.println(str2==str1);  //输出为 true

    System.out.println(str2.equals(str1));  //输出为 true

               

    String str3 = new String("abc");

    String str4 = new String("abc");

    System.out.println(str3==str4);  //输出为 false

    System.out.println(str3.equals(str4));  //输出为 true

    例子二:

    String d ="2";    
    String e = "23";
    e = e.substring(0, 1);
    System.out.println(e.equals(d)); //输出为true                                System.out.println(e==d);       //输出为 false 

    充分说明了:

    equals() 比较的是两个对象的值(内容)是否相同。

    "==" 比较的是两个对象的引用(内存地址)是否相同

    展开全文
  • 【Java进阶】自动装箱与享元模式自动装箱代码示例Integer i = 10; Integer j = 128;以上,可以把int型字面量直接赋值给Integer引用变量,jdk隐含了一步操作,将 int 型数字包装成Integer类型,这个升级是为了简化...

    【Java进阶】自动装箱与享元模式

    自动装箱

    代码示例

    Integer i = 10;
    Integer j = 128;

    以上,可以把int型字面量直接赋值给Integer引用变量,jdk隐含了一步操作,将 int 型数字包装成Integer类型,这个升级是为了简化编程。

    程序的升级一般包括三个目的中的至少一个:

    提高安全性
    简化编程
    提高性能

    小小的自动装箱背后隐藏着一个知识点,那就是享元模式,下面来聊聊它。


    自动装箱中的享元模式

    自动装箱拆箱AutoBox示例代码:

    int i = 10;
    int j = 128;
    
    Integer ii1 = i;
    Integer ii2 = i;
    System.out.println("ii == ij ? " + (ii1 == ii2));  // true,它们都是包装类型的对象,但是是同一个对象
    
    Integer ij1 = j;
    Integer ij2 = j;
    System.out.println("ii == ij ? " + (ij1 == ij2)); // false,它们都是包装类型的对象,但是不是同一个对象

    以上结果说明了什么?

    答案是这样的,当-128~127之间的整数(byte类型的范围)初始化包装类型,自动装箱时,内存将其缓存起来,下次再次遇到相等的整数,则直接从缓存中取出即可,不需要再次创建该对象。

    我们看看Integer的源代码中,其中包含了一个内部类IntegerCache,它默认缓存-128~127之间的整数包装类对象。

     /**
      * Cache to support the object identity semantics of autoboxing for values between
      * -128 and 127 (inclusive) as required by JLS.
      *
      * The cache is initialized on first usage.  The size of the cache
      * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
      * During VM initialization, java.lang.Integer.IntegerCache.high property
      * may be set and saved in the private system properties in the
      * sun.misc.VM class.
      */
    
     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() {}
     }

    为什么要这么做呢?
    以-128~127之间的整数初始化包装类型,自动装箱时,因为这些数字使用频率较高且可能不被改变,内存可以缓存起来,这样就可以节省内存。这就是享元模式。

    享元模式

    经常使用一些在一定范围内的对象,而且这些对象一般不被改变,当使用该对象时,就把它创建并缓存起来,以后其他地方再次使用时, 直接从缓存中取出来即可,不用再次创建,这样可以避免创建新对象而造成的资源浪费(cpu和内存等资源)。

    比如,文本编辑器中字符,对于英文字母的话,就创建52个字母对象,没必要每写一个字符就创建一个对象,只是显示的位置不一样而已。
    还有,操作系统中的文件夹的图标,也都是一个对象,只是文件名和位置不同而已。

    这就是享元设计模式,它简单,正因为它很简单,所以它是设计模式,如果它很复杂,那么它就是设计模式了。

    如果有很多很小的对象,它们有很多相同的属性,那么可以把它们当作一个对象,对于不同的属性,把它变成外部属性,作为方法的参数传入。 相同的属性称为对象的内部状态,不同的属性称为对象的外部状态。


    享元模式(Flyweight Pattern)是池技术的重要实现方式。它的定义如下:

    使用共享对象可有效地支持大量的细粒度的对象。

    享元模式的定义为我们提出了两个要求:细粒度的对象和共享对象。我们知道分配太多的对象到应用程序中将有损程序的性能,同时还容易造成内存溢出,那怎么避免呢?
    就是享元模式提到的共享技术。


    参考

    《Java基础强化教程-张孝祥》
    《设计模式之禅-秦小波》

    展开全文
  • 基本数据的自动装箱及享元设计模式

     

    基本数据的自动拆装箱及享元设计模式

    Integer i1 = 1;

    这行代码在JDK1.5之前是错误的。因为左边是基本数据类型,而右边是整数。

     

    JDK1.5之后,Integer i1 = 1是正确的,右边的1将自动被装箱为基本数据类型。

     

     

    i1与i2相同,i3与i4不相同。

    导致这个区别的原因是:在-128到127之间的基本数据类型将被缓存,因为它们经常会被使用,系统将在内存中查找之前被定义的

    对象。 超过这个范围的将不被缓存。

     

    享元设计模式:当某个对象经常被调用,并且有大部分相同属性很少修改,可以将它们相同部分(内部状态)剥离出来,设计成共享对象,其中不同的

    属性设计成方法的参数(外部状态)。

     

    展开全文
  • 通过借助C#,SQL Server 2008数据库的强大数据处理功能,对该系统进行开发,实现了货运作业、装箱作业、交接货物管理、基本信息管理等功能;提供国际通用的EDI报文接收与发送功能,以此利于未来客户信息的交换。通过...
  • 前言:自动装箱和拆箱是JDK1.5提供的新特性,大致是由编译器自动帮助完成基本类型和基本类型的包装类之间的转换。 好吧,知道了自动装箱的大致意思之后,我们先来复习一个有关基本类型以及包装类的概念: 基本...
  • 自动化码头岸边集装箱起重机远程操作一对多作业设计与实现.pdf
  • JDK1.5提供了自动装箱(Autoboxing)和自动拆箱(AutoUnboxing)功能。 所谓自动装箱,就是可以把一个基本类型变量直接赋给对应的包装类变量,或者赋给Object变量(Object类是所有类的父类,子类对象可以直接赋给...
  • 什么是自动装箱拆箱基本数据类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。 一般我们要创建一个类的对象的时候,我们会这样: Class a = new Class(parameter);当我们创建一个...
  • JAVA中最常用的语法糖--自动装箱和拆箱 一,究竟什么是自动装箱和拆箱 1.1 我们直接来看一段非常简单的实例代码: public static void main(String[] args) { int intValue = 100; Integer boxValue = int...
  • 这种自动装箱过程一般还是很有用的-它是保证类型安全所必需的操作,当然,它同时也带来了性能开销成本,每次创建一个堆上新对象时就会存在这样性能开销。所以这就意味着作为开发者,了解哪种场景下会发生Kotlin进行...
  • 枚举及自动装箱和拆箱 第十二集 枚举  /**  * 为什么要用枚举  * 问题:定义星期几或性别的变量,该怎么定义?  * 假设用1-7分别表示星期一到星期日,但有人可能会写成int weekDay = 0;  * 枚举就是要让某个...
  • 什么是Java中的自动装箱

    万次阅读 多人点赞 2018-09-03 12:47:37
    本文主要介绍Java中的自动拆箱与自动装箱的有关知识。 1、基本数据类型 基本类型,或者叫做内置类型,是Java中不同于类(Class)的特殊类型。它们是我们编程中使用最频繁的类型。 Java是一种强类型语言,第一次...
  • * 自动装箱的陷阱 * @param args */ public static void main(String[] args) { Integer a = 1; Integer b = 2; Integer c = 3; Integer d = 3; Integer e = 321; Integer f = 321; Long g = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,981
精华内容 9,192
关键字:

产品自动装箱系统设计