java中的一些坑

下面是去年的时候分享的一些java小知识点，今天在电脑里看到了，贴到这里。

其中一些来自《java解惑》、一些来自自己平时的积累，还有一些是在项目中掉到了“坑”里后才明白的

 

 

1.除0

代码：

 

        System.out.println(1.0d / 0);
        System.out.println(0.0d / 0);
        System.out.println(1 / 0);
        System.out.println(0 / 0);

 

 

输出：

Infinity

NaN

java.lang.ArithmeticException: / by zero

at test.ww.Test.main(Test.java:27)

java.lang.ArithmeticException: / by zero

at test.ww.Test.main(Test.java:32)

 

原因：

因为 IEEE 754 有规定无穷大是怎么表示的，因此被除数不为 0，除数是 0 的话计算结果是正无穷或者是负无穷，如果被除数和除数都是 0 的话，那么计算结果是 NaN

 

整数不在是 IEEE 754 规定的，也没有无穷大的表示，因此只能抛出异常了

 

2. Arrays.asList？可变长参数？

 

 

int[] arr = new int[]{1,2,3};
System.out.println(Arrays.asList(arr).contains(1));

 

 

 

输出什么？

大多数人的回答肯定是true，显而易见么。。但它输出的却是false，为什么，哪里出错了么？

分解一下表达式，先调用Arrays.asList(arr),通过遍历或者debug你会发现里面的元素个数为1，这又是什么原因呢，查看一下API或者源代码，发现它声明为List Arrays.asList（T... args），难道是可变长参数有问题？

做一个测试：

 

 public static void main(String[] args) {

        int[] arr = new int[]{1, 2, 3 };
        test1(arr);

    }

    private static void test1(Object... values) {
        System.out.println(values.length);
    }

 

 

 

输出

1

把int数组改为Integer数组后，输出

3

 

看来是基本类型的数组被当作了一个对象，而对象类型的数组的每个元素才能分别作为可变长参数方法的参数。

 

3.诡异的三元表达式

三元表达式，注释部分是该行的输出，为啥？

 

char x = 'X';
int i = 0;
System.out.println(true ? x : 0);// X
System.out.println(false ? i : x);// 88

 

 

原因：

 true ? x : 0返回的是x的类型，即char型，调用char的toString方法，输出X

 false ? i : x返回的是i的类型，即int型，先把‘X’转为整型（88），再输出。

 

即三元运算符返回类型以第二个变量为主（问号后第一个）

4.我的钱呢？

total是你兜里的所有的钱，price是你要买的东西的价格，remaining是剩余的钱。count是你最多买的东西的数量，请问下面的代码有什么问题，输出什么？

 

        
        double total = 2.0;
        double price = 0.1;
        double remaining = total;
        int count = 0;
        while (remaining >= price) {
            count++;
            remaining -= price;
        }
        System.out.println(count);
        System.out.println(remaining);

 代码看起来没有问题，判断兜里的钱大于物品的价格就买一个，直到买不起为止，看起来应该输出20和0.

可运行后会发现输出19和0.09999999999999937（可能根据不同的机器这个余数略有差异）。

钱怎么少了？

 

这个原因，和二进制无法精确的表示某些浮点数有关，2.0-1.1结果是0.899999999999。

所以，如果你想要精确的浮点数，请使用BigDecimal类进行运算，当然可能会慢一些，需要自己权衡。

5.x+=i等同于x = x + i？

1）

 

        short x = 1;
        int i = 1;
        x += i;
        x = x + i;

 

 

当你试图编译上面代码的时候，编译器会报错，在x=x+i的地方：Type mismatch: cannot convert from int to short

2)

        Object x = 1;
        String i = "";
        x += i;
        x = x + i;

 

当你试图编译上面代码的时候，编译器会报错，在x += i;的地方：The operator += is undefined for the argument type(s) Object, String

 

6.字符连接？？？

 System.out.println('N' + 'C');

当你运行上面代码的时候，它不会如你所愿输出NC，而会输出145，这是怎么了？

char型变量的加法不是连接字符，而是和int类似，但相加的是它的ASCII码，本例中输出78+67=145

7.E呢？

StringBuffer sb = new StringBuffer('E');
sb.append('M');
sb.appent('S');
System.out.println(sb.toString());

 

 

当你满心欢喜的运行上面代码的时候，会发现它并没有如你所愿的输出EMS，而是输出了MS，E呢？

 

看来是StringBuffer的构造器出问题，当你查看StringBuffer的构造函数的时候，你会惊奇的发现它并不提供char型参数的构造器，这是怎么回事？

如果你使用eclipse或者其他IDE点进入的时候，会发现new StringBuffer('E');进入的是StringBuffer（int）的构造器，这个构造器只是初始化了一下缓冲区大小。

 

到这里应该都明白了，所以使用char的时候要注意，它有时候更像是int而不是String。

 

8.单例？

相同虚拟机下下面的类什么时候能得到多于一个实例？

 

public class Test implements Seraziable{
    private static Test  instance = null;
    private Test (){
    }

    public static Test getInstance() {
        if(instance == null) { 
            instance = new Test();
        }
    }
}

 

 

第一个想到的应该是多线程，两个线程同时访问的时候可能会产生两个实例。

细心的人会发现这个类实现了序列化接口，也就是序列化反序列化的时候也可能产生多个实例：

 

 

public class TestSerializable implements Serializable {
    private static final TestSerializable instance = new TestSerializable();
    private String name = "t1";
    private TestSerializable() {
        System.out.println("**********TestSerializable************");
    }
    public static TestSerializable getInstance() {
        return instance;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static void main(String[] args) throws Exception {
        TestSerializable singleton = TestSerializable.getInstance();
         
        FileOutputStream fos = new FileOutputStream("E:\\test.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(TestSerializable.getInstance());
        oos.flush();
        oos.close();
        
        FileInputStream fis = new FileInputStream("E:\\test.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        
        TestSerializable singleton2 = (TestSerializable)ois.readObject();
        singleton.setName("111");
        System.out.println(singleton.getName());
        System.out.println(singleton2.getName());
    }
}

 

输出：

111

t1

 

解决这个问题首先要知道反序列化的时候怎么执行的，通过查找资料，知道了反序列化的时候调用了方法

private Object readResolve()

jdk有个默认的反序列化方式，会从序列化文件读取信息，并创建实例（不通过构造函数），然后对变量赋值。

 

如果不考虑远程传数据，下面的办法可以保证当前jvm只有一个实例：

在类中增加方法：

private Object readResolve(){
        return instance;
    }

 

 

输出：

**********TestSerializable************

111

111

但是这样仅仅保证了单例，而丢失了序列化应有的功能。

所以大家在设计可序列化接口的类时要多多考虑。

 

9.泛型？

编译下面的类，会发现编译器报错：Method test(List) has the same erasure test(List) as another method in type Test001

public class Test001 {

    public void test(List lst) {
    }
    public void test(List