BlogJava-sooxin-JAVA-文章分类-JAVA

MyEclipse下设置合适的Content Assist快捷键

sooxin — Wed, 23 Apr 2008 03:52:00 GMT

MyEclipse安装完成之后，有一个很常用的快捷键Content Assist（即代码提示）被默认为Ctrl + Space。

这会使得我们使用中文操作系统的计算机用起来很不方便，因为我们平时打字必用的切换打字法的快捷键，恰恰就是这个！

当然，你可以直接在Windows => Preferences... => General => Keys去替换掉这个快捷键，不过可能还会有其他快捷键与我们的中文操作系统有冲突。这里介绍一个一劳永逸，也是更“Eclipse化”的方法来改变这种尴尬局面：

在MyEclipse的启动选项中，其实有Duser.language这样一项设置，在MyEclipse安装完之后，它的默认值是等于en的，只要把它改成zh，重启MyEclipse之后，即可将Content Assist的快捷键改成Alt + /。

具体修改方式如下：

【方法一】右击MyEclipse快捷方式，选择属性，打开属性对话框，如下：

将 -Duser.language=en 改为 -Duser.language=zh；

【方法二】在Eclipse安装目录下，有一个eclipse.ini的配置文件，用文本编辑器打开它，找到-Duser.language=en这样一行，将它改为-Duser.language=zh即可：

改完之后，可以到Edit => Content Assist菜单下或快捷键设置面板中看到新的快捷键：

这样，就通过更改MyEclipse的默认系统语言，来达到更改使用习惯（如快捷键）的目的。

sooxin 2008-04-23 11:52 发表评论

使用POI生成Excel文件

sooxin — Wed, 05 Dec 2007 13:34:00 GMT

摘要: Apache的Jakata项目的POI子项目，目标是处理ole2对象。 POI可以到 http://www.apache.org/dyn/closer.cgi/jakarta/poi/ 下载。编译好的jar主要有这样4个：poi包,poi Browser包,poi hdf包,poi hssf例程包。实际运行时，需要有poi包就可以了。 HSSF提供给用户使用的对象在org.apache.p... 阅读全文

sooxin 2007-12-05 21:34 发表评论

POI读写Excel文件

sooxin — Wed, 05 Dec 2007 13:32:00 GMT

         在上一篇文章中，我们介绍了POI项目的基本概念，了解了如何用POI来读写OLE 2复合文档结构，并给出了两个简单的例子：用POI来读写Excel文件的Workbook流。本文继续前文的话题，阐述如何用POI来读取/写入完整的Excel文件。

　　约定：POI项目2.0版现在已经接近正式发行阶段，开发进度迅速，不断有新的功能集成到原有的系统，同时也有对原有系统的修改。为了保证本文的及时性，本文将按照最近的1.9开发版说明。虽然编译最近的发行版源代码也能正常运行，但现在的代码和2.0的发行版会有一些出入。

　　一、Excel基础

　　Microsoft Excel 97文件格式也被称为BIFF8，最近版本的Excel只对该格式作了少量的改动。增加对新格式的支持除了增加项目的复杂性之外，唯一的效果也许只是不得不使每个用户升级代码，没有什么实际的好处。因此，在下文说明中，凡是提到Excel 97格式的地方其实都是指Excel从97到XP的格式。

　　二、HSSF概况

　　POI项目实现的Excel 97文件格式称为HSSF——也许你已经猜到，HSSF是Horrible SpreadSheet Format的缩写，也即“讨厌的电子表格格式”（微软使某些原本简单的事情过分复杂，同时又过分简单地处理了某些原本需要灵活性的事情，让人不胜佩服！）也许HSSF的名字有点滑稽，就本质而言它是一个非常严肃、正规的API。通过HSSF，你可以用纯Java代码来读取、写入、修改Excel文件。

　　前面一篇文章提到了POIFS，那么HSSF和POIFS又有什么关系呢？就象其他POI的API一样，HSSF建立在 POIFS的基础上，因此在HSSF内的有些代码和前文的某些代码很相似。不过，当我们编写基于HSSF API的代码时，一般不需要了解POIFS API的细节。

　　HSSF为读取操作提供了两类API：usermodel和eventusermodel，即“用户模型”和“事件-用户模型”。前者很好理解，后者比较抽象，但操作效率要高得多。usermodel主要有 org.apache.poi.hssf.usermodel和org.apache.poi.hssf.eventusermodel包实现（在 HSSF的早期版本中，org.apache.poi.hssf.eventusermodel属于eventmodel包）。

　　 usermodel包把Excel文件映射成我们熟悉的结构，诸如Workbook、Sheet、Row、Cell等，它把整个结构以一组对象的形式保存在内存之中。eventusermodel要求用户熟悉文件格式的底层结构，它的操作风格类似于XML的SAX API和AWT的事件模型（这就是eventusermodel名称的起源），要掌握窍门才能用好。另外，eventusermodel的API只提供读取文件的功能，也就是说不能用这个API来修改文件。

　　三、通过usermodel读取文件

　　用HSSF的usermodel读取文件很简单。首先创建一个InputStream，然后创建一个HSSFWorkbook：

InputStream myxls = new FileInputStream("workbook.xls"));
HSSFWorkbook wb     = new HSSFWorkbook(myxls);

　　有了HSSFWorkbook实例，接下来就可以提取工作表、工作表的行和列，例如：

HSSFSheet sheet = wb.getSheetAt(0);       // 第一个工作表
HSSFRow row     = sheet.getRow(2);        // 第三行
HSSFCell cell   = row.getCell((short)3);  // 第四个单元格

　　上面这段代码提取出第一个工作表第三行第四单元格。利用单元格对象可以获得它的值，提取单元格的值时请注意它的类型：

if (cell.getCellType() == HSSFCell.CELL_TYPE_STRING) {
    ("单元格是字符串，值是： " + cell.getStringCellValue());
} else if (cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC) {
    ("单元格是数字，值是： " + cell.getCellValue());
} else () {
    ("单元格的值不是字符串或数值。");
}

　　如果搞错了数据类型，程序将遇到异常。特别地，用HSSF处理日期数据要小心。Excel内部以数值的形式保存日期数据，区别日期数据的唯一办法是通过单元格的格式（如果你曾经在Excel中设置过日期格式，应该明白这是什么意思）。

　　因此，对于包含日期数据的单元格，cell.getCellType()将返回HSSFCell.CELL_TYPE_NUMERIC，不过利用工具函数HSSFDateUtil.isCellDateFormatted(cell)可以判断出单元格的值是否为日期。 isCellDateFormatted函数通过比较单元格的日期和Excel的内置日期格式得出结论——可以想象，按照这种判断方法，很多时候 isCellDateFormatted函数会返回否定的结论，存在一定的误判可能。

　　本文附录包含了一个在Servlet环境中利用HSSF创建和返回Excel工作簿的实例。

　　四、通过usermodel写入文件

　　写入XLS文件比读取XLS文件还要简单。创建一个HSSFWorkbook实例，然后在适当的时候创建一个把文件写入磁盘的OutputStream，但延迟到处理结束时创建OutputStream也可以：

HSSFWorkbook wb = new HSSFWorkbook();
FileOutputStream fileOut
　　 = new FileOutputStream("workbook.xls");
wb.write(fileOut);
fileOut.close();

　　创建工作表及其内容必须从相应的父对象出发，例如：

HSSFSheet sheet = wb.createSheet();
HSSFRow row     = sheet.createRow((short)0);
HSSFCell cell   = row.createCell((short)0);
cell.setCellValue(1);
row.createCell((short)1).setCellValue(1.2);
row.createCell((short)2).setCellValue("一个字符串");
row.createCell((short)3).setCellValue(true);

　　如果要设置单元格的样式，首先要创建一个样式对象，然后把它指定给一个单元格——或者把它指定给多个具有相同样式的单元格，例如，如果Excel表格中有一个摘要行，摘要行的数据必须是粗体、斜体，你可以创建一个summaryRowStyle样式对象，然后把这个样式指定给所有摘要行上的单元格。

　　注意，CellFormat和CellStyle对象是工作簿对象的成员，单元格对象只是引用它们。

...
HSSFCellStyle style = workbook.createCellStyle();
style.setDataFormat
　　(HSSFDataFormat.getBuiltinFormat("($#,##0_);[Red]($#,##0)"));
style.setFillBackgroundColor(HSSFColor.AQUA.index);
style.setFillPattern(HSSFCellStyle.BIG_SPOTS);
...
someCell.setCellStyle(style);
someOtherCell.setCellStyle(style);

　　版本较新的HSSF允许使用数量有限的Excel公式。这一功能目前还是“Beta级质量”，正式使用之前务必仔细测试。指定公式的方式类如：someCell.setCellFormula(SUM(A1:A2:);。

　　当前，公式中已经可以调用所有内建的函数或操作符，但逻辑操作符和函数（例如IF函数）除外，这部分功能目前还在开发之中。

　　五、通过eventusermodel读取文件

　　通过eventusermodel读取文件要比使用usermodel复杂得多，但效率也要高不少，因为它要求应用程序一边读取数据，一边处理数据。 eventusermodel实际上模拟了DOM环境下SAX处理XML文档的办法，应用程序首先要注册期望处理的数据，eventusermodel将在遇到匹配的数据结构时回调应用程序注册的方法。使用eventusermodel最大的困难在于你必须熟悉Excel工作簿的内部结构。

　　在HSSF中，低层次的二进制结构称为记录（Record）。记录有不同的类型，每一种类型由org.apache.poi.hssf.record包中的一个Java类描述。例如，BOFRecord记录表示Workbook或Sheet区域的开始，RowRecord表示有一个行存在并保存其样式信息。所有具有CellValueRecordInterface接口的记录表示Excel的单元格，包括NumericRecord、 LabelSSTRecord和FormulaRecord（还有其他一些，其中部分已被弃置不用，部分用于优化处理，但一般而言，HSSF可以转换它们）。

　　下面是一个注册事件处理句柄的例子：

private EventRecordFactory factory = new EventRecordFactory();
factory.registerListener(new ERFListener() {
    public boolean processRecord(Record rec) {
        (got BOF Record);
        return true;
    }
}, new short[] {BOFRecord.sid});
factory.processRecords(someInputStream);

　　六、HSSF电子表格结构

　　如前所述，HSSF建立在POIFS的基础上。具体地说，Excel 97+文件是OLE 2复合文档（ OLE 2 Compound Document），底层的OLE 2复合文档保存了一个总是命名为Workbook（Excel 95除外，HSSF不支持Excel 95）的流。然而，宏和图片并不保存在Workbook流，它们有自己独立的流，有时甚至会放到OLE 2 CDF文件之内的另一个目录。理想情况下，宏也应该被保留，不过目前POI项目中还没有合适的API来处理宏。

　　每一个流之内是一组记录，一个记录其实就是一个字节数组，可分为记录头、记录体两部分。记录头指明了记录的类型（也即ID）以及后继数据的长度，记录体被分割成多个字段（Field），字段包含数值数据（包括对其他记录的引用）、字符数据或标记。

　　下图概要说明了Excel工作簿的顶级结构：

Bla.xls {
    OLE2CDF headers
    "Workbook" stream {
        Workbook {
            Static String Table Record..
            Sheet names… and pointers
        }
        Sheet {
            ROW
            ROW
            …
            NUMBER RECORD (cell)
            LABELSST Record (cell)
            …
        }
        Sheet
    }
}
… images, macros, etc.
Document Summary
Summary

　　七、通过HPSF读取文档属性

　　在Microsoft Word、Excel、PowerPoint等软件中，用户可以通过“文件”→“属性”菜单给文档添加附加信息，包括文档的标题、主题、摘要、类别、关键词等，同时应用软件本身还会加入最后访问的用户、最后访问和修改/打印的日期时间等信息。

　　文档的属性和正文是分开保存的。如前所述，OLE 2 CDF文件内部就象是一个容器，里面包含许多类似目录和文件的结构，而POIFS就是用来访问其中的文件的工具。这些文件也称为流，文档的属性就保存在 POIFS文件系统中专用的流里面。以一个Word文档为例：虽然在资源管理器中你只看到一个叫做MyFile.doc的文档，其实在这个文档的内部，又包含了一个WordDocument、一个SummaryInformation和一个DocumentSummaryInformation文档；通常还会有其他的文档，这里暂且不管。

　　你能够猜出这些文档（流）分别包含什么内容吗？不错，WordDocument包含了你在 Word里面编辑的文本，文档的属性保存在SummaryInformation和DocumentSummaryInformation流里面。也许将所有属性保存在单个文档里面看起来太简单了，所以Microsoft决心要使用两个流，为了使事情更复杂一点，这两个流的名字前面还加上了八进制的 \005字符——这是一个不可打印的字符，因此前面就把它省略了。

　　Microsoft定义的标准属性有一个好处，它们并不在乎主文档到底是什么类型——不管是Word文档、Excel工作簿还是PowerPoint幻灯。只要你知道如何读取Excel文档的属性，就知道了如何读取其他文档的属性。

　　读取文档属性其实并不复杂，因为Java程序可以利用POI项目的HPSF包。HPSF是 Horrible Property Set Format的缩写，译成中文就是“讨厌的属性集格式”。HPSF包是POI项目实现的读取属性工具，目前还不支持属性写入。

　　对于读取Microsoft定义的标准属性，通过HPSF提供的API可以很方便地办到；但如果要读取任意属性集就要用到更一般化的API，可以想象它要比读取标准属性的API复杂不少。本文只介绍读取标准属性的简单API，因为对大多数应用程序来说这已经完全足够了。

　　下面就是一个读取OLE 2 CDF文档的标题（title）属性的Java程序：

import java.io.*;
import org.apache.poi.hpsf.*;
import org.apache.poi.poifs.eventfilesystem.*;

/**
* 读取OLE 2文档标题的示例程序，
* 在命令行参数中指定文档的文件名字。
*/

public class ReadTitle
{
    public static void main(String[] args) throws IOException
    {
        final String filename = args[0];
        POIFSReader r         = new POIFSReader();
        r.registerListener(new MyPOIFSReaderListener(),
            "\005SummaryInformation");
        r.read(new FileInputStream(filename));
    }

    static class MyPOIFSReaderListener
　　　　 implements POIFSReaderListener
    {
        public void processPOIFSReaderEvent(POIFSReaderEvent event)
        {
            SummaryInformation si = null;
            try
            {
                si = (SummaryInformation)
                PropertySetFactory.create(event.getStream());
            }
            catch (Exception ex)
            {
                throw new RuntimeException
                    ("属性集流\"" + event.getPath() +
                        event.getName() + "\": " + ex);
            }

            final String title = si.getTitle();

            if (title != null)
                System.out.println("标题: \"" + title + "\"");
            else
                System.out.println("该文档没有标题.");
            }
        }
}

　　main()方法利用POIFS的事件系统从命令行指定的OLE 2文档读取名为\005SummaryInformation的流，当POIFSReader 遇到这个流时，它把控制传递给MyPOIFSReaderListener的processPOIFSReaderEvent()方法。

　　processPOIFSReaderEvent() 到底有什么用呢？它通过参数获得一个输入流，该输入流包含了文档标题等属性。为了访问文档的属性，我们从输入流创建一个PropertySet实例，如下所示：

si = (SummaryInformation) PropertySetFactory.create(event.getStream());

　　这个语句其实包含三个步骤的操作：

　　◆ event.getStream()从POIFSReader传入的POIFSReaderEvent获得输入流。

　　◆ 以刚才获得的输入流为参数，调用PropertySetFactory的静态方法create()。正如其名字所暗示的， PropertySetFactory是一个工厂类，它有一台“机器”能够把一个输入流转换成一个PropertySet实例，这台机器就是create ()方法。

　　◆ 把create()方法返回的PropertySet定型（cast）成为SummaryInformation。PropertySet提供了按照一般办法读取属性集的各种机制，SummaryInformation是PropertySet的子类，即SummaryInformation类在 PropertySet类的基础上增加了操作Microsoft标准属性的便捷方法。

　　在这个处理过程中，可能引起错误的因素很多，因此我们把这部分内容放入了一个try块——不过这个示例程序只按照最简单的方式处理了异常，在实际应用中，最好能够对可能出现的不同异常类型分别处理。除了一般的I/O异常之外，还有可能遇到HPSF特有的异常，例如，如果输入流不包含属性集或属性集非法，就会抛出 NoPropertySetStreamException异常。

　　有一种错误不太常见，但也不是绝无可能——\005SummaryInformation包含一个合法的属性集，但不是摘要信息属性集。如果出现这种情况，则定型成SummaryInformation操作会失败，引发ClassCastException异常。

　　获得SummaryInformation实例之后，剩下的事情就很简单了，只要调用getTitle()方法，然后输出结果。

　　除了getTitle()之外，SummaryInformation还包含其他一些便捷方法，例如getApplicationName()、 getAuthor()、getCharCount()、和getCreateDateTime()等。HPSF的JavaDoc文档详细说明了所有这些方法。

　　八、文档摘要信息

　　遗憾的是，并非所有的属性都保存在摘要信息属性集之中。许多（但不是全部）OLE 2文件还有另一个属性集，称为“文档摘要信息”，对应的流是\005DocumentSummaryInformation。这个属性集保存的属性包括文档的类别、PowerPoint幻灯的多媒体剪辑数量，等等。

　　要访问文档摘要信息属性集，程序的处理过程也和上例相似，只是注册的目标应该改成\005DocumentSummaryInformation流——有时，你可能想要同时注册到摘要信息和文档摘要信息这两个流。其余的处理方式和前面的例子差不多，你应该把包含文档摘要信息的流传递给PropertySetFactory.create()，但这次工厂方法将返回一个 DocumentSummaryInformation对象（而不是前面例子中的SummaryInformation对象）。如果同时注册到了两个流，注意检查返回值的具体类型，或者使用Java的instanceof操作符，或者使用专用的isSummaryInformation()和 isDocumentSummaryInformation()方法。记住，create()方法返回的总是一个PropertySet对象，因此你总是可以对create()返回对象调用isSummaryInformation()和isDocumentSummaryInformation()方法，PropertySet类之所以要提供这两个方法，是因为属性集可能是自定义的。

　　如果你想要处理自定义的属性集，或者要从标准的属性集读取用户定义的属性，必须使用一个更一般化的API，前面已经提到，这个API要复杂得多，本文不再讨论，请参见HPSF的HOW-TO文档和POI的文档。

　　结束语：本文探讨了HSSF的应用以及如何输出到Excel文件，另外还涉及了HPSF以及如何读取属性集文档摘要信息。POI是一个功能非常强大的项目，许多主题本文尚未涉及，例如如何用HSSF Serializer将XML文档转换成Excel格式等，这一切就有待你自己去研究了。

　　参考：

　　Jakarta POI项目主页

　　Jakarta POI 源代码

　　九、附录

　　实例：利用Servlet创建和返回一个工作簿。

package org.apache.poi.hssf.usermodel.examples;

import java.io.*;
import java.net.*;
import javax.servlet.*;
import javax.servlet.http.*;
import org.apache.poi.hssf.usermodel.*;

public class HSSFCreate extends HttpServlet {
    public void init(ServletConfig config)
　　 throws ServletException {
        super.init(config);
    }

    public void destroy() {
    }

    /** 处理HTTP GET 和POST请求
     * @param request：请求
     * @param response：应答
     */
    protected void processRequest(HttpServletRequest request,
        HttpServletResponse response)
　　　　 throws ServletException, IOException {

        response.setContentType("application/vnd.ms-excel");
        HSSFWorkbook wb = new HSSFWorkbook();
        HSSFSheet sheet = wb.createSheet("new sheet");

        // 创建一个新的行，添加几个单元格。
        // 行号从0开始计算
        HSSFRow row     = sheet.createRow((short)0);
        // 创建一个单元格，设置单元格的值
        HSSFCell cell   = row.createCell((short)0);
        cell.setCellValue(1);

        row.createCell((short)1).setCellValue(1.2);
        row.createCell((short)2).setCellValue("一个字符串值");
        row.createCell((short)3).setCellValue(true);
        // 写入输出结果
        OutputStream out = response.getOutputStream();
        wb.write(out);
        out.close();
    }

    /** 处理HTTP GET请求
     * @param request：请求
     * @param response：应答
     */
    protected void doGet(HttpServletRequest request,
        HttpServletResponse response)
　　　　 throws ServletException, IOException {
        processRequest(request, response);
    }

    /** 处理HTTP POST请求
     * @param request：请求
     * @param response：应答
     */
    protected void doPost(HttpServletRequest request,
        HttpServletResponse response)
　　　　 throws ServletException, IOException {
        processRequest(request, response);
    }

    /** 返回关于Servlet的简单说明
     */
    public String getServletInfo() {
       return "示例：在Servlet中用HSSF创建Excel工作簿";
    }
}
POI HSSF 操作MS Excel简述 (OMIS二期设计阶段寻找Excel导入导出实现方法）
POI HSSF 操作MS Excel简述

POI HSSF是一个专门操作EXCEL的java包，可通过纯java操作xls文件。
POI HSSF的类文件都放在在org.apache.poi.hssf包下，通过此包中的类就可实现用java操作Excel文件了。
下面是用POI HSSF操作Excel文件的方法简述：

一，建立Excel工作薄
HSSFWorkbook wb = new HSSFWorkbook();

二，建立Excel工作表，每个工作表对应的是Excel界面左下角的一个标签sheet1，sheet2 …
HSSFSheet sheet1 = wb.createSheet("new sheet");

三，在工作表中建立单元格

//首先，建立行对像，行号作为参数传给createRow方法，第一行由0开始计算。
HSSFRow row = sheet.createRow((short)0);

//建单元格
HSSFCell cell = row.createCell((short)0);

//给单元格赋值
cell.setCellValue(1);

//也可同一行内完成建立单元格和赋值
row.createCell((short)1).setCellValue(1.2);
row.createCell((short)2).setCellValue("This is a string");
row.createCell((short)3).setCellValue(true);

//数据格式可通过创建单元格值时默认如上面所视
//也可以创建单元格后调用setCellType指定
cell.setCellType(CELL_TYPE_NUMERIC);

四，向单元格插入日期值
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("new sheet");

// 可通过Sheet.setSheetName(sheetindex,"SheetName",encoding)设定工作表名

// 创建新行并向其加入单元格，行号由0开始。
HSSFRow row = sheet.createRow((short)0);

// 创建一个单元格并向其输入一日期值，但这第一个单元格并非是日期格式。
HSSFCell cell = row.createCell((short)0);
cell.setCellValue(new Date());

// 我们将这第二个单元格改成日期格式，这需要从工作薄创建一个新的单元格格式，这可// 以只影响当前建立的一个单元格。
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(HSSFDataFormat.getBuiltinFormat("m/d/yy h:mm"));
cell = row.createCell((short)1);
cell.setCellValue(new Date());
cell.setCellStyle(cellStyle);

五，各种单元格样式
HSSFCellStyle cellStyle = wb.createCellStyle();
//对齐
cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);

//带边框
cellStyle.setBorderBottom(HSSFCellStyle.BORDER_THIN);

//颜色与填充样式
cellStyle.setFillBackgroundColor(HSSFColor.AQUA.index);
cellStyle.setFillPattern(HSSFCellStyle.BIG_SPOTS);
cellStyle.setFillForegroundColor(HSSFColor.ORANGE.index);
cellStyle.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);

六，行高,列宽。
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("new sheet");
HSSFRow row = sheet.createRow((short)0);

//2是行高值
row.setRowHeight(2);

//3是列号，4是列宽值
sheet.setColumnWidth(3, 4);

七，例程

首先调用一个方法将Oracle数据库中的数据取出，放到List实例中，这里我调用了srrd项目中ProductData类的 listProductQuery()取得一个List实例。List中的对象是一系列名为ProductQuery实体类的实例。然后读List，将 ProductQuery实例中的数据取出放到HSSFCell单元格中。最后将HSSFWorkbook中的数据输出到输出流，完成数据导出。

//建工作薄
HSSFWorkbook wb = new HSSFWorkbook();
//建名为example的工作表
HSSFSheet sheet = wb.createSheet("example");
//给工作表前8列定义列宽
sheet.setColumnWidth((short)0,(short)2500);
sheet.setColumnWidth((short)1,(short)6000);
sheet.setColumnWidth((short)2,(short)3500);
sheet.setColumnWidth((short)3,(short)9000);
sheet.setColumnWidth((short)4,(short)8000);
sheet.setColumnWidth((short)5,(short)8000);
sheet.setColumnWidth((short)6,(short)20000);
sheet.setColumnWidth((short)7,(short)8000);
//在表中建行
HSSFRow row = sheet.createRow(0);
//建立单元格
HSSFCell cell[] = new HSSFCell[8];
for (short i = 0; i < 8; i++) {
cell= row.createCell(i);
//将单元格定义成UTF_16编码，这样才能使输出数据不会乱码
cell.setEncoding(HSSFCell.ENCODING_UTF_16);
}
//写单元格标题
cell[0].setCellValue("登记ID");
cell[1].setCellValue("登记号");
cell[2].setCellValue("所在地市ID");
cell[3].setCellValue("产品中文名");
cell[4].setCellValue("产品英文名");
cell[5].setCellValue("产品服务对象");
cell[6].setCellValue("产品功能描述");
cell[7].setCellValue("产品类别");
//查询数据库，取得数据列表的List实例
List list = new ArrayList();
ProductDataManager mgr = new ProductDataManager();
try {
list = mgr.listProductQuery("","", "", "", "", "1999-2-1", "2004-2-1");
} catch (SrrdException e) {
e.printStackTrace();
}
//从List中取出数据放入工作表中
if (list != null && list.size() > 0) {
for (int i = 0; i < list.size() - 1; i++) {
ProductQuery query = (ProductQuery) list.get(i);
HSSFRow datarow = sheet.createRow(i + 1);
HSSFCell data[] = new HSSFCell[8];
for (short j = 0; j < 8; j++) {
data[j] = datarow.createCell(j);
//将单元格定义成UTF_16编码，这样才能使输出数据不会乱码
data[j].setEncoding(HSSFCell.ENCODING_UTF_16);
}
data[0].setCellValue(query.getCertId());
data[1].setCellValue(query.getCertNum());
data[2].setCellValue(query.getCityCode());
data[3].setCellValue(query.getSoftWareCname());
data[4].setCellValue(query.getSoftWareEname());
data[5].setCellValue(query.getSoftwareFor());
data[6].setCellValue(query.getSoftwareFuncDesc());
data[7].setCellValue(query.getSoftwareType());
}
}
//将工作薄输出到输出流
ServletOutputStream sos=response.getOutputStream();
wb.write(sos);
sos.close();

//也可输出成xls文件
File file = new File("workbook.xls");
try {
FileOutputStream fileOut = new FileOutputStream(file);
wb.write(fileOut);
fileOut.close();
} catch (IOException e) {
e.printStackTrace();
}

/*****************************************************/

package com.kang.test.project;

import org.apache.log4j.Logger;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Calendar;
import java.util.List;

import javax.servlet.ServletOutputStream;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.util.HSSFColor;

public class TestPOI {
/**
* Logger for this class
*/
private static final Logger log = Logger.getLogger(TestPOI.class);
    private static String xmlFile=String.valueOf(Calendar.getInstance().getTimeInMillis())+".xls";
    private static String file_path="e:\\";
public static void main(String[] args) {
  TestPOI tpoi=new TestPOI();
  String temp=file_path+xmlFile;
  log.info("-----temp:"+temp);
  tpoi.creatExcelByPOI(temp);
  tpoi.getExcelConmentByPOI(temp);

}
/**
* 生成excel文件
*
* @param filename
*/
public void creatExcelByPOI(String filename){
  log.info("-----生成excel文件-----开始-----filename:"+filename);
  FileOutputStream ops=null;
  HSSFWorkbook workbook=new HSSFWorkbook();
  HSSFSheet sheet=workbook.createSheet();
  sheet.setColumnWidth((short)0, (short)2000);
  sheet.setColumnWidth((short)1, (short)4000);
  sheet.setColumnWidth((short)2, (short)4000);
  sheet.setColumnWidth((short)3, (short)8000);
  sheet.setColumnWidth((short)4, (short)1000);
  sheet.setColumnWidth((short)5, (short)2000);
  sheet.setColumnWidth((short)6, (short)2000000);
  sheet.setColumnWidth((short)7, (short)200000);
  sheet.setColumnWidth((short)8, (short)20000);
  sheet.setColumnWidth((short)9, (short)20000);
  //sheet.setDefaultColumnWidth((short)50);
  for(int i=0;i<10;i++){
   log.info("-----i:"+"第"+i+"行");
   HSSFRow row=sheet.createRow((short)i);
   for (int j=0;j<10;j++){
    HSSFCell cell = row.createCell((short)j);

      /**
        * 设置其它数据设置风格
        */
       HSSFCellStyle style = workbook.createCellStyle();
       style.setBorderBottom(HSSFCellStyle.BORDER_THIN); // 设置单无格的边框为粗体
       style.setBottomBorderColor(HSSFColor.BLACK.index); // 设置单元格的边框颜色．
       style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
       style.setLeftBorderColor(HSSFColor.BLACK.index);
       style.setBorderRight(HSSFCellStyle.BORDER_THIN);
       style.setRightBorderColor(HSSFColor.BLACK.index);
       style.setBorderTop(HSSFCellStyle.BORDER_THIN);
       style.setTopBorderColor(HSSFColor.BLACK.index);
       // style.setWrapText(true);//文本区域随内容多少自动调整
       // style.setFillForegroundColor(HSSFColor.LIME.index);
       // style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
       style.setBorderBottom(HSSFCellStyle.BORDER_THIN); // 设置单无格的边框为粗体
       style.setBottomBorderColor(HSSFColor.BLACK.index); // 设置单元格的边框颜色．
       style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
       style.setLeftBorderColor(HSSFColor.BLACK.index);
       style.setBorderRight(HSSFCellStyle.BORDER_THIN);
       style.setRightBorderColor(HSSFColor.BLACK.index);
       style.setBorderTop(HSSFCellStyle.BORDER_MEDIUM);
       style.setTopBorderColor(HSSFColor.BLACK.index);
       style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);// 最好的设置Pattern
       // 单元格背景的显示模式．
       style.setFillForegroundColor(new HSSFColor.BLUE_GREY().getIndex()); // 设置单元格背景色;
       style.setAlignment(HSSFCellStyle.ALIGN_CENTER); // 水平对齐方式
       // style.setWrapText(true); //文本区域随内容多少自动调整
       // style.setFillPattern(HSSFCellStyle.//);
       // 设置字体Color,首先创建Font对象,后对font设置,然后做为参数传给style
       HSSFFont font = workbook.createFont();
       font.setColor(HSSFFont.SS_NONE);
       // font.setFontHeightInPoints((short)24);
       font.setFontName("Courier New");
       // font.setItalic(true);
       // font.setStrikeout(true);//给字体加上删除线
       font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
       style.setFont(font);


       style.setWrapText(true);
       cell.setCellStyle(style);

     //cell.setCellNum((short)(i*10+j));
       cell.setCellType(HSSFCell.CELL_TYPE_STRING);
       cell.setEncoding(HSSFCell.ENCODING_UTF_16);
       cell.setCellStyle(style);

    cell.setCellValue("今天是第"+j+"天，好好学习天天向上，解决方法我已经找到了，具体应该是这样的用poi包的hssf，怎样让excel中的单元格cell里面的文字自动换行啊");
    log.info("-----j:"+"第"+j+"列");
   }
  }
  try {
   ops=new FileOutputStream(filename);
   workbook.write(ops);
   ops.flush();
   /**
    * 在servlet或Controller中
    * response.setContentType("application/vnd.ms-excel");
    * response.addHeader("Content-Disposition","attachment;filename=testReport.xls");//设置下载的文件名称
    * ServletOutputStream output=response.getOutputStream();
    * workbook.write(output);
    * output.close();
    */
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  }catch(IOException e){
   e.printStackTrace();
  }finally{
   try {
    ops.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
  log.info("-----生成excel文件-----完毕-----");
}
/**
* 解析excel文件
* @param filename
*/
public void getExcelConmentByPOI(String filename){
  log.info("-----解析excel文件-----开始-----filename:"+filename);
  InputStream is;
  try {
   is = new FileInputStream(filename);
   HSSFWorkbook book=new HSSFWorkbook(is);
   HSSFSheet sheet=book.getSheetAt(0);
   log.info("-----sheet.getPhysicalNumberOfRows():"+sheet.getPhysicalNumberOfRows());
   for(int i=0;i     HSSFRow row=sheet.getRow(i);
    log.info("-----第"+i+"行");
    for(int j=0;j      HSSFCell cell=row.getCell((short)j);
     log.info("-----第"+j+"列,内容："+cell.getStringCellValue());
    }
   }
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
  log.info("-----解析excel文件-----完毕-----");
}
/**
*
*/
public void getExcelOnWeb(){

}
}

POI读写Excel文件

sooxin 2007-12-05 21:32 发表评论

Java字符串处理总结

sooxin — Tue, 27 Nov 2007 10:18:00 GMT

valueOf

无需创建对象就可使用的方法     String str=String.valueOf(其他类型变量);

拓展字符串

用加号加就可以   str=str+"是的"；

或者用 concat发法。a=String.concat("是的");

StringBuffer才用 append方法

截取单个字符

charAt(字符下标)

截取字符串

substring(startindex)

substring(startindex,endindex)

截取字符串并赋予字符数组

getChars(sourceStart,sourceEnd,char target[],int targetStart)           截取从sourceStart到sourceEnd-1的字符串，下标从0开始

把整个字符串转化为字符数组

char[]   toCharArray()

把字符串存于字节数组

byte[] getByes()

字符串中字符替换

replace(char a,char b)

字符串中子字符串替换

replaceAll(String a ,String b)

字符串比较

equals()

大写转小写

String toLowerCase()

小写转大写

String toUpperCase()

搜索字符串

搜索字符首次出现在字符串中的下标

indexOf()      失败返回-1

搜索字符最后出现在字符串中的下标

lastIndexOf()    失败返回-1

sooxin 2007-11-27 18:18 发表评论

服务器系统时间不是24小时制时间，而是含有上午，下午等中文汉字，导致数图、tasi系统用户登录失败的问题之解决方法

sooxin — Tue, 27 Nov 2007 10:16:00 GMT

服务器系统时间不是24小时制时间，而是含有上午，下午等中文汉字，导致数图、tasi系统用户登录失败的问题之解决方法

西勾月 @ 2006-11-14 13:17

Q：数图3.7使用有密码用户登录时提示“系统拒绝匿名登录”，如何解决？

A：1，检查系统时间格式是否为“2006-11-14 13:01:01”格式，如果不是按照下面操作。

2，将服务器系统时间修改成24小时制时间，修改方法:“控制面板”- “区域设置和语言”– “区域选项”- “自定义” – “时间”。时间格式为：HH:mm:ss ，日期格式为：yyyy-M-d。

3，修改注册表。

将对应键值为HKEY_USERS/.Default/Control Panel/International
HKEY_CURRENT_USER/Control Panel/International
中的iTime = 1。
对应键值为HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\OLEAUT(OLEAUT有可能不存在,那就自己创建一个)

在该键下创建一个DWORD值 VarConversionLocaleSetting = 2

注：DWORD值在中文注册表编辑器里叫"双字节值" 。

4，重新启动计算机。

sooxin 2007-11-27 18:16 发表评论

两个分页代码！（mysql mssql）

sooxin — Sun, 25 Nov 2007 16:55:00 GMT

摘要: mssql: 1<%@ page contentType="text/html; charset=gb2312" %> 2<%@ page language="java" %> 3<%@ page ... 阅读全文

sooxin 2007-11-26 00:55 发表评论

两个整数相除得到小数（JAVA）

sooxin — Sat, 24 Nov 2007 07:13:00 GMT

结果完全不一样

        public class test{
              public static void main(String[] args){
                    double x = 1/4;
                  System.out.println(x+"");
            　}
        }

　　public class test{
          public static void main(String[] args){
                    double x = (double)1/4;
                  System.out.println(x+"");
                }
    　}

　　是变笨了还是。。。
　　基础不牢，唯一的解释。

sooxin 2007-11-24 15:13 发表评论

有关于java的反斜杠"\"

sooxin — Mon, 05 Nov 2007 06:19:00 GMT

先说说java的转义字符

\b    backspace键
\t     Tab键
\n    按行回车
\r     回车
\”     双引号
\’     单引号
\\     反斜杠

再看java的String replaceAll(String regex, String replacement)方法的例子:

把字符串ab.c变成ab/c

public class Test {

    public static void main(String args[]){
        String str="ab.c";
        System.out.println(str);
        str=str.replaceAll("\.", "/");
        System.out.println(str);
    }

}

String.replaceAll()是用regular expression 来作为参数的。但是java本身的字符串对于转义符\也有类似的处理。首先，java会把“\\\\”解释成一个字符串(其中包含两个char)——“\\”这个就是你在JDK的文档里看到的。
接下来，由于replaceAll是以正则表达式作为参数，所以“\\”被解释成一个regex。对于一个regex来说这就代表着一个字符，就是“\”。对后面的那个8个\来说，最终会被解释成“\\”。

再来个例子:

public class Test {

    public static void main(String args[]) throws Exception{

        String str="c:/abc";
        str=str.replaceAll("/","\\\\");
        System.out.println(str);
                                           //最后打印为 c:\abc
    }

}

sooxin 2007-11-05 14:19 发表评论

使用POI来处理Excel和Word文件格式

sooxin — Thu, 01 Nov 2007 12:56:00 GMT

7.3 使用POI来处理Excel和Word文件格式

Microsoft的Office系列产品拥有大量的用户，Word、Excel也成为办公文件的首选。在Java中，已经有很多对于Word、Excel的开源的解决方案，其中比较出色的是Apache的Jakata项目的POI子项目。该项目的官方网站是http://jakarta.apache.org/poi/。

POI包括一系列的API，它们可以操作基于MicroSoft OLE 2 Compound Document Format的各种格式文件，可以通过这些API在Java中读写Excel、Word等文件。POI是完全的Java Excel和Java Word解决方案。POI子项目包括：POIFS、HSSF、HDF、HPSF。表7-2对它们进行了简要介绍。

表7-2 POI子项目介绍

子项目名

说明

POIFS(POI File System)

POIFS是POI项目中最早的最基础的一个模块，是Java到OLE 2 Compound Document Format的接口，支持读写功能，所有的其他项目都依赖与该项目。

HSSF(Horrible Spreadsheet Format)

HSSF是Java到Microsoft Excel 97(-2002)文件的接口，支持读写功能

HWPF(Horrible Word Processing Format)

HWPF是Java到Microsoft Word 97文件的接口，支持读写功能，但目前该模块还处于刚开始开发阶段，只能实现一些简单文件的操作，在后续版本中，会提供更强大的支持

HPSF(Horrible Property Set Format)

HPSF 是Java到OLE 2 Compound Document Format文件的属性设置的接口，属性设置通常用来设置文档的属性（标题，作者，最后修改日期等），还可以设置用户定义的属性。HPSF支持读写功能，当前发布版本中直支持读功能。

7.3.1 对Excel的处理类

下面通过HSSF提供的接口对Excel文件经行处理。首先需要下载POI的包，可以到apache的官方网站下载，地址为：http://apache.justdn.org/jakarta/poi/，本书采用的是poi-2.5.1-final-20040804.jar，读者可以下载当前的稳定版本。把下载的包按照前面介绍的方式加入Build Path，然后新建一个ch7.poi包，并创建一个ExcelReader类。

ExcelReader类可以读取一个XLS文件，然后将其内容逐行提取出来，写入文本文件。其代码如下。

代码7.6

public class ExcelReader {

// 创建文件输入流

private BufferedReader reader = null;

// 文件类型

private String filetype;

// 文件二进制输入流

private InputStream is = null;

// 当前的Sheet

private int currSheet;

// 当前位置

private int currPosition;

// Sheet数量

private int numOfSheets;

// HSSFWorkbook

HSSFWorkbook workbook = null;

// 设置Cell之间以空格分割

private static String EXCEL_LINE_DELIMITER = " ";

// 设置最大列数

private static int MAX_EXCEL_COLUMNS = 64;

// 构造函数创建一个ExcelReader

public ExcelReader(String inputfile) throws IOException, Exception {

// 判断参数是否为空或没有意义

if (inputfile == null || inputfile.trim().equals("")) {

throw new IOException("no input file specified");

}

// 取得文件名的后缀名赋值给filetype

this.filetype = inputfile.substring(inputfile.lastIndexOf(".") + 1);

// 设置开始行为0

currPosition = 0;

// 设置当前位置为0

currSheet = 0;

// 创建文件输入流

is = new FileInputStream(inputfile);

// 判断文件格式

if (filetype.equalsIgnoreCase("txt")) {

// 如果是txt则直接创建BufferedReader读取

reader = new BufferedReader(new InputStreamReader(is));

}

else if (filetype.equalsIgnoreCase("xls")) {

// 如果是Excel文件则创建HSSFWorkbook读取

workbook = new HSSFWorkbook(is);

// 设置Sheet数

numOfSheets = workbook.getNumberOfSheets();

}

else {

throw new Exception("File Type Not Supported");

}

// 函数readLine读取文件的一行

public String readLine() throws IOException {

// 如果是txt文件则通过reader读取

if (filetype.equalsIgnoreCase("txt")) {

String str = reader.readLine();

// 空行则略去，直接读取下一行

while (str.trim().equals("")) {

str = reader.readLine();

}

return str;

}

// 如果是XLS文件则通过POI提供的API读取文件

else if (filetype.equalsIgnoreCase("xls")) {

// 根据currSheet值获得当前的sheet

HSSFSheet sheet = workbook.getSheetAt(currSheet);

// 判断当前行是否到但前Sheet的结尾

if (currPosition > sheet.getLastRowNum()) {

// 当前行位置清零

currPosition = 0;

// 判断是否还有Sheet

while (currSheet != numOfSheets - 1) {

// 得到下一张Sheet

sheet = workbook.getSheetAt(currSheet + 1);

// 当前行数是否已经到达文件末尾

if (currPosition == sheet.getLastRowNum()) {

// 当前Sheet指向下一张Sheet

currSheet++;

continue;

} else {

// 获取当前行数

int row = currPosition;

currPosition++;

// 读取当前行数据

return getLine(sheet, row);

}

return null;

}

// 获取当前行数

int row = currPosition;

currPosition++;

// 读取当前行数据

return getLine(sheet, row);

}

return null;

}

// 函数getLine返回Sheet的一行数据

private String getLine(HSSFSheet sheet, int row) {

// 根据行数取得Sheet的一行

HSSFRow rowline = sheet.getRow(row);

// 创建字符创缓冲区

StringBuffer buffer = new StringBuffer();

// 获取当前行的列数

int filledColumns = rowline.getLastCellNum();

HSSFCell cell = null;

// 循环遍历所有列

for (int i = 0; i < filledColumns; i++) {

// 取得当前Cell

cell = rowline.getCell((short) i);

String cellvalue = null;

if (cell != null) {

// 判断当前Cell的Type

switch (cell.getCellType()) {

// 如果当前Cell的Type为NUMERIC

case HSSFCell.CELL_TYPE_NUMERIC: {

// 判断当前的cell是否为Date

if (HSSFDateUtil.isCellDateFormatted(cell)) {

// 如果是Date类型则，取得该Cell的Date值

Date date = cell.getDateCellValue();

// 把Date转换成本地格式的字符串

cellvalue = cell.getDateCellValue().toLocaleString();

}

// 如果是纯数字

else {

// 取得当前Cell的数值

Integer num = new Integer((int) cell

.getNumericCellValue());

cellvalue = String.valueOf(num);

}

break;

}

// 如果当前Cell的Type为STRIN

case HSSFCell.CELL_TYPE_STRING:

// 取得当前的Cell字符串

cellvalue = cell.getStringCellValue().replaceAll("'", "''");

break;

// 默认的Cell值

default:

cellvalue = " ";

}

} else {

cellvalue = "";

}

// 在每个字段之间插入分割符

buffer.append(cellvalue).append(EXCEL_LINE_DELIMITER);

}

// 以字符串返回该行的数据

return buffer.toString();

}

// close函数执行流的关闭操作

public void close() {

// 如果is不为空，则关闭InputSteam文件输入流

if (is != null) {

try {

is.close();

} catch (IOException e) {

is = null;

}

// 如果reader不为空则关闭BufferedReader文件输入流

if (reader != null) {

try {

reader.close();

} catch (IOException e) {

reader = null;

}

7.3.2 ExcelReader的运行效果

下面创建一个main函数，用来测试上面的ExcelReader类，代码如下。

代码7.7

public static void main(String[] args) {

try{

ExcelReader er=new ExcelReader("c:\\xp.xls");

String line=er.readLine();

while(line != null){

System.out.println(line);

line=er.readLine();

}

er.close();

}catch(Exception e){

e.printStackTrace();

}

main函数先创建一个ExcelReader类，然后调用它提供的接口readLine，对XLS文件进行读取，打印到控制台，处理前的XLS文件如图7-12所示。

图7-12 处理前的XLS文件内容

运行main函数进行内容提取后，Eclipse的控制台输出如图7-13所示。

图7-13 输出结果

可以看到，Excel文件中的内容已经被成功的输出了出来。

7.3.3 POI中Excel文件Cell的类型

在读取每一个Cell的值的时候，通过getCellType方法获得当前Cell的类型，在Excel中Cell有6种类型，如表7-3所示。

表7-3 Cell的类型

CellType

说明

CELL_TYPE_BLANK

空值

CELL_TYPE_BOOLEAN

布尔型

CELL_TYPE_ERROR

错误

CELL_TYPE_FORMULA

公式型

CELL_TYPE_STRING

字符串型

CELL_TYPE_NUMERIC

数值型

本例采用了CELL_TYPE_STRING和CELL_TYPE_NUMERIC类型，因为在Excel文件中只有字符串和数字。如果Cell的Type为CELL_TYPE_NUMERIC时，还需要进一步判断该Cell的数据格式，因为它有可能是Date类型，在Excel中的Date类型也是以Double类型的数字存储的。Excel中的Date表示当前时间与1900年1月1日相隔的天数，所以需要调用HSSFDateUtil的isCellDateFormatted方法，判断该Cell的数据格式是否是Excel Date类型。如果是，则调用getDateCellValue方法，返回一个Java类型的Date。

实际上Excel的数据格式有很多，还支持用户自定义的类型，在Excel中，选择一个单元格然后右键选择“设置单元格格式”，在弹出的单元格格式中选中“数字”，如图7-14所示。

图7-14 Excel的单元格格式

图中的数据有数值、货币、时间、日期、文本等格式。这些数据格式在POI中的HSSFDataFormat类里都有相应的定义。

HSSFDataFormat是HSSF子项目里面定义的一个类。类HSSFDataFormat允许用户新建数据格式类型。HSSFDataFormat类包含静态方法static java.lang.String getBuiltinFormat(short index)，它可以根据编号返回内置数据类型。另外static short getBuiltinFormat(java.lang.String format)方法则可以根据数据类型返回其编号，static java.util.List getBuiltinFormats()可以返回整个内置的数据格式列表。

在HSSFDataFormat里一共定义了49种内置的数据格式，如表7-4所示。

表7-4 HSSFDataFormat的数据格式

内置数据类型

编号

"General"

"0"

"0.00"

"#,##0"

"#,##0.00"

"($#,##0_);($#,##0)"

"($#,##0_);[Red]($#,##0)"

"($#,##0.00);($#,##0.00)"

"($#,##0.00_);[Red]($#,##0.00)"

"0%"

"0.00%"

0xa

"0.00E+00"

0xb

"# ?/?"

0xc

"# ??/??"

0xd

"m/d/yy"

0xe

"d-mmm-yy"

0xf

"d-mmm"

0x10

"mmm-yy"

0x11

"h:mm AM/PM"

0x12

"h:mm:ss AM/PM"

0x13

"h:mm"

0x14

"h:mm:ss"

0x15

"m/d/yy h:mm"

0x16

保留为过国际化用

0x17 - 0x24

"(#,##0_);(#,##0)"

0x25

"(#,##0_);[Red](#,##0)"

0x26

"(#,##0.00_);(#,##0.00)"

0x27

"(#,##0.00_);[Red](#,##0.00)"

0x28

"_($*#,##0_);_($*(#,##0);_($* \"-\"_);_(@_)"

0x29

"_(*#,##0.00_);_(*(#,##0.00);_(*\"-\"??_);_(@_)"

0x2a

"_($*#,##0.00_);_($*(#,##0.00);_($*\"-\"??_);_(@_)"

0x2b

"_($*#,##0.00_);_($*(#,##0.00);_($*\"-\"??_);_(@_)"

0x2c

"mm:ss"

0x2d

"[h]:mm:ss"

0x2e

"mm:ss.0"

0x2f

"##0.0E+0"

0x30

"@" - This is text format

0x31

在上面表中，字符串类型所对应的是数据格式为"@"（最后一行），也就是HSSFDataFormat中定义的值为0x31（49）的那行。Date类型的值的范围是0xe-0x11，本例子中的Date格式为""m/d/yy""，在HSSFDataFormat定义的值为0xe（14）。

需要注意的一点是，所创建的Excel必须是在Microsoft Excel 97到Excel XP的版本上的，如果在Excel 2003中创建文件后，在使用POI进行解析时，可能会出现问题。它会把Date类型当作自定义类型。POI目前只提供对Microsoft Excel XP以下的版本的支持，在以后的版本中，希望会提供对Microsoft Excel 2003更好的支持。

7.3.4 对Word的处理类

除了支持对Excel文件的读取外，POI还提供对Word的DOC格式文件的读取。但在它的发行版本中没有发布对Word支持的模块，需要另外下载一个POI的扩展的Jar包。用户可以到http://www.ibiblio.org/maven2/org/textmining/tm-extractors/0.4/下载，本书采用的是tm-extractors-0.4_zip。

下载后，把该包加入工程的Build Path中，然后在ch7.poi包下新建一个类WordReader，该类提供一个静态方法readDoc，读取一个DOC文件并返回文本。函数内容很简单，就是调用WordExtractor的API来提取DOC的内容到字符串，该函数的代码如下。

代码7.8

public static String readDoc(String doc) throws Exception {

// 创建输入流读取DOC文件

FileInputStream in = new FileInputStream(new File(doc));

WordExtractor extractor = null;

String text = null;

// 创建WordExtractor

extractor = new WordExtractor();

// 对DOC文件进行提取

text = extractor.extractText(in);

return text;

}

在同一个类里创建一个main函数，测试WordReader，该main函数代码如下。

代码7.9

public static void main(String[] args) {

try{

String text = WordReader.readDoc("c:/test.doc");

System.out.println(text);

}catch(Exception e){

e.printStackTrace();

}

处理前的Doc文件如图7-15所示。

图7-15 处理前的Word文档

使用代码处理后的文本如图7-16所示。

图7-16 处理后的结果

可以看到Word文档内的文本已经全部被提取了出来。

sooxin 2007-11-01 20:56 发表评论

Thinking:Java中static、this、super、final用法

sooxin — Fri, 22 Jun 2007 09:13:00 GMT

本篇旨在帮助准备学习Java以及刚接触Java的朋友认识、掌握和使用static、this、super、final这几个关键字的使用。Java博大精深，我也是一位正在学习和使用Java的爱好者，文中难免有不妥之处，欢迎指正。

一、static

　　请先看下面这段程序：

public class Hello{
    public static void main(String[] args){ //(1)
      System.out.println("Hello,world!");   //(2)
    }
}

　　看过这段程序，对于大多数学过Java 的从来说，都不陌生。即使没有学过Java，而学过其它的高级语言，例如C，那你也应该能看懂这段代码的意思。它只是简单的输出“Hello,world”，一点别的用处都没有，然而，它却展示了static关键字的主要用法。

　　在1处，我们定义了一个静态的方法名为main，这就意味着告诉Java编译器，我这个方法不需创建一个此类的对象即可使用。你还得你是怎么运行这个程序吗？一般，我们都是在命令行下，打入如下的命令(加下划线为手动输入)：

javac Hello.java
java Hello
Hello,world!

　　这就是你运行的过程，第一行用来编译Hello.java这个文件，执行完后，如果你查看当前，会发现多了一个Hello.class文件，那就是第一行产生的Java二进制字节码。第二行就是执行一个Java程序的最普遍做法。执行结果如你所料。在2中，你可能会想，为什么要这样才能输出。好，我们来分解一下这条语句。（如果没有安装Java文档，请到Sun的官方网站浏览J2SE API）首先，System是位于java.lang包中的一个核心类，如果你查看它的定义，你会发现有这样一行：public static final PrintStream out;接着在进一步，点击PrintStream这个超链接，在METHOD页面，你会看到大量定义的方法，查找println，会有这样一行：

public void println(String x)。

　　好了，现在你应该明白为什么我们要那样调用了，out是System的一个静态变量，所以可以直接使用，而out所属的类有一个println方法。

静态方法

　　通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。如下所示：

class Simple{
   static void go(){
     System.out.println("Go...");
   }
}
public class Cal{
public static void main(String[] args){
    Simple.go();
}
}

　　调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。

静态变量

　　静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了。看下面这段代码：

class Value{
static int c=0;
static void inc(){
    c++;
}
}
class Count{
public static void prt(String s){
    System.out.println(s);
}
public static void main(String[] args){
    Value v1,v2;
    v1=new Value();
    v2=new Value();
    prt("v1.c="+v1.c+" v2.c="+v2.c);
    v1.inc();
    prt("v1.c="+v1.c+" v2.c="+v2.c);
}
}

　　结果如下：

v1.c=0 v2.c=0
v1.c=1 v2.c=1

由此可以证明它们共享一块存储区。static变量有点类似于C中的全局变量的概念。值得探讨的是静态变量的初始化问题。我们修改上面的程序：

class Value{
static int c=0;
Value(){
    c=15;
}
Value(int i){
    c=i;
}
static void inc(){
    c++;
}
}
class Count{
public static void prt(String s){
    System.out.println(s);
}
    Value v=new Value(10);
    static Value v1,v2;
    static{
      prt("v1.c="+v1.c+" v2.c="+v2.c);
      v1=new Value(27);
      prt("v1.c="+v1.c+" v2.c="+v2.c);
      v2=new Value(15);
      prt("v1.c="+v1.c+" v2.c="+v2.c);
    }

public static void main(String[] args){
    Count ct=new Count();
    prt("ct.c="+ct.v.c);
    prt("v1.c="+v1.c+" v2.c="+v2.c);
    v1.inc();
    prt("v1.c="+v1.c+" v2.c="+v2.c);
    prt("ct.c="+ct.v.c);
}
}

运行结果如下：

v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11

　　这个程序展示了静态初始化的各种特性。如果你初次接触Java，结果可能令你吃惊。可能会对static后加大括号感到困惑。首先要告诉你的是，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。如果你能读懂并理解这段代码，会帮助你对static关键字的认识。在涉及到继承的时候，会先初始化父类的static变量，然后是子类的，依次类推。非静态变量不是本文的主题，在此不做详细讨论，请参考Think in Java中的讲解。

静态类

　　通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。如下代码所示：

public class StaticCls{
public static void main(String[] args){
    OuterCls.InnerCls oi=new OuterCls.InnerCls();
}
}
class OuterCls{
public static class InnerCls{
    InnerCls(){
      System.out.println("InnerCls");
    }
   }
}

　　输出结果会如你所料：

InnerCls

　　和普通类一样。内部类的其它用法请参阅Think in Java中的相关章节，此处不作详解。

二、this & super

　　在上一篇拙作中，我们讨论了static的种种用法，通过用static来定义方法或成员，为我们编程提供了某种便利，从某种程度上可以说它类似于C语言中的全局函数和全局变量。但是，并不是说有了这种便利，你便可以随处使用，如果那样的话，你便需要认真考虑一下自己是否在用面向对象的思想编程，自己的程序是否是面向对象的。好了，现在开始讨论this&super这两个关键字的意义和用法。

　　在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数，这些马上就要讨论。如果你想引用父类的某种东西，则非super莫属。由于this与super有如此相似的一些特性和与生俱来的某种关系，所以我们在这一块儿来讨论，希望能帮助你区分和掌握它们两个。

在一般方法中

　　最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。下面的代码演示了上面的用法：

public class DemoThis{
private String name;
private int age;
DemoThis(String name,int age){
    setName(name); //你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的
    setAge(age);
    this.print();
}
public void setName(String name){
    this.name=name;//此处必须指明你要引用成员变量
}
public void setAge(int age){
    this.age=age;
}
public void print(){
    System.out.println("Name="+name+" Age="+age);//在此行中并不需要用this，因为没有会导致混淆的东西
}
public static void main(String[] args){
    DemoThis dt=new DemoThis("Kevin","22");
}
}

　　这段代码很简单，不用解释你也应该能看明白。在构造函数中你看到用this.print(),你完全可以用print()来代替它，两者效果一样。下面我们修改这个程序，来演示super的用法。

class Person{
public int c;
private String name;
private int age;
protected void setName(String name){
    this.name=name;
}
protected void setAge(int age){
    this.age=age;
}
protected void print(){
    System.out.println("Name="+name+" Age="+age);
}
}
public class DemoSuper extends Person{
public void print(){
    System.out.println("DemoSuper:");
    super.print();
}
public static void main(String[] args){
    DemoSuper ds=new DemoSuper();
    ds.setName("kevin");
    ds.setAge(22);
    ds.print();
}
}

　　在DemoSuper中，重新定义的print方法覆写了父类的print方法，它首先做一些自己的事情，然后调用父类的那个被覆写了的方法。输出结果说明了这一点：

DemoSuper:
Name=kevin Age=22

　　这样的使用方法是比较常用的。另外如果父类的成员可以被子类访问，那你可以像使用this一样使用它，用“super.父类中的成员名”的方式，但常常你并不是这样来访问父类中的成员名的。

在构造函数中

　　构造函数是一种特殊的方法，在对象初始化的时候自动调用。在构造函数中，this和super也有上面说的种种使用方式，并且它还有特殊的地方，请看下面的例子：

class Person{
public static void prt(String s){
    System.out.println(s);
}
Person(){
    prt("A Person.");
}
Person(String name){
    prt("A person name is:"+name);
}
}
public class Chinese extends Person{
Chinese(){
    super(); //调用父类构造函数（1）
    prt("A chinese.");//(4)
}
Chinese(String name){
    super(name);//调用父类具有相同形参的构造函数（2）
    prt("his name is:"+name);
}
Chinese(String name,int age){
    this(name);//调用当前具有相同形参的构造函数（3）
    prt("his age is:"+age);
}
public static void main(String[] args){
    Chinese cn=new Chinese();
    cn=new Chinese("kevin");
    cn=new Chinese("kevin",22);
}
}

　　在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道了。

　　最后，写了这么多，如果你能对“this通常指代当前对象，super通常指代父类”这句话牢记在心，那么本篇便达到了目的，其它的你自会在以后的编程实践当中慢慢体会、掌握。另外关于本篇中提到的继承，请参阅相关Java教程。

三、final

　　final在Java中并不常用，然而它却为我们提供了诸如在C语言中定义常量的功能，不仅如此，final还可以让你控制你的成员、方法或者是一个类是否可被覆写或继承等功能，这些特点使final在Java中拥有了一个不可或缺的地位，也是学习Java时必须要知道和掌握的关键字之一。

final成员

　　当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。下面这段代码演示了这一点：

import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class Bat{
    final PI=3.14;          //在定义时便给址值
    final int i;            //因为要在构造函数中进行初始化，所以此处便不可再给值
    final List list;        //此变量也与上面的一样
    Bat(){
        i=100;
        list=new LinkedList();
    }
    Bat(int ii,List l){
        i=ii;
        list=l;
    }
    public static void main(String[] args){
        Bat b=new Bat();
        b.list.add(new Bat());
        //b.i=25;
        //b.list=new ArrayList();
        System.out.println("I="+b.i+" List Type:"+b.list.getClass());
        b=new Bat(23,new ArrayList());
        b.list.add(new Bat());
        System.out.println("I="+b.i+" List Type:"+b.list.getClass());
    }
}

　　此程序很简单的演示了final的常规用法。在这里使用在构造函数中进行初始化的方法，这使你有了一点灵活性。如Bat的两个重载构造函数所示，第一个缺省构造函数会为你提供默认的值，重载的那个构造函数会根据你所提供的值或类型为final变量初始化。然而有时你并不需要这种灵活性，你只需要在定义时便给定其值并永不变化，这时就不要再用这种方法。在main方法中有两行语句注释掉了，如果你去掉注释，程序便无法通过编译，这便是说，不论是i的值或是list的类型，一旦初始化，确实无法再更改。然而b可以通过重新初始化来指定i的值或list的类型，输出结果中显示了这一点：

I=100 List Type:class java.util.LinkedList
I=23 List Type:class java.util.ArrayList

　　还有一种用法是定义方法中的参数为final，对于基本类型的变量，这样做并没有什么实际意义，因为基本类型的变量在调用方法时是传值的，也就是说你可以在方法中更改这个参数变量而不会影响到调用语句，然而对于对象变量，却显得很实用，因为对象变量在传递时是传递其引用，这样你在方法中对对象变量的修改也会影响到调用语句中的对象变量，当你在方法中不需要改变作为参数的对象变量时，明确使用final进行声明，会防止你无意的修改而影响到调用方法。
另外方法中的内部类在用到方法中的参变量时，此参变也必须声明为final才可使用，如下代码所示：

public class INClass{
   void innerClass(final String str){
        class IClass{
            IClass(){
                System.out.println(str);
            }
        }
        IClass ic=new IClass();
    }
public static void main(String[] args){
      INClass inc=new INClass();
      inc.innerClass("Hello");
}
}

final方法

　　将方法声明为final，那就说明你已经知道这个方法提供的功能已经满足你要求，不需要进行扩展，并且也不允许任何从此类继承的类来覆写这个方法，但是继承仍然可以继承这个方法，也就是说可以直接使用。另外有一种被称为inline的机制，它会使你在调用final方法时，直接将方法主体插入到调用处，而不是进行例行的方法调用，例如保存断点，压栈等，这样可能会使你的程序效率有所提高，然而当你的方法主体非常庞大时，或你在多处调用此方法，那么你的调用主体代码便会迅速膨胀，可能反而会影响效率，所以你要慎用final进行方法定义。

final类

　　当你将final用于类身上时，你就需要仔细考虑，因为一个final类是无法被任何人继承的，那也就意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展。对于final类中的成员，你可以定义其为final，也可以不是final。而对于方法，由于所属类为final的关系，自然也就成了final型的。你也可以明确的给final类中的方法加上一个final，但这显然没有意义。

　　下面的程序演示了final方法和final类的用法：

final class final{
    final String str="final Data";
    public String str1="non final data";
    final public void print(){
        System.out.println("final method.");
    }
    public void what(){
        System.out.println(str+"\n"+str1);
    }
}
public class FinalDemo {   //extends final 无法继承
    public static void main(String[] args){
        final f=new final();
        f.what();
        f.print();
    }
}

　　从程序中可以看出，final类与普通类的使用几乎没有差别，只是它失去了被继承的特性。final方法与非final方法的区别也很难从程序行看出，只是记住慎用。

final在设计模式中的应用

　　在设计模式中有一种模式叫做不变模式，在Java中通过final关键字可以很容易的实现这个模式，在讲解final成员时用到的程序Bat.java就是一个不变模式的例子。如果你对此感兴趣，可以参考阎宏博士编写的《Java与模式》一书中的讲解。

　　到此为止，this,static,supert和final的使用已经说完了，如果你对这四个关键字已经能够大致说出它们的区别与用法，那便说明你基本已经掌握。然而，世界上的任何东西都不是完美无缺的，Java提供这四个关键字，给程序员的编程带来了很大的便利，但并不是说要让你到处使用，一旦达到滥用的程序，便适得其反，所以在使用时请一定要认真考虑。

sooxin 2007-06-22 17:13 发表评论

java中static的作用

sooxin — Fri, 22 Jun 2007 07:23:00 GMT

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。

声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制：
·
它们仅能调用其他的static 方法。
·
它们只能访问static数据。
·
它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。
如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：
// Demonstrate static variables，methods，and blocks.

class UseStatic {
static int a = 3;
static int b;

static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);

}

static {
System.out.println("Static block initialized.");
b = a * 4;

}

public static void main(String args[]) {
meth(42);
}
}

一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。

注意：在一个static 方法中引用任何实例变量都是非法的。

下面是该程序的输出：

Static block initialized.
x = 42
a = 3
b = 12
在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：

classname.method( )

这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。

下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。

class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {

System.out.println("a = " + a);
}
}

class StaticByName {

public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);

}
}

下面是该程序的输出：

a = 42
b = 99

static成员是不能被其所在class创建的实例访问的。

如果不加static修饰的成员是对象成员，也就是归每个对象所有的。

加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的

sooxin 2007-06-22 15:23 发表评论

Where does the target="" go when using location.href=""?

sooxin — Fri, 15 Jun 2007 09:21:00 GMT

By default when using location.href="fileName.html", the target is the current document.

When coding location.href="fileName.html" what we are actually coding is document.location.href="fileName.html" or self.location.href="fileName.html", the self specifies the current window, or window.location.href="fileName.html".

When we need to target another window we need to navigate the window object hierarchy, either by specifying the parent frame, or the top frame (which may in fact be the same thing).

top.location.href="fileName.html" targets the top document.

top.frameName.location.href="fileName.html" targets the frame frameName within the top document.

parent.location.href="fileName.html" targets the parent of the current document.

parent.frameName.location.href="fileName.html" targets the child frame frameName of the parent of the current document, i.e. a sibling frame.

Feedback on 'Q18 Where does the target="" go when using location.href=""?'

sooxin 2007-06-15 17:21 发表评论

Java 16进制字符串与2进制字符串相互转换

sooxin — Tue, 08 May 2007 07:10:00 GMT

public static String hexString2binaryString(String hexString) {
    if (hexString == null || hexString.length() % 2 != 0)
      return null;
    String bString = "", tmp;
    for (int i = 0; i < hexString.length(); i++) {
      tmp = "0000" + Integer.toBinaryString(Integer.parseInt(hexString.substring(i, i + 1), 16));
      bString += tmp.substring(tmp.length() - 4);
    }
    return bString;
}
//------------------------------------------------------
public static String binaryString2hexString(String bString) {
    if (bString == null || bString.equals("") || bString.length() % 8 != 0)
      return null;
    StringBuffer tmp=new StringBuffer();
    int iTmp = 0;
    for (int i = 0; i < bString.length(); i += 4) {
      iTmp = 0;
      for (int j = 0; j < 4; j++) {
        iTmp += Integer.parseInt(bString.substring(i + j, i + j + 1)) << (4 - j - 1);
      }
      tmp.append(Integer.toHexString(iTmp));
    }
    return tmp.toString();
}

sooxin 2007-05-08 15:10 发表评论

JAVA中常用数据类型转换函数

sooxin — Tue, 08 May 2007 06:53:00 GMT

JAVA中常用数据类型转换函数:

string->byte
Byte static byte parseByte(String s)

byte->string
Byte static String toString(byte b)

char->string
Character static String to String (char c)

string->Short
Short static Short parseShort(String s)

Short->String
Short static String toString(Short s)

String->Integer
Integer static int parseInt(String s)

Integer->String
Integer static String tostring(int i)

String->Long
Long static long parseLong(String s)

Long->String
Long static String toString(Long i)

String->Float
Float static float parseFloat(String s)

Float->String
Float static String toString(float f)

String->Double
Double static double parseDouble(String s)

Double->String
Double static String toString(Double d)

这是一个例子，说的是JAVA中数据数型的转换。供大家学习参考

package cn.com.lwkj.erts.register;
import java.sql.Date;
public class TypeChange {
public TypeChange() {
}
//change the string type to the int type
public static int stringToInt(String intstr)
{
Integer integer;
integer = Integer.valueOf(intstr);
return integer.intValue();
}
//change int type to the string type
public static String intToString(int value)
{
Integer integer = new Integer(value);
return integer.toString();
}
//change the string type to the float type
public static float stringToFloat(String floatstr)
{
Float floatee;
floatee = Float.valueOf(floatstr);
return floatee.floatValue();
}
//change the float type to the string type
public static String floatToString(float value)
{
Float floatee = new Float(value);
return floatee.toString();
}
//change the string type to the sqlDate type
public static java.sql.Date stringToDate(String dateStr)
{
return java.sql.Date.valueOf(dateStr);
}
//change the sqlDate type to the string type
public static String dateToString(java.sql.Date datee)
{
return datee.toString();
}

public static void main(String[] args)
{
java.sql.Date day ;
day = TypeChange.stringToDate("2003-11-3");
String strday = TypeChange.dateToString(day);
System.out.println(strday);
}

}

sooxin 2007-05-08 14:53 发表评论

搭建Eclipse+MyEclipse开发环境

sooxin — Fri, 27 Apr 2007 09:11:00 GMT

搭建Eclipse+MyEclipse开发环境

一、安装JDK

　　首先下载JDK 5.0（JDK 5.0的下载页面为：http://java.sun.com/j2se/1.5.0/download.jsp ）；然后运行JDK 5.0安装程序jdk-1_5_0_06-windows-i586-p.exe，安装过程中所有选项保持默认；最后配置JDK的环境变量：在“我的电脑”上点右键—>“属性”—>“高级”—> “环境变量(N)”。

　　新建系统变量JAVA_HOME：C:\Program Files\Java\jdk1.5.0_06；

　　新建系统变量CLASSPATH：.;%JAVA_HOME%\lib;（注意：点号表示当前目录，不能省略）

　　在系统变量Path的值的前面加入以下内容：%JAVA_HOME%\bin;(注意:这里的分号不能省略)

　　到这里，JDK安装完毕。

　　下面我们测试一下JDK是否安装成功：

　　将以下内容复制到记事本中：

public class HelloJAVA
{
public static void main(String srg[])
{
System.out.println("Hello JAVA!");
}
}

　　另存为“HelloJAVA.java”（不含引号，下同），并保存到D盘根目录下。

　　在命令行依次输入下图中红线所标注的命令：

　　如果出现上图红框中所标注的内容，则说明JDK安装成功！

　　注意:如果以后要安装诸如Eclipse、Borland JBuilder、JCreator、IntelliJ IDEA等集成开发环境(IDE,Integrated Development Environment),应该在IDE中编译运行一个简单的HelloWorld程序，以保证IDE可以识别出JDK的位置。

　　二、安装Tomcat

　　首先下载jakarta-tomcat-5.0.30.zip，之所以下载免安装版的好处是可以使用多个Tomcat（jakarta-tomcat-5.0.30.zip的下载页面为：

http://apache.linuxforum.net/tomcat/tomcat-5/v5.0.30/bin/）；

　　然后将jakarta-tomcat-5.0.30.zip直接解压到D盘根目录：

　　最后配置Tomcat的环境变量：在“我的电脑”上点右键—>“属性”—>“高级”—> “环境变量(N)”。

　　新建系统变量CATALINA_HOME：D:\jakarta-tomcat-5.0.30

　　在系统变量CLASSPATH的值的后面加入：%CATALINA_HOME%\common\lib;

　　在系统变量Path的值中"%JAVA_HOME%\bin;"的后面加入以下内容：%CATALINA_HOME%\bin;

　　到这里，Tomcat安装完毕。

　　进行完一、二两步的设置以后，各系统变量的值如下：

JAVA_HOME:C:\Program Files\Java\jdk1.5.0_06
CATALINA_HOME:D:\jakarta-tomcat-5.0.30
CLASSPATH:.;%JAVA_HOME%\lib;%CATALINA_HOME%\common\lib;
Path:%JAVA_HOME%\bin;%CATALINA_HOME%\bin;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem

　　三、安装Eclipse

　　首先下载eclipse-SDK-3.1.2-win32.zip（eclipse-SDK-3.1.2-win32.zip下载地址为：

http://www.eclipse.org/downloads/）；

　　然后将eclipse-SDK-3.1.2-win32.zip直接解压到D盘根目录：

　　到这里， Eclipse安装完毕。

　　四、安装MyEclipse

　　首先下载EnterpriseWorkbenchInstaller_4.1.1GA_E3.1.exe（EnterpriseWorkbenchInstaller_4.1.1GA_E3.1.exe 的下载地址为：
http://www.myeclipseide.com/ContentExpress-display-ceid-10.html）；

　　然后安装EnterpriseWorkbenchInstaller_4.1.1GA_E3.1.exe。注意：当安装到下图所示的步骤的时候要选择Eclipse的安装路径（如图），其他选项保持默认。

　　安装完毕之后，将MyEclipse安装目录下的features和plugins这2个目录覆盖到Eclipse的安装目录下。

　　最后将刚才安装的 MyEclipse 卸载。

　　解释一下上面这样做的原因：因为MyEclipse是Eclipse的插件，所以只要把features和plugins这2个目录覆盖到Eclipse的安装目录，Eclipse就会自动认出这些插件。

　　到这里，MyEclipse安装完毕。

　　五、破解MyEclipse

　　运行MyEclipse4.1.1注册机MyEclipseKeyGen.exe，选择MyEclipse的版本号，输入注册名，生成序列号。（MyEclipse4.x注册机的下载地址为：

http://esoft.g8.com.cn/UploadFiles/2006-5/520753587.rar）

　　运行eclipse.exe（首次运行要求指定Workspace），依次点击Window ----> Preferences ---->MyEclipse---->Subscription ----> Enter Subscription，输入注册名以及注册机生成的注册码。

　　到这里，MyEclipse破解完毕。

　　六、指定Eclipse+MyEclipse的JRE 和Tomcat 服务器

　　1.设定Eclipse+MyEclipse的JRE

　　一般情况下，Eclipse可以自动找到JRE，我们不用进行过多的设置。

　　2.设定Eclipse+MyEclipse的Tomcat 服务器

　　只需设置图中所标注的两处即可，图中其余部分是自动生成的。

　　到这里，我们的Eclipse+MyEclipse开发环境就搭建完毕了！

　　七、新建一个项目来测试一下Eclipse+MyEclipse开发环境是否搭建成功

　　1.在Eclipse中依次点击“ File ----> New ----> Project” , 在弹出的“New Project”对话框中依次点击“Web Project ---->MyEclipse---->J2EE Projects---->Web Project”，再点“Next”，在“Project Name”中输入项目的名字“test”,最后点“Finish”。

　　2.在Eclipse左边Package Explorer列表中点击“test”，将项目test展开。右键点击 WebRoot ----> New ----> JSP , 新建一个名为hello.jsp的 JSP 页面。代码如下图（图中标注部分需要我们手动添加，其余部分是系统自动生成的）：

　　3. 再用同样的方法，新建一个叫 hello_result.jsp 的JSP文件，代码如下图：

　　4. deploy（部署）项目。

　　点击 deploy 按钮（用红线画了的按钮就是 deploy 按钮），在弹出的窗口中点击Add，部署test项目（如图所示）。

　　5. 启动Tomcat服务器。

　　如下图所示（用红线画了的按钮就是启动Tomcat 的按钮）：

　　Tomcat 启动输出信息如下图：

　　6.项目test的运行结果：

　　我们可以去Eclipse的Workspace目录下看看test项目的代码，也可以去Tomcat的webapps目录下，看看部署之后的 test项目的结构。

sooxin 2007-04-27 17:11 发表评论

JAVA字符串处理。

sooxin — Thu, 26 Apr 2007 08:18:00 GMT

第一节、String对象

一、

Java中将字符串作为String类型对象来处理。当创建一个String对象时，被创建的字符串是不能被改变的。每次需要改变字符串时都要创建一个新的String对象来保存新的内容。原始的字符串不变。之所以采用这种方法是因为实现固定的，不可变的字符串比实现可变的字符串更高效。对于那些想得到改变的字符串的情况，有一个叫做StringBuffer的String类的友类，它的对象包含了在创建之后可以改变的字符串。

String类和StringBuffer类都在java.lang中定义。因此它们可以自动的被所有程序使用。两者均被说明为final，这意味着两者均不含子类。

二、String构造函数

（1）String()，默认构造函数，无参数

String s1 = new String();

（2）String( char chars[]) ，传入字符数组

char[] myChars={'a', 'b', 'c'};

String s2 = new String(myChars) // 使用字符串“abc”初始化s2

（3）String( char chars[], int startIndex, int numChars) ，传入一个字符数组，从指定下标位置开始获取指定个数的字符，用这些字符来初始化字符串变量。

char[] myChars={'h', 'e', 'l', 'l', 'o'};

String s3 = new String(myChars,1,3); //使用字符串“ell”初始化s3

（4）String(String strObj)，传入另一个字符串对象，用该字符串对象的内容初始化

String s4= new String(s3); // 这是s4也是“ell”了。

（5）String(byte asciiChars[])

String(byte asciiChars[], int startIndex, int numChars)

尽管Java的char类型使用16位（bit）表示Unicode编码字符集，在Internet中，

字符串的典型格式使用由ASCII字符集构成的8位数组，因为8位ASCII字符串是共同的，当给定一个字节（byte）数组时，String类提供了上面两个初始化字符串的构造函数。

例子：

package Examples;

class SubStringConv{

public static void main(String[] args){

byte ascii[]={65,66,67,68,69,70};

String s1=new String(ascii);

System.out.println(s1);

String s2=new String(ascii,2,3);

System.out.println(s2);

}

编译和运行后输出：

ABCDEF

CDE

三、

（1）调用字符串的length()方法可以得到该字符串的长度（字符个数）；

（2）前面说明了如何使用new运算符创建一个字符串实例。然而这是一种早期的使用字符串常量的处理方法。对于程序中的每一个字符串常量，Java会自动创建String对象。因此，可以使用字符串常量初始化String对象。例如：

String s5="abc";

int i = "abc".length(); //可以将字符串作为对象来进行操作

（3）可以使用“+”运算符来将两个字符串连接起来产生一个新的String对象。只要+运算符有一个运算数是字符串（String）实例时，编译器就将另一个运算数转换为它的字符串形式。这种操作是通过调用一个由String类定义的字符串转换方法valueOf()来完成的。对于简单类型，valueOf()方法返回一个字符串，该字符串包含了该类型的值的字符串。对于对象，valueOf()方法调用toString()方法。每一个类都执行toString()方法，因为它是由Object定义的。toString()方法具有如下一般形式： String toString() 。 toString()方法返回一个String对象（即字符串）。该对象一般是对类的一个描述。

四、一些字符串操作

（1）字符截取

*char charAt(int where) ，注意，这里返回一个char字符例如：

char a ;

a="abcde".charAt(2); //将索引为2 ，即第三个字符赋给a

* void getChars(int sourceStart, int sourceEnd, char target[], int targetStart) ，这里是无返回值方法，指定要截取的子字符串的开始和结束下标，再指定要储存子字符串内字符的数组，和存放这些字符的起始位置。注意，子字符串并不包括位于结束下标的字符。

* byte[] getBytes() 这是getBytes()方法最简单的形式，它实现将字符存放于字节数组中。在将字符串（String）值输出到一个不支持16位Unicode编码的环境时，getBytes

()是最有用的。例如，大多数Internet协议和文本文件格式在文本交换时使用8位ASCII编码。

* char[] toCharArray() 将字符串中所有的字符转换到一个字符数组的最简当方法，也可以使用getChars()方法实现。

（2）字符串比较

* boolean equals(Object str) 比较两个字符串对象是否相等,

boolean equalsIgnoreCaseJ(String str) 比较两个字符串对象，且忽略字符的大小写

* regionMatches() 方法允许将一个字符串中指定的区间和另一字符串中指定的区间进行比较，它的重载形式允许在比较时忽略大小写。下面给出这两种方法的一般形式：

boolean regionMatches(int startIndex,String str2,int str2StartIndex,int numChars)

boolean regionMatches(boolean ignoreCase ,int startIndex,String str2,int str2StartIndex,int numChars)

其中startIndex指定调用此方法的字符串内子字符串的起始位置。

* boolean startsWith(String str) startsWith方法还有第二种形式：

boolean startWith(String str, int startIndex)

boolean endsWith(String str)

上面的方法用来判断一个给定的字符串是否是从指定的字符串开始或结束。

* int compareTo(String str) 方法用于比较两个字符串的大小。字符串比较的结果及其含义：

值	含义
小于0	调用此方法的字符串小于参数str
大于0	调用此方法的字符串大于参数str
等于0	两个字符串相等

（3）其他操作

* 搜索字符串：

int indexOf( int ch)

int lastIndexOf( int ch)

int indexOf(String str)

int lastIndexOf(String str)

指定搜索的起始点：

int indexOf( int ch, int startIndex)

int lastIndexOf( int ch ,int startIndex)

int indexOf(String str ,int startIndex)

int lastIndexOf(String str, int startIndex)

* 使用 substring()截取子字符串：

String substring(int startIndex) 注意substring中string没有大写，截取指定位置后的子字符串。

String substring(int startIndex,int endIndex) 截取指定起始位置和结束位置的子字符串。注意截取的字字符串不包括结束位置的字符。

* concat() 连接连个字符串，与+ 运算符执行相同功能。

String concat(String str)

* replace() 用另一个字符取代指定字符串中指定字符：

String replace(char original, char replacement) 例如：

String s=”Hello”.replace(‘l’,’w’); //执行后 s =”Hewwo”;

* trim() 返回一个字符串，该字符串是删除调用字符串前后的空白符所得的字符串

* 改变字符串内字符的大小写

String toLowerCase() 返回一个所有字母都是小写的字符串

String toUpperCase()返回一个所有字母都是大写的字符串

* 使用 valueOf()方法实现数据转换

例如：

String str = String.valueOf(3) ; //将int类型转换成字符串类型，其他基本数据类型和任何类的对象也可作为参数。

第二节、StringBuffer

StringBuffer定义了下面三个构造函数：

StringBuffer() // 默认构造函数，预留了16个字符的空间，该空间不需再分配

StringBuffer(int size) // 设置指定缓冲区大小

StringBuffer(String str) // 设置StringBuffer对象初始化的内容并预留16个字符空间，且不需再分配空间

* int length()

调用length()方法可以得到StringBuffer对象的长度，调用capacity()可以得到总的分配容量。两个方法都是返回一个int类型的值。

* void ensureCapacity(int capacity)

如果想在构造StringBuffer对象后为某些字符预分配空间，可以使用ensureCapacity()方法，设置缓冲区的大小，这在事先已知要在StringBuffer上追加大量小字符串的情况下是有用的。ensureCapcity()方法具有如下的一般形式： void ensureCapacity(int capacity)

* void setLength(int len)

使用setLength()方法可以设置StringBuffer对象的长度，它的一般形式如下：

void setLength(int len) 如果len大于StringBuffer对象当前的length()值的话，那么会在StringBuffer对象后面加上空字符；如果比length()小的话，则len后面的字符串会丢失。

* char charAt(int where)

void setCharAt(int where, char ch)

使用charAt()方法可以得到StringBuffer对象中指定位置上的字符，setCharAt() 可以设置指定位置上的字符。它们的一般形式如下：

char charAt(int where)

void setCharAt(int where,char ch)

对于这两种法法，where值必须是非负的，同时不能超过或等于StringBuffer对象的长度。

* getChars(int suorceStart,int sourceEnd,char target[] , int targetStart)

* append()

Append()方法将任一其他类型数据的字符串形式连接到调用StringBuffer对象的后面，对所有内置的类型和Object，它都有重载形式。下面是几种形式：

StringBuffer append(String str)

StringBuffer append(int num)

StringBuffer append(Object obj)

* insert()

Insert()方法将一个字符串插入另一个字符串中。下面是它的几种形式：

StringBuffer insert(int index,String str)

StringBuffer insert(int index,char ch)

StringBuffer insert(int index,Object obj)

*reverse() // StringBuffer reverse()

StringBuffer strbf=new StringBuffer(“ABCDEFG”);

strbf.reverse();

System.out.println(strbf); //输出 GFEDCBA

* StringBuffer delete(int startIndex,int endIndex)

StringBuffer deleteCharAt(int loc)

删除指定位置的字符串和指定位置的字符。例如删除第一个字符后的所有字符：

strbf.delete(1,strbf.length());

* replace()

它完成在StringBuffer内部用一个字符串代替另一个指定起始位置和结束位置的字符串的功能，注意的是，被代替的字符不包括结束位置上的字符，它的一般形式是，：

StringBuffer replace(int startIndex, int endIndex,String str)

* substring() 返回StringBuffer的一部分值

String substring(int startIndex)

String substring(int startIndex, int endIndex)

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=610794

sooxin 2007-04-26 16:18 发表评论

JSP从mysql中读取图片。

sooxin — Thu, 26 Apr 2007 08:14:00 GMT

摘要: 数据库应用程序，特别是基于WEB的数据库应用程序，常会涉及到图片信息的存储和显示。通常我们使用的方法是将所要显示的图片存在特定的目录下，在数据库中保存相应的图片的名称，在JSP中建立相应的数据源，利用数据库访问技术处理图片信息。但是，如果我们想动态的显示图片，上述方法就不能满足需要了。我们必须把图片存入数据库，然后通过编程动态地显示我们需要的图片。实际操作中，可以利用JSP的编程模式来实现图片的数据库存储和显示。阅读全文

我为J狂 2007-04-20 16:38 发表评论

文章来源:http://www.blogjava.net/lzqdiy/archive/2007/04/20/112242.html

sooxin 2007-04-26 16:14 发表评论

从JAVA读取BLOB

sooxin — Thu, 26 Apr 2007 08:13:00 GMT

如果將要檔案寫入資料庫，您可以在欄位上使用BLOB或CLOB資料型態，BLOB全名Binary Large Object，用於儲存大量的二進位資料，CLOB全名Character Large Object，用於儲存大量的文字資料。

在JDBC中也提供了Blob與Clob兩個類別分別代表BLOB與CLOB資料，JDBC並沒有提供直接存入BLOB或CLOB的對應介面（像是setBlob()、setClob()等），但我們可以使用PreparedStatement的setBinaryStream()、setObject()、setAsciiStream()、setUnicodeStream()等方法來代替，例如我們可以如下取得一個檔案，並將之存入資料庫中：

            // 取得檔案
            File file = new File("./logo_phpbb.jpg");
            int length = (int) file.length();
            InputStream fin = new FileInputStream(file);
            // 填入資料庫
            PreparedStatement pstmt = conn.prepareStatement(
            "INSERT INTO files VALUES(?, ?)");
             
            pstmt.setString(1, "米小國Logo");
            pstmt.setBinaryStream (2, fin, length);
             
            pstmt.executeUpdate();
            pstmt.clearParameters();
            pstmt.close();
            fin.close();

如果要從資料庫中取得BLOB或CLOB資料，我們可以如下進行：

1 2	Blob blob = result.getBlob(2); // 取得BLOB Clob clob = result.getClob(2) // 取得CLOB

Blob擁有getBinaryStream()、getBytes()等方法，可以取得二進位串流或byte等資料，同樣的，Clob擁有getCharacterStream()、getSubString()等方法，可以取得字元串流或子字串等資料，您可以查看API文件來獲得更詳細的訊息。

下面這個程式示範基本的檔案存入資料庫並取出另存新檔：

import java.io.*;
            import java.sql.*;
            public class DBTest {
            public static void main(String[] args) {
            String driver = "com.mysql.jdbc.Driver";
            String url = "jdbc:mysql://localhost:3306/upload?useUnicode=true&characterEncoding=Big5";
            String user = "caterpillar";
            String password = "123456";
            try {
            Class.forName(driver);
            Connection conn = DriverManager.getConnection(url, user, password);
             
            // 取得檔案
            File file = new File("./logo_phpbb.jpg");
            int length = (int) file.length();
            InputStream fin = new FileInputStream(file);
             
            // 填入資料庫
            PreparedStatement pstmt = conn.prepareStatement(
            "INSERT INTO files VALUES(?, ?)");
            pstmt.setString(1, "米小國Logo");
            pstmt.setBinaryStream (2, fin, length);
            pstmt.executeUpdate();
            pstmt.clearParameters();
            pstmt.close();
            fin.close();
             
            // 從資料庫取出檔案
            Statement stmt = conn.createStatement();
            ResultSet result = stmt.executeQuery("SELECT * FROM files");
            result.next();
            String description = result.getString(1);
            Blob blob = result.getBlob(2);
             
            // 寫入檔案
            System.out.println("檔案描述：" + description);
            FileOutputStream fout = new FileOutputStream("./logo_phpbb_2.jpg");
            fout.write(blob.getBytes(1, (int)blob.length()));
            fout.flush();
            fout.close();
            stmt.close();
            conn.close();
            }
            catch(ClassNotFoundException e) {
            System.out.println("找不到驅動程式");
            e.printStackTrace();
            }
            catch(SQLException e) {
            e.printStackTrace();
            }
            catch(IOException e) {
            e.printStackTrace();
            }
            }
            }

sooxin 2007-04-26 16:13 发表评论

您的位置：本站首页-JAVA指导-JAVA字符谜题8:字符串奶酪

sooxin — Tue, 24 Apr 2007 04:03:00 GMT

下面的程序从一个字节序列创建了一个字符串，然后迭代遍历字符串中的字符，并将它们作为数字打印。请描述一下程序打印出来的数字序列：

public class StringCheese {
public static void main(String[] args) {
byte bytes[] = new byte[256];
for (int i = 0; i < 256; i++)
bytes[i] = (byte)i;
String str = new String(bytes);
for (int i = 0, n = str.length(); i < n; i++)
System.out.println((int)str.charAt(i) + " ");
}
}

首先，byte数组用从0到255每一个可能的byte数值进行了初始化，然后这些byte数值通过String构造器被转换成了char数值。最后，char数值被转型为int数值并被打印。打印出来的数值肯定是非负整数，因为char数值是无符号的，因此，你可能期望该程序将按顺序打印出0到255的整数。

如果你运行该程序，可能会看到这样的序列。但是在运行一次，可能看到的就不是这个序列了。我们在四台机器上运行它，会看到四个不同的序列，包括前面描述的那个序列。这个程序甚至都不能保证会正常终止，比打印其他任何特定字符串都要缺乏这种保证。它的行为完全是不确定的。

这里的罪魁祸首就是String(byte[])构造器。有关它的规范描述道：“在通过解码使用平台缺省字符集的指定byte数组来构造一个新的String时，该新String的长度是字符集的一个函数，因此，它可能不等于byte数组的长度。当给定的所有字节在缺省字符集中并非全部有效时，这个构造器的行为是不确定的”[ Java -API]。

到底什么是字符集？从技术角度上讲，它是“被编码的字符集合和字符编码模式的结合物”[Java-API]。换句话说，字符集是一个包，包含了字符、表示字符的数字编码以及在字符编码序列和字节序列之间来回转换的方式。转换模式在字符集之间存在着很大的区别：某些是在字符和字节之间做一对一的映射，但是大多数都不是这样。ISO-8859-1是唯一能够让该程序按顺序打印从0到255的整数的缺省字符集，它更为大家所熟知的名字是Latin-1[ISO-8859-1]。

J2SE运行期环境（JRE）的缺省字符集依赖于底层的操作系统和语言。如果你想知道你的JRE的缺省字符集，并且你使用的是5.0或更新的版本，那么你可以通过调用java.nio.charset.Charset.defaultCharset()来了解。如果你使用的是较早的版本，那么你可以通过阅读系统属性“file.encoding”来了解。

幸运的是，你没有被强制要求必须去容忍各种稀奇古怪的缺省字符集。当你在char序列和byte序列之间做转换时，你可以且通常是应该显式地指定字符集。除了接受byte数字之外，还可以接受一个字符集名称的String构造器就是专为此目的而设计的。如果你用下面的构造器去替换在最初的程序中的String构造器，那么不管缺省的字符集是什么，该程序都保证能够按照顺序打印从0到255的整数：

String str = new String(bytes, "ISO-8859-1");

这个构造器声明会抛出UnsupportedEncodingException异常，因此你必须捕获它，或者更适宜的方式是声明main方法将抛出它，要不然程序不能通过编译。尽管如此，该程序实际上不会抛出异常。Charset的规范要求Java平台的每一种实现都要支持某些种类的字符集，ISO-8859-1就位列其中。

这个谜题的教训是：每当你要将一个byte序列转换成一个String时，你都在使用某一个字符集，不管你是否显式地指定了它。如果你想让你的程序的行为是可预知的，那么就请你在每次使用字符集时都明确地指定。对API的设计者来说，提供这么一个依赖于缺省字符集的String(byte[])构造器可能并非是一个好主意。

sooxin 2007-04-24 12:03 发表评论

转：与struts的亲密接触&理解web开发

sooxin — Fri, 20 Apr 2007 17:08:00 GMT

与struts的亲密接触
当时上网看招聘信息，j2ee相关职位的都要求懂struts。看来学习struts是势在必行了。Struts的确是当时最优秀的框架，开发人员再也不用对每个方法都写一个servlet类了。请求成功或失败后的页面跳转不用写死在代码中，而是可以通过struts-config.xml来进行配置，表单组件可以自动的绑定成actionForm对象。还可以自定义数据校验逻辑。Struts还提供了一个通用的数据校验框架.struts还提供了丰富的显示标签。主要的时间都花在标签的学习上了。Struts显示标签比时当时的jsp 表达式的确是一大进步了。在jsp页面，不达再写’<% %>’这些表过式语言了，而是使用像html那样的标签。当jstl出现后，jstl的类似c语言似的标记语言要比struts显示标答优秀得多。Struts显示标签不能自动处理null值问题，struts显示标签还是显得太复杂了，花那么大的力气去学习struts显示标签显然是很不值的一件事！
我用jsp+servlet开发的时间要比用struts进行开发的时间长得多，但是struts的确是一个非常优秀的框架。

基于html: web应用是基于html的，不管是jsp还是asp，asp.net还是jsf都是在服务器端把相应的代码解释成html代码，然后在客户端通过浏览器解析显示出来。
无状态编程：不管采用什么技术，web开发终竟是无状态编程。也就是在客户端并不能保持应用程序的任何状态。在swing或vb等桌面开发时，客户程序可以通过变量来保持系统的状态。而基于html的web应用是无法保持状态的。Web应用状态都需要由应用服务器来保持。
请求响应及推/拉模式：在swing或vb等桌面应用程序中，当某一状态发生改变时，后台程序可以触发系统更新前端的UI组件，甚至可以使用观察者模式，当某一状态发生改变时，通知所有需要更新的前端UI组件，加载数据刷新组件。完成UI组件的更新，用户可能没有做任何动作，这就是推模式。而web应用正好相反，用户从客户端发出一个请求，服务器接到客户端的请求后，读取请求参数，调用业务方法，获得业务数据，用业务数据重新生成新的html页面，呈现给客户端，由浏览器进行解析显示,这就是拉模式。请求响应的拉模式是web应用最大的特点，任何请求的页面在发出请求后，请求页面所有组件的状态都被刷新而无法得以保持。
MVC：MVC即model模型数据，view 视图,controller 控制器。MVC模式让每一个组件都有了一个明确的职责,模型数据不含有视图特有的代码，视图不含有控制代码或数据访问代码,主要是显示模型数据。控制器接收请求，获得数据，进行视图转发。
控制器是WEB应用中的中枢神经,web应用控制器的主要职责：校验及获取请数参数,调用业务对象进行业务处理,把从页面获得的请求参数传递给业务对象。通过业务调用获得数据或创建模型数据。在需要保持服务端状态的应用中，创建或操作session状态。创建一个视图，由视图来使用模型数据。
模型含有由视图显示的数据，在j2ee web应用中，模型一般是JavaBean。Web应用中的模型一般表示一个完整的业务操作的结果对象。这个结果对象通常不是一个真实的领域对象，而是一个只有getter,setter方法的对象(如值对象),通常称为伪数据对象。模型没有必要进行进一步的操作，如数据访问等，模型也不应该依赖Serlvet或某一WEB应用框架.
视图用于呈现模型数据，负责生成标签或其它内容。视图不需要了解控制器或业务对象。视图不应该直接处理请求参数，而是应该由控制器去做。也不应该进行数据查询，如sql查询,视图不应该处理数据查询异常。显图只需要执行必要的显示逻辑，把模型数据通过一定的逻辑呈现给用户。
Front Controller前端控制器与命令模式:采用纯Servlet和JSP的model 1进行web开发都是非常复杂的。不可能实现java开发人员与UI开发人员角色的分离。采用纯Servlet来开发web应用，如果要从serlvet这种纯java对象中配合html标记进行web开发是非常笨拙的，这样将十分难以维护。采用纯JSP来开发web应用，JSP可能很容易的嵌入html代码，并通过jsp表达式可以很容易的动成生成html内容，JSP还定义了对象的作用域。关键是可以在jsp中编写任何java代码,相比纯servlet来说，用JSP开发要轻松多了。但是把所有业务代码编写在JSP中，任然不能把java开发人员与UI开发人员进行分工。业务方法无法进行测试和重用，代码重用只能是简单的代码复制，这样的web应用仍然难以进行维护。
采用jsp+servlet的MVC模式进行开发，java开发人员负责开发servlet,而UI开发人员设计HTMl和编写JSP，每一个请求对应一个servlet，由servlet调用业务对象，获得业务数据，并选择视图进行转发。在这里JSP没有了任何业务代码，仅仅是显示数据。这样通过JSP与servlet相结合的MVC模式，可以让java开发人员与UI人员进行分工，也便于了业务代码的测试。但是每一个请求都对应一个单一的servlet,需要产生大量的servlet类，把许多方法分散到多个servlet类中，需要对相似的请求过程编写独立的方法，不能进行方法的重用。从而产生大量的重复代码，大量的servlet配置将非常烦琐。从而需要对大量的servlet进行维护。如果有一个控制器来接收所有的请求，根据请求的参数，把请求传递一个委托对象，由委托对象来完成以前控制器完成的工作。这个控制器一般由一个servlet来完成,这就是前端控制器模式。这个前端控制器作为一个web应用的处理中心，用来处理所有相关的请求，对所有请求进行集中控制。前端控制器相当于web应用的集中处理器，完成所有请求的控制，对所有请求都需要处理的逻辑可以在端控制器中完成。把请求对象传递给委托对象。这个委托对象就像以前的控制器那样工作，也就是命令模式的运用。通过这种方式，一个WEB应用只需要配置一个前端控制器（当然有必要时可以多个）,具体的控制逻辑交给委托对象去完成,我把这个委托对象称为控制器，可以很好的实现代码重用，java开发人员与UI开发人员的真正分离，让开发人员只关心真正的业务实现。业务对象是真正的pojo对象，可以方便的进行单元测试。
几乎所有WEB框架都是基于前端控制器，命令模式的MVC运用,如webwork,spring mvc,struts。

sooxin 2007-04-21 01:08 发表评论

二进制数据就是完全数字型

sooxin — Fri, 20 Apr 2007 03:21:00 GMT

二进制文件："二进制文件"本来就是一种似是而非的叫法。我们知道,存在有种类繁多的不同类型(格式)的文件,如文本文件,视频文件,图像文件,数据库文件...., 文件格式的具体定义取决于应用。不同的文件格式的主要差别之一就是信息的编码不同,而编码总归都是"二进制"的,从这个方面看,所有的都是"二进制文件 "。而我们常讲的"二进制文件"并不是这个意思,它是想对于"文本文件"而言的,也就是说,所有非文本文件(即非ASCII编码)都被称为"二进制文件 ".在这里很容易提出疑问,文本文件只是文件格式的一种,所有格式的文件应该都是平等的,为什么在这里把它单独提出来作为一种特殊的参照呢?原因很简单, 那就是无论从应用时间的久远程度还是应用的普遍性上,ASCII编码的文件都是其他格式的文件所不能比拟的。
可以简单理解成：

只由ASCII字符构成的文件称为[b]文本文件[/b]（text files），所有其他的文件则称为[b]二进制文件[/b]。

所谓的ASII字符构成的文件，就是用一个唯一的字节大小的整数值来表示每个字符，比如字符"i"的ASCII值为105，"c"为99，“\n”为10 等等。更通俗的讲，在文本文件中，你看到的是一个个的字符“a”，“b”，“c”，他们都由一个唯一的整数值表示，表现在内存上，就是整数值97，98， 99。而二进制文件没有字符概念，它是一个个的值，当然，你认为这个值代表什么，它就可以代表什么。
二进制对象：计算机中，一个大型二进制对象通常是一个大型的文件，例如一个图片或声音文件。而这些文件不得不以一种特殊的方式存放在数据库中。按照Eric Raymond的解释，大型二进制对象的意义在于，当文件的处理者（例如数据库管理工具）无法识别文件的格式以致无法处理该文件时，就把它作为大型二进制对象来处理。也有人说大型二进制对象实际上指代的是大型数据对象。一个需要处理大型二进制对象的应用程序是存储了大型多媒体对象（例如电影和电视节目）的数据存储器。

sooxin 2007-04-20 11:21 发表评论