java 复习——数据类型

java基本数据类型：

整型

byte：8位，取值范围[-128,127]

short：16位，取值范围[-32768,32767]

int：32位，取值范围[-2147483648,2147483647],即[-2^31,(2^31)-1]，

long：64位，取值范围[-2^63,(2^63)-1]

浮点数

float：32位，单精度浮点数

double：64位，双精度浮点数

java中的浮点数可能会出现精度丢失的问题，因此做精确运算的时候可以用使用BigDecimal代替浮点数。

参考：java浮点数的精度问题

字符类型

char：16位。char类型表示单个字符，赋值时使用单引号'，char i='a';

布尔类型

boolean：true/false

转型

低字节到高字节可以自动转型:byte->short->int->long->float->double
高字节到低字节需要强制转型，会产生精度丢失问题。int a=(int)3.14;

包装类：

数据类型分为值类型和类类型。值类型没有可调用的方法。而类类型则有类方法可调用：

Integer：int 的包装类。

Character：char的包装类

Float：float的包装类

Double：double的包装类

Byte：byte的包装类

Short：short的包装类

Long：long的包装类

Boolean：boolean的包装类

装箱：把基本类型用它们对应的引用类型包起来

拆箱：将对象中的值从对象中提取出来（对象重新简化成值类型）。

jdk1.5以上提供自动装箱和拆箱功能。

查看下面一段代码？为什么两条输出不同？

Integer i1=100;//自动装箱，实际代码为Integer i1=Integer.valueOf(100);当int i=i1时会自动拆箱，即是int i=i1.intValue();
Integer i2=100;
System.out.println(i1==i2);//true
Integer i3=128;
Integer i4=128;
System.out.println(i3==i4);//false

这是因为在IntegerCache类中用一个数组缓存了值-128~127的Integer对象。对于-128~127之间的值，调用Integer.valueOf(int i)返回的是缓存的Integer对象。因此i1与i2其实同一个对象。

Integer.valueOf(int i)源码如下

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

IntegerCache源码如下

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

但是如果将上面的例子改为以下代码，输出的结果却不同。

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

这是因为==比较的是两个对象的引用是否相同，因为i1和i2都是通过new新建的对象，因此它们不是同一个对象。改为以下代码

System.out.println(i1.equals(i2));//true

则可以得到true结果。equals()比较的是两个对象值是否相同。

同理，LongCache也是一样的。LongCache源码如下

 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);
        }
    }

stackoverflow的解释：  Why does the behavior of the Integer constant pool change at 127

java自动装箱

而Float的valueOf(float f)则是直接返回new对象。

public static Float valueOf(float f) {
        return new Float(f);
    }

String类

String类被final修饰，被final修饰的类不能被继承。在类中使用char[]存储内容。String有两种赋值方式，一种是直接赋值：String s1="Hello";第二种是String s2=new String("Hello");前者会先在String Pool查找是否已经存在"Hello"，如果有直接返回它的引用给s1，否则则在String Pool中创建"Hello"，并将其放入String Pool中。再将它的引用返回给s1，而后者前面的操作以前者相同，但是它还会在内存中创建String对象，把内存上的String对象返回给s2。

String s1="Hello";//String Pool不存在"Hello"，创建新对象放入String Pool并返回引用给s1
String s2=new String("Hello");//String Pool已有"Hello"，String Pool不会创建"Hello"。在内存中创建"Hello"，并返回内存中的"Hello"引用给s2
String s3="Hello";//在String Pool已存在"Hello",返回String Pool中的"Hello"的引用给s3
System.out.println("s1==s2");//false
System.out.println("s1==s3");//true . s1和s3引用的是同一个对象。

参考: JAVA创建String对象的问题

String类不可变，String a="a"; a=a+"b"+"c"+"d";看起来a改变，其实是在String Pool分别创建创建了新对象为"ab","abc","abcd"并将"abcd"引用返回给a。

附上R神的关于String的一篇博客请别再拿“String s = new String("xyz");创建了多少个String实例”来面试了吧

为什么使用String Pool？

池化思想：用一个存储区把需要共享的数据放入以减少存储空间的开销。因为String是不可改变的Unicode字符序列，如果每次创建都需要新增字符串，将会更加系统的开销，所以使用一个存储区将其存储起来，节省内存。

What is the Java string pool and how is “s” different from new String(“s”)?

StringBulder,StringBuffer

都是可以改变的Unicode字符序列，不同的是StringBulder是线程安全，StringBuffer是非线程安全的。

其他

在java中，参数传递分为引用传递和值传递。一般情况下简单数据类型是值传递，类实例则是引用传递，String 是值传递的。但是这不是肯定的，看下面的代码，a2没有被改变。因为chang2(A a)中使用的new，则chang2中的a不再是指向传入的a的地址，而是一个新对象的地址，此后对a进行的操作不涉及到test2中的a2.

附上知乎上对java传值还是传引用的讨论

	class A{
		String name;
		A(){
			super();
		}
		A(String name){
			super();
			this.name=name;
		}
		public void setName(String name){
			this.name=name;
		}
		public String getName(){
			return name;
		}
	}
	
	@Test
	public void test2(){
		Integer i=12;
		String s="hello";
		A a=new A("jay");
		A a2=new A("www");
		change(i,s,a);
		change2(a2);
		logger.info(i.toString());//12，没有改变
		logger.info(s);//hello，没有改变
		logger.info(a.getName());//joy,从jay改为joy
		logger.info(a2.getName());//没有改变。
	}
	
	public void change(Integer i,String s,A a){
		i=2333;
		s="world";
		a.name="joy";
	}
	
	public void change2(A a){
		a=new A("3333");
	}