本文假设您已基本了解 SAX 和 DOM。如果您完全不懂 XML 解析，那么可能需要首先阅读在线参考资料中有关 SAX 和 DOM 的信息，或者浏览我的书（参阅 参考资料）。您不需要精通回调或 DOM Node，但必须至少了解是 SAX 和 DOM 在解析 API。本文还有助于基本了解它们之间的差别。如果您掌握了这些基本知识，本文将对您更有帮助。

JAXP：是 API 还是抽象？

严格说来，JAXP 是 API，但更准确地说是抽象层。它没有提供解析 XML 的新方法，没有添加到 SAX 或 DOM，也没有为 Java 和 XML 处理提供新功能。（如果您还不相信这一点，那么阅读这篇文章算对了。）但是，JAXP 使得使用 DOM 和 SAX 来处理一些困难任务变得更容易。它还允许以开发商中立的方式处理一些在使用 DOM 和 SAX API 时可能遇到的特定于开发商的任务。

逐渐晋级 在 Java 平台的早期版本中，JAXP 是核心平台中单独的下载。在 Java 5.0 中，JAXP 已经是 Java 语言的主要产品。如果已经有最新版本的 JDK（参阅 参考资料），您就已经获得了 JAXP。

没有 SAX、DOM 或另一个 XML 解析 API，则无法解析 XML。我曾经看到过许多关于将 SAX、DOM、JDOM 和 dom4j 与 JAXP 进行比较的请求，但作这样的比较是不可能的，因为前面四个 API 与 JAXP 具有完全不同的用途。SAX、DOM、JDOM 和 dom4j 都解析 XML。JAXP 提供了一种到达这些解析器及其所涉及的数据的方法，但并未提供一种解析 XML 文档的新方法。如果您要正确使用 JAXP，则理解此差别是非常必要的。这还很有可能使您远远领先于您的 XML 开发同行。

如果仍有疑问，请确保您具有 JAXP 发行版（参阅 逐渐晋级）。启动 Web 浏览器并加载 JAXP API 文档。导航至位于 javax.xml.parsers 软件包中的 API 的解析部分。令人奇怪的是，您将只找到六个类。这个 API 到底怎么回事？所有这些类都位于现有解析器的顶部。其中两个类仅用于错误处理。JAXP 比人们想像的要简单得多。那么为何会有混淆呢？

位于顶部 甚至 JDOM 和 dom4j（参阅 参考资料）与 JAXP 一样都位于其他解析 API 的顶部。但这两个 API 都提供了从 SAX 或 DOM 中访问数据的不同模型，它们在内部使用 SAX（带有一些技巧和修改）来到达它们提供给用户的数据。

Sun 的 JAXP 和 Sun 的解析器

许多解析器/API 混淆来自于 Sun 软件包 JAXP 和该 JAXP 默认使用的解析器。在 JAXP 的早期版本中，Sun 包括 JAXP API（带有刚才提到的六个类和一些常用于转换的类）和 一个叫做 Crimson 的解析器。Crimson 是 com.sun.xml 软件包的一部分。在 JAXP 的新版本中 —— 包括在 JDK 中 —— Sun 已经重新包装了 Apache Xerces 解析器（参阅 参考资料）。在这两种情况下，虽然解析器是 JAXP 发行版的一部分，但不是 JAXP API 的一部分。

可以认为是 JDOM 附带了 Apache Xerces 解析器。该解析器不是 JDOM 的一部分，但由 JDOM 使用，所以包括它是为了确保 JDOM 可以即装即用。同一原则适用于 JAXP，但并未明确公布：JAXP 附带解析器是为了可以立即使用。但是，许多人将 Sun 的解析器中包括的类作为 JAXP API 本身的一部分。例如，新闻组上的常见问题通常是“我如何使用 JAXP 附带的 XMLDocument 类？它的作用是什么？”答案有些复杂。

软件包名称中是什么？ 当我第一次在 Java 1.5 中贸然打开源代码时，我惊奇于我所看到的 —— 或者更应该说是我没有 看到的。没有在正常中的软件包 org.apache.xerces 中找到 Xerces，因为 Sun 将 Xerces 类重新分配给了 com.sun.org.apache.xerces.internal。（我发现这有点不正常，但没有人问我。）在任何情况下，如果您在 JDK 中查找 Xerces，就能找到它。

首先，com.sun.xml.tree.XMLDocument 类不是 JAXP 的一部分。它是 Sun 的 Crimson 解析器的一部分，包装在 JAXP 的早期版本中。所以这个问题从一开始就令人误解。其次，JAXP 的主要用途是在处理解析器时提供开发商独立性。有了 JAXP，您可以用 Sun 的 XML 解析器、Apache 的 Xerces XML 解析器和 Oracle 的 XML 解析器来处理相同的代码。因而使用特定于 Sun 的类会违反使用 JAXP 的要点。是否弄清楚了本主题是如何变得复杂起来的？JAXP 发行版中的 API 和解析器 已经组合在一起，一些开发人员误将解析器中的类和特性作为 API 的一部分，反之亦然。

既然弄清楚了所有的混淆，那么您就可以深入了解一些代码和概念了。

回页首

SAX 入门

SAX 是事件驱动的 XML 处理方法。它由许多回调组成。例如，startElement() 回调在每次 SAX 解析器遇到元素的起始标记时被调用。characters() 回调为字符数据所调用，然后 endElement() 为元素的结束标记所调用。许多回调用于文档处理、错误和其他词汇结构。您明白了。SAX 程序员实现一个 SAX 接口来定义这些回调。SAX 还提供一个叫做 DefaultHandler 的类（在 org.xml.sax.helpers 软件包中）来实现所有这些回调，并提供所有回调方法默认的空实现。（您将看到，这对于下一节 处理 DOM 中讨论 DOM 是重点。）SAX 开发人员只需要继承该类，然后实现需要插入特定逻辑的方法。所以 SAX 中的关键是提供这些各种回调的代码，然后让解析器在适当的时候触发其中的一个。下面是典型的 SAX 例程：

1. 使用特定开发商的解析器实现来创建 SAXParser 实例。
2. 注册回调实现（例如，通过使用继承 DefaultHandler 的类）。
3. 开始解析并在回调实现启动时停止。

JAXP 的 SAX 组件提供了完成所有这些操作的简单方法。没有 JAXP，SAX 解析器实例要么必须从开发商类（比如 org.apache.xerces.parsers.SAXParser）中直接实例化，要么必须使用一个叫做 XMLReaderFactory 的 SAX 帮助类（也在 org.xml.sax.helpers 软件包中）。第一种方法的问题很显然：它不是开发商中立的。第二种方法的问题在于，工厂需要使用解析器类的 String 名称作为参数（又是 Apache 类 org.apache.xerces.parsers.SAXParser）。可以通过传递不同的解析器类作为 String 而更改解析器。使用该方法，如果更改解析器名称，则不需要更改任何导入语句，但仍需要重新编译类。这显然不是最好的解决方案。如果能够不重新编译类而更改解析器就方便多了。

JAXP 提供了更好的备选方法：它允许将解析器作为 Java 系统特性。当然，从 Sun 中下载发行版时，您能得到使用 Sun 的 Xerces 版本的 JAXP 实现。更改解析器（比如更改为 Oracle 的解析器）需要更改类路径设置，从一个解析器实现移动到另一个解析器实现。但不 需要重新编译代码。这就是 JAXP 的全部魔力 —— 抽象。

诡异的 SAX 开发人员 稍叉开一下话题。使用巧妙一点的编码，可以使得 SAX 应用程序从系统特性或特性文件中选择要使用的解析器类。但是，JAXP 提供了相同的行为，且无需任何工作，所以大多数人更愿意走 JAXP 路线。

SAX 解析器工厂一览

JAXP SAXParserFactory 类是能够轻易更改解析器实现的关键。必须创建该类的新实例（一会将用到它）。新实例创建之后，工厂提供一种方法用于获得具有 SAX 功能的解析器。实际上，JAXP 实现保护着开发商相关的代码，从而使您的代码完全不受污染。工厂还具有一些其他的有用特性。

除了创建 SAX 解析器实例的基本工作之外，工厂还允许设置配置选项。这些选项影响通过工厂获得的所有解析器实例。JAXP 1.3 中两个常用的选项是，用于设置名称空间意识的 setNamespaceAware(boolean awareness) 和用于打开 DTD 验证的 setValidating(boolean validating)。记住，一旦设置了这些选项，它们将影响在方法调用后从工厂获得的所有实例。

设置了工厂之后，调用 newSAXParser() 会返回 JAXP SAXParser 类立即可用的实例。该类包装底层的 SAX 解析器（SAX 类 org.xml.sax.XMLReader 的实例）。它还防止您使用解析器类的任何特定于开发商的附加项。（是否记得上文中有关 XmlDocument 类的 讨论？）该类允许启动实际的解析行为。清单 1 显示如何创建、配置和使用 SAX 工厂：

import java.io.OutputStreamWriter;
import java.io.Writer;
// JAXP
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.parsers.SAXParser;
// SAX
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class TestSAXParsing {
    public static void main(String[] args) {
        try {
            if (args.length != 1) {
                System.err.println ("Usage: java TestSAXParsing [filename]");
                System.exit (1);
            }
            // Get SAX Parser Factory
            SAXParserFactory factory = SAXParserFactory.newInstance();
            // Turn on validation, and turn off namespaces
            factory.setValidating(true);
            factory.setNamespaceAware(false);
            SAXParser parser = factory.newSAXParser();
            parser.parse(new File(args[0]), new MyHandler());
        } catch (ParserConfigurationException e) {
            System.out.println("The underlying parser does not support " +
                               " the requested features.");
        } catch (FactoryConfigurationError e) {
            System.out.println("Error occurred obtaining SAX Parser Factory.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class MyHandler extends DefaultHandler {
    // SAX callback implementations from ContentHandler, ErrorHandler, etc.
}

在 清单 1 中，可以看到在使用工厂时出现两个特定于 JAXP 的问题：无法获得或配置 SAX 工厂，及无法配置 SAX 解析器。第一个问题由 FactoryConfigurationError 表示，通常发生在无法获得 JAXP 实现或系统特性中指定的解析器时。第二个问题由 ParserConfigurationException 表示，发生在请求的特性在所使用的解析器中不可用时。两个问题都易于处理，且不应在使用 JAXP 时造成任何困难。事实上，您可能想要编写代码，来尝试设置几个特征并巧妙处理某个特性不可用时的情况。

SAXParser 实例是在获得工厂、关闭名称空间支持并打开验证时获得的；然后解析开始。SAX 解析器的 parse() 方法采用前面提到的 SAX HandlerBase 帮助类的一个实例，自定义处理器类继承自该类。请参阅代码发行版来查看该类的实现的完整 Java 清单（参阅 下载）。还传递 File 以进行解析。但是，SAXParser 类不只包含这一个方法。

使用 SAX 解析器

一旦具有 SAXParser 类的实例后，您可以做的远远不止于给它传递 File 来解析。由于大型应用程序中组件的通信方式，所以假设对象实例的创建者就是它的用户并不总是安全的。一个组件可能创建 SAXParser 实例，而另一个组件（可能由另一个开发人员编码）可能需要使用相同的实例。因此，JAXP 提供了确定解析器的设置的方法。例如，可以使用 isValidating() 来确定解析器是否将执行验证，使用 isNamespaceAware() 来查看解析器是否可以处理 XML 文档中的名称空间。这些方法可以为您提供关于解析器可以做什么的信息，但只带有 SAXParser 实例而非 SAXParserFactory 本身的用户无法更改这些特性。您必须在解析器工厂级别完成这一操作。

还有许多方法来请求文档的解析。并非只能接受 File 和 SAX DefaultHandler 实例，SAXParser 的 parse() 方法还可以接受字符串格式的 SAX InputSource、Java InputStream 或 URL，它们全部具有 DefaultHandler 实例。所以仍可以解析包装在各种格式中的文档。

最后，可以获得底层 SAX 解析器（org.xml.sax.XMLReader 的实例），并直接通过 SAXParser 的 getXMLReader() 方法来使用它。一旦获得该底层实例，一般的 SAX 方法都可用。清单 2 显示 JAXP 中的核心类 SAXParser 类在 SAX 解析中的各种用法的例子：

// Get a SAX Parser instance
SAXParser saxParser = saxFactory.newSAXParser();
// Find out if validation is supported
boolean isValidating = saxParser.isValidating();
// Find out if namespaces are supported
boolean isNamespaceAware = saxParser.isNamespaceAware();
// Parse, in a variety of ways
// Use a file and a SAX DefaultHandler instance
saxParser.parse(new File(args[0]), myDefaultHandlerInstance);
// Use a SAX InputSource and a SAX DefaultHandler instance
saxParser.parse(mySaxInputSource, myDefaultHandlerInstance);
// Use an InputStream and a SAX DefaultHandler instance
saxParser.parse(myInputStream, myDefaultHandlerInstance);
// Use a URI and a SAX DefaultHandler instance
saxParser.parse("http://www.newInstance.com/xml/doc.xml",
                myDefaultHandlerInstance);
// Get the underlying (wrapped) SAX parser
org.xml.sax.XMLReader parser = saxParser.getXMLReader();
// Use the underlying parser
parser.setContentHandler(myContentHandlerInstance);
parser.setErrorHandler(myErrorHandlerInstance);
parser.parse(new org.xml.sax.InputSource(args[0]));

到此为止，已经针对 SAX 谈了许多，但还没有显示任何显著的或惊人的内容。JAXP 的附加功能相当小，尤其是涉及到 SAX 的地方。这个最小功能使得代码更易移植，让其他开发人员用任何 SAX 兼容的 XML 解析器来自由或商业地使用它。好了。使用 SAX 与 JAXP 再无其他内容。如果已经了解了 SAX，您已经成功了大约 98％。您只需要学习两个新类和一对 Java 异常，然后就可以开始行动了。如果从未用过 SAX，从现在开始也足够了。

回页首

处理 DOM

如果您认为需要休息一下来对付 DOM 的挑战，那么就休息一下吧。使用 DOM 与 JAXP 和使用 JAXP 与 SAX 几乎完全相同，惟一要做的就是更改类名和返回类型，这就足够了。如果理解 SAX 如何工作和 DOM 是什么，那就根本没有问题。

DOM 和 SAX 的主要差别是 API 本身的结构。SAX 由基于事件的回调集组成，而 DOM 具有内存树结构。在 SAX 中，决不会有需要处理的数据结构（除非开发人员手动创建一个）。因此，SAX 没有提供修改 XML 文档的能力。DOM 提供了此功能。org.w3c.dom.Document 类表示 XML 文档，由表示元素、属性和其他 XML 构造的 DOM 节点组成。所以 JAXP 不需要启动 SAX 回调；它只负责从解析中返回 DOM Document 对象。

DOM 解析器工厂一览

基本了解了 DOM 以及 DOM 和 SAX 之间的差别之后，就不需要了解其他内容了。清单 3 看起来与 清单 1 中的 SAX 代码十分相似。首先，获得 DocumentBuilderFactory（与清单 1 中获得 SAXParserFactory 的方法一样）。然后，配置工厂来处理验证和名称空间（与 SAX 中的方法一样）。其次，从工厂中检索与 SAXParser 类似的 DocumentBuilder 实例（与 SAX 中的方法一样）。 然后进行解析，得到的 DOM Document 对象传递给输出 DOM 树的方法：

import java.io.File;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
// JAXP
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
// DOM
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class TestDOMParsing {
    public static void main(String[] args) {
        try {
            if (args.length != 1) {
                System.err.println ("Usage: java TestDOMParsing " +
                                    "[filename]");
                System.exit (1);
            }
            // Get Document Builder Factory
            DocumentBuilderFactory factory = 
                DocumentBuilderFactory.newInstance();
            // Turn on validation, and turn off namespaces
            factory.setValidating(true);
            factory.setNamespaceAware(false);
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document doc = builder.parse(new File(args[0]));
            // Print the document from the DOM tree and
            //   feed it an initial indentation of nothing
            printNode(doc, "");
        } catch (ParserConfigurationException e) {
            System.out.println("The underlying parser does not " +
                               "support the requested features.");
        } catch (FactoryConfigurationError e) {
            System.out.println("Error occurred obtaining Document " +
                               "Builder Factory.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static void printNode(Node node, String indent)  {
        // print the DOM tree
    }
}

该代码可以出现两个问题（与 JAXP 中的 SAX 一样）：FactoryConfigurationError 和 ParserConfigurationException。每个问题的原因都于 SAX 中的一样。一个问题出现在实现类中（导致 FactoryConfigurationError），另一个问题是提供的解析器不支持请求的特性（导致 ParserConfigurationException）。在这方面，DOM 和 SAX 之间的惟一差别是，在 DOM 中用 DocumentBuilderFactory 替代 SAXParserFactory，用 DocumentBuilder 替代 SAXParser。 仅此一点。（可以查看完整的代码清单，其中包括用于输出 DOM 树的方法；请参阅 下载。）

使用 DOM 解析器

一旦拥有 DOM 工厂后，就可以获得 DocumentBuilder 实例。可用于 DocumentBuilder 实例的方法与可用于对应 SAX 实例的方法非常相似。主要差别在于 parse() 方法的变种不接受 SAX DefaultHandler 类的实例。而是返回一个表示已解析的 XML 文档的 DOM Document 实例。其余的惟一差别就是两个方法提供了类似 SAX 的功能：

• setErrorHandler()，执行 SAX ErrorHandler 实现来处理解析时可能出现的问题。
• setEntityResolver()，执行 SAX EntityResolver 实现来处理实体解析。

清单 4 显示这些方法的实际例子：

// Get a DocumentBuilder instance
DocumentBuilder builder = builderFactory.newDocumentBuilder();
// Find out if validation is supported
boolean isValidating = builder.isValidating();
// Find out if namespaces are supported
boolean isNamespaceAware = builder.isNamespaceAware();
// Set a SAX ErrorHandler
builder.setErrorHandler(myErrorHandlerImpl);
// Set a SAX EntityResolver
builder.setEntityResolver(myEntityResolverImpl);
// Parse, in a variety of ways
// Use a file
Document doc = builder.parse(new File(args[0]));
// Use a SAX InputSource
Document doc = builder.parse(mySaxInputSource);
// Use an InputStream
Document doc = builder.parse(myInputStream, myDefaultHandlerInstance);
// Use a URI 
Document doc = builder.parse("http://www.newInstance.com/xml/doc.xml");

如果您在阅读 DOM 这一节时感到一点乏味，那么您并不孤单；我在编写时也感到有些乏味，因为将已经学过的有关 SAX 的知识应用到 DOM 是如此简单。

回页首

执行验证

在 Java 5.0（和 JAXP 1.3 中），JAXP 引进一种新方法来验证文档。不是仅仅在 SAX 或 DOM 工厂上使用 setValidating() 方法，而是将验证划分到新 javax.xml.validation 软件包中的几个类中。由于篇幅所限，本文没有详细介绍验证的所有细微差别，包括 W3C XML Schema、DTD、RELAX NG 模式，以及其他约束模型，但如果已经具有一些约束，那么使用新验证模型并确保文档与约束相匹配则相当容易。

冗余并非总是好事 您不 应该做的一件事是使用 setValidating(true) 和 javax.xml.validation 软件包。您将会得到一些严重错误，其中大多数错误难以解决。最好是养成从不调用 setValidating()（默认为假）的习惯，而是使用新的 JAXP 验证框架。

首先，将约束模型（可能是某个磁盘上的文件）转化为 JAXP 可以使用的格式。将此文件加载到 Source 实例中。（我将在第 2 部分更详细地介绍 Source；现在只要知道它表示磁盘某个位置的文档，可以是 DOM Document 或其他文档。）然后，使用 SchemaFactory.newSchema(Source) 创建 SchemaFactory 并加载模式，这将返回一个新 Schema 对象。最后，使用此 Schema 对象，用 Schema.newValidator() 方法创建一个新 Validator 对象。清单 5 清楚地显示了全部操作：

DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(new File(args[0]));
// Handle validation
SchemaFactory constraintFactory = 
    SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
Source constraints = new StreamSource(new File(args[1]));
Schema schema = constraintFactory.newSchema(constraints);
Validator validator = schema.newValidator();
// Validate the DOM tree
try {
    validator.validate(new DOMSource(doc));
    System.out.println("Document validates fine.");
} catch (org.xml.sax.SAXException e) {
    System.out.println("Validation error: " + e.getMessage());
}

一旦掌握之后，这一切十分简单。亲自输入此代码，或查看完整清单（参阅 下载）。

回页首

更改解析器

更改 JAXP 工厂类使用的解析器很容易。更改解析器实际上意味着更改解析器工厂，因为所有 SAXParser 和 DocumentBuilder 实例都来自这些工厂。工厂确定加载哪个解析器，所以必须更改工厂。要更改 SAXParserFactory 接口的实现，请设置 Java 系统特性 javax.xml.parsers.SAXParserFactory。如果未定义此特性，则返回默认实现（不管开发商指定哪个解析器）。同一规则适用于所使用的 DocumentBuilderFactory 实现。在这种情况下，将会查询 javax.xml.parsers.DocumentBuilderFactory 系统特性。

回页首

结束语

阅读完本文后，您差不多已经了解到 JAXP 的全部范围：

• 提供到 SAX 的钩子
• 提供到 DOM 的钩子
• 允许容易地更改解析器

转自：http://www.java3z.com/cwbwebhome/article/article5/5924.html?id=1838

Java遍历文件夹的2种方法：

A.不使用递归：

import java.io.File;
import java.util.LinkedList;
public class FileSystem {
    public static void main(String[] args) {
        
        long a = System.currentTimeMillis();
        
        LinkedList list = new LinkedList();
        File dir = new File("c:\\java\\");
        File file[] = dir.listFiles();
        for (int i = 0; i < file.length; i++) {
            if (file[i].isDirectory())
                list.add(file[i]);
            else
                System.out.println(file[i].getAbsolutePath());
        }
        File tmp;
        while (!list.isEmpty()) {
            tmp = list.removeFirst();
            if (tmp.isDirectory()) {
                file = tmp.listFiles();
                if (file == null)
                    continue;
                for (int i = 0; i < file.length; i++) {
                    if (file[i].isDirectory())
                        list.add(file[i]);
                    else
                        System.out.println(file[i].getAbsolutePath());
                }
            } else {
                System.out.println(tmp.getAbsolutePath());
            }
        }
        
        System.out.println(System.currentTimeMillis() - a);
    }
}
                      

       import java.io.File;
import java.util.ArrayList;
public class FileSystem1 {
    private static ArrayList filelist = new ArrayList(); 
    
    public static void main(String[] args) {
        
        long a = System.currentTimeMillis();
        refreshFileList("c:\\java");
        System.out.println(System.currentTimeMillis() - a);
    }
    public static void refreshFileList(String strPath) { 
        File dir = new File(strPath); 
        File[] files = dir.listFiles(); 
        
        if (files == null) 
            return; 
        for (int i = 0; i < files.length; i++) { 
            if (files[i].isDirectory()) { 
                refreshFileList(files[i].getAbsolutePath()); 
            } else { 
                String strFileName = files[i].getAbsolutePath().toLowerCase();
                System.out.println("---"+strFileName);
                filelist.add(files[i].getAbsolutePath());                    
            } 
        } 
    }
}

结论：经过测试，使用递归的方法B性能相对好一些

1、Runtime.getRuntime()可以取得当前JVM的运行时环境，这也是在Java中唯一一个得到运行时环境的方法。

2、Runtime上其他大部分的方法都是实例方法，也就是说每次进行运行时调用时都要用到getRuntime方法。

3、Runtime中的exit方法是退出当前JVM的方法，估计也是唯一的一个吧，因为我看到System类中的exit实际上也是通过调用Runtime.exit()来退出JVM的，这里说明一下Java对Runtime返回值的一般规则（后边也提到了），0代表正常退出，非0代表异常中止，这只是Java的规则，在各个操作系统中总会发生一些小的混淆。

4、Runtime.addShutdownHook()方法可以注册一个hook在JVM执行shutdown的过程中，方法的参数只要是一个初始化过但是没有执行的Thread实例就可以。（注意，Java中的Thread都是执行过了就不值钱的哦）

5、说到addShutdownHook这个方法就要说一下JVM运行环境是在什么情况下shutdown或者abort的。文档上是这样写的，当最后一个非精灵进程退出或者收到了一个用户中断信号、用户登出、系统shutdown、Runtime的exit方法被调用时JVM会启动shutdown的过程，在这个过程开始后，他会并行启动所有登记的shutdown hook（注意是并行启动，这就需要线程安全和防止死锁）。当shutdown过程启动后，只有通过调用halt方法才能中止shutdown的过程并退出JVM。

那什么时候JVM会abort退出那？首先说明一下，abort退出时JVM就是停止运行但并不一定进行shutdown。这只有JVM在遇到SIGKILL信号或者windows中止进程的信号、本地方法发生类似于访问非法地址一类的内部错误时会出现。这种情况下并不能保证shutdown hook是否被执行。

现在开始看这篇文章，呵呵。

首先讲的是Runtime.exec()方法的所有重载。这里要注意的有一点，就是public Process exec(String [] cmdArray, String [] envp);这个方法中cmdArray是一个执行的命令和参数的字符串数组，数组的第一个元素是要执行的命令往后依次都是命令的参数，envp我个人感觉应该和C中的execve中的环境变量是一样的，envp中使用的是name=value的方式。

<!--[if !supportLists]-->1、 <!--[endif]-->一个很糟糕的调用程序，代码如下，这个程序用exec调用了一个外部命令之后马上使用exitValue就对其返回值进行检查，让我们看看会出现什么问题。

import java.util.*;
import java.io.*;

public class BadExecJavac
{
public static void main(String args[])
{
try
{ 
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("javac");
int exitVal = proc.exitValue();
System.out.println("Process exitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}

A run of BadExecJavac produces: 

E:classescomjavaworldjpitfallsarticle2>java BadExecJavac
java.lang.IllegalThreadStateException: process has not exited
at java.lang.Win32Process.exitValue(Native Method)
at BadExecJavac.main(BadExecJavac.java:13)

这里看原文就可以了解，这里主要的问题就是错误的调用了exitValue来取得外部命令的返回值（呵呵，这个错误我也曾经犯过），因为exitValue这个方法是不阻塞的，程序在调用这个方法时外部命令并没有返回所以造成了异常的出现，这里是由另外的方法来等待外部命令执行完毕的，就是waitFor方法，这个方法会一直阻塞直到外部命令执行结束，然后返回外部命令执行的结果，作者在这里一顿批评设计者的思路有问题，呵呵，反正我是无所谓阿，能用就可以拉。但是作者在这里有一个说明，就是exitValue也是有好多用途的。因为当你在一个Process上调用waitFor方法时，当前线程是阻塞的，如果外部命令无法执行结束，那么你的线程就会一直阻塞下去，这种意外会影响我们程序的执行。所以在我们不能判断外部命令什么时候执行完毕而我们的程序还需要继续执行的情况下，我们就应该循环的使用exitValue来取得外部命令的返回状态，并在外部命令返回时作出相应的处理。

2、对exitValue处改进了的程序

import java.util.*;
import java.io.*;

public class BadExecJavac2
{
public static void main(String args[])
{
try
{ 
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("javac");
int exitVal = proc.waitFor();
System.out.println("Process exitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}

不幸的是，这个程序也无法执行完成，它没有输出但却一直悬在那里，这是为什么那？

JDK文档中对此有如此的解释：因为本地的系统对标准输入和输出所提供的缓冲池有效，所以错误的对标准输出快速的写入和从标准输入快速的读入都有可能造成子进程的锁，甚至死锁。

文档引述完了，作者又开始批评了，他说JDK仅仅说明为什么问题会发生，却并没有说明这个问题怎么解决，这的确是个问题哈。紧接着作者说出自己的做法，就是在执行完外部命令后我们要控制好Process的所有输入和输出（视情况而定），在这个例子里边因为调用的是Javac，而他在没有参数的情况下会将提示信息输出到标准出错，所以在下面的程序中我们要对此进行处理。

import java.util.*;
import java.io.*;

public class MediocreExecJavac
{
public static void main(String args[])
{
try
{ 
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("javac");
InputStream stderr = proc.getErrorStream();
InputStreamReader isr = new InputStreamReader(stderr);
BufferedReader br = new BufferedReader(isr);
String line = null;
System.out.println("<ERROR>");
while ( (line = br.readLine()) != null)
System.out.println(line);
System.out.println("</ERROR>");
int exitVal = proc.waitFor();
System.out.println("Process exitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}

程序的运行结果为

E:classescomjavaworldjpitfallsarticle2>java MediocreExecJavac
<ERROR>
Usage: javac <options> <source files>

where <options> includes:
-g Generate all debugging info
-g:none Generate no debugging info
-g:{lines,vars,source} Generate only some debugging info
-O Optimize; may hinder debugging or enlarge class files
-nowarn Generate no warnings
-verbose Output messages about what the compiler is doing
-deprecation Output source locations where deprecated APIs are used
-classpath <path> Specify where to find user class files
-sourcepath <path> Specify where to find input source files
-bootclasspath <path> Override location of bootstrap class files
-extdirs <dirs> Override location of installed extensions
-d <directory> Specify where to place generated class files
-encoding <encoding> Specify character encoding used by source files
-target <release> Generate class files for specific VM version
</ERROR>
Process exitValue: 2

哎，不管怎么说还是出来了结果，作者作了一下总结，就是说，为了处理好外部命令大量输出的情况，你要确保你的程序处理好外部命令所需要的输入或者输出。

下一个题目，当我们调用一个我们认为是可执行程序的时候容易发生的错误（今天晚上我刚刚犯这个错误，没事做这个练习时候发生的）

import java.util.*;
import java.io.*;

public class BadExecWinDir
{
public static void main(String args[])
{
try
{ 
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("dir");
InputStream stdin = proc.getInputStream();
InputStreamReader isr = new InputStreamReader(stdin);
BufferedReader br = new BufferedReader(isr);
String line = null;
System.out.println("<OUTPUT>");
while ( (line = br.readLine()) != null)
System.out.println(line);
System.out.println("</OUTPUT>");
int exitVal = proc.waitFor(); 
System.out.println("Process exitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}

A run of BadExecWinDir produces: 

E:classescomjavaworldjpitfallsarticle2>java BadExecWinDir
java.io.IOException: CreateProcess: dir error=2
at java.lang.Win32Process.create(Native Method)
at java.lang.Win32Process.<init>(Unknown Source)
at java.lang.Runtime.execInternal(Native Method)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at BadExecWinDir.main(BadExecWinDir.java:12)

说实在的，这个错误还真是让我摸不着头脑，我觉得在windows中返回2应该是没有找到这个文件的缘故，可能windows 2000中只有cmd命令，dir命令不是当前环境变量能够解释的吧。我也不知道了，慢慢往下看吧。

嘿，果然和作者想的一样，就是因为dir命令是由windows中的解释器解释的，直接执行dir时无法找到dir.exe这个命令，所以会出现文件未找到这个2的错误。如果我们要执行这样的命令，就要先根据操作系统的不同执行不同的解释程序command.com 或者cmd.exe。

作者对上边的程序进行了修改

import java.util.*;
import java.io.*;

class StreamGobbler extends Thread
{
InputStream is;
String type;

StreamGobbler(InputStream is, String type)
{
this.is = is;
this.type = type;
}

public void run()
{
try
{
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line=null;
while ( (line = br.readLine()) != null)
System.out.println(type + ">" + line); 
} catch (IOException ioe)
{
ioe.printStackTrace(); 
}
}
}

public class GoodWindowsExec
{
public static void main(String args[])
{
if (args.length < 1)
{
System.out.println("USAGE: java GoodWindowsExec <cmd>");
System.exit(1);
}

try
{ 
String osName = System.getProperty("os.name" );
String[] cmd = new String[3];

if( osName.equals( "Windows NT" ) )
{
cmd[0] = "cmd.exe" ;
cmd[1] = "/C" ;
cmd[2] = args[0];
}
else if( osName.equals( "Windows 95" ) )
{
cmd[0] = "command.com" ;
cmd[1] = "/C" ;
cmd[2] = args[0];
}

Runtime rt = Runtime.getRuntime();
System.out.println("Execing " + cmd[0] + " " + cmd[1] 
+ " " + cmd[2]);
Process proc = rt.exec(cmd);
// any error message?
StreamGobbler errorGobbler = new 
StreamGobbler(proc.getErrorStream(), "ERROR"); 

// any output?
StreamGobbler outputGobbler = new 
StreamGobbler(proc.getInputStream(), "OUTPUT");

// kick them off
errorGobbler.start();
outputGobbler.start();

// any error???
int exitVal = proc.waitFor();
System.out.println("ExitValue: " + exitVal); 
} catch (Throwable t)
{
t.printStackTrace();
}
}
}

Running GoodWindowsExec with the dir command generates: 

E:classescomjavaworldjpitfallsarticle2>java GoodWindowsExec "dir *.java"
Execing cmd.exe /C dir *.java
OUTPUT> Volume in drive E has no label.
OUTPUT> Volume Serial Number is 5C5F-0CC9
OUTPUT>
OUTPUT> Directory of E:classescomjavaworldjpitfallsarticle2
OUTPUT>
OUTPUT>10/23/00 09:01p 805 BadExecBrowser.java
OUTPUT>10/22/00 09:35a 770 BadExecBrowser1.java
OUTPUT>10/24/00 08:45p 488 BadExecJavac.java
OUTPUT>10/24/00 08:46p 519 BadExecJavac2.java
OUTPUT>10/24/00 09:13p 930 BadExecWinDir.java
OUTPUT>10/22/00 09:21a 2,282 BadURLPost.java
OUTPUT>10/22/00 09:20a 2,273 BadURLPost1.java
... (some output omitted for brevity)
OUTPUT>10/12/00 09:29p 151 SuperFrame.java
OUTPUT>10/24/00 09:23p 1,814 TestExec.java
OUTPUT>10/09/00 05:47p 23,543 TestStringReplace.java
OUTPUT>10/12/00 08:55p 228 TopLevel.java
OUTPUT> 22 File(s) 46,661 bytes
OUTPUT> 19,678,420,992 bytes free
ExitValue: 0

这里作者教了一个windows中很有用的方法，呵呵，至少我是不知道的，就是cmd.exe /C +一个windows中注册了后缀的文档名，windows会自动地调用相关的程序来打开这个文档，我试了一下，的确很好用，但是好像文件路径中有空格的话就有点问题，我加上引号也无法解决。

这里作者强调了一下，不要假设你执行的程序是可执行的程序，要清楚自己的程序是单独可执行的还是被解释的，本章的结束作者会介绍一个命令行工具来帮助我们分析。

这里还有一点，就是得到process的输出的方式是getInputStream，这是因为我们要从Java 程序的角度来看，外部程序的输出对于Java来说就是输入，反之亦然。

最后的一个漏洞的地方就是错误的认为exec方法会接受所有你在命令行或者Shell中输入并接受的字符串。这些错误主要出现在命令作为参数的情况下，程序员错误的将所有命令行中可以输入的参数命令加入到exec中（这段翻译的不好，凑合看吧）。下面的例子中就是一个程序员想重定向一个命令的输出。

import java.util.*;
import java.io.*;

// StreamGobbler omitted for brevity

public class BadWinRedirect
{
public static void main(String args[])
{
try
{ 
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("java jecho 'Hello World' > test.txt");
// any error message?
StreamGobbler errorGobbler = new 
StreamGobbler(proc.getErrorStream(), "ERROR"); 

// any output?
StreamGobbler outputGobbler = new 
StreamGobbler(proc.getInputStream(), "OUTPUT");

// kick them off
errorGobbler.start();
outputGobbler.start();

// any error???
int exitVal = proc.waitFor();
System.out.println("ExitValue: " + exitVal); 
} catch (Throwable t)
{
t.printStackTrace();
}
}
}

Running BadWinRedirect produces: 

E:classescomjavaworldjpitfallsarticle2>java BadWinRedirect
OUTPUT>'Hello World' > test.txt
ExitValue: 0

程序员的本意是将Hello World这个输入重订向到一个文本文件中，但是这个文件并没有生成，jecho仅仅是将命令行中的参数输出到标准输出中，用户觉得可以像dos中重定向一样将输出重定向到一个文件中，但这并不能实现，用户错误的将exec认为是一个shell解释器，但它并不是，如果你想将一个程序的输出重定向到其他的程序中，你必须用程序来实现他。可用java.io中的包。

import java.util.*;
import java.io.*;

class StreamGobbler extends Thread
{
InputStream is;
String type;
OutputStream os;

StreamGobbler(InputStream is, String type)
{
this(is, type, null);
}

StreamGobbler(InputStream is, String type, OutputStream redirect)
{
this.is = is;
this.type = type;
this.os = redirect;
}

public void run()
{
try
{
PrintWriter pw = null;
if (os != null)
pw = new PrintWriter(os);

InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line=null;
while ( (line = br.readLine()) != null)
{
if (pw != null)
pw.println(line);
System.out.println(type + ">" + line); 
}
if (pw != null)
pw.flush();
} catch (IOException ioe)
{
ioe.printStackTrace(); 
}
}
}

public class GoodWinRedirect
{
public static void main(String args[])
{
if (args.length < 1)
{
System.out.println("USAGE java GoodWinRedirect <outputfile>");
System.exit(1);
}

try
{ 
FileOutputStream fos = new FileOutputStream(args[0]);
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("java jecho 'Hello World'");
// any error message?
StreamGobbler errorGobbler = new 
StreamGobbler(proc.getErrorStream(), "ERROR"); 

// any output?
StreamGobbler outputGobbler = new 
StreamGobbler(proc.getInputStream(), "OUTPUT", fos);

// kick them off
errorGobbler.start();
outputGobbler.start();

// any error???
int exitVal = proc.waitFor();
System.out.println("ExitValue: " + exitVal);
fos.flush();
fos.close(); 
} catch (Throwable t)
{
t.printStackTrace();
}
}
}

Running GoodWinRedirect produces: 

E:classescomjavaworldjpitfallsarticle2>java GoodWinRedirect test.txt
OUTPUT>'Hello World'
ExitValue: 0

这里就不多说了，看看就明白，紧接着作者给出了一个监测命令的小程序

import java.util.*;
import java.io.*;

// class StreamGobbler omitted for brevity

public class TestExec
{
public static void main(String args[])
{
if (args.length < 1)
{
System.out.println("USAGE: java TestExec "cmd"");
System.exit(1);
}

try
{
String cmd = args[0];
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec(cmd);

// any error message?
StreamGobbler errorGobbler = new 
StreamGobbler(proc.getErrorStream(), "ERR"); 

// any output?
StreamGobbler outputGobbler = new 
StreamGobbler(proc.getInputStream(), "OUT");

// kick them off
errorGobbler.start();
outputGobbler.start();

// any error???
int exitVal = proc.waitFor();
System.out.println("ExitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}

对这个程序进行运行: 
E:classescomjavaworldjpitfallsarticle2>java TestExec "e:javadocsindex.html"
java.io.IOException: CreateProcess: e:javadocsindex.html error=193
at java.lang.Win32Process.create(Native Method)
at java.lang.Win32Process.<init>(Unknown Source)
at java.lang.Runtime.execInternal(Native Method)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at TestExec.main(TestExec.java:45)

193在windows中是说这不是一个win32程序，这说明路径中找不到这个网页的关联程序，下面作者决定用一个绝对路径来试一下。

E:classescomjavaworldjpitfallsarticle2>java TestExec 
"e:program filesnetscapeprogramnetscape.exe e:javadocsindex.html"
ExitValue: 0

好用了，这个我也试了一下，用的是IE。

最后，作者总结了几条规则，防止我们在进行Runtime.exec()调用时出现错误。

1、 在一个外部进程执行完之前你不能得到他的退出状态

2、 在你的外部程序开始执行的时候你必须马上控制输入、输出、出错这些流。

3、 你必须用Runtime.exec()去执行程序

4、你不能象命令行一样使用Runtime.exec()。

				
package com.bjinfotech.practice.annotation.runtimeframework;

import java.lang.annotation.*;

/**
 * 用于修饰类的固有类型成员变量的annotation
 * @author cleverpig
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Persistent { 
        String value() default "";
}

				
package com.bjinfotech.practice.annotation.runtimeframework;

import java.lang.annotation.*;

/**
 * 用于修饰类的类型的annotation
 * @author cleverpig
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Exportable {
        //名称
        String name() default "";
        //描述
        String description() default "";
        //省略name和description后，用来保存name值
        String value() default "";
        
}

				
package com.bjinfotech.practice.annotation.runtimeframework;

/**
 * 用于测试的地址类
 * @author cleverpig
 *
 */
@Exportable("address")
public class AddressForTest {
        //国家
        @Persistent
        private String country=null;
        
        //省级
        @Persistent
        private String province=null;
        
        //城市
        @Persistent
        private String city=null;
        
        //街道
        @Persistent
        private String street=null;

        //门牌
        @Persistent
        private String doorplate=null;
        
        public AddressForTest(String country,String province,
                        String city,String street,String doorplate){
                this.country=country;
                this.province=province;
                this.city=city;
                this.street=street;
                this.doorplate=doorplate;
        }
        
}

				
package com.bjinfotech.practice.annotation.runtimeframework;

import java.util.*;

/**
 * 友人通讯录
 * 包含：姓名、年龄、电话、住址（多个）、备注
 * @author cleverpig
 *
 */
@Exportable(name="addresslist",description="address list")
public class AddressListForTest {
        //友人姓名
        @Persistent
        private String friendName=null;
        
        //友人年龄
        @Persistent
        private int age=0;
        
        //友人电话
        @Persistent
        private ArrayList<String> telephone=null;
        
        //友人住址：家庭、单位
        @Persistent
        private ArrayList<AddressForTest> AddressForText=null;
        
        //备注
        @Persistent
        private String note=null;
        
        public AddressListForTest(String name,int age,
                        ArrayList<String> telephoneList, 
                        ArrayList<AddressForTest> addressList,
                        String note){
                this.friendName=name;
                this.age=age;
                this.telephone=new ArrayList<String>(telephoneList);
                this.AddressForText=new ArrayList<AddressForTest>(addressList);
                this.note=note;
                
        }
}

				
package com.bjinfotech.practice.annotation.runtimeframework;

import java.lang.reflect.Field;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.ArrayList;

/**
 * 将具有Exportable Annotation的对象转换为xml格式文本 
 * @author cleverpig
 *
 */
public class ExportToXml {
        /**
         * 返回对象的成员变量的值（字符串类型）
         * @param field 对象的成员变量
         * @param fieldTypeClass 对象的类型
         * @param obj 对象
         * @return 对象的成员变量的值（字符串类型）
         */
        private String getFieldValue(Field field,Class fieldTypeClass,Object obj){
                String value=null;
                
                try{
                        if (fieldTypeClass==String.class){
                                value=(String)field.get(obj);
                        }
                        else if (fieldTypeClass==int.class){
                                value=Integer.toString(field.getInt(obj));
                        }
                        else if (fieldTypeClass==long.class){
                                value=Long.toString(field.getLong(obj));
                        }
                        else if (fieldTypeClass==short.class){
                                value=Short.toString(field.getShort(obj));
                        }
                        else if (fieldTypeClass==float.class){
                                value=Float.toString(field.getFloat(obj));
                        }
                        else if (fieldTypeClass==double.class){
                                value=Double.toString(field.getDouble(obj));
                        }
                        else if (fieldTypeClass==byte.class){
                                value=Byte.toString(field.getByte(obj));
                        }
                        else if (fieldTypeClass==char.class){
                                value=Character.toString(field.getChar(obj));
                        }
                        else if (fieldTypeClass==boolean.class){
                                value=Boolean.toString(field.getBoolean(obj));
                        }
                }
                catch(Exception ex){
                        ex.printStackTrace();
                        value=null;
                }
                return value;
        }
        
        /**
         * 输出对象的字段，当对象的字段为Collection或者Map类型时，要调用exportObject方法继续处理
         * @param obj 被处理的对象
         * @throws Exception
         */
        public void exportFields(Object obj) throws Exception{
                Exportable exportable=obj.getClass().getAnnotation(Exportable.class);        
                if (exportable!=null){
                        if (exportable.value().length()>0){
//                                System.out.println("Class annotation Name:"+exportable.value());
                        }
                        else{
//                                System.out.println("Class annotation Name:"+exportable.name());
                        }
                }
                else{
//                        System.out.println(obj.getClass()+"类不是使用Exportable标注过的");
                }
                
                //取出对象的成员变量
                Field[] fields=obj.getClass().getDeclaredFields();
                
                for(Field field:fields){
                        //获得成员变量的标注
                        Persistent fieldAnnotation=field.getAnnotation(Persistent.class);
                        if (fieldAnnotation==null){
                                continue;
                        }
                        //重要:避免java虚拟机检查对私有成员的访问权限
                        field.setAccessible(true);
                        Class typeClass=field.getType();
                        String name=field.getName();
                        String value=getFieldValue(field,typeClass,obj);
                        
                        //如果获得成员变量的值，则输出
                        if (value!=null){
                                System.out.println(getIndent()+"<"+name+">\n"
                                                +getIndent()+"\t"+value+"\n"+getIndent()+"</"+name+">");
                        }
                        //处理成员变量中类型为Collection或Map
                        else if ((field.get(obj) instanceof Collection)||
                                        (field.get(obj) instanceof Map)){
                                exportObject(field.get(obj));
                        }
                        else{
                                exportObject(field.get(obj));
                        }
                        
                }
        }
        
        //缩进深度
        int levelDepth=0;
        //防止循环引用的检查者，循环引用现象如：a包含b，而b又包含a
        Collection<Object> cyclicChecker=new ArrayList<Object>();
        
        /**
         * 返回缩进字符串
         * @return
         */
        private String getIndent(){
                String s="";
                for(int i=0;i<levelDepth;i++){
                        s+="\t";
                }
                return s;
        }
        /**
         * 输出对象，如果对象类型为Collection和Map类型，则需要递归调用exportObject进行处理
         * @param obj
         * @throws Exception
         */
        public void exportObject(Object obj) throws Exception{
                Exportable exportable=null;
                String elementName=null;
                
                //循环引用现象处理
                if (cyclicChecker.contains(obj)){
                        return;
                }
                
                cyclicChecker.add(obj);
                
                //首先处理Collection和Map类型
                if (obj instanceof Collection){
                        for(Iterator i=((Collection)obj).iterator();i.hasNext();){
                                exportObject(i.next());
                        }
                }
                else if (obj instanceof Map){
                        for(Iterator i=((Map)obj).keySet().iterator();i.hasNext();){
                                exportObject(i.next());
                        }
                }
                else{

                        exportable=obj.getClass().getAnnotation(Exportable.class);
                        //如果obj已经被Exportable Annotation修饰过了（注意annotation是具有继承性的），
                        //则使用其name作为输出xml的元素name
                        if (exportable!=null){
                                if (exportable.value().length()>0){
                                        elementName=exportable.value();
                                }
                                else{
                                        elementName=exportable.name();
                                }
                        }
                        //未被修饰或者Exportable Annotation的值为空字符串，
                        //则使用类名作为输出xml的元素name
                        if (exportable==null||elementName.length()==0){
                                elementName=obj.getClass().getSimpleName();
                        }
                        //输出xml元素头
                        System.out.println(getIndent()+"<"+elementName+">");
                        levelDepth++;
                        //如果没有被修饰，则直接输出其toString()作为元素值
                        if (exportable==null){
                                System.out.println(getIndent()+obj.toString());
                        }
                        //否则将对象的成员变量导出为xml
                        else{
                                exportFields(obj);
                        }
                        levelDepth--;
                        //输出xml元素结尾
                        System.out.println(getIndent()+"</"+elementName+">");
                        
                }
                cyclicChecker.remove(obj);
        }
        
        public static void main(String[] argv){
                try{
                        AddressForTest ad=new AddressForTest("China","Beijing",
                                        "Beijing","winnerStreet","10");
                        
                        ExportToXml test=new ExportToXml();
                        
                        ArrayList<String> telephoneList=new ArrayList<String>();
                        telephoneList.add("66608888");
                        telephoneList.add("66608889");
                        
                        ArrayList<AddressForTest> adList=new ArrayList<AddressForTest>();
                        adList.add(ad);
                        
                        AddressListForTest adl=new AddressListForTest("coolBoy",
                                        18,telephoneList,adList,"some words");
                        
                        test.exportObject(adl);
                }
                catch(Exception ex){
                        ex.printStackTrace();
                }
        }
}

<addresslist>
        <friendName>
                coolBoy
        </friendName>
        <age>
                18
        </age>
        <String>
                66608888
        </String>
        <String>
                66608889
        </String>
        <address>
                <country>
                        China
                </country>
                <province>
                        Beijing
                </province>
                <city>
                        Beijing
                </city>
                <street>
                        winnerStreet
                </street>
                <doorplate>
                        10
                </doorplate>
        </address>
        <note>
                some words
        </note>
</addresslist>

package com.bjinfotech.practice.annotation.apt;

/**
 * 定义Review Annotation
 * @author cleverpig
 *
 */
public @interface Review {
        public static enum TypeEnum{EXCELLENT,NICE,NORMAL,BAD};
        TypeEnum type();
        String name() default "Review";
}

package com.bjinfotech.practice.annotation.apt;

import java.util.Collection;
import java.util.Set;
import java.util.Arrays;
import com.sun.mirror.apt.*;
import com.sun.mirror.declaration.AnnotationTypeDeclaration;
import com.sun.mirror.apt.AnnotationProcessorEnvironment;
//请注意为了方便，使用了静态import
import static java.util.Collections.unmodifiableCollection;
import static java.util.Collections.emptySet;

/**
 * 生成ReviewProcessor的工厂类
 * @author cleverpig
 *
 */
public class ReviewProcessorFactory implements AnnotationProcessorFactory{
        /**
         * 获得针对某个（些）类型声明定义的Processor
         * @param atds 类型声明集合
         * @param env processor环境
         */
        public AnnotationProcessor getProcessorFor(
                        Set<AnnotationTypeDeclaration> atds, 
                        AnnotationProcessorEnvironment env){
                return new ReviewProcessor(env);
        }
        /**
         * 定义processor所支持的annotation类型
         * @return processor所支持的annotation类型的集合
         */
        public Collection<String>         supportedAnnotationTypes(){
                //“*”表示支持所有的annotation类型
                //当然也可以修改为“foo.bar.*”、“foo.bar.Baz”，来对所支持的类型进行修饰
            return unmodifiableCollection(Arrays.asList("*"));
    }
        
        /**
         * 定义processor支持的选项
         * @return processor支持选项的集合
         */
        public Collection<String>         supportedOptions(){
                //返回空集合
            return emptySet();
    }
        
        public static void main(String[] argv){
                System.out.println("ok");
        }
}

package com.bjinfotech.practice.annotation.apt;

import com.sun.mirror.apt.AnnotationProcessor;
import com.sun.mirror.apt.AnnotationProcessorEnvironment;
import com.sun.mirror.declaration.TypeDeclaration;
import com.sun.mirror.util.DeclarationVisitors;
import com.sun.mirror.util.DeclarationVisitor;

/**
 * 定义Review annotation的Processor
 * @author cleverpig
 *
 */
public class ReviewProcessor implements AnnotationProcessor{
        //Processor所工作的环境
        AnnotationProcessorEnvironment env=null;
        
        /**
         * 构造方法
         * @param env 传入processor环境
         */
        public ReviewProcessor(AnnotationProcessorEnvironment env){
                this.env=env;
        }
        
        /**
         * 处理方法：查询processor环境中的类型声明，
         */
        public void process(){
                //查询processor环境中的类型声明
                for(TypeDeclaration type:env.getSpecifiedTypeDeclarations()){
                        //返回对类进行扫描、访问其声明时使用的DeclarationVisitor，
                        //传入参数：new ReviewDeclarationVisitor()，为扫描开始前进行的对类声明的处理
                        //        DeclarationVisitors.NO_OP，表示在扫描完成时进行的对类声明不做任何处理
                        DeclarationVisitor visitor=DeclarationVisitors.getDeclarationScanner(
                                        new ReviewDeclarationVisitor(),DeclarationVisitors.NO_OP);
                        //应用DeclarationVisitor到类型
                        type.accept(visitor);
                }
        }
}

package com.bjinfotech.practice.annotation.apt;

import com.sun.mirror.util.*;
import com.sun.mirror.declaration.*;

/**
 * 定义Review annotation声明访问者
 * @author cleverpig
 *
 */
public class ReviewDeclarationVisitor extends SimpleDeclarationVisitor{
        /**
         * 定义访问类声明的方法：打印类声明的全名
         * @param cd 类声明对象
         */
        public void visitClassDeclaration(ClassDeclaration cd){
                System.out.println("获取Class声明:"+cd.getQualifiedName());
        }
        
        public void visitAnnotationTypeDeclaration(AnnotationTypeDeclaration atd){
                System.out.println("获取Annotation类型声明:"+atd.getSimpleName());
        }
        
        public void visitAnnotationTypeElementDeclaration(AnnotationTypeElementDeclaration aed){
                System.out.println("获取Annotation类型元素声明:"+aed.getSimpleName());
        }
}

E:
rem 项目根目录
set PROJECT_ROOT=E:\eclipse3.1RC3\workspace\tigerFeaturePractice
rem 包目录路径
set PACKAGEPATH=com\bjinfotech\practice\annotation\apt
rem 运行根路径
set RUN_ROOT=%PROJECT_ROOT%\build
rem 源文件所在目录路径
set SRC_ROOT=%PROJECT_ROOT%\test
rem 设置Classpath
set CLASSPATH=.;%JAVA_HOME%;%JAVA_HOME%/lib/tools.jar;%RUN_ROOT%

cd %SRC_ROOT%\%PACKAGEPATH%
apt -nocompile -factory com.bjinfotech.practice.annotation.apt.ReviewProcessorFactory  ./*.java

@Override
public String toSting() {   // 注意方法名拼写错了
    return "[" + super.toString() + "]";
}

下面是一段使用@Deprecated的代码：
/**
 * 这里是javadoc的@deprecated声明.
 * @deprecated No one has players for this format any more.  Use VHS instead.
 */
@Deprecated public class Betamax { ... }

@SuppressWarnings(value={"unchecked","fallthrough"})
public void lintTrap() { /* sloppy method body omitted */ }

@SuppressWarnings({"unchecked","fallthrough"})

@SuppressWarnings("unchecked")

@Reviews({  // Single-value annotation, so "value=" is omitted here
    @Review(grade=Review.Grade.EXCELLENT,
            reviewer="df"),
    @Review(grade=Review.Grade.UNSATISFACTORY,
            reviewer="eg",
            comment="This method needs an @Override annotation")
})

@UncheckedExceptions({
    IllegalArgumentException.class, StringIndexOutOfBoundsException.class
})

/**
 * This package holds my custom annotation types.
 */
@com.davidflanagan.annotations.Author("David Flanagan")
package com.davidflanagan.annotations;

import java.lang.reflect.*;

Class c = WhizzBangClass.class;                           
Method m = c.getMethod("whizzy", int.class, int.class);  
boolean unstable = m.isAnnotationPresent(Unstable.class);

AnnotatedElement target = WhizzBangClass.class; //获得被查询的AnnotatedElement
// 查询AnnotatedElement的@Reviews annotation信息
Reviews annotation = target.getAnnotation(Reviews.class);
// 因为@Reviews annotation类型的成员为@Review annotation类型的数组，
// 所以下面声明了Review[] reviews保存@Reviews annotation类型的value成员值。
Review[] reviews = annotation.value();
// 查询每个@Review annotation的成员信息
for(Review r : reviews) {
    Review.Grade grade = r.grade();
    String reviewer = r.reviewer();
    String comment = r.comment();
    System.out.printf("%s assigned a grade of %s and comment '%s'%n",
                      reviewer, grade, comment);
}

package com.davidflanagan.annotations;
import java.lang.annotation.*;

/**
 * 使用annotation来描述那些被标注的成员是不稳定的，需要更改
*/
@Retention(RetentionPolicy.RUNTIME)
public @interface Unstable {}

/**
 * 使用Author这个annotation定义在程序中指出代码的作者
 */
public @interface Author {
    /** 返回作者名 */
    String value();
}

import java.lang.annotation.*;
        
/**
 * Reviews annotation类型只有一个成员，
 * 但是这个成员的类型是复杂的：由Review annotation组成的数组
 */
@Retention(RetentionPolicy.RUNTIME)
public @interface Reviews {
    Review[] value();
}

/**
* Review annotation类型有3个成员： 
* 枚举类型成员grade、
  * 表示Review名称的字符串类型成员Reviewer、
  * 具有默认值的字符串类型成员Comment。
 */
public @interface Review {
    // 内嵌的枚举类型
    public static enum Grade { EXCELLENT, SATISFACTORY, UNSATISFACTORY };

    // 下面的方法定义了annotation的成员
    Grade grade();                
    String reviewer();          
    String comment() default "";  
}

public @interface UncheckedExceptions {
    Class<? extends RuntimeException>[] value();
}

    /**
     * Describes the Request-For-Enhancement(RFE) that led
     * to the presence of the annotated API element.
     */
    public @interface RequestForEnhancement {
        int    id();
        String synopsis();
        String engineer() default "[unassigned]"; 
        String date();    default "[unimplemented]"; 
    }

    @RequestForEnhancement(
        id       = 2868724,
        synopsis = "Enable time-travel",
        engineer = "Mr. Peabody",
        date     = "4/1/3007"
    )
    public static void travelThroughTime(Date destination) { ... }

    /**
     * Indicates that the specification of the annotated API element
     * is preliminary and subject to change.
     */
    public @interface Preliminary { }

    @Preliminary public class TimeTravel { ... }

    /**
     * Associates a copyright notice with the annotated API element.
     */
    public @interface Copyright {
        String value();
    }

    @Copyright("2002 Yoyodyne Propulsion Systems")
    public class OscillationOverthruster { ... }

    import java.lang.annotation.*;

    /**
     * Indicates that the annotated method is a test method.
     * This annotation should be used only on parameterless static methods.
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface Test { }

    public class Foo {
        @Test public static void m1() { }
        public static void m2() { }
        @Test public static void m3() {
            throw new RuntimeException("Boom");
        }
        public static void m4() { }
        @Test public static void m5() { }
        public static void m6() { }
        @Test public static void m7() {
            throw new RuntimeException("Crash");
        }
        public static void m8() { }
    }

Here is the testing tool:

    import java.lang.reflect.*;

    public class RunTests {
       public static void main(String[] args) throws Exception {
          int passed = 0, failed = 0;
          for (Method m : Class.forName(args[0]).getMethods()) {
             if (m.isAnnotationPresent(Test.class)) {
                try {
                   m.invoke(null);
                   passed++;
                } catch (Throwable ex) {
                   System.out.printf("Test %s failed: %s %n", m, ex.getCause());
                   failed++;
                }
             }
          }
          System.out.printf("Passed: %d, Failed %d%n", passed, failed);
       }
    }

    $ java RunTests Foo
    Test public static void Foo.m3() failed: java.lang.RuntimeException: Boom 
    Test public static void Foo.m7() failed: java.lang.RuntimeException: Crash 
    Passed: 2, Failed 2

package com.bjinfotech.practice.annotation;

/**
 * 演示如何使用java5内建的annotation
 * 参考资料：
 * http://java.sun.com/docs/books/tutorial/java/javaOO/annotations.html
 * http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html
 * http://mindprod.com/jgloss/annotations.html
 * @author cleverpig
 *
 */
import java.util.List;

public class UsingBuiltInAnnotation {
        //食物类
        class Food{}
        //干草类
        class Hay extends Food{}
        //动物类
        class Animal{
                Food getFood(){
                        return null;
                }
                //使用Annotation声明Deprecated方法
                @Deprecated
                void deprecatedMethod(){
                }
        }
        //马类-继承动物类
        class Horse extends Animal{
                //使用Annotation声明覆盖方法
                @Override
                Hay getFood(){
                        return new Hay();
                }
                //使用Annotation声明禁止警告
                @SuppressWarnings({"deprecation","unchecked"})
                void callDeprecatedMethod(List horseGroup){
                        Animal an=new Animal();
                        an.deprecatedMethod();
                        horseGroup.add(an);
                }
        }
}

package com.bjinfotech.practice.annotation;

import java.lang.annotation.*;
/**
 * 定义annotation
 * @author cleverpig
 *
 */
//加载在VM中，在运行时进行映射
@Retention(RetentionPolicy.RUNTIME)
//限定此annotation只能标示方法
@Target(ElementType.METHOD)
public @interface AnnotationDefineForTestFunction{}

package com.bjinfotech.practice.annotation;

import java.lang.reflect.*;

/**
 * 一个实例程序应用前面定义的Annotation：AnnotationDefineForTestFunction
 * @author cleverpig
 *
 */
public class UsingAnnotation {
        @AnnotationDefineForTestFunction public static void method01(){}
        
        public static void method02(){}
        
        @AnnotationDefineForTestFunction public static void method03(){
                throw new RuntimeException("method03");
        }
        
        public static void method04(){
                throw new RuntimeException("method04");
        }
        
        public static void main(String[] argv) throws Exception{
                int passed = 0, failed = 0;
                //被检测的类名
                String className="com.bjinfotech.practice.annotation.UsingAnnotation";
                //逐个检查此类的方法，当其方法使用annotation声明时调用此方法
            for (Method m : Class.forName(className).getMethods()) {
               if (m.isAnnotationPresent(AnnotationDefineForTestFunction.class)) {
                  try {
                     m.invoke(null);
                     passed++;
                  } catch (Throwable ex) {
                     System.out.printf("测试 %s 失败: %s %n", m, ex.getCause());
                     failed++;
                  }
               }
            }
            System.out.printf("测试结果： 通过: %d, 失败： %d%n", passed, failed);
        }
}

CLASSPATH：也指定一个路径列表，是用于搜索 Java 编译或者运行时需要用到的类。在 CLASSPATH 列表中除了可以包含路径外，还可以包含 .jar 文件。Java 查找类时会把这个 .jar 文件当作一个目录来进行查找。通常，我们需要把 JDK 安装路径下的 jre\lib\rt.jar (Linux: jre/lib/rt.jar) 包含在 CLASSPATH 中。

    try{
    FileWriter fw=new FileWriter(SystemConfig.getRealPath()+"WEB-INF/url.txt");
    fw.write("movie"+name);
    fw.close();
   }catch(IOException e){
   e.printStackTrace();
   }

读文件中内容

   try{
       FileReader fr = null;
        fr = new FileReader(SystemConfig.getRealPath()+"WEB-INF/url.txt");
        BufferedReader br=new BufferedReader(fr);
        String Line = null;
        String s = null；      
        Line = br.readLine();
       while(Line!=null){
           s+=Line;
           Line=null;
        }
           br.close();
           fr.close();
       }
       }catch(IOException e1){
           e1.printStackTrace();
       }

上传文件

    try {
        InputStream stream = getUpFile().getInputStream();//把文件读入
        OutputStream bos = new FileOutputStream(filePath + "movie" +name);//建立一个上传文件的输出流
        int bytesRead = 0;
        byte[] buffer = new byte[1026];
        while ( (bytesRead = stream.read(buffer, 0, 1026)) != -1) {
          bos.write(buffer, 0, bytesRead);//将文件写入服务器
        }
        bos.close();
        stream.close();
      }catch(Exception e){
        System.err.print(e);
      }

FileWriter(File file, boolean append)
          Constructs a FileWriter object given a File object. 构建一个给定File对象的FileWriter对象,append指明是否覆盖以前内容。

一、 整型、实型、字符型变量中的相互转换 

在Java中整型、实型、字符型被视为同一类数据，这些类型由低级到高级分别为(byte，short，char)——int——long——float——double，低级变量可以直接转换为高级变量，例如，下面的语句可以在Java中直接通过： 

byte b; 

int i=b; 

而将高级变量转换为低级变量时，情况会复杂一些，你可以使用强制类型转换。即你必须采用下面这种语句格式： 

int i; 

byte b=(byte)i; 

可以想象，这种转换肯定可能会导致溢出或精度的下降，因此我们并不推荐使用这种转换。 

二、Java的包装类 

在我们讨论其它变量类型之间的相互转换时，我们需要了解一下Java的包装类，所谓包装类，就是可以直接将简单类型的变量表示为一个类，在执行变量类型的相互转换时，我们会大量使用这些包装类。Java共有六个包装类，分别是Boolean、Character、Integer、Long、Float和Double，从字面上我们就可以看出它们分别对应于 boolean、char、int、long、float和double。而String和Date本身就是类。所以也就不存在什么包装类的概念了。 

三、简单类型变量和包装类之间的相互转换 

简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即： Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value) 而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。 

四、String类和其它数据类型的相互转换 

对于上面的这些包装类，除了Character以外，都有可以直接使用字符串参数的构造函数，这也就使得我们将String类转换为这些数据类型变得相当之简单，即： Boolean(String s)、Integer(String s)、Long(String s)、Float(String s)、Double(String s) 而将String类转换为Date类也可以使用这样的构造函数：Date(String s) 现在我们还剩下一个字符型变量，事实上String类可以理解为一个char型数组，因此我们可以在String类中找到这样的方法来实现这种转换：charAt(int index)可以得到String类中某一位置上的字符，toCharArray()更可以将整个String类转换成一个char的数组。 对于所有的包装类都存在一个名为toString()的方法可以将其转换成对应的String类，而对于整型类和长整型类，还可以使用toBinaryString(int i)、toHexString(int i)、toOctalString(int i)分别以二进制、十六进制和八进制的形式进行到String类的转换。 

五、将字符型直接做为数值转换为其它数据类型 

将字符型变量转换为数值型变量实际上有两种对应关系，在我们在第一部分所说的那种转换中，实际上是将其转换成对应的ASCII码，但是我们有时还需要另一种转换关系，例如，‘1'就是指的数值1，而不是其ASCII码，对于这种转换，我们可以使用Character的getNumericValue(char ch)方法。 

六、Date类与其它数据类型的相互转换 

整型和Date类之间并不存在直接的对应关系，只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，在作这种转换时，你可以使用Date类构造函数的三种形式： 

Date(int year, int month, int date)：以int型表示年、月、日 

Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分 

Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、分、秒 

在长整型和Date类之间有一个很有趣的对应关系，就是将一个时间表示为距离格林尼治标准时间

1970年1月1日0时0分0秒的毫秒数。对于这种对应关系，Date类也有其相应的构造函数：Date(long date) 获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以将其理解为将Date类转换成int。而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，与包装类一样，Date类也有一个toString()方法可以将其转换为String类。

nsm8415 发表于 >2006-6-15 20:44:44   [全文] [评论] [引用] [推荐] [档案] [推给好友] [收藏到网摘]

2006-6-15

java数据类型转换[转]

一些初学JAVA的朋友可能会遇到JAVA的数据类型之间转换的苦恼，例如，整数和float,double型之间的转换，整数和String类型之间的转换，以及处理、显示时间方面的问题等。下面笔者就开发中的一些体会介绍给大家。

        我们知道，Java的数据类型分为三大类，即布尔型、字符型和数值型，而其中数值型又分为整型和浮点型；相对于数据类型，Java的变量类型为布尔型boolean；字符型char；整型byte、short、int、long；浮点型float、double。其中四种整型变量和两种浮点型变量分别对应于不同的精度和范围。此外，我们还经常用到两种类变量，即String和Date。对于这些变量类型之间的相互转换在我们编程中经常要用到，在下面的论述中，我们将阐述如何实现这些转换。

1 数据类型转换的种类

    java数据类型的转换一般分三种,分别是:

    (1). 简单数据类型之间的转换 

    (2). 字符串与其它数据类型的转换 

    (3). 其它实用数据类型转换

    下面我们对这三种类型转换分别进行论述。

2 简单数据类型之间的转换

    在Java中整型、实型、字符型被视为简单数据类型，这些类型由低级到高级分别为

(byte，short，char)--int--long--float--double

     简单数据类型之间的转换又可以分为：

    ●低级到高级的自动类型转换

    ●高级到低级的强制类型转换

    ●包装类过渡类型能够转换

2.1自动类型转换

    低级变量可以直接转换为高级变量，笔者称之为自动类型转换,例如，下面的语句可以在Java中直接通过：

byte b;

int i=b;

long l=b;

float f=b;

double d=b;

     如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如

    char c='c';      int i=c;      System.out.println("output:"+i);

输出：output:99;

对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。

short i=99 ;

char c=(char)i;

System.out.println("output:"+c);

输出：output:c;

但根据笔者的经验，byte,short,int三种类型都是整型，因此如果操作整型数据时，最好统一使用int型。

2.2强制类型转换 

   将高级变量转换为低级变量时，情况会复杂一些，你可以使用强制类型转换。即你必须采用下面这种语句格式：

int i=99;

byte b=(byte)i;

char c=(char)i;

float f=(float)i;

     可以想象，这种转换肯定可能会导致溢出或精度的下降，因此笔者并不推荐使用这种转换。

   2.3包装类过渡类型转换

    在我们讨论其它变量类型之间的相互转换时，我们需要了解一下Java的包装类，所谓包装类，就是可以直接将简单类型的变量表示为一个类，在执行变量类型的相互转换时，我们会大量使用这些包装类。Java共有六个包装类，分别是Boolean、Character、Integer、Long、Float和Double，从字面上我们就可以看出它们分别对应于 boolean、char、int、long、float和double。而String和Date本身就是类。所以也就不存在什么包装类的概念了。

    在进行简单数据类型之间的转换（自动转换或强制转换）时，我们总是可以利用包装类进行中间过渡。

    一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了。例如：

   例1，当希望把float型转换为double型时：

   float f1=100.00f; 

   Float F1=new Float(f1); 

   double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法

    当希望把double型转换为int型时：

    double d1=100.00;

    Double D1=new Double(d1);

    int i1=D1.intValue();

    当希望把int型转换为double型时，自动转换：

     int i1=200;      double d1=i1;

     简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即：

Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)

而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。

   3 字符串型与其它数据类型的转换 

     通过查阅类库中各个类提供的成员方法可以看到，几乎从java.lang.Object类派生的所有类提供了toString()方法，即将该类转换为字符串。例如：Characrer,Integer,Float,Double,Boolean,Short等类的toString()方法toString()方法用于将字符、整数、浮点数、双精度数、逻辑数、短整型等类转换为字符串。如下所示：

int i1=10;

float f1=3.14f

;double d1=3.1415926;

Integer I1=new Integer(i1);//生成Integer类

Float F1=new Float(f1); //生成Float类

Double D1=new Double(d1); //生成Double类

//分别调用包装类的toString()方法转换为字符串

String si1=I1.toString();

String sf1=F1.toString();

String sd1=D1.toString();

Sysytem.out.println("si1"+si1);

Sysytem.out.println("sf1"+sf1);

Sysytem.out.println("sd1"+sd1);

五、将字符型直接做为数值转换为其它数据类型

     将字符型变量转换为数值型变量实际上有两种对应关系，在我们在第一部分所说的那种转换中，实际上是将其转换成对应的ASCII码，但是我们有时还需要另一种转换关系，例如，'1'就是指的数值1，而不是其ASCII码，对于这种转换，我们可以使用Character的getNumericValue(char ch)方法。

六、Date类与其它数据类型的相互转换

   整型和Date类之间并不存在直接的对应关系，只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，在作这种转换时，你可以使用Date类构造函数的三种形式：

Date(int year, int month, int date)：以int型表示年、月、日

Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分

Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、分、秒

        在长整型和Date类之间有一个很有趣的对应关系，就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。对于这种对应关系，Date类也有其相应的构造函数：Date(long date)

获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以将其理解为将Date类转换成int。

而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，与包装类一样，Date类也有一个toString()方法可以将其转换为String类。

有时我们希望得到Date的特定格式，例如20020324，我们可以使用以下方法，首先在文件开始引入，

import java.text.SimpleDateFormat;

import java.util.*;

java.util.Date date = new java.util.Date();

//如果希望得到YYYYMMDD的格式

SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMDD";

String dateFormat=sy1.format(date);

//如果希望分开得到年，月，日

SimpleDateFormat sy=new SimpleDateFormat("yyyy";

SimpleDateFormat sm=new SimpleDateFormat("MM";

SimpleDateFormat sd=new SimpleDateFormat("dd";

String syear=sy.format(date);

String smon=sm.format(date);

String sday=sd.format(date);