【java面试题】基本数据类型之类的问题。

最新推荐文章于 2022-03-14 11:19:28 发布

aosuizheng8460

最新推荐文章于 2022-03-14 11:19:28 发布

阅读量95

点赞数

文章标签：数据结构与算法 java

原文链接：http://www.cnblogs.com/JoeySong/p/8276475.html

版权

(黑色字体代表重点，红色字体代表不确定对错)

1、java中的基本数据类型

　　java是一个近乎纯洁的面向对象编程语音，引入基本数据类型是为了编程方便，但是为了能够将这些基本数据类型当成对象操作，java为每一个基本数据类型引入了对应的包装类型(wrapper class)。具体如下：

　　int　　---　　Integer

　　short　---　　Short

　　long　---　　Long

　　double　---　　Double

　　float　　---　　Float

　　boolean　---　　Boolean

　　byte 　　---　　Byte

　　char　---　　Character

从java 5 开始引入了自动装箱/拆箱机制，使得两者可以相互转换。

2、基本类型和引用类型的区别。

java中的数据类型分为两大类：基本数据类型和引用数据类型

基本类型的值就是一个数字，一个字符，或者一个布尔值。存放在栈空间中，未初始化时为随机值。

引用类型是一个对象类型，值是指向内存空间的引用，就是地址。所指向的内存中保存着变量所表示的一个值或一组值。存放在堆空间中，未初始化时由默认的值，比如int未初始化时为0，boolean未初始化时为false。

基本数据类型，包括数值型，字符型和布尔型。

引用数据类型：类、接口类型、数组类型、枚举类型、注解类型；

栈的数据大小和生存期都是确定的，特点是其中的数据可以共享，存取速度比对快，仅次于寄存器。主要存放基本类型的变量（byte,short,int,long,float,double,boolean,char）和对象引用。

例如：

int a=1;

int b=1;

以上变量的实现过程可以栈的数据共享，编译器首先处理a的实现，实现过程是先在栈中查找是否存在值为1的空间，如果有就直接将a指向该空间，如果没有就会开辟新空间，并把1存进来，因此，在处理b的实现时就会出现a,b都会指向同一个值为1的空间，实现共享。当修改b的值时，过程还是一样，比如，修改b=2,会查找为2的空间，有则指向，无则，保存。这样就会有利于空间的充分利用。

其中，String不是基本数据类型，是个引用类型，基础类型只表示简单的字符或数字，引用类型可以是任何复杂的数据结构，java虚拟机处理基础类型与引用类型的方式是不一样的，对于基本类型，java虚拟机会为其分配数据类型实际占用的内存空间，而对于引用类型变量，他仅仅是一个指向堆区中某个实例的指针。

 1 class AutoUnboxingTest {
 2 
 3     public static void main(String[] args) {
 4         Integer a = new Integer(3);
 5         Integer b = 3;                  // 将3自动装箱成Integer类型
 6         int c = 3;
 7         System.out.println(a == b);     // false 两个引用没有引用同一对象
 8         System.out.println(a == c);     // true a自动拆箱成int类型再和c比较
 9     }
10 }

1 public class Test03 {
2 
3     public static void main(String[] args) {
4         Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
5 
6         System.out.println(f1 == f2);   // true
7         System.out.println(f3 == f4);　　　//false
8     }
9 }

第二段代码中，第一个输出为true，第二个输出为false。

因为f1、f2、f3、f4四个变量都是Integer的对象引用，所以在下面的==运算比较的不是值，而是引用。装箱的本质就是在给Integer对象赋Int类型的值时，会调用Integer类的静态方法valueOf，下面是valueOf的源代码

1  public static Integer valueOf(int i) {
2         if (i >= IntegerCache.low && i <= IntegerCache.high)
3             return IntegerCache.cache[i + (-IntegerCache.low)];
4         return new Integer(i);
5     }

IntegerCache是Integer的内部类，其代码如下所示：

 1 /**
 2      * Cache to support the object identity semantics of autoboxing for values between
 3      * -128 and 127 (inclusive) as required by JLS.
 4      *
 5      * The cache is initialized on first usage.  The size of the cache
 6      * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 7      * During VM initialization, java.lang.Integer.IntegerCache.high property
 8      * may be set and saved in the private system properties in the
 9      * sun.misc.VM class.
10      */
11 
12     private static class IntegerCache {
13         static final int low = -128;
14         static final int high;
15         static final Integer cache[];
16 
17         static {
18             // high value may be configured by property
19             int h = 127;
20             String integerCacheHighPropValue =
21                 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
22             if (integerCacheHighPropValue != null) {
23                 try {
24                     int i = parseInt(integerCacheHighPropValue);
25                     i = Math.max(i, 127);
26                     // Maximum array size is Integer.MAX_VALUE
27                     h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
28                 } catch( NumberFormatException nfe) {
29                     // If the property cannot be parsed into an int, ignore it.
30                 }
31             }
32             high = h;
33 
34             cache = new Integer[(high - low) + 1];
35             int j = low;
36             for(int k = 0; k < cache.length; k++)
37                 cache[k] = new Integer(j++);
38 
39             // range [-128, 127] must be interned (JLS7 5.1.7)
40             assert IntegerCache.high >= 127;
41         }
42 
43         private IntegerCache() {}
44     }

如果整型字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，java中基本类型的包装类的大部分都实现了常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用常量池，也即对象不负责创建和管理大于127的这些类的对象。

转载于:https://www.cnblogs.com/JoeySong/p/8276475.html