您的位置：首页 > 编程语言 > Java开发

JAVA常用方法

2015-04-14 11:52 225 查看

http://www.itjhwd.com/javachangyonfangfa/

/**

 * 将某个日期以固定格式转化成字符串

 *

 * @param date

 * @return String

 */

 public static String dateToStr(java.util.Date date)

 {

 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

 String str = sdf.format(date);

 return str;

 }

/**

 * 判断任意一个整数是否素数

 *

 * @param n

 * @return boolean

 */

 public static boolean isPrimes(int n)

 {

 for (int i = 2; i <= Math.sqrt(n); i++)

 {

 if (n % i == 0)

 {

 return false;

 }

 }

 return true;

 }

/**

 * 获得任意一个整数的阶乘，递归

 *

 * @param n

 * @return n!

 */

 public static int factorial(int n)

 {

 if (n == 1)

 {

 return 1;

 }

 return n * factorial(n - 1);

 }

/**

 * 将指定byte数组以16进制的形式打印到控制台

 *

 * @param hint

 * String

 * @param b

 * byte[]

 * @return void

 */

 public static void printHexString(String hint, byte[] b)

 {

 System.out.print(hint);

 for (int i = 0; i < b.length; i++)

 {

 String hex = Integer.toHexString(b & 0xFF);

 if (hex.length() == 1)

 {

 hex = '0' + hex;

 }

 System.out.print(hex.toUpperCase() + " ");

 }

 System.out.println("");

 }

package net.java2000.tools;

/**

* Title: Java Bean 工具

* @version 1.0

*/

import java.util.*;

import java.util.regex.Pattern;

public class StrTools {

/**

 * 分割字符串

 *

 * @param str String 原始字符串

 * @param splitsign String 分隔符

 * @return String[] 分割后的字符串数组

 */

@SuppressWarnings("unchecked")

public static String[] split(String str, String splitsign) {

 int index;

 if (str == null || splitsign == null)

 return null;

 ArrayList al = new ArrayList();

 while ((index = str.indexOf(splitsign)) != -1) {

 al.add(str.substring(0, index));

 str = str.substring(index + splitsign.length());

 }

 al.add(str);

 return (String[]) al.toArray(new String[0]);

}

/**

 * 替换字符串

 *

 * @param from String 原始字符串

 * @param to String 目标字符串

 * @param source String 母字符串

 * @return String 替换后的字符串

 */

public static String replace(String from, String to, String source) {

 if (source == null || from == null || to == null)

 return null;

 StringBuffer bf = new StringBuffer("");

 int index = -1;

 while ((index = source.indexOf(from)) != -1) {

 bf.append(source.substring(0, index) + to);

 source = source.substring(index + from.length());

 index = source.indexOf(from);

 }

 bf.append(source);

 return bf.toString();

}

/**

 * 替换字符串，能能够在HTML页面上直接显示(替换双引号和小于号)

 *

 * @param str String 原始字符串

 * @return String 替换后的字符串

 */

public static String htmlencode(String str) {

 if (str == null) {

 return null;

 }

 return replace("\"", """, replace("<", "<", str));

}

/**

 * 替换字符串，将被编码的转换成原始码（替换成双引号和小于号）

 *

 * @param str String

 * @return String

 */

public static String htmldecode(String str) {

 if (str == null) {

 return null;

 }

 return replace(""", "\"", replace("<", "<", str));

}

private static final String _BR = " ";

/**

 * 在页面上直接显示文本内容，替换小于号，空格，回车，TAB

 *

 * @param str String 原始字符串

 * @return String 替换后的字符串

 */

public static String htmlshow(String str) {

 if (str == null) {

 return null;

 }

 str = replace("<", "<", str);

 str = replace(" ", " ", str);

 str = replace("\r\n", _BR, str);

 str = replace("\n", _BR, str);

 str = replace("\t", " ", str);

 return str;

}

/**

 * 返回指定字节长度的字符串

 *

 * @param str String 字符串

 * @param length int 指定长度

 * @return String 返回的字符串

 */

public static String toLength(String str, int length) {

 if (str == null) {

 return null;

 }

 if (length <= 0) {

 return "";

 }

 try {

 if (str.getBytes("GBK").length <= length) {

 return str;

 }

 } catch (Exception ex) {

 }

 StringBuffer buff = new StringBuffer();

 int index = 0;

 char c;

 length -= 3;

 while (length > 0) {

 c = str.charAt(index);

 if (c < 128) {

 length--;

 } else {

 length--;

 length--;

 }

 buff.append(c);

 index++;

 }

 buff.append("...");

 return buff.toString();

}

/**

 * 判断是否为整数

 *

 * @param str 传入的字符串

 * @return 是整数返回true,否则返回false

 */

public static boolean isInteger(String str) {

 Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");

 return pattern.matcher(str).matches();

}

/**

 * 判断是否为浮点数，包括double和float

 *

 * @param str 传入的字符串

 * @return 是浮点数返回true,否则返回false

 */

public static boolean isDouble(String str) {

 Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");

 return pattern.matcher(str).matches();

}

/**

 * 判断输入的字符串是否符合Email样式.

 *

 * @param str 传入的字符串

 * @return 是Email样式返回true,否则返回false

 */

public static boolean isEmail(String str) {

 Pattern pattern = Pattern.compile("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");

 return pattern.matcher(str).matches();

}

/**

 * 判断输入的字符串是否为纯汉字

 *

 * @param str 传入的字符窜

 * @return 如果是纯汉字返回true,否则返回false

 */

public static boolean isChinese(String str) {

 Pattern pattern = Pattern.compile("[\u0391-\uFFE5]+$");

 return pattern.matcher(str).matches();

}

/**

 * 是否为空白,包括null和""

 *

 * @param str

 * @return

 */

public static boolean isBlank(String str) {

 return str == null || str.trim().length() == 0;

}

/**

 * 判断是否为质数

 *

 * @param x

 * @return

 */

public static boolean isPrime(int x) {

 if (x <= 7) {

 if (x == 2 || x == 3 || x == 5 || x == 7)

 return true;

 }

 int c = 7;

 if (x % 2 == 0)

 return false;

 if (x % 3 == 0)

 return false;

 if (x % 5 == 0)

 return false;

 int end = (int) Math.sqrt(x);

 while (c <= end) {

 if (x % c == 0) {

 return false;

 }

 c += 4;

 if (x % c == 0) {

 return false;

 }

 c += 2;

 if (x % c == 0) {

 return false;

 }

 c += 4;

 if (x % c == 0) {

 return false;

 }

 c += 2;

 if (x % c == 0) {

 return false;

 }

 c += 4;

 if (x % c == 0) {

 return false;

 }

 c += 6;

 if (x % c == 0) {

 return false;

 }

 c += 2;

 if (x % c == 0) {

 return false;

 }

 c += 6;

 }

 return true;

}

public static void main(String[] args) {

 String[] numbers = { "12345", "-12345", "123.45", "-123.45", ".12345", "-.12345", "a12345", "12345a", "123.a45" };

 for (String str : numbers) {

 System.out.println(str + "=" + isInteger(str) + " " + isDouble(str));

 }

 String[] emails = { "1@2.com", "1.2@3.com", "1@3.4.5.com" };

 for (String str : emails) {

 System.out.println(str + "=" + isEmail(str));

 }

 String[] chineses = { "中国", "1中国", "中国1", "1中国2", "中1国" };

 for (String str : chineses) {

 System.out.println(str + "=" + isChinese(str));

 }

}

}

/* * Db.java

Created on 2007年8月20日, 上午 8:37

*/

import java.io.*;

import java.sql.*;

import java.util.Properties;

public class Db {

 private String driver;

 private String url;

 private String user;

 private String password;

 private Connection conn;

 private Statement stm;

 private ResultSet rs;

 public Db(){

 this("DBConf.properties");

 }

 public Db(String conf) {

 loadProperties(conf);

 setConn();

 }

 public Connection getConn(){

 return this.conn;

 }

//handle the properties file to get the informations for connection

 private void loadProperties(String conf){

 Properties props = new Properties();

 try {

 props.load(new FileInputStream(conf));

 } catch (FileNotFoundException e) {

 e.printStackTrace();

 } catch (IOException e) {

 e.printStackTrace();

 }

 this.driver = props.getProperty("driver");

 this.url = props.getProperty("url");

 this.user = props.getProperty("user");

 this.password = props.getProperty("password");

 }

 //implement the Connection

 private void setConn(){

 try {

 Class.forName(driver);

 this.conn = DriverManager.getConnection(url,user,password);

 } catch(ClassNotFoundException classnotfoundexception) {

 classnotfoundexception.printStackTrace();

 System.err.println("db: " + classnotfoundexception.getMessage());

 } catch(SQLException sqlexception) {

 System.err.println("db.getconn(): " + sqlexception.getMessage());

 }

 }

 public void doInsert(String sql) {

 try {

 Statement statement = conn.createStatement();

 int i = stm.executeUpdate(sql);

 } catch(SQLException sqlexception) {

 System.err.println("db.executeInset:" + sqlexception.getMessage());

 }

 }

 public void doDelete(String sql) {

 try {

 stm = conn.createStatement();

 int i = stm.executeUpdate(sql);

 } catch(SQLException sqlexception) {

 System.err.println("db.executeDelete:" + sqlexception.getMessage());

 }

 }

 public void doUpdate(String sql) {

 try {

 stm = conn.createStatement();

 int i = stm.executeUpdate(sql);

 } catch(SQLException sqlexception) {

 System.err.println("db.executeUpdate:" + sqlexception.getMessage());

 }

 }

 public ResultSet doSelect(String sql) {

 try {

 stm = conn.createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,java.sql.ResultSet.CONCUR_READ_ONLY);

 rs = stm.executeQuery(sql);

 } catch(SQLException sqlexception) {

 System.err.println("db.executeQuery: " + sqlexception.getMessage());

 }

 return rs;

 }

 public static void main(String[] args){

 try{

 Db db = new Db();

 Connection conn = db.getConn();

 if(conn != null && !conn.isClosed()) {

 System.out.println("連結成功");

 ResultSet rs = db.doSelect("select * from content");

 while(rs.next()){

 System.out.println(rs.getString(1)+":"+rs.getString(2)+":"+rs.getString(3));

 }

 rs.close();

 conn.close();

 }

 }catch(SQLException e) {

 e.printStackTrace();

 }

 }

}

DBConf.properties:

driver=oracle.jdbc.driver.OracleDriver

url=jdbcracle:thintdt151:1521:train

user=XX

password=XX

/**

 * 人民币转成大写

 *

 * @param value

 * @return String

 */

 public static String hangeToBig(double value)

 {

 char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示

 char[] vunit = { '万', '亿' }; // 段名表示

 char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示

 long midVal = (long) (value * 100); // 转化成整形

 String valStr = String.valueOf(midVal); // 转化成字符串

 String head = valStr.substring(0, valStr.length() - 2); // 取整数部分

 String rail = valStr.substring(valStr.length() - 2); // 取小数部分

 String prefix = ""; // 整数部分转化的结果

 String suffix = ""; // 小数部分转化的结果

 // 处理小数点后面的数

 if (rail.equals("00"))

 { // 如果小数部分为0

 suffix = "整";

 }

 else

 {

 suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来

 }

 // 处理小数点前面的数

 char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组

 char zero = '0'; // 标志'0'表示出现过0

 byte zeroSerNum = 0; // 连续出现0的次数

 for (int i = 0; i < chDig.length; i++)

 { // 循环处理每个数字

 int idx = (chDig.length - i - 1) % 4; // 取段内位置

 int vidx = (chDig.length - i - 1) / 4; // 取段位置

 if (chDig == '0')

 { // 如果当前字符是0

 zeroSerNum++; // 连续0次数递增

 if (zero == '0')

 { // 标志

 zero = digit[0];

 }

 else if (idx == 0 && vidx > 0 && zeroSerNum < 4)

 {

 prefix += vunit[vidx - 1];

 zero = '0';

 }

 continue;

 }

 zeroSerNum = 0; // 连续0次数清零

 if (zero != '0')

 { // 如果标志不为0,则加上,例如万,亿什么的

 prefix += zero;

 zero = '0';

 }

 prefix += digit[chDig - '0']; // 转化该数字表示

 if (idx > 0)

 prefix += hunit[idx - 1];

 if (idx == 0 && vidx > 0)

 {

 prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿

 }

 }

 if (prefix.length() > 0)

 prefix += '圆'; // 如果整数部分存在,则有圆的字样

 return prefix + suffix; // 返回正确表示

 }

/**

 * 全角字符转半角字符

 *

 * @param QJStr

 * @return String

 */

 public static final String QJToBJChange(String QJStr)

 {

 char[] chr = QJStr.toCharArray();

 String str = "";

 for (int i = 0; i < chr.length; i++)

 {

 chr = (char) ((int) chr - 65248);

 str += chr;

 }

 return str;

 }

 /**

 * 去掉字符串中重复的子字符串

 *

 * @param str

 * @return String

 */

 private static String removeSameString(String str)

 {

 Set<String> mLinkedSet = new LinkedHashSet<String>();

 String[] strArray = str.split(" ");

 StringBuffer sb = new StringBuffer();

 for (int i = 0; i < strArray.length; i++)

 {

 if (!mLinkedSet.contains(strArray))

 {

 mLinkedSet.add(strArray);

 sb.append(strArray + " ");

 }

 }

 System.out.println(mLinkedSet);

 return sb.toString().substring(0, sb.toString().length() - 1);

 }

/**

 * 设置JSpinner的编辑属性

 * @param spinner 目标JSpinner

 * @param isAllowInvalid 是否允许输入非法值

 * @param isEditable 是否允许编辑

 */

 public static void setAllowsInvalid(JSpinner spinner, boolean isAllowInvalid, boolean isEditable)

 {

 JSpinner.NumberEditor editor = new JSpinner.NumberEditor(spinner, "#");

 spinner.setEditor(editor);

 JFormattedTextField tf = ((JSpinner.NumberEditor)spinner.getEditor()).getTextField();

 tf.setEditable(isEditable);

 DefaultFormatterFactory factory = (DefaultFormatterFactory)tf.getFormatterFactory();

 NumberFormatter formatter = (NumberFormatter)factory.getDefaultFormatter();

 formatter.setAllowsInvalid(isAllowInvalid);

 }

/**

 * 根据指定方法的参数去构造一个新的对象的拷贝并将他返回

 * @param obj 原始对象

 * @return 新对象

 * @throws NoSuchMethodException

 * @throws InvocationTargetException

 * @throws IllegalAccessException

 * @throws InstantiationException

 * @throws SecurityException

 * @throws IllegalArgumentException

 */

 @SuppressWarnings("unchecked")

 public static Object copy(Object obj) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException,

 InvocationTargetException, NoSuchMethodException

 {

 //获得对象的类型

 Class classType = obj.getClass();

 //通过默认构造方法去创建一个新的对象，getConstructor的视其参数决定调用哪个构造方法

 Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

 //获得对象的所有属性

 Field[] fields = classType.getDeclaredFields();

 for(int i = 0; i < fields.length; i++)

 {

 //获取数组中对应的属性

 Field field = fields;

 String fieldName = field.getName();

 String stringLetter = fieldName.substring(0, 1).toUpperCase();

 //获得相应属性的getXXX和setXXX方法名称

 String getName = "get" + stringLetter + fieldName.substring(1);

 String setName = "set" + stringLetter + fieldName.substring(1);

 //获取相应的方法

 Method getMethod = classType.getMethod(getName, new Class[]{});

 Method setMethod = classType.getMethod(setName, new Class[]{field.getType()});

 //调用源对象的getXXX（）方法

 Object value = getMethod.invoke(obj, new Object[]{});

 //调用拷贝对象的setXXX（）方法

 setMethod.invoke(objectCopy, new Object[]{value});

 }

 return objectCopy;

 }

//过滤特殊字符

public static String encoding(String src){

 if (src==null)

 return "";

 StringBuilder result=new StringBuilder();

 if (src!=null){

 src=src.trim();

 for (int pos=0;pos<src.length();pos++){

 switch(src.charAt(pos)){

 case '\"':result.append(""");break;

 case '<':result.append("<");break;

 case '>':result.append(">");break;

 case '\'':result.append("'");break;

 case '&':result.append("&");break;

 case '%':result.append("&pc;");break;

 case '_':result.append("&ul;");break;

 case '#':result.append("&shap;");break;

 case '?':result.append("&ques;");break;

 default:result.append(src.charAt(pos));break;

 }

 }

 }

 return result.toString();

 }

//反过滤特殊字符

 public static String decoding(String src){

 if (src==null)

 return "";

 String result=src;

 result=result.replace(""", "\"").replace("'", "\'");

 result=result.replace("<", "<").replace(">", ">");

 result=result.replace("&", "&");

 result=result.replace("&pc;", "%").replace("&ul", "_");

 result=result.replace("&shap;", "#").replace("&ques", "?");

 return result;

 }

//利用反射调用一个继承层次上的函数族，比如安装程序，有安装数据库的，安装文件系统的等，命名均已“install”开始，你就可以将参数part设为“install”，src是其实类实例，root是终止父类

 public static <T> void invokeMethods(String part,T src,Class root) throws ExceptionManager{

 if (root!=null){

 if (!root.isInstance(src))return;

 root=(Class)root.getGenericSuperclass();

 }

 HashMap<String,Method> invokees=new HashMap<String,Method>();

 Class target=src.getClass();

 do{

 Method [] methods=target.getDeclaredMethods();

 for (Method method:methods){

 String mn=method.getName();

 Boolean isPass=mn.startsWith(part);

 if (isPass){

 Integer nopt=method.getParameterTypes().length;

 Boolean isStatic=Modifier.isStatic(method.getModifiers());

 if ((nopt==0)&&(!isStatic)){

 if (!invokees.containsKey(mn))

 invokees.put(mn, method);

 }

 }

 }

 target=(Class)target.getGenericSuperclass();

 }while(target!=root);

 Iterator<String> methods=invokees.keySet().iterator();

 while (methods.hasNext()){

 Method invokee=invokees.get(methods.next());

 Boolean access=invokee.isAccessible();

 invokee.setAccessible(true);

 try {

 invokee.invoke(src);

 } catch (InvocationTargetException e) {

 throw ExceptionManager.wrap(e.getTargetException());

 }catch (Exception e){}

 invokee.setAccessible(access);

 }

 }

MySQL：

 String Driver="com.mysql.jdbc.Driver"; //驱动程序

 String URL="jdbc:mysql://localhost:3306/db_name"; //连接的URL,db_name为数据库名

 String Username="username"; //用户名

 String Password="password"; //密码

 Class.forName(Driver).new Instance();

 Connection con=DriverManager.getConnection(URL,Username,Password);

Microsoft SQL Server 2.0驱动(3个jar的那个):

 String Driver="com.microsoft.jdbc.sqlserver.SQLServerDriver"; //连接SQL数据库的方法

 String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name"; //db_name为数据库名

 String Username="username"; //用户名

 String Password="password"; //密码

 Class.forName(Driver).new Instance(); //加载数据可驱动

 Connection con=DriverManager.getConnection(URL,UserName,Password); //

Microsoft SQL Server 3.0驱动(1个jar的那个): // 老紫竹完善

 String Driver="com.microsoft.sqlserver.jdbc.SQLServerDriver"; //连接SQL数据库的方法

 String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name"; //db_name为数据库名

 String Username="username"; //用户名

 String Password="password"; //密码

 Class.forName(Driver).new Instance(); //加载数据可驱动

 Connection con=DriverManager.getConnection(URL,UserName,Password); //

Sysbase:

 String Driver="com.sybase.jdbc.SybDriver"; //驱动程序

 String URL="jdbc:Sysbase://localhost:5007/db_name"; //db_name为数据可名

 String Username="username"; //用户名

 String Password="password"; //密码

 Class.forName(Driver).newInstance();

 Connection con=DriverManager.getConnection(URL,Username,Password);

Oracle(用thin模式):

 String Driver="oracle.jdbc.driver.OracleDriver"; //连接数据库的方法

 String URL="jdbcracle:thinloaclhost:1521rcl"; //orcl为数据库的SID

 String Username="username"; //用户名

 String Password="password"; //密码

 Class.forName(Driver).newInstance(); //加载数据库驱动

 Connection con=DriverManager.getConnection(URL,Username,Password);

PostgreSQL:

 String Driver="org.postgresql.Driver"; //连接数据库的方法

 String URL="jdbc:postgresql://localhost/db_name"; //db_name为数据可名

 String Username="username"; //用户名

 String Password="password"; //密码

 Class.forName(Driver).newInstance();

 Connection con=DriverManager.getConnection(URL,Username,Password);

DB2：

 String Driver="com.ibm.db2.jdbc.app.DB2.Driver"; //连接具有DB2客户端的Provider实例

 //String Driver="com.ibm.db2.jdbc.net.DB2.Driver"; //连接不具有DB2客户端的Provider实例

 String URL="jdbc:db2://localhost:5000/db_name"; //db_name为数据可名

 String Username="username"; //用户名

 String Password="password"; //密码

 Class.forName(Driver).newInstance();

 Connection con=DriverManager.getConnection(URL,Username,Password);

Informix:

 String Driver="com.informix.jdbc.IfxDriver";

 String URL="jdbc:Informix-sqli://localhost:1533/db_name:INFORMIXSER=myserver"; //db_name为数据可名

 String Username="username"; //用户名

 String Password="password"; //密码

 Class.forName(Driver).newInstance();

 Connection con=DriverManager.getConnection(URL,Username,Password);

JDBC-ODBC:

 String Driver="sun.jdbc.odbc.JdbcOdbcDriver";

 String URL="jdbcdbc:dbsource"; //dbsource为数据源名

 String Username="username"; //用户名

 String Password="password"; //密码

 Class.forName(Driver).newInstance();

 Connection con=DriverManager.getConnection(URL,Username,Password);

/**

* 把TXT转换为XML

*/

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.util.StringTokenizer;

public class TxtToXml {

private String strTxtFileName;

private String strXmlFileName;

public TxtToXml() {

strTxtFileName = new String();

strXmlFileName = new String();

}

public void createXml(String strTxt, String strXml) {

strTxtFileName = strTxt;

strXmlFileName = strXml;

String strTmp;

try {

 BufferedReader inTxt = new BufferedReader(new FileReader(

 strTxtFileName));

 BufferedWriter outXml = new BufferedWriter(new FileWriter(

 strXmlFileName));

 outXml.write("<?xml version= \"1.0\" encoding=\"gb2312\"?>");

 outXml.newLine();

 outXml.write("<people>");

 while ((strTmp = inTxt.readLine()) != null) {

 StringTokenizer strToken = new StringTokenizer(strTmp, "，");

 String arrTmp[];

 arrTmp = new String[3];

 for (int i = 0; i < 3; i++)

 arrTmp = new String("");

 int index = 0;

 outXml.newLine();

 outXml.write(" <students>");

 while (strToken.hasMoreElements()) {

 strTmp = (String) strToken.nextElement();

 strTmp = strTmp.trim();

 arrTmp[index++] = strTmp;

 }

 outXml.newLine();

 outXml.write(" <name>" + arrTmp[0] + "</name>");

 outXml.newLine();

 outXml.write(" <sex>" + arrTmp[1] + "</sex>");

 outXml.newLine();

 outXml.write(" <age>" + arrTmp[2] + "</age>");

 outXml.newLine();

 outXml.write(" </students>");

 }

 outXml.newLine();

 outXml.write("</people>");

 outXml.flush();

} catch (Exception e) {

 e.printStackTrace();

}

}

public static void main(String[] args) {

String txtName = "testtxt.txt";

String xmlName = "testxml.xml";

TxtToXml thisClass = new TxtToXml();

thisClass.createXml(txtName, xmlName);

}

}

/**

* 写入日志

* filePath 日志文件的路径

* code 要写入日志文件的内容

*/

public static boolean print(String filePath,String code) {

try {

 File tofile=new File(filePath);

 FileWriter fw=new FileWriter(tofile,true);

 BufferedWriter bw=new BufferedWriter(fw);

 PrintWriter pw=new PrintWriter(bw);

 System.out.println(getDate()+":"+code);

 pw.println(getDate()+":"+code);

 pw.close();

 bw.close();

 fw.close();

 return true;

} catch (IOException e) {

 return false;

}

}

/**

* 判断是不是合法手机

* handset 手机号码

*/

public static boolean isHandset(String handset) {

try {

 if(!handset.substring(0,1).equals("1")) {

 return false;

 }

 if (handset==null || handset.length()!=11) {

 return false;

 }

 String check = "^[0123456789]+$";

 Pattern regex = Pattern.compile(check);

 Matcher matcher = regex.matcher(handset);

 boolean isMatched = matcher.matches();

 if(isMatched) {

 return true;

 } else {

 return false;

 }

} catch (RuntimeException e) {

 return false;

}

}

}

字符串匹配的算法.

public String getMaxMatch(String a,String b) {

 StringBuffer tmp = new StringBuffer();

 String maxString = "";

 int max = 0;

 int len = 0;

 char[] aArray = a.toCharArray();

 char[] bArray = b.toCharArray();

 int posA = 0;

 int posB = 0;

 while(posA<aArray.length-max) {

 posB = 0;

 while(posB<(bArray.length-max)) {

 if(aArray[posA]==bArray[posB]) {

 len = 1;

 tmp = new StringBuffer();

 tmp.append(aArray[posA]);

 while((posA+len<aArray.length)&&(posB+len<bArray.length)&&(aArray[posA+len]==bArray[posB+len])) {

 tmp.append(aArray[posA+len]);

 len++;

 }

 if(len>max) {

 max = len;

 maxString = tmp.toString();

 }

 }

 posB++;

 }

 posA++;

 }

 return maxString;

 }

import java.text.DecimalFormat;

import java.util.Arrays;

/**

* 时间计算工具类

*/

public class Time {

 /**

 * 时间字段常量，表示“秒”

 */

 public final static int SECOND = 0;

 /**

 * 时间字段常量，表示“分”

 */

 public final static int MINUTE = 1;

 /**

 * 时间字段常量，表示“时”

 */

 public final static int HOUR = 2;

 /**

 * 时间字段常量，表示“天”

 */

 public final static int DAY = 3;

 /**

 * 各常量允许的最大值

 */

 private final int[] maxFields = { 59, 59, 23, Integer.MAX_VALUE - 1 };

 /**

 * 各常量允许的最小值

 */

 private final int[] minFields = { 0, 0, 0, Integer.MIN_VALUE };

 /**

 * 默认的字符串格式时间分隔符

 */

 private String timeSeparator = ":";

 /**

 * 时间数据容器

 */

 private int[] fields = new int[4];

 /**

 * 无参构造，将各字段置为 0

 */

 public Time() {

 this(0, 0, 0, 0);

 }

 /**

 * 使用时、分构造一个时间

 * @param hour 小时

 * @param minute 分钟

 */

 public Time(int hour, int minute) {

 this(0, hour, minute, 0);

 }

 /**

 * 使用时、分、秒构造一个时间

 * @param hour 小时

 * @param minute 分钟

 * @param second 秒

 */

 public Time(int hour, int minute, int second) {

 this(0, hour, minute, second);

 }

 /**

 * 使用一个字符串构造时间 

 * Time time = new Time("14:22:23");

 * @param time 字符串格式的时间，默认采用“:”作为分隔符

 */

 public Time(String time) {

 this(time, null);

 }

 /**

 * 使用天、时、分、秒构造时间，进行全字符的构造

 * @param day 天

 * @param hour 时

 * @param minute 分

 * @param second 秒

 */

 public Time(int day, int hour, int minute, int second) {

 set(DAY, day);

 set(HOUR, hour);

 set(MINUTE, minute);

 set(SECOND, second);

 }

 /**

 * 使用一个字符串构造时间，指定分隔符 

 * Time time = new Time("14-22-23", "-");

 * @param time 字符串格式的时间

 */

 public Time(String time, String timeSeparator) {

 if(timeSeparator != null) {

 setTimeSeparator(timeSeparator);

 }

 String pattern = patternQuote(this.timeSeparator);

 String matcher = new StringBuffer()

 .append("\\d+?").append(pattern)

 .append("\\d+?").append(pattern)

 .append("\\d+?")

 .toString();

 if(!time.matches(matcher)) {

 throw new IllegalArgumentException(time + ", time format error, HH"

 + this.timeSeparator + "mm" + this.timeSeparator + "ss");

 }

 String[] times = time.split(pattern);

 set(DAY, 0);

 set(HOUR, Integer.parseInt(times[0]));

 set(MINUTE, Integer.parseInt(times[1]));

 set(SECOND, Integer.parseInt(times[2]));

 }

 /**

 * 设置时间字段的值

 * @param field 时间字段常量

 * @param value 时间字段的值

 */

 public void set(int field, int value) {

 if(value < minFields[field]) {

 throw new IllegalArgumentException(value +

 ", time value must be positive.");

 }

 fields[field] = value % (maxFields[field] + 1);

 // 进行进位计算

 int carry = value / (maxFields[field] + 1);

 if(carry > 0) {

 int upFieldValue = get(field + 1);

 set(field + 1, upFieldValue + carry);

 }

 }

 /**

 * 获得时间字段的值

 * @param field 时间字段常量

 * @return 该时间字段的值

 */

 public int get(int field) {

 if(field < 0 || field > fields.length - 1) {

 throw new IllegalArgumentException(field + ", field value is error.");

 }

 return fields[field];

 }

 /**

 * 将时间进行“加”运算，即加上一个时间

 * @param time 需要加的时间

 * @return 运算后的时间

 */

 public Time addTime(Time time) {

 Time result = new Time();

 int up = 0; // 进位标志

 for (int i = 0; i < fields.length; i++) {

 int sum = fields + time.fields + up;

 up = sum / (maxFields + 1);

 result.fields = sum % (maxFields + 1);

 }

 return result;

 }

 /**

 * 将时间进行“减”运算，即减去一个时间

 * @param time 需要减的时间

 * @return 运算后的时间

 */

 public Time subtractTime(Time time) {

 Time result = new Time();

 int down = 0; // 退位标志

 for (int i = 0, k = fields.length - 1; i < k; i++) {

 int difference = fields + down;

 if (difference >= time.fields) {

 difference -= time.fields;

 down = 0;

 } else {

 difference += maxFields + 1 - time.fields;

 down = -1;

 }

 result.fields = difference;

 }

 result.fields[DAY] = fields[DAY] - time.fields[DAY] + down;

 return result;

 }

 /**

 * 获得时间字段的分隔符

 * @return

 */

 public String getTimeSeparator() {

 return timeSeparator;

 }

 /**

 * 设置时间字段的分隔符（用于字符串格式的时间）

 * @param timeSeparator 分隔符字符串

 */

 public void setTimeSeparator(String timeSeparator) {

 this.timeSeparator = timeSeparator;

 }

 /**

 * 正则表达式引用处理方法，源自 JDK @link java.util.regex.Pattern#quote(String)

 */

 private String patternQuote(String s) {

 int slashEIndex = s.indexOf("\\E");

 if (slashEIndex == -1)

 return "\\Q" + s + "\\E";

 StringBuilder sb = new StringBuilder(s.length() * 2);

 sb.append("\\Q");

 slashEIndex = 0;

 int current = 0;

 while ((slashEIndex = s.indexOf("\\E", current)) != -1) {

 sb.append(s.substring(current, slashEIndex));

 current = slashEIndex + 2;

 sb.append("\\E\\\\E\\Q");

 }

 sb.append(s.substring(current, s.length()));

 sb.append("\\E");

 return sb.toString();

 }

 public String toString() {

 DecimalFormat df = new DecimalFormat("00");

 return new StringBuffer().append(fields[DAY]).append(", ")

 .append(df.format(fields[HOUR])).append(timeSeparator)

 .append(df.format(fields[MINUTE])).append(timeSeparator)

 .append(df.format(fields[SECOND]))

 .toString();

 }

 public int hashCode() {

 final int PRIME = 31;

 int result = 1;

 result = PRIME * result + Arrays.hashCode(fields);

 return result;

 }

 public boolean equals(Object obj) {

 if (this == obj)

 return true;

 if (obj == null)

 return false;

 if (getClass() != obj.getClass())

 return false;

 final Time other = (Time) obj;

 if (!Arrays.equals(fields, other.fields)) {

 return false;

 }

 return true;

 }

}

ISBN（国际标准书号）的校验

public class Test {

 public static void main(String[] args) {

 System.out.println("9787302155638 " + ISBN.checkISBN("9787302155638"));

 System.out.println("7564105607 " + ISBN.checkISBN("7564105607"));

 System.out.println("730213880X " + ISBN.checkISBN("730213880X"));

 System.out.println("7302138800 " + ISBN.checkISBN("7302138800"));

 System.out.println("9790000000000 " + ISBN.checkISBN("9790000000000"));

 try {

 System.out.println(ISBN.checkISBN("9770000000000"));

 }catch(Exception e) {

 System.out.println("9770000000000 " + e.getMessage());

 }

 try {

 System.out.println(ISBN.checkISBN("123456545"));

 }catch(Exception e) {

 System.out.println("123456545 " + e.getMessage());

 }

 }

}

public final class ISBN {

 /**

 * 根据输入的ISBN号，检验ISBN的有效性。依据 GB/T 5795-2006 和 ISO 2108:2005 ISBN

 * 10位标准和13位标准实现（13位标准自2007年1月1日开始实行，在此之前采用10位标准）。

 *

 * @param String isbn：需要进行校验的ISBN字符串

 * @return true：所输入的ISBN校验正确； false：所输入的ISBN校验错误

 */

 public static boolean checkISBN(String isbn) {

 int count = 0;

 int checkBitInt = 0;

 // 将ISBN数据全取大写字母

 //isbn = isbn.toUpperCase();

 char[] cs = isbn.toCharArray();

 switch (isbn.length()) {

 case 10:

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

 // 当ISBN为10位时，进行的校验，用于2007年1月1日前的出版物

 // 数据格式：从左至右前9位为ISBN数据，第10位为校验位

 // 校验方法：

 // (1) 从左至右将前9位数据从10开始至2进行编号，作为位权

 // (2) 将9位数据与各位位权进行加权，并求其9位和（称为加权和，记作M）

 // (3) 第10位校验位计算方法，校验位为C：

 // M + C ≡ 0 (mod 11)

 // C为10时，记作“X”

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

 // 取出前9位数字进行加权和计算

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

 // 若前9位数据中有非数字字符，则抛出异常

 if (cs < '0' || cs > '9') {

 throw new ISBNFormatException("ISBN " + isbn +

 " 第 " + (i + 1) + " 位中出现非法字符 " + cs);

 }

 int c = cs - '0';

 // 求加权和

 count += c * (10 - i);

 }

 // 取出校验位数据0～9和X符合校验字符要求

 if (cs[9] >= '0' && cs[9] <= '9') {

 checkBitInt = cs[9] - '0';

 } else if (cs[9] == 'X' || cs[9] == 'x') {

 // 校验位中的“X”表示数据“10”

 checkBitInt = 10;

 } else {

 // 非0～9或X时抛出异常

 throw new ISBNFormatException("ISBN " + isbn +

 " 第 10 位中出现非法字符 " + cs[9]);

 }

 // 进行校验

 if ((count + checkBitInt) % 11 == 0) {

 return true; // 校验成功

 } else {

 return false; // 校验失败

 }

 case 13:

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

 // 当ISBN为13位时，进行的校验，用于2007年1月1日后的出版物

 // 数据格式：从左至右前12位为ISBN数据，第13位为校验位

 // 校验方法：

 // (1) 从左至右将前12位数的取其奇位数和和偶位数和

 // (2) 将偶位数和乘3，并其与奇位数和的和，得加权和

 // (3) 第13位校验位计算方法，校验位为C：

 // M + C ≡ 0 (mod 10)

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

 // ISBN为13位数据时，前3位目前只能是“978”（已实行）或“979”（暂未实行）

 if (!isbn.startsWith("978") && !isbn.startsWith("979")) {

 throw new ISBNFormatException("ISBN-13 格式不符合标准");

 }

 // 取出前12位数字进行加权和计算

 int countEven = 0;

 int countOdd = 0;

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

 int c = cs - '0';

 // 若前12位数据中有非数字字符，则抛出异常

 if (c < 0 || c > 9) {

 throw new ISBNFormatException("ISBN " + isbn +

 " 第 " + (i + 1) + " 位中出现非法字符 " + cs);

 }

 // 分别计算奇位数和偶位数的和

 if ((i & 0x1) == 0) {

 countOdd += c;

 } else {

 countEven += c;

 }

 }

 // 求加权和

 count = countOdd + (countEven * 3);

 // 取出校验位数据

 if (cs[12] < '0' || cs[12] > '9') {

 // 校验位为非0~9字符时，抛出异常

 throw new ISBNFormatException("ISBN " + isbn

 + " 第 13 位中出现非法字符 " + cs[12]);

 }

 checkBitInt = cs[12] - '0';

 // 进行校验

 if ((count + checkBitInt) % 10 == 0) {

 return true; // 校验成功

 } else {

 return false; // 校验失败

 }

 default:

 // ISBN为非10位或13位时抛出异常

 throw new ISBNFormatException("ISBN 格式不符合标准");

 }

 }

}

import java.util.ArrayList;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

/**

* JSON utility class

*

* @since 2008-04-21

*/

public class Json {

 // test

 public static void main(String[] args) {

 Json json1 = new Json();

 json1.add("totalCount", 2);

 json1.add("isTest", true);

 Json json_a = new Json();

 json_a.add("menuid", 1);

 json_a.add("menuname", "testmenu");

 json1.add("topics", json_a);

 Json json_b = new Json();

 json_b.add("menuid", 2);

 json_b.add("menuname", "testmenu");

 json1.add("topics", json_b);

 System.out.println(json1.toString());

 }

 private Map map = new LinkedHashMap();

 /**

 * 添加一个 JSON 属性，值为一个字符串，重复添加时产生数组

 *

 * add("name", "value"); 

 * 添加一个字符串，产生的 JSON 如：{"name":"value"}

 *

 * add("name", "value1"); 

 * add("name", "value2"); 

 * 添加两个同属性的字符串，产生的 JSON 如：{"name":["value1", "value2"]}

 *

 * @param key JSON 属性名

 * @param str 字符串格式的属性值

 */

 public void add(String key, String value) {

 addElement(key, value);

 }

 public void add(String key, int num) {

 addElement(key, new Integer(num));

 }

 public void add(String key, boolean b) {

 addElement(key, new Boolean(b));

 }

 /**

 * 添加一个 JSON 属性，值为一个 JSON，重复添加时产生 JSON 数组

 *

 * Json json1 = new Json(); 

 * json1.add("name1", "value1"); 

 * json1.add("name2", "value2"); 

 * Json json = new Json(); 

 * json.add("message", json1); 

 * 添加一个 JSON，产生的 JSON 如：{"message":{"name1":"value1", "name2":"value2"}}

 *

 * Json json1 = new Json(); 

 * json1.add("name1", "value1"); 

 * json1.add("name2", "value2"); 

 * Json json2 = new Json(); 

 * json2.add("name1", "value3"); 

 * json2.add("name2", "value4"); 

 * Json json = new Json(); 

 * json.add("message", json1); 

 * json.add("message", json2); 

 * 添加两个同属性的 JSON，产生的 JSON 如：{"message":[{"name1":"value1", "name2":"value2"}, {"name1":"value3", "name2":"value4"}]}

 *

 * @param key JSON 属性名

 * @param json JSON 格式的属性值

 */

 public void add(String key, Json json) {

 addElement(key, json);

 }

 public String toString() {

 StringBuilder sb = new StringBuilder();

 sb.append("{");

 int k = 0;

 for (Iterator i = map.keySet().iterator(); i.hasNext();) {

 String key = (String)(i.next());

 Object obj = map.get(key);

 if (k > 0) {

 sb.append(",");

 }

 appendKey(sb, key);

 if (obj instanceof String) {

 appendString(sb, (String)obj);

 } else if (obj instanceof List) {

 appendList(sb, (List)obj);

 } else if (obj instanceof Json) {

 appendJson(sb, (Json)obj);

 } else {

 appendOther(sb, obj);

 }

 k++;

 }

 sb.append("}");

 return sb.toString();

 }

 private void addElement(String key, Object obj) {

 if (!map.containsKey(key)) {

 if(obj instanceof Json) {

 List list = new ArrayList();

 list.add(obj);

 map.put(key, list);

 } else {

 map.put(key, obj);

 }

 return;

 }

 Object o = map.remove(key);

 if (o instanceof List) {

 ((List)o).add(obj);

 map.put(key, o);

 return;

 }

 // o is a String

 List list = new ArrayList();

 list.add(o);

 list.add(obj);

 map.put(key, list);

 }

 /**

 * Append JSON property name

 *

 * @param sb

 * @param key

 */

 private void appendKey(StringBuilder sb, String key) {

 sb.append("\"").append(key).append("\":");

 }

 /**

 * Append JSON property value that is a String

 *

 * @param sb

 * @param str

 */

 private void appendString(StringBuilder sb, String str) {

 sb.append("\"").append(str).append("\"");

 }

 /**

 * Append JSON property value that is a Integer

 *

 * @param sb

 * @param num

 */

 private void appendOther(StringBuilder sb, Object obj) {

 sb.append(obj);

 }

 /**

 * Append JSON property value that is a List

 *

 * @param sb

 * @param list

 */

 private void appendList(StringBuilder sb, List list) {

 sb.append("[");

 for (int j = 0, m = list.size(); j < m; j++) {

 if (j > 0) {

 sb.append(",");

 }

 Object obj = list.get(j);

 if (obj instanceof String) {

 appendString(sb, (String)obj);

 } else if (obj instanceof Json) {

 appendJson(sb, (Json)obj);

 } else {

 appendOther(sb, obj);

 }

 }

 sb.append("]");

 }

 /**

 * Append JSON property value that is a JSON

 *

 * @param sb

 * @param json

 */

 private void appendJson(StringBuilder sb, Json json) {

 sb.append(json.toString());

 }

}

/**

* 从指定的字符串中提取Email

* content 指定的字符串

*/

public static String parse(String content) {

String email = null;

if (content==null || content.length()<1) {

 return email;

}

//找出含有@

int beginPos;

int i;

String token = "@";

String preHalf="";

String sufHalf = "";

beginPos = content.indexOf(token);

if (beginPos>-1) {

 //前项扫描

 String s = null;

 i= beginPos;

 while(i>0) {

 s = content.substring(i-1,i);

 if (isLetter(s))

 preHalf = s+preHalf;

 else

 break;

 i--;

 }

 //后项扫描

 i= beginPos+1;

 while( i<content.length()) {

 s = content.substring(i,i+1);

 if (isLetter(s))

 sufHalf = sufHalf +s;

 else

 break;

 i++;

 }

 //判断合法性

 email = preHalf + "@" + sufHalf;

 if (isEmail(email)) {

 return email;

 }

}

return null;

}

/**

* 判断是不是合法Email

* email Email地址

*/

public static boolean isEmail(String email) {

try {

 if (email==null || email.length()<1 || email.length()>256) {

 return false;

 }

 String check = "^([0-9a-zA-Z]+[_.0-9a-zA-Z-]+)@([a-zA-Z0-9-]+[.])+([a-zA-Z]{2,3})$";

 Pattern regex = Pattern.compile(check);

 Matcher matcher = regex.matcher(email);

 boolean isMatched = matcher.matches();

 if(isMatched) {

 return true;

 } else {

 return false;

 }

} catch (RuntimeException e) {

 return false;

}

}

/**

* 判断是不是合法字符

* c 要判断的字符

*/

public static boolean isLetter(String c) {

boolean result = false;

if (c==null || c.length()<0) {

 return false;

}

//a-z

if (c.compareToIgnoreCase("a")>=0 && c.compareToIgnoreCase("z")<=0) {

 return true;

}

//0-9

if (c.compareToIgnoreCase("0")>=0 && c.compareToIgnoreCase("9")<=0) {

 return true;

}

//. - _

if (c.equals(".") || c.equals("-") || c.equals("_") ) {

 return true;

}

return result;

}

/**

 * 列出某文件夹及其子文件夹下面的文件，并可根据扩展名过滤

 *

 * @param path

 */

 public static void list(File path)

 {

 if (!path.exists())

 {

 System.out.println("文件名称不存在!");

 }

 else

 {

 if (path.isFile())

 {

 if (path.getName().toLowerCase().endsWith(".pdf")

 || path.getName().toLowerCase().endsWith(".doc")

 || path.getName().toLowerCase().endsWith(".html")

 || path.getName().toLowerCase().endsWith(".htm"))

 {

 System.out.println(path);

 System.out.println(path.getName());

 }

 }

 else

 {

 File[] files = path.listFiles();

 for (int i = 0; i < files.length; i++)

 {

 list(files);

 }

 }

 }

 }

/**

 * 拷贝一个目录或者文件到指定路径下

 *

 * @param source

 * @param target

 */

 public static void copy(File source, File target)

 {

 File tarpath = new File(target, source.getName());

 if (source.isDirectory())

 {

 tarpath.mkdir();

 File[] dir = source.listFiles();

 for (int i = 0; i < dir.length; i++)

 {

 copy(dir, tarpath);

 }

 }

 else

 {

 try

 {

 InputStream is = new FileInputStream(source);

 OutputStream os = new FileOutputStream(tarpath);

 byte[] buf = new byte[1024];

 int len = 0;

 while ((len = is.read(buf)) != -1)

 {

 os.write(buf, 0, len);

 }

 is.close();

 os.close();

 }

 catch (FileNotFoundException e)

 {

 e.printStackTrace();

 }

 catch (IOException e)

 {

 e.printStackTrace();

 }

 }

 }

Java日期格式化及其使用例子

1 SimpleDateFormat担当重任,怎样格式化都行

import java.util.Date;

import java.text.SimpleDateFormat;

public class Demo

{

public static void main(String[] args)

{

Date now=new Date();

SimpleDateFormat f=newSimpleDateFormat("今天是"+"yyyy年MM月dd日 E kk点mm分");

System.out.println(f.format(now));

f=new SimpleDateFormat("a hh点mm分ss秒");

System.out.println(f.format(now));

}

}

2 从字符串到日期类型的转换：

import java.util.Date;

import java.text.SimpleDateFormat;

import java.util.GregorianCalendar;

import java.text.*;

publicclass Demo

{

public static void main(String[] args)

{

String strDate="2005年04月22日";

//注意：SimpleDateFormat构造函数的样式与strDate的样式必须相符

SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd日");

//必须捕获异常

try

{

Date date=simpleDateFormat.parse(strDate);

System.out.println(date);

}

catch(ParseException px)

{

px.printStackTrace();

}

}

}

3 将毫秒数换转成日期类型

import java.util.Date;

import java.text.SimpleDateFormat;

import java.util.GregorianCalendar;

import java.text.*;

public class Demo

{

public static void main(String[] args)

{

long now=System.currentTimeMillis();

System.out.println("毫秒数："+now);

Date dNow=new Date(now);

System.out.println("日期类型："+dNow);

}

}

这3例源自http://blog.csdn.net/zhoujian2003/archive/2005/04/22/358363.aspx

4 获取系统时期和时间，转换成SQL格式后更新到数据库

(http://blog.csdn.net/netrope/archive/2005/11/19/532729.aspx)

java.util.Date d=new java.util.Date(); //获取当前系统的时间

//格式化日期

new java.text.SimpleDateFormat s= new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String dateStr = s.format(d); //转为字符串

使用RS更新数据库，仍然要用rs.updateString，而不是rs.updateDade。

rs.updateString("regtime",dateStr); //regtime字段为datetime类型的

下面两例源自 http://blog.csdn.net/kingter520/archive/2004/10/27/155435.aspx
5 按本地时区输出当前日期

Date myDate = new Date();

System.out.println(myDate.toLocaleString());

输出结果为：

2003-5-30

6 如何格式化小数

DecimalFormat df = new DecimalFormat(",###.00");

double aNumber = 33665448856.6568975;

String result = df.format(aNumber);

Sytem. out.println(result);

输出结果为：

33,665,448,856.66

其他：获取毫秒时间 System.currentTimeMillis();

7 在数据库里的日期只以年-月-日的方式输出

(http://blog.csdn.net/zzsxvzzsxv/archive/2007/08/27/1761004.aspx)

定义日期格式：SimpleDateFormat sdf = new SimpleDateFormat(yy-MM-dd);

sql语句为：String sqlStr = "select bookDate from roomBook where bookDate between '2007-4-10' and '2007-4-25'";

输出：

System.out.println(df.format(rs.getDate("bookDate")));

Java中的鼠标和键盘事件

1、使用MouseListener借口处理鼠标事件

鼠标事件有5种：按下鼠标键，释放鼠标键，点击鼠标键，鼠标进入和鼠标退出

鼠标事件类型是MouseEvent，主要方法有：

getX(),getY() 获取鼠标位置

getModifiers() 获取鼠标左键或者右键

getClickCount() 获取鼠标被点击的次数

getSource() 获取鼠标发生的事件源

事件源获得监视器的方法是addMouseListener()，移去监视器的方法是removeMouseListener()

处理事件源发生的时间的事件的接口是MouseListener 接口中有如下的方法

mousePressed(MouseEvent) 负责处理鼠标按下事件

mouseReleased(MouseEvent) 负责处理鼠标释放事件

mouseEntered(MouseEvent) 负责处理鼠标进入容器事件

mouseExited(MouseEvent) 负责处理鼠标离开事件

mouseClicked(MouseEvent) 负责处理点击事件

2、使用MouseMotionListener接口处理鼠标事件

事件源发生的鼠标事件有2种：拖动鼠标和鼠标移动

鼠标事件的类型是MouseEvent

事件源获得监视器的方法是addMouseMotionListener()

处理事件源发生的事件的接口是MouseMotionListener 接口中有如下的方法

mouseDragged() 负责处理鼠标拖动事件

mouseMoved() 负责处理鼠标移动事件

3、控制鼠标的指针形状

setCursor(Cursor.getPreddfinedCursor(Cursor.鼠标形状定义)) 鼠标形状定义见（书 P 210）

4、键盘事件

键盘事件源使用addKeyListener 方法获得监视器

键盘事件的接口是KeyListener 接口中有3个方法

public void keyPressed(KeyEvent e) 按下键盘按键

public void keyReleased(KeyEvent e) 释放键盘按键

public class IsChineseOrEnglish {

// GENERAL_PUNCTUATION 判断中文的“号

// CJK_SYMBOLS_AND_PUNCTUATION 判断中文的。号

// HALFWIDTH_AND_FULLWIDTH_FORMS 判断中文的，号

 public static boolean isChinese(char c) {

 Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);

 if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS

 || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS

 || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A

 || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION

 || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION

 || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS){

 return true;

 }

 return false;

 }

 public static void isChinese(String strName) {

 char[] ch = strName.toCharArray();

 for (int i = 0; i < ch.length; i++) {

 char c = ch;

 if(isChinese(c)==true){

 System.out.println(isChinese(c));

 return;

 }else{

 System.out.println(isChinese(c));

 return ;

 }

 }

 }

 public static void main(String[] args){

 isChinese("zhongguo");

 isChinese("中国");

}

}

MD5和一个可逆加密算法相接合的加密和解密程序

比较简单。

import java.security.MessageDigest;

/**

*先通过MD5加密之后，再来一次可逆的加密。

*顺序可以调整，可以选择先用可逆加密，然后再用MD5加密

*/

public class MD5andKL{

//MD5加码。32位

public static String MD5(String inStr) {

MessageDigest md5 = null;

try {

md5 = MessageDigest.getInstance("MD5");

} catch (Exception e) {

System.out.println(e.toString());

e.printStackTrace();

return "";

}

char[] charArray = inStr.toCharArray();

byte[] byteArray = new byte[charArray.length];

for (int i = 0; i < charArray.length; i++)

byteArray = (byte) charArray;

byte[] md5Bytes = md5.digest(byteArray);

StringBuffer hexValue = new StringBuffer();

for (int i = 0; i < md5Bytes.length; i++) {

int val = ((int) md5Bytes) & 0xff;

if (val < 16)

hexValue.append("0");

hexValue.append(Integer.toHexString(val));

}

return hexValue.toString();

}

//可逆的加密算法

public static String KL(String inStr){

//String s = new String(inStr);

char[] a = inStr.toCharArray();  

  for (int i = 0;i <a.length;i++)  {  

  a = (char)(a^'t');  

  }  

  String s=new String(a);

  return s;  

}

//加密后解密

public static String JM(String inStr){

char[] a=inStr.toCharArray();

for (int i = 0;i <a.length;i++)  {  

a= (char)(a^'t');  

  }      

  String k=new String(a);

  return k;

}

//测试主函数

public static void main (String args[]){

String s = new String("admin");

System.out.println("原始："+s);

System.out.println("MD5后："+MD5(s));

System.out.println("MD5后再加密："+KL(MD5(s)));

System.out.println("解密为MD5后的："+JM(KL(MD5(s))));

}

}

/**

* 取得服务器当前的各种具体时间

* 回车：日期时间

*/

import java.util.*;

public class GetNowDate{

 Calendar calendar = null;

 public GetNowDate(){

 calendar = Calendar.getInstance();

 calendar.setTime(new Date());

 }

 public int getYear(){

 return calendar.get(Calendar.YEAR);

 }

 public int getMonth(){

 return 1 + calendar.get(Calendar.MONTH);

 }

 public int getDay(){

 return calendar.get(Calendar.DAY_OF_MONTH);

 }

 public int getHour(){

 return calendar.get(Calendar.HOUR_OF_DAY);

 }

 public int getMinute(){

 return calendar.get(Calendar.MINUTE);

 }

 public int getSecond(){

 return calendar.get(Calendar.SECOND);

 }

 public String getDate(){

 return getMonth()+"/"+getDay()+"/"+getYear();

 }

 public String getTime(){

 return getHour()+":"+getMinute()+":"+getSecond();

 }

 public String getDate2(){

 String yyyy="0000", mm="00", dd="00";

 yyyy = yyyy + getYear();

 mm = mm + getMonth();

 dd = dd + getDay();

 yyyy = yyyy.substring(yyyy.length()-4);

 mm = mm.substring(mm.length()-2);

 dd = dd.substring(dd.length()-2);

 return yyyy + "/" + mm + "/" + dd;

 }

 public String getTime2(){

 String hh="00", mm="00", ss="00";

 hh = hh + getHour();

 mm = mm + getMinute();

 ss = ss + getSecond();

 hh = hh.substring(hh.length()-2, hh.length());

 mm = mm.substring(mm.length()-2, mm.length());

 ss = ss.substring(ss.length()-2, ss.length());

 return hh + ":" + mm + ":" + ss;

 }

}

/**

* 用半角的特殊符号代替全角的特殊符号

* 防止特殊字符在传输参数时出现错误

*

*/

public class ReplaceStrE{

 public static String rightToError(String ss){

 String strs;

 String strs1;

 String strs2;

 String strs3;

 String strs4;

 try{

 strs = ss.replace('＃','#');

 }

 catch(Exception ex){

 return ss;

 }

 try{

 strs1 = strs.replace('＂','"');

 }

 catch(Exception ex){

 return strs;

 }

 try{

 strs2 = strs1.replace(' ','&');

 }

 catch(Exception ex){

 return strs1;

 }

 try{

 strs3 = strs2.replace('＋','+');

 }

 catch(Exception ex){

 return strs2;

 }

 try{

 strs4 = strs3.replace('＇','\'');

 }

 catch(Exception ex){

 return ss;

 }

 return strs4;

 }

}

/**

* Big5字与Unicode的互换

* 转换后的正常字型

*/

import java.io.*;

public class MyUtil{

 public static String big5ToUnicode(String s){

 try{

 return new String(s.getBytes("ISO8859_1"), "Big5");

 }

 catch (UnsupportedEncodingException uee){

 return s;

 }

 }

 public static String UnicodeTobig5(String s){

 try{

 return new String(s.getBytes("Big5"), "ISO8859_1");

 }

 catch (UnsupportedEncodingException uee){

 return s;

 }

 }

 public static String toHexString(String s){

 String str="";

 for (int i=0; i<s.length(); i++){

 int ch=(int)s.charAt(i);

 String s4="0000"+Integer.toHexString(ch);

 str=str+s4.substring(s4.length()-4)+" ";

 }

 return str;

 }

}

import java.io.*;

import java.util.ArrayList;

import java.util.List;

public class FileCopy {

private String message = "";

public String getMessage() {

return message;

}

public void setMessage(String message) {

this.message = message;

}

/**

* 将源文件拷贝到目标文件

*

* @param src

* 写源文件地址，需文件名

* @param des

* 写目标文件地址，无需文件名

*/

public boolean copyFile(String src, String des) {

File srcFile = new File(src);

File desDir = new File(des);

File desFile = new File(des + "/" + srcFile.getName());

// 判断源文件是否存在

if (!srcFile.exists()) {

 this.setMessage("源文件不存在！");

 return false;

} else if (!srcFile.isFile()) {

 this.setMessage("源文件格式错！");

 return false;

}

// 判断源文件是否存在

if (!desDir.exists()) {

 this.setMessage("目标目录不存在！");

 return false;

} else if (!desDir.isDirectory()) {

 this.setMessage("不是有效的目录！");

 return false;

}

BufferedReader reader = null;

BufferedWriter writer = null;

String str;

try {

 reader = new BufferedReader(new FileReader(srcFile));

 writer = new BufferedWriter(new FileWriter(desFile));

 // 判断目标文件是否存在及其格式，不存在就创建，格式不对先删除，存在就替代

 if (!desFile.exists() || !desFile.isFile()) {

 if (desFile.exists()) {

 desFile.delete();

 }

 desFile.createNewFile();

 }

 // 从源文件读取数据，并写入目标文件

 str = reader.readLine();

 while (str != null) {

 writer.write(str);

 writer.newLine();

 str = reader.readLine();

 }

} catch (IOException e) {

 this.setMessage(e.getMessage());

 return false;

} finally {

 if (reader != null) {

 try {

 reader.close();

 } catch (IOException e) {

 this.setMessage(e.getMessage());

 }

 }

 if (writer != null) {

 try {

 writer.close();

 } catch (IOException e) {

 this.setMessage(e.getMessage());

 }

 }

}

return true;

}

private List fileList = new ArrayList();

/**

* 列出所有文件

* @param srcFile

*/

private void file(File srcFile) {

if (srcFile.isDirectory()) {

 String[] files = srcFile.list();

 for (int i = 0; i < files.length; i++) {

 File f = new File(srcFile + "/" + files);

 // 如果是文件加入列表，否则递归列出

 if (f.isFile()) {

 fileList.add(f);

 } else

 file(f);

 }

}else this.setMessage(srcFile.getAbsolutePath()+"不是目录");

}

/**

* 建立目录

* @param des

* @throws IOException

*/private void mkdir(File des) {

if (!des.exists() || !des.isDirectory()) {

 mkdir(des.getParentFile());

 if (des.exists()) {

 des.delete();

 }

 des.mkdir();

}

}

/**

* 复制目录将源目录下所有文件拷贝到目标目录下

* @param src 源目录

 * @param des 目标目录

*/

public boolean copyDir(String src, String des) {

File srcFile = new File(src);

if (!srcFile.exists()) {

 this.setMessage("源目录不存在！");

 return false;

} else if (!srcFile.isDirectory()) {

 this.setMessage(src+"不是有效的目录！");

 return false;

}

file(srcFile);

for (int i = 0; i < fileList.size(); i++) {

 String srcName = ((File) fileList.get(i)).getPath();

 String desName = srcName.substring(src.length(), srcName.length());

 desName = des + desName;

 File dir=new File(desName).getParentFile();

 mkdir(dir);

 if(!copyFile(srcName, dir.getPath())){

 return false;

 }

}

return true;

}

public static void main(String[] args) {

FileCopy t = new FileCopy();

System.out.println(t.copyFile("D:/aaa.txt","E:"));

String src="D:/asdf";

String des="E:/adf";

System.out.println(t.copyDir(src, des));

System.out.println(t.getMessage());

}

}

/**

 * Description: 获取GMT8时间

 * @return 将当前时间转换为GMT8时区后的Date

 */

 public static Date getGMT8Time(){

 Date gmt8 = null;

 try {

 Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT+8"),Locale.CHINESE);

 Calendar day = Calendar.getInstance();

 day.set(Calendar.YEAR, cal.get(Calendar.YEAR));

 day.set(Calendar.MONTH, cal.get(Calendar.MONTH));

 day.set(Calendar.DATE, cal.get(Calendar.DATE));

 day.set(Calendar.HOUR_OF_DAY, cal.get(Calendar.HOUR_OF_DAY));

 day.set(Calendar.MINUTE, cal.get(Calendar.MINUTE));

 day.set(Calendar.SECOND, cal.get(Calendar.SECOND));

 gmt8 = day.getTime();

 } catch (Exception e) {

 System.out.println("获取GMT8时间 getGMT8Time() error !");

 e.printStackTrace();

 gmt8 = null;

 }

 return gmt8;

 }

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.util.Properties;

/**

* ReadProperties.java

* Description: 读取操作属性配置文件

* @author li.b

* @version 2.0

* Jun 26, 2008

*/

public class ReadProperties {

 /**

 * Description: 获取属性配置文件

 * @param path 资源文件路径

 * @return Properties Object

 * @throws FileNotFoundException

 * @throws IOException

 */

 public static Properties getProperties(String path) throws FileNotFoundException, IOException{

 Properties props = null;

 File file = new File(path);

 if(file.exists() && file.isFile()){

 props = new Properties();

 props.load(new FileInputStream(file));

 }else{

 System.out.println(file.toString() + "不存在！");

 }

 return props;

 }

 /**

 * Description: 从属性文件获取值

 * @param props Properties Object

 * @param key

 * @return 通过key匹配到的value

 */

 public static String getValue(Properties props,String key,String encod){

 String result = "";

 String en = "";

 String localEN = System.getProperty("file.encoding");

 if(encod !=null && !encod.equals("") ){

 en = encod;

 }else{

 en = localEN;

 }

 try {

 key = new String(key.getBytes(en),"ISO-8859-1");

 result = props.getProperty(key);

 if(!result.equals("")){

 result = new String(result.getBytes("ISO-8859-1"),en);

 }

 } catch (Exception e) {

 }finally{

 if(result == null)result = "";

 return result;

 }

 }

 public static String getValue(Properties props,String key){

 return getValue(props, key, "");

 }

}

import java.lang.reflect.Array;

import java.util.Date;

public class TestCast {

 /**

 * @param args

 */

 //public static void main(String[] args) {

 /** *//**

 *

 * 一般情况下数组和数组是不能直接进行转换的,例如:

 * Object[] t1={"1","2"};

 * String[] t2=(String[])t1;//这里会出现转换错误

 *

 * 下面提供了一种方式进行转换

 */

 //1.0测试一般基础类

 /* Object[] t1={"1","2","3","4","5"};

 String[] m1=(String[])TestCast.cast(t1,String.class);

 for(int i=0;i<m1.length;i++)

 System.out.println(m1);

 //2.0测试复杂对象

 Object[] t2={new Date(1000),new Date(2000)};

 Date[] m2=(Date[])TestCast.cast(t2,Date.class);

 for(int i=0;i<m2.length;i++)

 System.out.println(m2.toString());*/

 // }

 /** *//**

 * 将数组array转换成clss代表的类型后返回

 * @param array 需要转换的数组

 * @param clss 要转换成的类型

 * @return 转换后的数组

 */

 public static Object cast(Object array,Class clss){

 if(null==clss)

 throw new IllegalArgumentException("argument clss cannot be null");

 if(null==array)

 throw new IllegalArgumentException("argument array cannot be null");

 if(false==array.getClass().isArray())

 throw new IllegalArgumentException("argument array must be array");

 Object[] src=(Object[])array;

 Object[] dest=(Object[])Array.newInstance(clss, src.length);

 System.arraycopy(src, 0, dest, 0, src.length);

 return dest;

 }

}

处理特殊符号的工具类，这个类是从sturts源码里挖出来的

/**

* DealingCharacter.java

* Description:

* @author li.b

* @version 2.0

* Jun 27, 2008

*/

public class DealingCharacter {

 /**

 * Description: 转译特殊符号标签

 * @param value 需要处理的字符串

 * @return

 */

 public static String filter(String value)

 {

 if(value == null || value.length() == 0)

 return value;

 StringBuffer result = null;

 String filtered = null;

 for(int i = 0; i < value.length(); i++)

 {

 filtered = null;

 switch(value.charAt(i))

 {

 case 60: // '<'

 filtered = "<";

 break;

 case 62: // '>'

 filtered = ">";

 break;

 case 38: // '&'

 filtered = "&";

 break;

 case 34: // '"'

 filtered = """;

 break;

 case 39: // '\''

 filtered = "'";

 break;

 }

 if(result == null)

 {

 if(filtered != null)

 {

 result = new StringBuffer(value.length() + 50);

 if(i > 0)

 result.append(value.substring(0, i));

 result.append(filtered);

 }

 } else

 if(filtered == null)

 result.append(value.charAt(i));

 else

 result.append(filtered);

 }

 return result != null ? result.toString() : value;

 }

 public static void main(String[] args) {

 System.out.println(DealingCharacter.filter("<HTML>sdfasfas</HTML>"));

 }

}

小标签

import java.io.IOException;

import java.util.List;

import javax.servlet.jsp.JspException;

import javax.servlet.jsp.tagext.TagSupport;

import com.formcontent.show.ShowFormTypeOperateDb;

import com.forum.hibernatePrj.Space;

public class OutPrintForumType extends TagSupport{

public int doStartTag() throws JspException

{

String printStr="";

ShowFormTypeOperateDb showtype=new ShowFormTypeOperateDb();

List list=showtype.getForumType();

if(list!=null&&list.size()>0)

{

for(int i=0;i <list.size();i++)

{

Space space=(Space)list.get(i);

if(space!=null)

{

printStr+=" <tr> <td>"+" <div align='left' class='TypeCss'>"+

 space.getSpaceName()+" "+space.getSpaceDescription()+" 目前登陆总人数:"+i+" 人访问数:"+i+"人 </div> </td> </tr>"

 +" <tr> <td> </td> </tr>";

}

 }

}

try {

pageContext.getOut().write(printStr);

} catch (IOException e) {

e.printStackTrace();

}

 return super.doStartTag();

}

}

正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。

匹配中文字符的正则表达式： [\u4e00-\u9fa5]

评注：匹配中文还真是个头疼的事，有了这个表达式就好办了

匹配双字节字符(包括汉字在内)：[^\x00-\xff]

评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

匹配空白行的正则表达式：\n\s*\r

评注：可以用来删除空白行

匹配HTML标记的正则表达式： <(\S*?)[^>]*>.*? </\1> | <.*? />

评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力

匹配首尾空白字符的正则表达式：^\s* |\s*$

评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式

匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

评注：表单验证时很实用

匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*

评注：网上流传的版本功能很有限，上面这个基本可以满足需求

匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$

评注：表单验证时很实用

匹配国内电话号码：\d{3}-\d{8} |\d{4}-\d{7}

评注：匹配形式如 0511-4405222 或 021-87888822

匹配腾讯QQ号：[1-9][0-9]{4,}

评注：腾讯QQ号从10000开始

匹配中国邮政编码：[1-9]\d{5}(?!\d)

评注：中国邮政编码为6位数字

匹配身份证：\d{15} |\d{18}

评注：中国的身份证为15位或18位

匹配ip地址：\d+\.\d+\.\d+\.\d+

评注：提取ip地址时有用

匹配特定数字：

^[1-9]\d*$　　 //匹配正整数

^-[1-9]\d*$ 　 //匹配负整数

^-?[1-9]\d*$　　 //匹配整数

^[1-9]\d* |0$　 //匹配非负整数（正整数 + 0）

^-[1-9]\d* |0$　　 //匹配非正整数（负整数 + 0）

^[1-9]\d*\.\d* |0\.\d*[1-9]\d*$　　 //匹配正浮点数

^-([1-9]\d*\.\d* |0\.\d*[1-9]\d*)$　 //匹配负浮点数

^-?([1-9]\d*\.\d* |0\.\d*[1-9]\d* |0?\.0+ |0)$　 //匹配浮点数

^[1-9]\d*\.\d* |0\.\d*[1-9]\d* |0?\.0+ |0$　　 //匹配非负浮点数（正浮点数 + 0）

^(-([1-9]\d*\.\d* |0\.\d*[1-9]\d*)) |0?\.0+ |0$　　//匹配非正浮点数（负浮点数 + 0）

评注：处理大量数据时有用，具体应用时注意修正

匹配特定字符串：

^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串

^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串

^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串

^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串

^\w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串

/**

 * 将数组转成字符串在调试或记录日志时用到

 *

 * @param array

 * @return

 */

 public static String byte2string(byte[] array) {

 StringBuilder sb = new StringBuilder();

 sb.append("Length " + array.length + " Content ");

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

 sb = sb.append(String.format("%02X", array)).append(":");

 }

 int ind = sb.lastIndexOf(":");

 sb.delete(ind, ind + 1);

 return sb.toString();

 }

import java.util.Arrays;

import java.util.Random;

/**

* <code>RandomUtil</code> - Random Tool Class.

* @author SageZk

* @version 1.0

*/

public class RandomUtil {

 private RandomUtil() {}

 private static Random rnd = null;

 /**

 * 初始化随机数发生器。

 */

 private static void initRnd() {

 if (rnd == null) rnd = new Random();

 }

 /**

 * 计算并返回无重复值的以 <code>min</code> 为下限 <code>max</code> 为上限的随机整数数组。

 * @param min 随机整数下限（包含）

 * @param max 随机整数上限（包含）

 * @param len 结果数组长度

 * @return 结果数组

 */

 public static int[] getLotteryArray(int min, int max, int len) {

 //参数校验及性能优化

 if (len < 0) return null; //长度小于 0 的数组不存在

 if (len == 0) return new int[0]; //返回长度为 0 的数组

 if (min > max) { //校正参数 min max

 int t = min;

 min = max;

 max = t;

 }

 final int LEN = max - min + 1; //种子个数

 if (len > LEN) return null; //如果出现 35 选 36 的情况就返回 null

 //计算无重复值随机数组

 initRnd(); //初始化随机数发生器

 int[] seed = new int[LEN]; //种子数组

 for (int i = 0, n = min; i < LEN;) seed[i++] = n++; //初始化种子数组

 for (int i = 0, j = 0, t = 0; i < len; ++i) {

 j = rnd.nextInt(LEN - i) + i;

 t = seed;

 seed = seed[j];

 seed[j] = t;

 }

 return Arrays.copyOf(seed, len); //注意：copyOf 需要 JRE1.6

 }

 //Unit Testing

 public static void main(String[] args) {

 final int N = 10000; //测试次数

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

 int[] la = RandomUtil.getLotteryArray(1, 35, 7);

 if (la == null) continue;

 for (int v : la) System.out.printf("%0$02d ", v);

 System.out.println();

 }

 }

}

/*

操作属性文件，可以为我们的程序带来更方便的移植性，下面是一个示例，可以读、写、更改属性

读采用了两种方式，一种是采用Properties类，另外一种是采用资源绑定类ResourceBundle类，

下面是源程序，里面有详细的注释：

*/

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.util.Properties;

import java.util.ResourceBundle;

/**

*对属性文件（xx.properties）的操作

*注：属性文件一定要放在当前工程的根目录下，也就是放在与src目录在同一个目录下（我的JDevelop

*是这样的）

*/

public class OperatePropertiesFile {

 public OperatePropertiesFile() {

 }

 /**

 *采用Properties类取得属性文件对应值

 *@parampropertiesFileNameproperties文件名，如a.properties

 *@parampropertyName属性名

 *@return根据属性名得到的属性值，如没有返回""

 */

 public static String getValueByPropertyName(String propertiesFileName,String propertyName) {

 String s="";

 Properties p=new Properties();//加载属性文件读取类

 FileInputStream in;

 try {

 //propertiesFileName如test.properties

 in = new FileInputStream(propertiesFileName);//以流的形式读入属性文件

 p.load(in);//属性文件将该流加入的可被读取的属性中

 in.close();//读完了关闭

 s=p.getProperty(propertyName);//取得对应的属性值

 } catch (Exception e) {

 e.printStackTrace();

 }

 return s;

 }

 /**

 *采用ResourceBundel类取得属性文件对应值，这个只能够读取，不可以更改及写新的属性

 *@parampropertiesFileNameWithoutPostfixproperties文件名，不带后缀

 *@parampropertyName属性名

 *@return根据属性名得到的属性值，如没有返回""

 */

 public static String getValueByPropertyName_(String propertiesFileNameWithoutPostfix,String propertyName) {

 String s="";

 //如属性文件是test.properties，那此时propertiesFileNameWithoutPostfix的值就是test

 ResourceBundle bundel = ResourceBundle.getBundle(propertiesFileNameWithoutPostfix);

 s=bundel.getString(propertyName);

 return s;

 }

 /**

 *更改属性文件的值，如果对应的属性不存在，则自动增加该属性

 *@parampropertiesFileNameproperties文件名，如a.properties

 *@parampropertyName属性名

 *@parampropertyValue将属性名更改成该属性值

 *@return是否操作成功

 */

 public static boolean changeValueByPropertyName(String propertiesFileName,String propertyName,String propertyValue) {

 boolean writeOK=true;

 Properties p=new Properties();

 InputStream in;

 try {

 in = new FileInputStream(propertiesFileName);

 p.load(in);//

 in.close();

 p.setProperty(propertyName,propertyValue);//设置属性值，如不属性不存在新建

 //p.setProperty("testProperty","testPropertyValue");

 FileOutputStream out=new FileOutputStream(propertiesFileName);//输出流

 p.store(out,"");//设置属性头，如不想设置，请把后面一个用""替换掉

 out.flush();//清空缓存，写入磁盘

 out.close();//关闭输出流

 } catch (Exception e) {

 e.printStackTrace();

 }

 return writeOK;

 }

}

/**

 * 如果是null，则返回空字符串，如果是非空值则返回该字符串头尾不为空白字符的字符串

 *

 * @param str

 */

 public static String toNoNullTrimedString(String str) {

 if (str == null) {

 return "";

 }

 return new String(str.trim());

 }

 /**

 * 如果是null，则返回空字符串，如果是非空值则返回该对象所toString后的字符串

 *

 * @param obj

 */

 public static String toNoNullString(Object obj) {

 if (obj == null)

 return "";

 return obj.toString();

 }

 /**

 * 本方法把一个Throwable的StackTrace作为一个字符串输出，以利于对StackTrace的操作。 

 * 通常用于把抛出的Exception转化成字符串进行后续操作。

 */

 public static String exceptionToStackTrace(Throwable throwable) {

 StringBuffer retu = new StringBuffer();

 StackTraceElement[] traces = throwable.getStackTrace();

 for (StackTraceElement ste : traces) {

 retu.append("\n").append(ste.toString());

 }

 return retu.substring(1);

 }

package com.sipgl.eam.utils;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.LinkedHashMap;

/**

* 日期公用处理类

*

* @author SongJun

* @version 1.3

*/

public class DateUtil {

 /**

 * 解析一个日期之间的所有月份

 *

 * @param beginDateStr

 * @param endDateStr

 * @return

 */

 public static ArrayList getMonthList(String beginDateStr, String endDateStr) {

 // 指定要解析的时间格式

 SimpleDateFormat f = new SimpleDateFormat("yyyy-MM");

 // 返回的月份列表

 String sRet = "";

 // 定义一些变量

 Date beginDate = null;

 Date endDate = null;

 GregorianCalendar beginGC = null;

 GregorianCalendar endGC = null;

 ArrayList list = new ArrayList();

 try {

 // 将字符串parse成日期

 beginDate = f.parse(beginDateStr);

 endDate = f.parse(endDateStr);

 // 设置日历

 beginGC = new GregorianCalendar();

 beginGC.setTime(beginDate);

 endGC = new GregorianCalendar();

 endGC.setTime(endDate);

 // 直到两个时间相同

 while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {

 sRet = beginGC.get(Calendar.YEAR) + "-"

 + (beginGC.get(Calendar.MONTH) + 1);

 list.add(sRet);

 // 以月为单位，增加时间

 beginGC.add(Calendar.MONTH, 1);

 }

 return list;

 } catch (Exception e) {

 e.printStackTrace();

 return null;

 }

 }

 /**

 * 解析一个日期段之间的所有日期

 *

 * @param beginDateStr

 * 开始日期

 * @param endDateStr

 * 结束日期

 * @return

 */

 public static ArrayList getDayList(String beginDateStr, String endDateStr) {

 // 指定要解析的时间格式

 SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");

 // 定义一些变量

 Date beginDate = null;

 Date endDate = null;

 Calendar beginGC = null;

 Calendar endGC = null;

 ArrayList list = new ArrayList();

 try {

 // 将字符串parse成日期

 beginDate = f.parse(beginDateStr);

 endDate = f.parse(endDateStr);

 // 设置日历

 beginGC = Calendar.getInstance();

 beginGC.setTime(beginDate);

 endGC = Calendar.getInstance();

 endGC.setTime(endDate);

 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

 // 直到两个时间相同

 while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {

 list.add(sdf.format(beginGC.getTime()));

 // 以日为单位，增加时间

 beginGC.add(Calendar.DAY_OF_MONTH, 1);

 }

 return list;

 } catch (Exception e) {

 e.printStackTrace();

 return null;

 }

 }

 public static ArrayList getYearList() {

 ArrayList list = new ArrayList();

 Calendar c = null;

 c = Calendar.getInstance();

 c.setTime(new Date());

 int currYear = Calendar.getInstance().get(Calendar.YEAR);

 int startYear = currYear - 5;

 int endYear = currYear + 10;

 for (int i = startYear; i < endYear; i++) {

 list.add(new Integer(i));

 }

 return list;

 }

 public static int getCurrYear() {

 return Calendar.getInstance().get(Calendar.YEAR);

 }

 /**

 * 得到某一年周的总数

 *

 * @param year

 * @return

 */

 public static LinkedHashMap getWeekList(int year) {

 LinkedHashMap map = new LinkedHashMap();

 Calendar c = new GregorianCalendar();

 c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);

 int count = getWeekOfYear(c.getTime());

 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

 String dayOfWeekStart = "";

 String dayOfWeekEnd = "";

 for (int i = 1; i <= count; i++) {

 dayOfWeekStart = sdf.format(getFirstDayOfWeek(year, i));

 dayOfWeekEnd = sdf.format(getLastDayOfWeek(year, i));

 map.put(new Integer(i), "第"+i+"周(从"+dayOfWeekStart + "至" + dayOfWeekEnd+")");

 }

 return map;

 }

 /**

 * 得到一年的总周数

 * @param year

 * @return

 */

 public static int getWeekCountInYear(int year){

 Calendar c = new GregorianCalendar();

 c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);

 int count = getWeekOfYear(c.getTime());

 return count;

 }

 /**

 * 取得当前日期是多少周

 *

 * @param date

 * @return

 */

 public static int getWeekOfYear(Date date) {

 Calendar c = new GregorianCalendar();

 c.setFirstDayOfWeek(Calendar.MONDAY);

 c.setMinimalDaysInFirstWeek(7);

 c.setTime(date);

 return c.get(Calendar.WEEK_OF_YEAR);

 }

 /**

 * 得到某年某周的第一天

 *

 * @param year

 * @param week

 * @return

 */

 public static Date getFirstDayOfWeek(int year, int week) {

 Calendar c = new GregorianCalendar();

 c.set(Calendar.YEAR, year);

 c.set(Calendar.MONTH, Calendar.JANUARY);

 c.set(Calendar.DATE, 1);

 Calendar cal = (GregorianCalendar) c.clone();

 cal.add(Calendar.DATE, week * 7);

 return getFirstDayOfWeek(cal.getTime());

 }

 /**

 * 得到某年某周的最后一天

 *

 * @param year

 * @param week

 * @return

 */

 public static Date getLastDayOfWeek(int year, int week) {

 Calendar c = new GregorianCalendar();

 c.set(Calendar.YEAR, year);

 c.set(Calendar.MONTH, Calendar.JANUARY);

 c.set(Calendar.DATE, 1);

 Calendar cal = (GregorianCalendar) c.clone();

 cal.add(Calendar.DATE, week * 7);

 return getLastDayOfWeek(cal.getTime());

 }

 /**

 * 得到某年某月的第一天

 * @param year

 * @param month

 * @return

 */

 public static Date getFirestDayOfMonth(int year,int month){

 month = month-1;

 Calendar c = Calendar.getInstance();

 c.set(Calendar.YEAR, year);

 c.set(Calendar.MONTH, month);

 int day = c.getActualMinimum(c.DAY_OF_MONTH);

 c.set(Calendar.DAY_OF_MONTH, day);

 return c.getTime();

 }

 /**

 * 提到某年某月的最后一天

 * @param year

 * @param month

 * @return

 */

 public static Date getLastDayOfMonth(int year,int month){

 month = month-1;

 Calendar c = Calendar.getInstance();

 c.set(Calendar.YEAR, year);

 c.set(Calendar.MONTH, month);

 int day = c.getActualMaximum(c.DAY_OF_MONTH);

 c.set(Calendar.DAY_OF_MONTH, day);

 return c.getTime();

 }

 /**

 * 取得当前日期所在周的第一天

 *

 * @param date

 * @return

 */

 public static Date getFirstDayOfWeek(Date date) {

 Calendar c = new GregorianCalendar();

 c.setFirstDayOfWeek(Calendar.MONDAY);

 c.setTime(date);

 c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday

 return c.getTime();

 }

 /**

 * 取得当前日期所在周的最后一天

 *

 * @param date

 * @return

 */

 public static Date getLastDayOfWeek(Date date) {

 Calendar c = new GregorianCalendar();

 c.setFirstDayOfWeek(Calendar.MONDAY);

 c.setTime(date);

 c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday

 return c.getTime();

 }

}

/**

 * 为RootPaneContainer组件添加键盘事件

 * @param rpc RootPaneContainer组件

 * @param action 需要执行的动作

 * @param keyName 键的名称

 * @param keyCode 键的数字代码

 * @param modifiers 任意修饰符的按位或组合

 */

 public static void registerKeyEvent(RootPaneContainer rpc, Action action, String keyName, int keyCode, int modifiers)

 {

 JRootPane rp = rpc.getRootPane();

 InputMap inputMap = rp.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);

 inputMap.put(KeyStroke.getKeyStroke(keyCode, modifiers), keyName);

 rp.getActionMap().put(keyName, action);

 }

// 判断一个文件是否为二进制文件

public static boolean isBinary(File file) {

boolean isBinary = false;

try {

FileInputStream fin = new FileInputStream(file);

long len = file.length();

 for (int j = 0; j < (int) len; j++) {

int t = fin.read();

if (t < 32 && t != 9 && t != 10 && t != 13) {

isBinary = true;

break;

}

}

} catch (Exception e) {

e.printStackTrace();

}

return isBinary;

}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航