Stackoverflow上人气最旺的10个Java问题

（3623个赞）

如果执行下面的程序，程序解析两个间隔1秒的日期字符串并比较：

public static void main(String[] args) throws ParseException { 
 
    SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
 
    String str3 = "1927-12-31 23:54:07";  
 
    String str4 = "1927-12-31 23:54:08";  
 
    Date sDt3 = sf.parse(str3);  
 
    Date sDt4 = sf.parse(str4);  
 
    long ld3 = sDt3.getTime() /1000;  
 
    long ld4 = sDt4.getTime() /1000; 
 
    System.out.println(ld4-ld3); 
 
} 

输出是：

353 

为什么 ld4-ld3 不是1（因为我希望这两个时间差是一秒），而是353？

如果将日期字符串各加一秒：

String str3 = "1927-12-31 23:54:08";  
 
String str4 = "1927-12-31 23:54:09"; 

ld4-ld3 的结果是1.

sun.util.calendar.ZoneInfo[id="Asia/Shanghai", 
 
offset=28800000,dstSavings=0, 
 
useDaylight=false, 
 
transitions=19, 
 
lastRule=null] 
 
  
 
Locale(Locale.getDefault()): zh_CN 

解决方案

这是上海时区，在12月31日有一个变化。

查阅这个网址来了解上海在1927年时区变化的细节。基本上在1927年年底的午夜，始终会回拨5分52秒。所以“1927-12-31 23:54:08”实际上发生了两次，看起来Java解析了后一次的时间作为当地的日期和时间导致了差异。

我一直认为Java是引用传递；然而，我看了一堆博客（例如这篇）声称不是这样的。我认为我没有理解它们之间的区别。

给个解释？

解决方案

（2223赞）

直到今天我认为这个例子：

i += j; 

只是一个简写的：

i = i + j; 

但如果这样做：

int i = 5; 
long j = 8; 

然而 i = i + j; 没法编译，而 i += j; 就可以编译。

这意味着i += j; 实际上是i = (type of i) (i + j)的简写么？

解决方案

总有人问这类问题，JLS里有答案。参见 §15.26.2复合赋值运算符。摘录：

E1 op= E2 型的复合赋值表达式等价于 E1 = (T)((E1) op (E2))，这里 T 是 E1 的类型，不同的是 E1 只计算一次。

一个例子，引自 §15.26.2

[...] 下面的代码是正确的：

short x = 3; 
x += 4.6; 

x的结果等于7，因为它等价于：

short x = 3; 
x = (short)(x + 4.6); 

换句话说，你的假设是正确的。

Java中 HashMap 和 Hashtable的不同是什么？

非多线程应用中使用哪个更有效率？

解决方案

Java 中 HashMap 和 HashTable 有几个不同点：

因为同步对你来说不是个问题，我推荐使用HashMap。如果同步成为问题，你可能还要看看ConcurrentHashMap。

如果你有一个 java.io.InputStream 对象，如处理这个对象并生成一个字符串？

假定我有一个 InputStream 对象，它包含文本数据，我希望将它转化成一个字符串（例如，这样我可以将流的内容写到一个log文件中）。

InputStream 转化成 String 最简单方法是什么？

解决方案

使用 Apache commons IOUtils库来拷贝InputStream到StringWriter是一种不错的方式，类似这样：

StringWriter writer = new StringWriter(); 
IOUtils.copy(inputStream, writer, encoding); 
String theString = writer.toString(); 

甚至

// NB: does not close inputStream, you can use IOUtils.closeQuietly for that 
// 注意：不关闭inputStream，你可以使用 IOUtils.closeQuietly 
String theString = IOUtils.toString(inputStream, encoding); 

或者，如果不想混合Stream和Writer，可以使用 ByteArrayOutputStream。

#p#

在Swing中，密码字段有一个getPassword()（返回 char数组）方法而不是通常的getText()（返回String）方法。同样的，我遇到过一个建议，不要使用 String 来处理密码。

为什么String涉及到密码时，它就成了一个安全威胁？感觉使用char数组不太方便。

解决方案

String是不可变的。这意味着一旦创建了字符串，如果另一个进程可以进行内存转储，在GC发生前，（除了反射）没有方法可以清除字符串数据。

使用数组操作完之后，可以显式地清除数据：可以给数组赋任何值，密码也不会存在系统中，甚至垃圾回收之前也是如此。

所以，是的，这是一个安全问题 – 但是即使使用了char数组，仅仅缩小了了攻击者有机会获得密码的窗口，它值针对制定的攻击类型。

这样遍历entrySet：

public static void printMap(Map mp) { 
 
    Iterator it = mp.entrySet().iterator(); 
 
    while (it.hasNext()) { 
 
        Map.Entry pair = (Map.Entry)it.next(); 
 
        System.out.println(pair.getKey() + " = " + pair.getValue()); 
 
        it.remove(); // avoids a ConcurrentModificationException 
 
    } 
 
} 

更多请查阅Map。

我有一个数组，初始化如下：

Element[] array = {new Element(1), new Element(2), new Element(3)}; 

我希望将这个数组转化成一个ArrayList类的对象。

解决方案

new ArrayList<Element>(Arrays.asList(array)) 

9、产生一个Java的内存泄露

（1478个赞）

我有过一个面试，被问到如何产生一个Java内存泄露。不用说，我感到相当傻，甚至如何产生一个的线索都没有。

那么怎么才能产生一个内存泄露呢？

解决方案

在纯Java中，有一个很好的方式可以产生真正的内存泄露（通过执行代码使对象不可访问但仍存在于内存中）：

这样是有效的，因为ThreadLocal持有对象的引用，对象持有类的引用，接着类持有类加载器的引用。反过来，类加载器持有所有已加载类的引用。这会使泄露变得更加严重，因为很多JVM实现的类和类加载都直接从持久带（permgen）分配内存，因而不会被GC回收。

标准的解决方式（Java1.7 之前）如下：

import java.util.Random; 
public static int randInt(int min, int max) { 
    Random rand; 
    int randomNum = rand.nextInt((max - min) + 1) + min; 
    return randomNum; 
 
} 

请查看相关的JavaDoc。在实践中，java.util.Random 类总是优于 java.lang.Math.random()。

特别是当标准库里有一个直接的API来完成这个工作，就没有必要重复制造轮子了。