CSS Hack 链接

• Vertical centering using CSS
• Vertical Centering in CSS
• CSS List Grid Layout

Java 从控制台中读取数据完全攻略

详尽地介绍了JDK各版本从控制台中读入数据的方法，并且分析了它们的优缺点，以及给出了一些使用建议。

从控制台中读取数据是一个比较常用的功能，在 JDK 5.0 以前的版本中的实现是比较复杂的，需要手工处理系统的输入流。有意思的是，从 JDK 5.0 版本开始，能从控制台中输入数据的方法每增加一个版本号，就有一种新增的方法，这也增加了选择的种类，可以依据不同的要求来进行选择。下面来看一下，各个版本中如何从控制台中读取数据以及各自的优缺点。

JDK 1.4 及以下版本读取的方法

JDK 1.4 及以下的版本中要想从控制台中输入数据只有一种办法，即使用System.in获得系统的输入流，再桥接至字符流从字符流中读入数据。示例代码如下：

import java.io.IOException;
import java.io.InputStreamReader;

public class Test1 {

    public static void main(String[] args) {
        String str = readString("请输入字符串：");
        System.out.println("readString 方法的输入：" + str);
    }

    /**
     * 使用系统的输入流，从控制台中读取数据

     * 用于所用的JDK版本
     * @param prompt 提示信息
     * @return 输入的字符串
     */
    private static String readString(String prompt) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        try {
            System.out.print(prompt);
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
}

从上面的代码段来看，这种控制台输入的方法非常地麻烦，为了能读取整行的数据，采用了BufferedReader类来进行处理，而且在读取的过程中还需要捕获IOException。不过这是 JDK 1.4 及以下版本中从控制台读取数据唯一的办法。还有一种非控制台读入数据的办法，就是采用 Swing 中的JOptionPane，会弹出一个非常漂亮的输入对话框让使用者输入数据，但这是一种比较另类的做法，不推荐使用。

import javax.swing.JOptionPane;

public class Test2 {

    public static void main(String[] args) {
        String str = readStringFromDialog("请输入字符串：");
        System.out.println("readStringFromDialog 方法的输入：" + str);
    }

    /**
     * 使用JOptionPane的输入对话框，输入字符串

     * 用于所用的JDK版本
     * @param prompt 提示信息
     * @return 输入的字符串
     */
    private static String readStringFromDialog(String prompt) {
        return JOptionPane.showInputDialog(prompt);
    }
}

上面的两种方法都有个共同的缺点——只能读取字符串，若需要读取其他类型的数据需要手工进行转换。

JDK 5.0 读取的方法

从 JDK 5.0 开始，基本类库中增加了java.util.Scanner类，根据它的 API 文档说明，这个类是采用正则表达式进行基本类型和字符串分析的文本扫描器。使用它的Scanner(InputStream source)构造方法，可以传入系统的输入流System.in而从控制台中读取数据。示例代码如下：

import java.util.Scanner;

public class Test3 {

    public static void main(String[] args) {
        String str = readString5("请输入字符串：");
        System.out.println("readString5 方法的输入：" + str);
    }

    /**
     * 使用扫描器类（Scanner）从控制台中读取字符串

     * 适用于JDK 5.0及以后的版本
     * @param prompt 提示信息
     * @return 输入的字符串
     */
    private static String readString5(String prompt) {
        Scanner scanner = new Scanner(System.in);
        System.out.print(prompt);
        return scanner.nextLine();
    }
}

从代码量上来看，Test3比Test1少了很多的代码，核心代码只有两行。其实并不是Scanner将控制台输入给简单化了，只是在其内部的实现中已经将IOException处理了，而且采用InputStreamReader来一个字符一个字符进行扫描读取的（嘿嘿，它本身就是个扫描器），只是Scanner做了更高层次的封装。

Scanner不仅可以从控制台中读取字符串，还可以读取除char之外的其他七种基本类型和两个大数字类型，并不需要显式地进行手工转换。Scanner不单单只能扫描控制台中输入的字符，它还可以让读入的字符串匹配一定的正则表达式模式，如果不匹配时将抛出InputMismatchException异常。

使用System.in作为它的构造参数时，它只扫描了系统输入流中的字符。它还有其他的构造，分别可以从文件或者是字符串中扫描分析字符串的，具体的使用方法可以参考 API 文档说明。

JDK 6.0 读取的方法

从 JDK 6.0 开始，基本类库中增加了java.io.Console类，用于获得与当前 Java 虚拟机关联的基于字符的控制台设备。在纯字符的控制台界面下，可以更加方便地读取数据。示例代码如下：

import java.io.Console;
import java.util.Scanner;

public class Test4 {

    public static void main(String[] args) {      
        String str = readString6("请输入字符串：");
        System.out.println("readString6 方法的输入：" + str);
    }
    
    /**
     * 使用控制台类（Console）从控制台中读取字符串

     * 适用于JDK 1.6或以后的版本
     * @param prompt 提示信息
     * @return 输入的字符串
     */
    private static String readString6(String prompt) {
        Console console = System.console();
        if (console == null) {
            throw new IllegalStateException("不能使用控制台");
        }
        return console.readLine(prompt);
    }
}

在Test1和Test3中，输入数据前的提示信息需要使用System.out.print();来输出，但是使用基于Console的Test4类，可以在方法参数中直接放入提示信息。

如果需要在控制台中输入密码等敏感信息的话，像在浏览器或者是应用程序中那样显示替代字符，在 JDK 6.0 以前的做法是相当麻烦的（具体的做法可以参考Java 编程语言中的口令屏蔽一文），而使用Console类的readPassword()方法可以在控制台上不回显地输入密码，并将密码结果保存在char数组中，根据 API 文档的建议，在使用后应立即将数组清空，以减少其在内存中占用的时间，以便增强安全性。

但是，Console也有一些缺点，根据ConsoleAPI 文档的说明：

虚拟机是否具有控制台取决于底层平台，还取决于调用虚拟机的方式。如果虚拟机从一个交互式命令行开始启动，且没有重定向标准输入和输出流，那么其控制台将存在，并且通常连接到键盘并从虚拟机启动的地方显示。如果虚拟机是自动启动的（例如，由后台作业调度程序启动），那么它通常没有控制台。

通过上面的文档说明可以看出，在使用 IDE 的情况下，是无法获取到Console实例的，原因在于在 IDE 的环境下，重新定向了标准输入和输出流，也是就是将系统控制台上的输入输出重定向到了 IDE 的控制台中。因此，在 IDE 中不能使用这个程序，而Test1和Test3就没有这种限制。

总结

以上囊括了 Java 中各种版本从控制台中读入数据的方法，将对它们的优缺点进行了分析。下面给出了一些使用建议，可供参考：

• JRE 1.4 或以下版本的情况下，没得选择只能采用Test1或者是非控制台读入的Test2的方法。
• JRE 5.0 的情况下，建议使用基于Scanner的Test3的方法，更方便地进行数据读取。
• JRE 6.0 的情况，并且只在字符界面的控制台下运行时，采用Test4的方法，如果需要读入像密码之类的敏感数据，为了安全性考虑也必须使用Test4或者是自行实现。如果需要读入除字符串类型之外的其他数据类型，建议使用基于Scanner的控制台输入。

本文最初发布于 CSDN 博客Java从控制台中读取数据完全攻略

Win32 FILETIME 结构与 java.util.Date 互转

今天在 CSDN 上有人问起 Win32 FileTime 格式与 Java 中Date格式如何进行相互转换。详见：http://topic.csdn.net/u/20090420/11/8016744d-d151-4041-a837-5a14f2592e3f.html

根据 MSDN 上关于FILETIME结构的描述，可以很方便地在FILETIME与 Java 中Date进行互转。根据 MSDN 上的说明，FILETIME采用 64 位数值表示与 UTC 时间 1601 年 1 月 1 日 0 时起百纳秒的时间间隔。

根据 MSDN 上的描述，FILETIME的结构如下：

typedef struct _FILETIME {
    DWORD dwLowDateTime;
    DWORD dwHighDateTime;
} FILETIME, *PFILETIME;

由于DWORD仅能表示 32 位无符号的整数，因此要需要使用两个DWORD才能表示 file time。dwLowDateTime是指 file time 的低 32 位值，而dwHighDateTime是指 file time 的高 32 位值。

在 Java 中的时间是采用 Unix 纪元，即与 UTC 时间 1970 年 1 月 1 日 0 时起的毫秒时间间隔，在 Java 中是使用long类型来表示这个值的。

有了上面的知识点，就可以很容易地把 Win32 FileTime 时间与 Java 中Date进行互相转换。需要做的是计算出 1601 年 1 月 1 日 0 时与 1970 年 1 月 1 日 0 时之间的毫秒数差值，再加上 Unix 纪元的毫秒数时间，再将其换算成百纳秒就可以进行转换了。按 Unix 纪元 1970 年 1 月 1 日 0 时之前均为负数。

由于涉及时间计算，为了保证正确性，先用代码来校验一下时区，看看 1970 年 1 月 1 日 0 时是否为 0。

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test5 {

    public static void main(String[] args) {
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = parseDate("1970-01-01 00:00:00", format);
        System.out.println(date.getTime());
    }
    
    public static Date parseDate(String str, DateFormat format) {
        Date date = null;
        try {
            date = format.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

上面代码运行的结果是：

-28800000

可见这个结果是不正确的，由于我们当前系统的时区是 GMT+8 区，也就是比格林尼治标准时间相差 8 个小时，这 28800000 也正好是 8 个小时的毫秒数。我们只要为DateFormat加上下面这一段代码就可以将格式化器转为 GMT 时间（对于本文而言 UTC 时间与 GMT 时间没有区别，具体的区别可以参考其他资料）。

public static void main(String[] args) {
    DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    format.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date date = parseDate("1970-01-01 00:00:00", format);
    System.out.println(date.getTime());
}

此时我们输出的结果就是 0 了，再将其换成“1601-01-01 00:00:00”时输出为：

-11644473600000

由于这个值是个常量固定值，将这个值取绝对值暂且命名为UNIX_FILETIME_MILLISECOND_DIFF。

接下来需要获得毫秒数与百纳秒数的倍率。众所周知，1 秒等于 10³ 毫秒，而 1 毫秒等于 10⁶ 纳秒，因此可以推算出 1 毫秒等于 10⁴ 百纳秒。

由于FILETIME结构是采用两个DWORD来表示的，对于 Java 而言，可以将DWORD映射为int类型。通过移位运算符<<可以将这两个 32 位的int转换为 64 位的long数据，以便于对 Unix 纪元毫秒数的计算。

为了采用面向对象的方式进行设计，可以仿照FILETIME结构的定义，声明一个FILETIME的类，其中包含高 32 位数字和低 32 位数字。为了封装一下，把 Unix 纪元与FILETIME零起点的毫秒值与毫秒与百纳秒的倍率置为常量。

public class FileTime {
    
    /**
     * Unix 时间 1970-01-01 00:00:00 与 Win32 FileTime 时间 1601-01-01 00:00:00
     * 毫秒数差 
     */
    public final static long UNIX_FILETIME_MILLISECOND_DIFF = 11644473600000L;
    
    /**
     * Win32 FileTime 采用 100ns 为单位的，定义 100ns 与 1ms 的倍率
     */
    public final static int MILLISECOND_100NANOSECOND_MULTIPLE = 10000;
    
    /**
     * FileTime 的低 32 位数
     */
    private int low;
    
    /**
     * FileTime 的高 32 位数
     */
    private int high;
    
    public FileTime() {
        
    }
    
    /**
     * 获得 FileTime 以 64 位数字表示的数据
     * @return
     */
    public long getFileTime() {
        return (((long)high << 32) & 0xffffffff) | ((long)low & 0xffffffff);
    }
    
    public FileTime(int low, int high) {
        this.low = low;
        this.high = high;
    }

    public int getLow() {
        return low;
    }
    
    public void setLow(int low) {
        this.low = low;
    }
    
    public int getHigh() {
        return high;
    }
    
    public void setHigh(int high) {
        this.high = high;
    }
    
    public String toString() {
        return "high: " + high + ", low: " + low;
    }
}

定义好了结构，为了能与java.util.Date互转，还需要增加一个toDate的方法和一个date2FileTime的静态方法。

/**
 * 将 Win32 的 FileTime 结构转为 Java 中的 Date 类型
 * @param fileTime
 * @return
 */
public Date toDate() {
    return new Date(getFileTime() / MILLISECOND_100NANOSECOND_MULTIPLE - 
            UNIX_FILETIME_MILLISECOND_DIFF);
}

/**
 * 将 Java 中的 Date 类型转为 Win32 的 FileTime 结构
 * @param date
 * @return
 */
public static FileTime date2FileTime(Date date) {
    long time = (UNIX_FILETIME_MILLISECOND_DIFF + date.getTime()) * 
            MILLISECOND_100NANOSECOND_MULTIPLE;
    FileTime fileTime = new FileTime();
    fileTime.setHigh((int)(time >> 32) & 0xffffffff);
    fileTime.setLow((int)time & 0xffffffff);
    return fileTime;
}

结构和代码都定义完成了，写个测试代码来测试一下，看看“2010-07-10 15:35:18”的 FileTime 值是多少。

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test5 {

    public static void main(String[] args) {
        
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        Date date1 = parseDate("2010-07-10 15:35:18", format);
        
        FileTime fileTime = FileTime.date2FileTime(date1);
        System.out.println(fileTime.toString());
        
        FileTime fileTile = new FileTime();
        fileTile.setHigh(30089218);
        fileTile.setLow(1907785472);
        Date date2 = fileTile.toDate();
        System.out.println(format.format(date2));
    }
    
    public static Date parseDate(String str, DateFormat format) {
        Date date = null;
        try {
            date = format.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

更多阅读

• 在中文维基百科上可以找到协调世界时（UTC）与格林尼治标准时间（GMT）的相关资料，也可以在其他资源上搜索到相关资料。
• 在 MSDN 上可以找到更多关于FILETIME结构的描述，
• 更多关于java.text.SimpleDateFormat格式参数的信息可以参见这个类的API 文档。
• 如果对于java.util.TimeZone这个类不是很了解的话，可以参见这个类的API 文档。

Java 开发 without MyEclipse

在各大论坛上看到大多数的 Java 开发人员使用的开发工具是 MyEclipse。

（编辑进行中）

Java 中的运算符

优先级	操作符	含义	关联性	用法
1	[ ]	数组下标	左	array_name[expr]
	.	成员选择	左	object.member
	( )	方法参数	左	method_name(expr_list)
	( )	实例构造	左	class_name(expr_list)
	++	后缀自增	左	lvalue++
	--	后缀自减	左	lvalue--
2	++	前缀自增	右	++rvalue
	--	前缀自减	右	--lvalue
	~	按位取反	右	~expr
	!	逻辑非	右	!expr
	+	一元加	右	+expr
	-	一元减	右	-expr
3	( )	强制转换	右	(type)expr
	new	对象实例化	右	new type() new type(expr_list) new type[expr]
4	*	乘	左	expr * expr
	/	除	左	expr / expr
	%	求余	左	expr % expr
5	+	加	左	expr + expr
	-	减	左	expr - expr
	+	字符串连接	左	strExpr + strExpr
6	>>	有符号右移	左	expr >> distance
	>>>	无符号右移	左	expr >>> distance
7	<	小于	左	expr < expr
	<=	小于等于	左	expr <= expr
	>	大于	左	expr > expr
	>=	大于等于	左	expr >= expr
	instanceof	类型比较	左	ref instanceof refType
	==	等于	左	expr == expr
	!=	不等于	左	expr != expr
8	&	整数按位与	左	integralExpr & integralExpr
	&	布尔与	左	booleanExpr & booleanExpr
9	^	整数按位异或	左	integralExpr ^ integralExpr
	^	布尔异或	左	booleanExpr ^ booleanExpr
10	|	整数按位或	左	integralExpr | integralExpr
	|	布尔或	左	booleanExpr | booleanExpr
11	&&	逻辑与	左	booleanExpr && booleanExpr
12	||	逻辑或	左	booleanExpr || booleanExpr
13	? :	条件运算	右	booleanExpr ? expr : expr
14	=	赋值	右	lvalue = expr
	*=	乘赋值	右	lvalue *= expr
	/=	除赋值	右	lvalue /= expr
	%=	模赋值	右	lvalue %= expr
	+=	加赋值	右	lvalue += expr
	+=	字符串连接赋值	右	lvalue += expr
	-=	减赋值	右	lvalue -= expr
	<<=	左移赋值	右	lvalue <<= expr
	>>=	有符号右移赋值	右	lvalue >>= expr
	>>>=	无符号右移赋值	右	lvalue >>>= expr
	&=	整数按位与赋值	右	lvalue &= expr
	&=	布尔与赋值	右	lvalue &= expr
	|=	整数按位或赋值	右	lvalue |= expr
	|=	布尔或赋值	右	lvalue |= expr
	^=	整数按位异或赋值	右	lvalue ^= expr
	^=	布尔异或赋值	右	lvalue ^= expr