[转载] 什么是Java中的自动拆装箱 integer

参考链接： Java中autoboxing自动装箱整数对象的比较

本文主要介绍Java中的自动拆箱与自动装箱的有关知识。 

  

1、基本数据类型   

基本类型，或者叫做内置类型，是Java中不同于类(Class)的特殊类型。它们是我们编程中使用最频繁的类型。 

Java是一种强类型语言，第一次申明变量必须说明数据类型，第一次变量赋值称为变量的初始化。 

Java基本类型共有八种，基本类型可以分为三类： 

字符类型char 

布尔类型boolean 

整数类型byte、short、int、long 

浮点数类型float、double。 

Java中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。 

实际上，Java中还存在另外一种基本类型void，它也有对应的包装类java.lang.Void，不过我们无法直接对它们进行操作。 

基本数据类型有什么好处 我们都知道在Java语言中，new一个对象是存储在堆里的，我们通过栈中的引用来使用这些对象；所以，对象本身来说是比较消耗资源的。 

对于经常用到的类型，如int等，如果我们每次使用这种变量的时候都需要new一个Java对象的话，就会比较笨重。 

所以，和C++一样，Java提供了基本数据类型，这种数据的变量不需要使用new创建，他们不会在堆上创建，而是直接在栈内存中存储，因此会更加高效。 

整型的取值范围 

Java中的整型主要包含byte、short、int和long这四种，表示的数字范围也是从小到大的，之所以表示范围不同主要和他们存储数据时所占的字节数有关。 

先来个简答的科普，1字节=8位（bit）。java中的整型属于有符号数。 

先来看计算中8bit可以表示的数字： 

最小值：10000000 （-128）(-2^7) 最大值：01111111（127）(2^7-1) 整型的这几个类型中， 

byte：byte用1个字节来存储，范围为-128(-2^7)到127(2^7-1)，在变量初始化的时候，byte类型的默认值为0。 

short：short用2个字节存储，范围为-32,768 (-2^15)到32,767 (2^15-1)，在变量初始化的时候，short类型的默认值为0，一般情况下，因为Java本身转型的原因，可以直接写为0。 

int：int用4个字节存储，范围为-2,147,483,648 (-2^31)到2,147,483,647 (2^31-1)，在变量初始化的时候，int类型的默认值为0。 

long：long用8个字节存储，范围为-9,223,372,036,854,775,808 (-2^63)到9,223,372,036, 854,775,807 (2^63-1)，在变量初始化的时候，long类型的默认值为0L或0l，也可直接写为0。 

超出范围怎么办 上面说过了，整型中，每个类型都有一定的表示范围，但是，在程序中有些计算会导致超出表示范围，即溢出。如以下代码： 

int i = Integer.MAX_VALUE;

int j = Integer.MAX_VALUE;

 

int k = i + j;

System.out.println("i (" + i + ") + j (" + j + ") = k (" + k + ")"); 

输出结果：i (2147483647) + j (2147483647) = k (-2) 

这就是发生了溢出，溢出的时候并不会抛异常，也没有任何提示。所以，在程序中，使用同类型的数据进行运算的时候，一定要注意数据溢出的问题。 

  

2、包装类型 

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。 

包装类均位于java.lang包，包装类和基本数据类型的对应关系如下表所示 

基本数据类型    包装类 

byte          Byte

boolean       Boolean

short         Short

char          Character

int           Integer

long          Long

float         Float

double        Double 

 在这八个类名中，除了Integer和Character类以后，其它六个类的类名和基本数据类型一致，只是类名的第一个字母大写即可。 

为什么需要包装类 很多人会有疑问，既然Java中为了提高效率，提供了八种基本数据类型，为什么还要提供包装类呢？ 

这个问题，其实前面已经有了答案，因为Java是一种面向对象语言，很多地方都需要使用对象而不是基本数据类型。比如，在集合类中，我们是无法将int 、double等类型放进去的。因为集合的容器要求元素是Object类型。 

为了让基本类型也具有对象的特征，就出现了包装类型，它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。 

  

3、拆箱与装箱 

那么，有了基本数据类型和包装类，肯定有些时候要在他们之间进行转换。比如把一个基本数据类型的int转换成一个包装类型的Integer对象。 

我们认为包装类是对基本类型的包装，所以，把基本数据类型转换成包装类的过程就是打包装，英文对应于boxing，中文翻译为装箱。 

反之，把包装类转换成基本数据类型的过程就是拆包装，英文对应于unboxing，中文翻译为拆箱。 

在Java SE5之前，要进行装箱，可以通过以下代码： 

Integer i = new Integer(10); 

  

4、自动拆箱与自动装箱 

在Java SE5中，为了减少开发人员的工作，Java提供了自动拆箱与自动装箱功能。 

自动装箱: 就是将基本数据类型自动转换成对应的包装类。 

自动拆箱：就是将包装类自动转换成对应的基本数据类型。 

Integer i =10;  //自动装箱

int b= i;     //自动拆箱 

Integer i=10 可以替代 Integer i = new Integer(10); 这就是因为Java帮我们提供了自动装箱的功能，不需要开发者手动去new一个Integer对象。 

  

5、自动装箱与自动拆箱的实现原理 

既然Java提供了自动拆装箱的能力，那么，我们就来看一下，到底是什么原理，Java是如何实现的自动拆装箱功能。 

我们有以下自动拆装箱的代码： 

public static  void main(String[]args){

    Integer integer=1; //装箱

    int i=integer; //拆箱

}

对以上代码进行反编译后可以得到以下代码：

 

public static  void main(String[]args){

    Integer integer=Integer.valueOf(1); 

    int i=integer.intValue(); 

} 

 从上面反编译后的代码可以看出，int的自动装箱都是通过Integer.valueOf()方法来实现的，Integer的自动拆箱都是通过integer.intValue来实现的。如果读者感兴趣，可以试着将八种类型都反编译一遍 ，你会发现以下规律： 

自动装箱都是通过包装类的valueOf()方法来实现的.自动拆箱都是通过包装类对象的xxxValue()来实现的。 

6、哪些地方会自动拆装箱 

我们了解过原理之后，在来看一下，什么情况下，Java会帮我们进行自动拆装箱。前面提到的变量的初始化和赋值的场景就不介绍了，那是最简单的也最容易理解的。 

我们主要来看一下，那些可能被忽略的场景。 

场景一、将基本数据类型放入集合类 

我们知道，Java中的集合类只能接收对象类型，那么以下代码为什么会不报错呢？ 

List<Integer> li = new ArrayList<>();

for (int i = 1; i < 50; i ++){

    li.add(i);

} 

将上面代码进行反编译，可以得到以下代码： 

List<Integer> li = new ArrayList<>();

for (int i = 1; i < 50; i += 2){

    li.add(Integer.valueOf(i));

} 

以上，我们可以得出结论，当我们把基本数据类型放入集合类中的时候，会进行自动装箱。 

场景二、包装类型和基本类型的大小比较 

有没有人想过，当我们对Integer对象与基本类型进行大小比较的时候，实际上比较的是什么内容呢？看以下代码： 

I 

Integer a=1;

System.out.println(a==1?"等于":"不等于");

Boolean bool=false;

System.out.println(bool?"真":"假"); 

对以上代码进行反编译，得到以下代码： 

Integer a=1;

System.out.println(a.intValue()==1?"等于":"不等于");

Boolean bool=false;

System.out.println(bool.booleanValue?"真":"假"); 

可以看到，包装类与基本数据类型进行比较运算，是先将包装类进行拆箱成基本数据类型，然后进行比较的。 

场景三、包装类型的运算 

有没有人想过，当我们对Integer对象进行四则运算的时候，是如何进行的呢？看以下代码： 

Integer i = 10;

Integer j = 20;

System.out.println(i+j); 

反编译后代码如下： 

Integer i = Integer.valueOf(10);

Integer j = Integer.valueOf(20);

System.out.println(i.intValue() + j.intValue()); 

我们发现，两个包装类型之间的运算，会被自动拆箱成基本类型进行。 

场景四、三目运算符的使用 

这是很多人不知道的一个场景，作者也是一次线上的血淋淋的Bug发生后才了解到的一种案例。看一个简单的三目运算符的代码： 

boolean flag = true;

Integer i = 0;

int j = 1;

int k = flag ? i : j; 

很多人不知道，其实在int k = flag ? i : j;这一行，会发生自动拆箱。反编译后代码如下： 

boolean flag = true;

Integer i = Integer.valueOf(0);

int j = 1;

int k = flag ? i.intValue() : j; 

这其实是三目运算符的语法规范：当第二，第三位操作数分别为基本类型和对象时，其中的对象就会拆箱为基本类型进行操作。 

因为例子中，flag ? i : j;片段中，第二段的i是一个包装类型的对象，而第三段的j是一个基本类型，所以会对包装类进行自动拆箱。如果这个时候i的值为null，那么久会发生NPE。（自动拆箱导致空指针异常） 

场景五、函数参数与返回值 

这个比较容易理解，直接上代码了： 

//自动拆箱

public int getNum1(Integer num) {

 return num;

}

//自动装箱

public Integer getNum2(int num) {

 return num;

} 

7、自动拆装箱与缓存 

Java SE的自动拆装箱还提供了一个和缓存有关的功能，我们先来看以下代码，猜测一下输出结果： 

public static void main(String... strings) {

 

    Integer integer1 = 3; //通过反编译发现执行的是  Integer.valueOf(1); 

    Integer integer2 = 3;

 

    if (integer1 == integer2)

        System.out.println("integer1 == integer2");

    else

        System.out.println("integer1 != integer2");

 

    Integer integer3 = 300;

    Integer integer4 = 300;

 

    if (integer3 == integer4)

        System.out.println("integer3 == integer4");

    else

        System.out.println("integer3 != integer4");

 

} 

我们普遍认为上面的两个判断的结果都是false。虽然比较的值是相等的，但是由于比较的是对象，而对象的引用不一样，所以会认为两个if判断都是false的。 

在Java中，==比较的是对象应用，而equals比较的是值。 

所以，在这个例子中，不同的对象有不同的引用，所以在进行比较的时候都将返回false。奇怪的是，这里两个类似的if条件判断返回不同的布尔值。 

上面这段代码真正的输出结果： 

integer1 == integer2 integer3 != integer4 原因就和Integer中的缓存机制有关。在Java 5中，在Integer的操作上引入了一个新功能来节省内存和提高性能。整型对象通过使用相同的对象引用实现了缓存和重用。 

适用于整数值区间-128 至 +127。 

只适用于自动装箱。使用构造函数创建对象不适用。 

具体的代码实现可以阅读Java中整型的缓存机制一文，这里不再阐述。 

-- 源码

 public static Integer valueOf(int i) {

        assert IntegerCache.high >= 127;

        if (i >= IntegerCache.low && i <= IntegerCache.high)

            return IntegerCache.cache[i + (-IntegerCache.low)];

        return new Integer(i);

  } 

我们只需要知道，当需要进行自动装箱时，如果数字在-128至127之间时，会直接使用缓存中的对象，而不是重新创建一个对象。 

扩展:  

        int i =50;

        Integer i1 =50;

        Integer i2 =50;

        Integer i3 = new Integer(50);

        Integer i4 = new Integer(50);

        Integer i5 = 300;

        Integer i6 = 300;

        System.out.println(i == i1);// true；i1 自动拆箱变成基本类型,两基本类型比较值

        System.out.println(i == i3);// true； i3自动拆箱变成基本类型,两基本类型比较值

        System.out.println(i1 == i2);// true; i1和i3都指向常量池中同一个地址

        System.out.println(i1 == i3);// false; 两个不同的对象

        System.out.println(i3 == i4);// false； 两个不同的对象

        System.out.println(i5 == i6);// false; 自动装箱时，如果值不在-128到127，就会创建一个新的对象

    System.out.println( "11".equals( 11 ));//false; 不同类型之间的额比较 

其中的javadoc详细的说明了缓存支持-128到127之间的自动装箱过程。最大值127可以通过-XX:AutoBoxCacheMax=size修改。缓存通过一个 for 循环实现。从小到大的创建尽可能多的整数并存储在一个名为 cache 的整数数组中。这个缓存会在 Integer 类第一次被使用的时候被初始化出来。以后就可以使用缓存中包含的实例对象，而不是创建一个新的实例(在自动装箱的情况下)。 

实际上这个功能在Java 5中引入的时候,范围是固定的-128 至 +127。后来在Java 6中，可以通过java.lang.Integer.IntegerCache.high设置最大值。这使我们可以根据应用程序的实际情况灵活地调整来提高性能。到底是什么原因选择这个-128到127范围呢？因为这个范围的数字是最被广泛使用的。 在程序中，第一次使用Integer的时候也需要一定的额外时间来初始化这个缓存。 

/** 

 * 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() {}  

}   

在Boxing Conversion部分的Java语言规范(JLS)规定如下： 

如果一个变量p的值是： 

-128至127之间的整数(§3.10.1)   true 和 false的布尔值 (§3.10.3)   ‘\u0000’至 ‘\u007f’之间的字符(§3.10.4) 范围内的时，将p包装成a和b两个对象时，可以直接使用a==b判断a和b的值是否相等。 

补充:  

 注意，Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。  Double、Float的valueOf方法的实现是类似的。 

而其中double和float又有所不同，我们就以double为例子，贴出代码讨论： 

public class Test {

  /**

   * Double

   */

  public static void first() {

    Double i1 = 100.0;

    Double i2 = 100.0;

    Double i3 = 200.0;

    Double i4 = 200.0;

    System.out.println(i1 == i2);//false

    System.out.println(i3 == i4);//false

  }

  /**

   * 测试方法

   */

  public static void main(String[] args) {

    first();

  }

}

 

注意为什么上面的代码的输出结果都是false呢？同样的我们依旧以Double类中的valueOf方法来讨论，贴出源码就一目了然了：

 

  

  public static Double valueOf(double d) {

    return new Double(d);

  }

也就是说不管你的double是什么范围的值，他都是给你返回一个新的对象。float同double，就不过多赘述了。 

  

8、自动拆装箱带来的问题   

当然，自动拆装箱是一个很好的功能，大大节省了开发人员的精力，不再需要关心到底什么时候需要拆装箱。但是，他也会引入一些问题。包装对象的数值比较，不能简单的使用==，虽然-128到127之间的数字可以，但是这个范围之外还是需要使用equals比较。 

前面提到，有些场景会进行自动拆装箱，同时也说过，由于自动拆箱，如果包装类对象为null，那么自动拆箱时就有可能抛出NPE。 

如果一个for循环中有大量拆装箱操作，会浪费很多资源。 

性能问题

首先在堆内存中创建对象的消耗肯定是要比使用栈内存要多的，同时在自动拆装箱的时候，也有一定的性能消耗，如果在数据量比较大，或者是循环的情况下，频繁的拆装箱并且生成包装类的时候，对性能的影响就是一星半点了，所以不是特殊的需求，例如上述被集合持有的情况，还是使用基本类型而不是包装类 

在循环的时候 

Integer sum = 0;

 for(int i=1000; i<5000; i++){

   sum+=i;

} 

上面的代码sum+=i可以看成sum = sum + i，在sum被+操作符操作的时候，会对sum进行自动拆箱操作，进行数值相加操作，最后发生自动装箱操作转换成Integer对象。其内部变化如下 

sum = sum.intValue() + i;

Integer sum = new Integer(result); 

sum为Integer类型，在上面的循环中会创建4000个无用的Integer对象，在这样庞大的循环中，会降低程序的性能并且加重了垃圾回收的工作量。因此在我们编程时，需要注意到这一点，正确地声明变量类型，避免因为自动装箱引起的性能问题 

再举一个例子，在Java中的HashMap的性能也受到自动拆装箱的影响 因为HashMap接收的参数类型是HashMap <Object, Object>，所以在增删改查的时候，都会对Key值进行大量的自动拆装箱，为了解决这个问题，Java提供了SparseArray，包括SparseBoolMap, SparseIntMap, SparseLongMap, LongSparseMap,所接受的Key值都是基本类型的值，例如SparseIntMap就是SparseIntMap<int, Object>,在避免了大量自动拆装箱的同时，还降低的内存消耗。这里就点到为止，具体的数据结构的问题我们就不深入了 

2. 重载与自动装箱 

在Java5之前，value(int i)和value(Integer o)是完全不相同的方法，开发者不会因为传入是int还是Integer调用哪个方法困惑，但是由于自动装箱和拆箱的引入，处理重载方法时稍微有点复杂，例如在ArrayList中，有remove(int index)和remove(Object o)两个重载方法，如果集合持有三个Integer类型值为3,1,2的对象，我们调用remove(3), 是调用了remove的哪个重载方法？remove掉的是值为3的对象，还是remove了index为3，值为2的那个对象呢？其实问题就是，参数3是否会被自动打包呢？答案是：不会，在这种情况下，编译器不会进行自动拆装箱，所以调用的是remove(int index),index为3值为2的这个Integer对象会被remove 

通过以下例子我们可以验证 

public void testAutoBoxing(int i){

    System.out.println("primitive argument");

 

}

 

public void testAutoBoxing(Integer integer){

    System.out.println("wrapper argument");

 

}

 

//calling overloaded method

int value = 1;

test(value); //no autoboxing 

Integer iValue = value;

test(iValue); //no autoboxing

 

Output:

primitive argument

wrapper argument 

3. 缓存值问题 

4. 警惕NullPointerException 

我们在使用基本类型的时候，在声明的时候即使我们没有对变量进行赋值，编译器也会自动的为其赋予初始值，比如int值就是0，boolean就是flase，所以我们在使用基本类型的时候，是不会出现NullPointerException的，但在使用包装类的时候，我们就要注意这个问题了，不能因为有自动拆装箱这个语法糖，就忘记了包装类和基本类型的区别，将其同等对待了，如果你没有在使用包装类的时候通过显式、或是通过自动装箱机制为其赋值，在你取出值、或是通过自动拆箱使用该值的时候，就会发生NullPointerException，这个是大家要注意的 

 链接：https://www.jianshu.com/p/547b36f04239    https://www.jianshu.com/p/547b36f04239

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

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

相关文章

[转载] python常用库

[转载] python常用库

参考链接&#xff1a; Python–新一代语言 转载至&#xff1a;https://www.cnblogs.com/jiangchunsheng/p/9275881.html 今天我将介绍20个属于我常用工具的Python库&#xff0c;我相信你看完之后也会觉得离不开它们。他们是&#xff1a; Requests.Kenneth Reitz写的最富盛…
阅读更多...
linux下安装配置oracle

linux下安装配置oracle

检查系统是否已安装所需的开发包 使用rpm -qa命令&#xff0c;确保以下包已成功安装。对于包的版本,只有版本高于下面的都可以,如果低于此版本,则要升级处理,如下: binutils-2.15.92.0.2-13.EL4 compat-db-4.1.25-9 compat-libstdc-296-2.96-132.7.2 control-center-2.8.0-12 g…
阅读更多...
[转载] c++多态与java多态性_Java中的多态性

[转载] c++多态与java多态性_Java中的多态性

参考链接&#xff1a; Java中的加法和串联 c多态与java多态性 Polymorphism is one of the core concepts of OOPS paradigm. The meaning of polymorphism is the condition of occurring in several different forms. 多态是OOPS范式的核心概念之一。 多态性的含义是以几种不…
阅读更多...
USB peripherals can turn against their users

USB peripherals can turn against their users

Turning USB peripherals into BadUSB USB devices are connected to – and in many cases even built into – virtually all computers. The interface standard conquered the world over the past two decades thanks to its versatility: Almost any computer peripheral…
阅读更多...
[转载] JAVA条件表达式的陷阱

[转载] JAVA条件表达式的陷阱

参考链接&#xff1a; Java条件表达式中的数字类型提升 Map<String, Integer> map new HashMap<String, Integer>(); map.put("count", null); Integer it map null ? 0 : map.get("count"); 注意&#xff1a;在第三行&#xff0c;会…
阅读更多...
Linux系统管理初步（七）系统服务管理、chkconfig与systemd 编辑中

Linux系统管理初步（七）系统服务管理、chkconfig与systemd 编辑中

Linux系统本身包含了很多服务&#xff0c;CentOS6之前系统的服务用SysV控制&#xff0c;CentOS7改为systemd控制 一、chkconfig服务管理机制 简而言之&#xff0c;chkconfig就是CentOS6以前用来控制系统服务的工具&#xff0c; 常用方法举例 chkconfig --list #列出所有的系统服…
阅读更多...
[转载] 菜鸟举例理解字节流和字符流区别

[转载] 菜鸟举例理解字节流和字符流区别

参考链接&#xff1a; Java中的字符流与字节流 Character Stream对比Byte Stream 菜鸟举例理解字节流和字符流区别 按照uft8编码方式存储文档 文档存储路径在D盘下 /** * 按照utf8格式存储文档 */ public static void storeDataByUTF8(){ String path "D:" …
阅读更多...
[转载] Java9发布回顾Java 8的十大新特性

[转载] Java9发布回顾Java 8的十大新特性

参考链接&#xff1a; Java中的DoubleStream mapToObj() java9已经在北京时间9月22日正式发布&#xff0c;开发者可以在oracle jdk官网上下载到最新的jdk9。 今天&#xff0c;我们先来一起复习一下2014年发布的Java 8的十大新特性。先来喝杯java~~~ 按照java升级的传统&…
阅读更多...
窗体间传递数据

窗体间传递数据

前言 做项目的时候&#xff0c;winfrom因为没有B/S的缓存机制&#xff0c;窗体间传递数据没有B/S页面传递数据那么方便&#xff0c;今天我们就说下winfrom中窗体传值的几种方式。 共有字段传递 共有字段传递实现起来很方便&#xff0c;就是在窗体类中加个共有字段属性&#xff…
阅读更多...
[转载] c语言中检查命令行参数_C中的命令行参数

[转载] c语言中检查命令行参数_C中的命令行参数

参考链接&#xff1a; Java中的命令行参数 c语言中检查命令行参数 Command line argument is a parameter supplied to the program when it is invoked. Command line argument is an important concept in C programming. It is mostly used when you need to control your …
阅读更多...
MySQL关闭Enterprise Server源码

MySQL关闭Enterprise Server源码

今天从MySQL官方网站上获知&#xff0c;MySQL宣布关闭Enterprise Server的源码&#xff0c;对于广大开源爱好者来说&#xff0c;这是一个沉重的打击。虽然免费的用户群体一般仅仅使用MySQL Community Server&#xff08;开源免费社区版&#xff09;&#xff0c;但关闭MySQL Ent…
阅读更多...
[转载] Java中Scanner用法总结

[转载] Java中Scanner用法总结

参考链接&#xff1a; Java之Scanner类 最近在做OJ类问题的时候&#xff0c;经常由于Scanner的使用造成一些细节问题导致程序不通过&#xff08;最惨的就是网易笔试&#xff0c;由于sc死循环了也没发现&#xff0c;导致AC代码也不能通过。。。&#xff09;&#xff0c;因此对S…
阅读更多...
os和shutil模块

os和shutil模块

import os //os模块基本实现了linux系统中所有的命令 os.system(终端命令)&#xff1a;在终端执行命令 os.getcwd():获取当前的工作路径 os.chdir():修改工作路径 os.chmod():修改权限 os.chown():修改属主属组 os.mkdir():创建单个目录&#xff0c;当目录存在时报异常&…
阅读更多...
[转载] JAVA语言程序设计（基础篇）第十版课后题答案（第一章）

[转载] JAVA语言程序设计（基础篇）第十版课后题答案（第一章）

参考链接&#xff1a; Java中的Scanner和nextChar() JAVA语言程序设计&#xff08;基础篇&#xff09;第十版课后题答案 第一章 第二题 /** Created by ysy on 2018/7/6. */ public class text2 { public static void main(String[] args){ for(int i 0; i < 5; i) Syste…
阅读更多...
java.util.Date和java.sql.Date 一点区别

java.util.Date和java.sql.Date 一点区别

最近无意中发现&#xff0c;在oracle中同一样的一个Date类型字段&#xff0c;存储的日期格式有两种不同的情况&#xff0c;第一种是2011-1-1 12:00:00&#xff0c;第二种是2011-1-1&#xff0c;仔细查找发现在向数据库中写数据的时候定义的变量的问题。 第一种是&#xff1a;ja…
阅读更多...
[转载] java中关于用\t格式输出

[转载] java中关于用\t格式输出

参考链接&#xff1a; 用Java格式化输出 看了好多人关于\t的用法&#xff0c;感觉找不到自己想要的答案&#xff0c;所以索性就自己输出来看看&#xff0c;如图&#xff1a;这样可以一目了然的看出来&#xff0c;\t&#xff08;制表符&#xff09;的作用就是看前面输出满不满8…
阅读更多...
微信抢房软件开发

微信抢房软件开发

2019独角兽企业重金招聘Python工程师标准>>> 这两年楼市真可谓是一个"火“字难以形容 经历了长沙两次开盘&#xff0c;都没有抢到&#xff0c;目前还没有买到房子&#xff0c;说说我的悲剧吧&#xff0c;让大伙都开心开心 第一次抢房是今年4月份长沙万科金域国…
阅读更多...
[转载] Java——数组习题

[转载] Java——数组习题

参考链接&#xff1a; Java从控制台读取输入的方法 package chap02; import java.util.Scanner; /** * * author admin * date 2020-4-8 * description: * 题目内容&#xff1a; 编写程序&#xff0c; 从控制台读取下面的信息&#xff0c; 每月按22天工作日计算&#xff0c;…
阅读更多...
超全Linux备份工具集合，满足你的所有需要！

超全Linux备份工具集合，满足你的所有需要！

经常备份计算机上的数据是个好的做法&#xff0c;它可以手动完成&#xff0c;也可以设置成自动执行。许多备份工具拥有不同的功能特性&#xff0c;让用户可以配置备份类型、备份时间、备份对象、将备份活动记入日志及执行更多操作。 1.Rsync这是一款在Linux用户当中颇受欢迎的命…
阅读更多...
[转载] Java内存管理-你真的理解Java中的数据类型吗（十）

[转载] Java内存管理-你真的理解Java中的数据类型吗（十）

参考链接&#xff1a; Java中的字符串类String 1 做一个积极的人 编码、改bug、提升自己 我有一个乐园&#xff0c;面向编程&#xff0c;春暖花开&#xff01; 推荐阅读 第一季 0、Java的线程安全、单例模式、JVM内存结构等知识梳理 1、Java内存管理-程序运行过程&#x…
阅读更多...
最新文章

Copyright @ 2022~2023