/etc/init.d/mysql start (stop) 为启动和停止服务器
/etc/mysql/ 主要配置文件所在位置 my.cnf
/var/lib/mysql/ 放置的是数据库表文件夹，这里的mysql相当于windows下mysql的date文件夹

启动mysql后，以root登录mysql
isher@isher-ubuntu:~$ mysql -u root
>show variables like 'character%'; #执行编码显示
+--------------------------+----------------------------+
| Variable_name | Value |
+--------------------------+----------------------------+
| character_set_client | latin1 |
| character_set_connection | latin1 |
| character_set_database | latin1 |
| character_set_filesystem | binary |
| character_set_results | latin1 |
| character_set_server | latin1 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+

在某些时候，我们续要修改mysql默认数据库的编码，以保证某些迁移的程序可以正常显示，编辑my.cnf文件进行编码修改,windows可以直接用Ｍysql Server Instance Config Wizard 进行设置

在linux下修改３个my.cnf的１个/etc/mysql/my.cnf文件

找到客户端配置[client] 在下面添加
default-character-set=utf8 默认字符集为utf8
在找到[mysqld] 添加
default-character-set=utf8 默认字符集为utf8
init_connect='SET NAMES utf8' （设定连接mysql数据库时使用utf8编码，以让mysql数据库为utf8运行）

修改好后，重新启动mysql 即可，查询一下show variables like 'character%';
+--------------------------+----------------------------+
| Variable_name | Value |
+--------------------------+----------------------------+
| character_set_client | utf8 |
| character_set_connection | utf8 |
| character_set_database | utf8 |
| character_set_filesystem | binary |
| character_set_results | utf8 |
| character_set_server | utf8 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+



此方法用于标准mysql版本同样有效，对于/etc/my.cnf文件，需要从mysql/support-files的文件夹cp my-large.cnf一份到/etc/my.cnf


一般安装系统默认是INNODB
default-storage-engine=INNODB

　　你可以使用很多方法指定一个要使用的存储引擎。最简单的方法是，如果你喜欢一种能满足你的大多数数据库需求的存储引擎，你可以在MySQL设置文件中设置一个默认的引擎类型（使用storage_engine 选项）或者在启动数据库服务器时在命令行后面加上--default-storage-engine或--default-table-type选项。

　　更灵活的方式是在随MySQL服务器发布同时提供的MySQL客户端时指定使用的存储引擎。最直接的方式是在创建表时指定存储引擎的类型，向下面这样:

　　CREATE TABLE mytable (id int, title char(20)) ENGINE = INNODB

AppFuse 2.0 快速起步

 英文版网址:http://appfuse.org/display/APF/AppFuse+QuickStart

请依照以下步骤开始使用AppFuse开发Java EE应用程序：

目录

1.        建立一个新项目.

2.        运行.

建立项目

1.        下载安装JDK 5+.

2.        下载安装MySQL 5.x.

3.        设置一个本地的SMTP 服务器或者修改mail.properties文件(位于src/main/resources) 来使用其它的主机名-默认使用"localhost".

4.        下载 安装Maven 2.0.8.

5、下载appfuse2.0.1并解压appfuse
https://appfuse.dev.java.net/files/documents/1397/77082/appfuse-dependencies-2.0.1-with-source-and-javadoc.zip
假定解压到D:/appfuse2.0.1/repository下

6、修改%maven_home%/conf/settings.xml
修改settings.xml中的localRepository，指向appfuse的解压目录
<settings>
  <!– localRepository
  | The path to the local repository maven will use to store artifacts.
  | Default: ~/.m2/repository
  –>
  <localRepository>D:/appfuse2.0.1/repository</localRepository>

修改原因：默认情况下 repository 在 C:"Documents and Settings"$USER_HOME ".m2"repository ，因为这个路径中包含一个空格,所以在后续使用 mvn appfuse:full-source 命令的时候会产生异常；

[INFO] Scanning for projects...

[INFO] Searching repository for plugin with prefix: 'appfuse'.

[INFO] ------------------------------------------------------------------------

[INFO] Building AppFuse Modular Application - Core

[INFO]    task-segment: [appfuse:full-source]

[INFO] ------------------------------------------------------------------------

[INFO] ------------------------------------------------------------------------

[ERROR] FATAL ERROR

[INFO] ------------------------------------------------------------------------

[INFO] null

Illegal character in path at index 18: file:/C:/Documents and Settings/Administrator/.m2/repository/org/apache/ant/ant/1.7.0/ant-1.7.0.jar

[INFO] ------------------------------------------------------------------------

[INFO] Trace

java.lang.IllegalArgumentException

        at java.net.URI.create(URI.java:842)

        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)

        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)

        at java.lang.reflect.Method.invoke(Method.java:597)

        at org.apache.tools.ant.launch.Locator.fromURI(Locator.java:162)

        at org.apache.tools.ant.launch.Locator.getResourceSource(Locator.java:119)

        at org.apache.tools.ant.launch.Locator.getClassSource(Locator.java:90)

        at org.apache.tools.ant.Project.setAntLib(Project.java:313)

        at org.apache.tools.ant.Project.initProperties(Project.java:309)

        at org.apache.tools.ant.Project.init(Project.java:295)

官方解决地址http://www.nabble.com/Re%3A-problem-with-appfuse%3Agen-in-windows-p13974654s2369.html

意思是讲是ant的bug，里面不能有空格，因为Documents and Settings里面有空格所以报错。

另外，由于ant 1.7存在的bug（Problem with appfuse:gen in windows ），因此如果用的是ant 1.7，确认一下$USER_HOME/.m2/repository是否存在，不存在手工创建，并把修改后的settings.xml 拷贝到~".m2"repository下不然在执行后续操作mvn appfuse:full-source时候会报如下错误
java.lang.IllegalArgumentException: When not aligning with a user install you mu
st specify a local repository location using the setLocalRepositoryDirectory( Fi
le ) method.
        at org.apache.maven.embedder.MavenEmbedder.createMavenSettings(MavenEmbe
dder.java:699)
        at org.apache.maven.embedder.MavenEmbedder.start(MavenEmbedder.java:628)
        at org.appfuse.mojo.installer.InstallSourceMojo.addModuleDependencies(In
stallSourceMojo.java:341)
        at org.appfuse.mojo.installer.InstallSourceMojo.addModuleDependencies(In
stallSourceMojo.java:303)
        at org.appfuse.mojo.installer.InstallSourceMojo.execute(InstallSourceMoj
o.java:142)
        at org.apache.maven.plugin.DefaultPluginManager.executeMojo(DefaultPlugi
nManager.java:443)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoals(Defa
ultLifecycleExecutor.java:539)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeStandalone
Goal(DefaultLifecycleExecutor.java:493)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoal(Defau
ltLifecycleExecutor.java:463)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeGoalAndHan
dleFailures(DefaultLifecycleExecutor.java:311)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.executeTaskSegmen
ts(DefaultLifecycleExecutor.java:278)
        at org.apache.maven.lifecycle.DefaultLifecycleExecutor.execute(DefaultLi
fecycleExecutor.java:143)
        at org.apache.maven.DefaultMaven.doExecute(DefaultMaven.java:334)
        at org.apache.maven.DefaultMaven.execute(DefaultMaven.java:125)
        at org.apache.maven.cli.MavenCli.main(MavenCli.java:280)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.
java:39)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAcces
sorImpl.java:25)
        at java.lang.reflect.Method.invoke(Method.java:585)
        at org.codehaus.classworlds.Launcher.launchEnhanced(Launcher.java:315)
        at org.codehaus.classworlds.Launcher.launch(Launcher.java:255)
        at org.codehaus.classworlds.Launcher.mainWithExitCode(Launcher.java:430)

        at org.codehaus.classworlds.Launcher.main(Launcher.java:375)
[INFO] ————————————————————————

7．AppFuse拥有很多构造不同风格项目的能力. 为使用户使用起来更优化、更简单, 我们建立了多种原型（又称作：起始项目）. 现在又两种类型的AppFuse 原型:基本的（basic）和模块化的（modular）. 基本原型用于建立基于web应用的项目；模块化原型包含“核心”（core）"和"web"模块，用于后台可复用的项目。下表中的命令是用于产生其实项目的，改变groupId就定制包名（package name）；改变artifactId来定制项目名（project's name）. 进入D:"java"workspace,运行如下命令，生成struts2.0的项目

mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-basic-struts -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.1 -DgroupId=cn.net.xinyi.nvs -DartifactId=nvsweb

8.      如果你安装了MySQL 5.x而且它的root 用户没有设置口令(可以通过updateuser set password=password('') where user='root'; flush privileges;去掉root的密码)，那你的AppFuse应用就能立即运行起来. 如果你想使用内嵌式的数据库（embedded database）, 我们最近正好增加了一个Database Profiles 文件用于使用H2, HSQLDB等数据库.

运行应用程序

现在，运行AppFuse是非常容易得. 一旦建立了原型项目，Maven 就会分别使用hibernate3and dbunit插件来为你建立并设置数据库.需要你做的只是使用Maven来运行Jetty容器并开始浏览应用了.

1.        除非你有更好的主意，应该首先把你的项目检入到源码控制服务器中。Google Code提供免费的Subversion 服务, 当然类似的还有很多.

2.        进入命令行， cd到你的新项目目录，运行mvn integration-test把JARs, Tomcat 和综合测试程序下载到项目里。现在是喝杯咖啡或啤酒和好时机，因为下载和运行测试大约需要5-10分钟.

3.        要浏览应用需在项目目录里运行命令 mvn jetty:run-war (对于模块化项目-modular project, 应在项目的web目录下运行mvn jetty:run-war命令). Maven 将会启动Jetty ，于是就可以在浏览器输入地址http://localhost:8080/来浏览应用了。

4. 运行命令 mvn war:inplace可以覆盖（override）AppFuse的文件.将会只把依赖的WARs文件抽取到src/main/webapp目录,在这里，你可以根据需要改变文件.当你把释放到你的源文件树时，可以运行 mvn jetty:run命令. 这样一来可以即时修改文件，而Jetty可以根据需要重新装载. 这种方式的唯一的问题是你的项目里的AppFuse将会是不完整("exploded AppFuse"), 会导致更新升级困难.我们推荐在运行命令mvn war:inplace以前，首先将项目检入源码控制系统。这样一来决定哪些文件被保留或删除文件会更容易些.

如果出现内存溢出（OutOfMemory ）错误，请使用jetty:run命令，参照 this mailing list thread.

在项目目录里运行命令mvn appfuse:full-source可以将AppFuse的运行模式由内嵌（"embedded mode"）改变为全源码模式（full-source mode）。

应用的部署

可以使用Eclipse, IDEA 或 NetBeans来部署应用.使用Eclipse,运行 mvn eclipse:eclipse来生成项目文件. 使用IDEA, 就要使用mvn idea:idea命令。进一步的介绍请参考IDE Reference Guide.

public class QuickSort {
 /**
  * 快速排序
  *
  * @param arr
  * @param left
  * @param right
  */
 public void quickSort(int[] arr, int left, int right) {
  int middle, temp;
  int i, j;
  i = left;
  j = right;
  middle = arr[(i + j) / 2];
  do {
   // 找出左边比中间值大的数
   while (arr[i] < middle && i < right)
    i++;
   // 找出右边比中间值小的数
   while (arr[j] > middle && j > left)
    j--;
   // 将左边大的数和右边小的数进行替换
   if (i <= j) {
    temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
    i++;
    j--;
   }
  } while (i <= j); // 当两者交错时停止

  if (i < right) {
   quickSort(arr, i, right);// 从右边进行递归
  }
  if (j > left) {
   quickSort(arr, left, j);// 从左边进行递归
  }
 }

 /**
  * @param args
  */
 public static void main(String[] args) {
  int[] arr = { 11, 66, 22, 0, 55, 22, 0, 32 };
  QuickSort sort = new QuickSort();
  sort.quickSort(arr, 0, arr.length - 1);
  for (int i = 0; i < arr.length; i++) {
   System.out.print(arr[i] + " ");
  }
 }
}

import java.text.NumberFormat;
import java.util.HashMap;

public class SimpleMoneyFormat {
 public static final String EMPTY = "";

 public static final String ZERO = "零";

 public static final String ONE = "壹";

 public static final String TWO = "贰";

 public static final String THREE = "叁";

 public static final String FOUR = "肆";

 public static final String FIVE = "伍";

 public static final String SIX = "陆";

 public static final String SEVEN = "柒";

 public static final String EIGHT = "捌";

 public static final String NINE = "玖";

 public static final String TEN = "拾";

 public static final String HUNDRED = "佰";

 public static final String THOUSAND = "仟";

 public static final String TEN_THOUSAND = "万";

 public static final String HUNDRED_MILLION = "亿";

 public static final String YUAN = "元";

 public static final String JIAO = "角";

 public static final String FEN = "分";

 public static final String DOT = ".";

 private static SimpleMoneyFormat formatter = null;

 private HashMap chineseNumberMap = new HashMap();

 private HashMap chineseMoneyPattern = new HashMap();

 private NumberFormat numberFormat = NumberFormat.getInstance();

 private SimpleMoneyFormat() {
  numberFormat.setMaximumFractionDigits(4);
  numberFormat.setMinimumFractionDigits(2);
  numberFormat.setGroupingUsed(false);
  chineseNumberMap.put("0", ZERO);
  chineseNumberMap.put("1", ONE);
  chineseNumberMap.put("2", TWO);
  chineseNumberMap.put("3", THREE);
  chineseNumberMap.put("4", FOUR);
  chineseNumberMap.put("5", FIVE);
  chineseNumberMap.put("6", SIX);
  chineseNumberMap.put("7", SEVEN);
  chineseNumberMap.put("8", EIGHT);
  chineseNumberMap.put("9", NINE);
  chineseNumberMap.put(DOT, DOT);
  chineseMoneyPattern.put("1", TEN);
  chineseMoneyPattern.put("2", HUNDRED);
  chineseMoneyPattern.put("3", THOUSAND);
  chineseMoneyPattern.put("4", TEN_THOUSAND);
  chineseMoneyPattern.put("5", TEN);
  chineseMoneyPattern.put("6", HUNDRED);
  chineseMoneyPattern.put("7", THOUSAND);
  chineseMoneyPattern.put("8", HUNDRED_MILLION);
 }

 public static SimpleMoneyFormat getInstance() {
  if (formatter == null)
   formatter = new SimpleMoneyFormat();
  return formatter;
 }

 public String format(String moneyStr) {
  checkPrecision(moneyStr);
  String result = null;
  result = convertToChineseNumber(moneyStr);
  result = addUnitsToChineseMoneyString(result);
  return result;
 }

 public String format(double moneyDouble) {
  return format(numberFormat.format(moneyDouble));
 }

 public String format(int moneyInt) {
  return format(numberFormat.format(moneyInt));
 }

 public String format(long moneyLong) {
  return format(numberFormat.format(moneyLong));
 }

 public String format(Number moneyNum) {
  return format(numberFormat.format(moneyNum));
 }

 private void checkPrecision(String moneyStr) {
  int fractionDigits = moneyStr.length() - moneyStr.indexOf(DOT) - 1;
  if (fractionDigits > 2)
   throw new RuntimeException("金额" + moneyStr + "的小数位多于两位。"); // 精度不能比分低
 }

 private String convertToChineseNumber(String moneyStr) {
  String result;
  StringBuffer cMoneyStringBuffer = new StringBuffer();
  for (int i = 0; i < moneyStr.length(); i++) {
   cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(
     i, i + 1)));
  }
  // 拾佰仟万亿等都是汉字里面才有的单位，加上它们
  int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
  int moneyPatternCursor = 1;
  for (int i = indexOfDot - 1; i > 0; i--) {
   cMoneyStringBuffer.insert(i, chineseMoneyPattern.get(EMPTY
     + moneyPatternCursor));
   moneyPatternCursor = moneyPatternCursor == 8 ? 1
     : moneyPatternCursor + 1;
  }
  String fractionPart = cMoneyStringBuffer.substring(cMoneyStringBuffer
    .indexOf("."));
  cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("."),
    cMoneyStringBuffer.length());

  replace(cMoneyStringBuffer, "零拾", ZERO);
  replace(cMoneyStringBuffer, "零佰", ZERO);
  replace(cMoneyStringBuffer, "零仟", ZERO);
  replace(cMoneyStringBuffer, "零万", TEN_THOUSAND);
  replace(cMoneyStringBuffer, "零亿", HUNDRED_MILLION);
  replace(cMoneyStringBuffer, "零零", ZERO);

  if (cMoneyStringBuffer.lastIndexOf(ZERO) == cMoneyStringBuffer.length() - 1)
   cMoneyStringBuffer.delete(cMoneyStringBuffer.length() - 1,
     cMoneyStringBuffer.length());
  cMoneyStringBuffer.append(fractionPart);
  result = cMoneyStringBuffer.toString();
  return result;
 }

 private String addUnitsToChineseMoneyString(String moneyStr) {
  String result;
  StringBuffer cMoneyStringBuffer = new StringBuffer(moneyStr);
  int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
  cMoneyStringBuffer.replace(indexOfDot, indexOfDot + 1, YUAN);
  cMoneyStringBuffer.insert(cMoneyStringBuffer.length() - 1, JIAO);
  cMoneyStringBuffer.insert(cMoneyStringBuffer.length(), FEN);
  if (cMoneyStringBuffer.indexOf("零角零分") != -1)// 没有零头，加整
   cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零角零分"),
     cMoneyStringBuffer.length(), "整");
  else if (cMoneyStringBuffer.indexOf("零分") != -1)// 没有零分，加整
   cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零分"),
     cMoneyStringBuffer.length(), "整");
  else {
   if (cMoneyStringBuffer.indexOf("零角") != -1)
    cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("零角"),
      cMoneyStringBuffer.indexOf("零角") + 2);
  }
  result = cMoneyStringBuffer.toString();
  return result;
 }

 private void replace(StringBuffer pValue, String pSource, String pDest) {
  if (pValue == null || pSource == null || pDest == null)
   return;
  /** 记录pSource在pValue中的位置 */
  int intPos = 0;
  do {
   intPos = pValue.toString().indexOf(pSource);
   /** 没有找到pSource */
   if (intPos == -1)
    break;
   pValue.delete(intPos, intPos + pSource.length());
   pValue.insert(intPos, pDest);
  } while (true);
 }

 public static void main(String args[]) {
  System.out.println(getInstance().format(new Double(100110010001.01)));
 }
}

import java.util.Random;

public class Poker {
 public static void main(String[] args) {
  int[] pokers = new int[54];
  for (int i = 0; i < pokers.length; i++)
   pokers[i] = i;
  int j = 0, temp = 0;
  for (int i = 0; i < pokers.length; i++) {
   Random r = new Random();
   j = r.nextInt(54);
   temp = pokers[i];
   pokers[i] = pokers[j];
   pokers[j] = temp;
  }
  for (int i = 0; i < pokers.length; i++) {
   System.out.print(pokers[i] + " ");
   if ((i + 1) % 10 == 0)
    System.out.println();
  }
 }
}

class BinaryNode {
 Comparable element;

 BinaryNode left;

 BinaryNode right;

 BinaryNode(Comparable element) {
  this(element, null, null);
 }

 BinaryNode(Comparable element, BinaryNode left, BinaryNode right) {
  this.element = element;
  this.left = left;
  this.right = right;
 }
}

public class BinarySearchTree {
 private BinaryNode root;

 public BinarySearchTree() {
  root = null;
 }

 public void makeEmpty() {
  root = null;
 }

 public boolean isEmpty() {
  return root == null;
 }

 public Comparable find(Comparable x) {
  return elementAt(find(x, root));
 }

 public Comparable findMin() {
  return elementAt(findMin(root));
 }

 public Comparable findMax() {
  return elementAt(findMax(root));
 }

 public void insert(Comparable x) {
  root = insert(x, root);
 }

 public void remove(Comparable x) {
  root = remove(x, root);
 }

 public void printTree() {
  if (isEmpty())
   System.out.println("Empty Tree");
  else
   printTree(root);
 }

 private Comparable elementAt(BinaryNode t) {
  return t == null ? null : t.element;
 }

 private BinaryNode find(Comparable x, BinaryNode t) {
  if (t == null)
   return null;
  if (x.compareTo(t.element) < 0)
   return find(x, t.left);
  else if (x.compareTo(t.element) > 0)
   return find(x, t.right);
  else
   return t;
 }

 private BinaryNode findMin(BinaryNode t) {
  if (t == null)
   return null;
  else if (t.left == null)
   return t;
  return findMin(t.left);
 }

 private BinaryNode findMax(BinaryNode t) {
  if (t != null) {
   while (t.right != null)
    t = t.right;
  }
  return t;
 }

 private BinaryNode insert(Comparable x, BinaryNode t) {
  if (t == null)
   t = new BinaryNode(x);
  else if (x.compareTo(t.element) < 0)
   t.left = insert(x, t.left);
  else if (x.compareTo(t.element) > 0)
   t.right = insert(x, t.right);
  else
   ;
  return t;
 }

 private BinaryNode remove(Comparable x, BinaryNode t) {
  if (t == null)
   return t;
  if (x.compareTo(t.element) < 0)
   t.left = remove(x, t.left);
  else if (x.compareTo(t.element) > 0)
   t.right = remove(x, t.right);
  else if (t.left != null && t.right != null) {
   t.element = findMin(t.right).element;
   t.right = remove(x, t.right);
  } else
   t = (t.left != null) ? t.left : t.right;
  return t;
 }

 private void printTree(BinaryNode t) {
  if (t != null) {
   printTree(t.left);
   System.out.print(t.element);
   printTree(t.right);
  }
 }

 public static void main(String[] args) {
  BinarySearchTree bst = new BinarySearchTree();
  bst.insert(new Integer(1));
  bst.insert(new Integer(2));
  bst.insert(new Integer(3));
  bst.insert(new Integer(4));
  bst.insert(new Integer(5));
  bst.insert(new Integer(6));
  Comparable c = bst.find(new Integer(6));
  if (c != null)
   System.out.print(c);
  else
   System.out.println("not exist");
 }
}

import java.util.StringTokenizer;

public class ReverseWords {
 public static String reverseWords(String str) {
  if (str == null || str.trim().equals(""))
   return null;
  StringTokenizer spaceToker = new StringTokenizer(str);
  String[] result = new String[spaceToker.countTokens()];
  int index = 0;
  while (spaceToker.hasMoreTokens()) {
   result[index] = spaceToker.nextToken();
   index++;
  }
  StringBuffer sb = new StringBuffer();
  for (int i = result.length - 1; i >= 0; i--)
   sb.append(result[i]+" ");
  return sb.toString();
 }

 public static void main(String[] args) {
  String str = "Do or do not, there is no try.";
  System.out.print(reverseWords(str));
 }
}

1、ExcelWriter.java
package com.eruite.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

/**
 * @author caihua
 */
public class ExcelReader {
 private HSSFWorkbook wb = null;// book [includes sheet]

 private HSSFSheet sheet = null;

 private HSSFRow row = null;

 private int sheetNum = 0; // 第sheetnum个工作表

 private int rowNum = 0;

 private FileInputStream fis = null;

 private File file = null;

 public ExcelReader() {
 }

 public ExcelReader(File file) {
  this.file = file;
 }

 public void setRowNum(int rowNum) {
  this.rowNum = rowNum;
 }

 public void setSheetNum(int sheetNum) {
  this.sheetNum = sheetNum;
 }

 public void setFile(File file) {
  this.file = file;
 }

 /**
  * 读取excel文件获得HSSFWorkbook对象
  */
 public void open() throws IOException {
  fis = new FileInputStream(file);
  wb = new HSSFWorkbook(new POIFSFileSystem(fis));
  fis.close();
 }

 /**
  * 返回sheet表数目
  *
  * @return int
  */
 public int getSheetCount() {
  int sheetCount = -1;
  sheetCount = wb.getNumberOfSheets();
  return sheetCount;
 }

 /**
  * sheetNum下的记录行数
  *
  * @return int
  */
 public int getRowCount() {
  if (wb == null)
   System.out.println("=============>WorkBook为空");
  HSSFSheet sheet = wb.getSheetAt(this.sheetNum);
  int rowCount = -1;
  rowCount = sheet.getLastRowNum();
  return rowCount;
 }

 /**
  * 读取指定sheetNum的rowCount
  *
  * @param sheetNum
  * @return int
  */
 public int getRowCount(int sheetNum) {
  HSSFSheet sheet = wb.getSheetAt(sheetNum);
  int rowCount = -1;
  rowCount = sheet.getLastRowNum();
  return rowCount;
 }

 /**
  * 得到指定行的内容
  *
  * @param lineNum
  * @return String[]
  */
 public String[] readExcelLine(int lineNum) {
  return readExcelLine(this.sheetNum, lineNum);
 }

 /**
  * 指定工作表和行数的内容
  *
  * @param sheetNum
  * @param lineNum
  * @return String[]
  */
 public String[] readExcelLine(int sheetNum, int lineNum) {
  if (sheetNum < 0 || lineNum < 0)
   return null;
  String[] strExcelLine = null;
  try {
   sheet = wb.getSheetAt(sheetNum);
   row = sheet.getRow(lineNum);

   int cellCount = row.getLastCellNum();
   strExcelLine = new String[cellCount + 1];
   for (int i = 0; i <= cellCount; i++) {
    strExcelLine[i] = readStringExcelCell(lineNum, i);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return strExcelLine;
 }

 /**
  * 读取指定列的内容
  *
  * @param cellNum
  * @return String
  */
 public String readStringExcelCell(int cellNum) {
  return readStringExcelCell(this.rowNum, cellNum);
 }

 /**
  * 指定行和列编号的内容
  *
  * @param rowNum
  * @param cellNum
  * @return String
  */
 public String readStringExcelCell(int rowNum, int cellNum) {
  return readStringExcelCell(this.sheetNum, rowNum, cellNum);
 }

 /**
  * 指定工作表、行、列下的内容
  *
  * @param sheetNum
  * @param rowNum
  * @param cellNum
  * @return String
  */
 public String readStringExcelCell(int sheetNum, int rowNum, int cellNum) {
  if (sheetNum < 0 || rowNum < 0)
   return "";
  String strExcelCell = "";
  try {
   sheet = wb.getSheetAt(sheetNum);
   row = sheet.getRow(rowNum);

   if (row.getCell((short) cellNum) != null) { // add this condition
    // judge
    switch (row.getCell((short) cellNum).getCellType()) {
    case HSSFCell.CELL_TYPE_FORMULA:
     strExcelCell = "FORMULA ";
     break;
    case HSSFCell.CELL_TYPE_NUMERIC: {
     strExcelCell = String.valueOf(row.getCell((short) cellNum)
       .getNumericCellValue());
    }
     break;
    case HSSFCell.CELL_TYPE_STRING:
     strExcelCell = row.getCell((short) cellNum)
       .getStringCellValue();
     break;
    case HSSFCell.CELL_TYPE_BLANK:
     strExcelCell = "";
     break;
    default:
     strExcelCell = "";
     break;
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return strExcelCell;
 }

 public static void main(String args[]) {
  File file = new File("C:\\qt.xls");
  ExcelReader readExcel = new ExcelReader(file);
  try {
   readExcel.open();
  } catch (IOException e) {
   e.printStackTrace();
  }
  readExcel.setSheetNum(0); // 设置读取索引为0的工作表
  // 总行数
  int count = readExcel.getRowCount();
  for (int i = 0; i <= count; i++) {
   String[] rows = readExcel.readExcelLine(i);
   for (int j = 0; j < rows.length; j++) {
    System.out.print(rows[j] + " ");
   }
   System.out.print("\n");
  }
 }
}

2、ExcelWriter.java

package com.eruite.util;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Calendar;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFDataFormat;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

/**
 * 生成导出Excel文件对象
 *
 * @author caihua
 *
 */
public class ExcelWriter {
 // 设置cell编码解决中文高位字节截断
 private static short XLS_ENCODING = HSSFCell.ENCODING_UTF_16;

 // 定制浮点数格式
 private static String NUMBER_FORMAT = "#,##0.00";

 // 定制日期格式
 private static String DATE_FORMAT = "m/d/yy"; // "m/d/yy h:mm"

 private OutputStream out = null;

 private HSSFWorkbook workbook = null;

 private HSSFSheet sheet = null;

 private HSSFRow row = null;

 public ExcelWriter() {
 }

 /**
  * 初始化Excel
  *
  */
 public ExcelWriter(OutputStream out) {
  this.out = out;
  this.workbook = new HSSFWorkbook();
  this.sheet = workbook.createSheet();
 }

 /**
  * 导出Excel文件
  *
  * @throws IOException
  */
 public void export() throws FileNotFoundException, IOException {
  try {
   workbook.write(out);
   out.flush();
   out.close();
  } catch (FileNotFoundException e) {
   throw new IOException(" 生成导出Excel文件出错! ", e);
  } catch (IOException e) {
   throw new IOException(" 写入Excel文件出错! ", e);
  }

 }

 /**
  * 增加一行
  *
  * @param index
  *            行号
  */
 public void createRow(int index) {
  this.row = this.sheet.createRow(index);
 }

 /**
  * 获取单元格的值
  *
  * @param index
  *            列号
  */
 public String getCell(int index) {
  HSSFCell cell = this.row.getCell((short) index);
  String strExcelCell = "";
  if (cell != null) { // add this condition
   // judge
   switch (cell.getCellType()) {
   case HSSFCell.CELL_TYPE_FORMULA:
    strExcelCell = "FORMULA ";
    break;
   case HSSFCell.CELL_TYPE_NUMERIC: {
    strExcelCell = String.valueOf(cell.getNumericCellValue());
   }
    break;
   case HSSFCell.CELL_TYPE_STRING:
    strExcelCell = cell.getStringCellValue();
    break;
   case HSSFCell.CELL_TYPE_BLANK:
    strExcelCell = "";
    break;
   default:
    strExcelCell = "";
    break;
   }
  }
  return strExcelCell;
 }

 /**
  * 设置单元格
  *
  * @param index
  *            列号
  * @param value
  *            单元格填充值
  */
 public void setCell(int index, int value) {
  HSSFCell cell = this.row.createCell((short) index);
  cell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
  cell.setCellValue(value);
 }

 /**
  * 设置单元格
  *
  * @param index
  *            列号
  * @param value
  *            单元格填充值
  */
 public void setCell(int index, double value) {
  HSSFCell cell = this.row.createCell((short) index);
  cell.setCellType(HSSFCell.CELL_TYPE_NUMERIC);
  cell.setCellValue(value);
  HSSFCellStyle cellStyle = workbook.createCellStyle(); // 建立新的cell样式
  HSSFDataFormat format = workbook.createDataFormat();
  cellStyle.setDataFormat(format.getFormat(NUMBER_FORMAT)); // 设置cell样式为定制的浮点数格式
  cell.setCellStyle(cellStyle); // 设置该cell浮点数的显示格式
 }

 /**
  * 设置单元格
  *
  * @param index
  *            列号
  * @param value
  *            单元格填充值
  */
 public void setCell(int index, String value) {
  HSSFCell cell = this.row.createCell((short) index);
  cell.setCellType(HSSFCell.CELL_TYPE_STRING);
  cell.setEncoding(XLS_ENCODING);
  cell.setCellValue(value);
 }

 /**
  * 设置单元格
  *
  * @param index
  *            列号
  * @param value
  *            单元格填充值
  */
 public void setCell(int index, Calendar value) {
  HSSFCell cell = this.row.createCell((short) index);
  cell.setEncoding(XLS_ENCODING);
  cell.setCellValue(value.getTime());
  HSSFCellStyle cellStyle = workbook.createCellStyle(); // 建立新的cell样式
  cellStyle.setDataFormat(HSSFDataFormat.getBuiltinFormat(DATE_FORMAT)); // 设置cell样式为定制的日期格式
  cell.setCellStyle(cellStyle); // 设置该cell日期的显示格式
 }

 public static void main(String[] args) {
  System.out.println(" 开始导出Excel文件 ");

  File f = new File("C:\\qt.xls");
  ExcelWriter e = new ExcelWriter();

  try {
   e = new ExcelWriter(new FileOutputStream(f));
  } catch (FileNotFoundException e1) {
   e1.printStackTrace();
  }

  e.createRow(0);
  e.setCell(0, "试题编码 ");
  e.setCell(1, "题型");
  e.setCell(2, "分值");
  e.setCell(3, "难度");
  e.setCell(4, "级别");
  e.setCell(5, "知识点");

  e.createRow(1);
  e.setCell(0, "t1");
  e.setCell(1, 1);
  e.setCell(2, 3.0);
  e.setCell(3, 1);
  e.setCell(4, "重要");
  e.setCell(5, "专业");

  try {
   e.export();
   System.out.println(" 导出Excel文件[成功] ");
  } catch (IOException ex) {
   System.out.println(" 导出Excel文件[失败] ");
   ex.printStackTrace();
  }
 }

}