总结一下最近程序中用到的代码吧，大部分不是自己写的，放到这里，备份一下，以后忘记了来看一下；
//正则表达式验证手机号
public static void phoneTest(String phone) {
/**
* 目前移动、联通、电信三大运营商的手机号段如下：
* 1、移动号段有: 134,135,136,137,138,139,147,150,151,152,157,158,159,178,182,183,184,187,188;
* 2、联通号段有: 130,131,132,155,156,185,186,145,176;
* 3、电信号段有: 133,153,177,180,181,189;
* 4、 170号段为虚拟运营商专属号段，170号段的11位手机号前四位来区分基础运营商，其中 "1700" 为中国电信，"1705" 为中国移动，"1709" 为中国联通;
*/
Pattern pattern = Pattern
.compile("^((13[0-9])|(15[^4,\\D])|(14[5,7])|(17[0,6-8])|(18[0-9]))\\d{8}$");
Matcher matcher = pattern.matcher(phone); if (matcher.find()) {
System.out.println("your phone number is right: " + phone);
} }
//正则表达式验证邮箱
public static void mailTest(String mail) {
/**
* 合法E-mail地址：
* 1. 必须包含一个并且只有一个符号"@"
* 2. 第一个字符不得是"@"或者"."
* 3. 不允许出现"@."或者".@"
* 4. 结尾不得是字符"@"或者"."
* 5. 允许"@"前的字符中出现"＋"
* 6. 不允许"＋"在最前面，或者"＋@"
*/
Pattern pattern = Pattern
.compile("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");
Matcher matcher = pattern.matcher(mail);
if (matcher.find()) {
System.out.println("your email is right: " + mail);
} }
/**
* 随机选取集合里的一个数字
*
*/ // 集合是List类型
public static int getList(List<Integer> list) {
int number = list.get((int) (Math.random() * list.size()));
return number;
} // 集合是Set类型
public static int getSet(Set<Integer> set) {
Object[] object = set.toArray();
int number = (int) object[(int) (Math.random() * object.length)];
return number;
}
/*
* 查找字符串中子字符串的个数
*/
private static int number = 0; public static int stringNumbers(String str) {
if (str.indexOf("java") == -1) {
return 0;
} else {
number++;
stringNumbers(str.substring(str.indexOf("java") + 4));
return number;
}
} // 也可以使用此种方式，但除了以下情况；
// 子字符串是一个首尾相同的字符串，且字符串最后没有空格；
// "java%%%%java****java %%%% java"
public static int stringNumber(String str) {
if (str.indexOf("java") != -1) {
String[] str1 = str.split("java");
return str1.length - 1;
} else {
return 0;
}
}
package test; import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination; /**
* 将中文解析为拼音
* 需要导入pinyin4j的jar包
*/
public class ChineseToPinyin { // 将中文转化为拼音
public static String getPinYin(String chinese)
throws BadHanyuPinyinOutputFormatCombination { // 首先需要创建格式化对象HanyuPinyinOutputFormat
HanyuPinyinOutputFormat outputFormat = new HanyuPinyinOutputFormat(); // 设置大小写格式
// outputFormat.setCaseType(HanyuPinyinCaseType);
// HanyuPinyinCaseType.LOWERCASE 转换后以全小写方式输出
// HanyuPinyinCaseType.UPPERCASE 转换后以全大写方式输出
outputFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE); // 方法参数HanyuPinyinToneType有以下常量对象：
// HanyuPinyinToneType.WITH_TONE_NUMBER 用数字表示声调，例如：zhao4
// HanyuPinyinToneType.WITHOUT_TONE 无声调表示，例如：zhao
// HanyuPinyinToneType.WITH_TONE_MARK 用声调符号表示，例如：zhao
outputFormat.setToneType(HanyuPinyinToneType.WITH_TONE_NUMBER); // 方法参数HanyuPinyinVCharType有以下常量对象：
// HanyuPinyinVCharType.WITH_U_AND_COLON 以U和一个冒号表示该拼音，
// HanyuPinyinVCharType.WITH_V 以V表示该字符，
// HanyuPinyinVCharType.WITH_U_UNICODE
outputFormat.setVCharType(HanyuPinyinVCharType.WITH_U_AND_COLON); StringBuffer buffer = new StringBuffer();
for (Character c : chinese.toCharArray()) {
buffer.append(PinyinHelper
.toHanyuPinyinStringArray(c, outputFormat)[0]);
buffer.append(" ");
}
return buffer.toString().substring(0, buffer.length() - 1);
} public static void main(String[] args)
throws BadHanyuPinyinOutputFormatCombination {
String s = "我们都是中国人";
System.out.println(s);
String pinYin = getPinYin(s);
System.out.println(pinYin);
}
}
package test; import java.util.regex.Matcher;
import java.util.regex.Pattern; public class StringConvert { // 正则表达式匹配字符串，不区分大小写
public static void ignore(String string) {
Pattern p = Pattern.compile("great", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(string);
while (m.find()) {
System.out.println(m.group());
}
} /*
* 在字符串中使用
* 与Pattern.CASE_INSENSITIVE对应的表达式是(?i)
* 它有四种形式： (?i) (?-i) (?i:X) (?-i:X) 不带有 - 的是开标志，带有 - 的是关标志。
* 具体实现可看API
*/
public static void stringIgnore(String string) {
String regex = "(?i)great";
System.out.println(string.matches(regex));
} // 如： 将字符串中的某一个子字符串转换为特定的字符串
public static String replace(String source, String str) {
return source.replaceAll("(?i)" + str, str);
} public static void main(String[] args) {
String string = "you are greaT, you are GrEat,you are GREAt";
string = replace(string, "great");
System.out.println(string);
}
}
import java.lang.reflect.Field; import test.EntityTest; /**
* 利用反射获取类的属性值（包括私有属性）
*
*/
public class TestReflect {
public static void main(String[] args) throws Exception {
getFields(EntityTest.class);
System.out.println("-----------");
getField(EntityTest.class);
} // 获取所有的属性值
public static void getFields(Class<?> className) throws Exception { Class<?> cls = Class.forName(className.getName());
// 得到className类所有的属性（包括私有属性）
Field fields[] = cls.getDeclaredFields();
String[] name = new String[fields.length];
Object os = cls.newInstance();
// 该方法表示取消java语言访问检查
Field.setAccessible(fields, true);
for (int i = 0; i < name.length; i++) {
name[i] = fields[i].getName();
System.out.println(name[i] + ":" + fields[i].get(os));
}
} // 获取某个属性值
public static void getField(Class<?> className) throws Exception { Class<?> cls = Class.forName(className.getName());
Object obj = cls.newInstance();
Field field = cls.getDeclaredField("name");
// 该方法表示取消java语言访问检查
field.setAccessible(true); // 为属性赋值
field.set(obj, "name"); Object object = field.get(obj);
System.out.println(object);
}
}
// 正则表达式 将多个斜杠 转换为一个
String url = "af///ddsf/sfsf//sf/d///ds////d////ds//////r";
url = url.replaceAll("/{2,}", "/");
System.out.println(url);
// 把一个字符串的第一个字母大写
public static String setFirstName(String name) {
char[] chars = name.toCharArray();
chars[0] -= 'a' - 'A';
return new String(chars);
}
/**
* 在Window或Linux系统下使用通用分割符来分割路径
*
* 在Windows系统下，Java程序获取到的路径分隔符是"\" ，转译之后就是"\\"
* 例如：通过"\"分割目录：c:\\xxxx\\xxxx\\ String[] tmp = test.split("\\\\");
*
* 在Linux系统下，Java程序获取到的路径分隔符是"/"，无需转义
* 例如：通过"/"分割目录：/xxxx/xxxx/xxxx/
*/ // 而该方法为通用方法，适用于Windows和Linux系统
String[] tmp = path.split(System.getProperty("file.separator"));
/**
* Json与对象的转换，使用google的GSON包来解析
*/ // 对象转换为Gson，包括List转JSON
public static String toJSON(Object object) {
// Gson gson = new GsonBuilder().disableHtmlEscaping().serializeNulls()
// .create();
Gson gson = new Gson();
String json = gson.toJson(object);
return json; } // Gson转换为对象
public static Object jsonToObject(String json) {
Gson gson = new Gson(); //Gson转换为 单一对象
EntityTest entityTest = gson.fromJson(json, EntityTest.class); //Gson转换为List对象
List<EntityTest> objList = gson.fromJson(json,
new TypeToken<List<EntityTest>>() {}.getType()); //Gson转换为Map对象
Map<String, EntityTest> entityTests = gson.fromJson(json,
new TypeToken<Map<String, EntityTest>>() {}.getType()); return objList;
}
/**
* 查找数据库中所有的表
* @param conn
*/
public void getTableNameByCon(Connection conn) {
try {
DatabaseMetaData meta = conn.getMetaData();
ResultSet rs = meta.getTables(null, null, null,
new String[] { "TABLE" });
while (rs.next()) {
System.out.println("表名：" + rs.getString("TABLE_NAME"));
System.out.println("表所属用户名：" + rs.getString(2));
System.out.println("------------------------------");
} } catch (Exception e) {
e.printStackTrace();
} finally {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry; //对map 使用value进行排序（value为int类型）
public class MapSorted { public static Map<String, Integer> solveMap(Map<String, Integer> map) {
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
ComparatorTest comparatorTest = new ComparatorTest();
ArrayList<Map.Entry<String, Integer>> entrys = new ArrayList<Map.Entry<String, Integer>>(
map.entrySet());
Collections.sort(entrys, comparatorTest); for (Map.Entry<String, Integer> entry : entrys) {
linkedHashMap.put(entry.getKey(), entry.getValue());
}
return linkedHashMap;
} static class ComparatorTest implements
Comparator<Map.Entry<String, Integer>> { public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
return o1.getValue().compareTo(o2.getValue());
}
} public static void main(String[] args) {
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("Lisi", 90);
map.put("Zhaoliu", 150);
map.put("Zhangsan", 40);
map.put("Wangwu", 120);
map = solveMap(map);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + " ----- " + entry.getValue());
}
}
}
// Java 获取当前时间前一个小时的时间
public static void beforeOneHourToNowDate() {
Calendar calendar = Calendar.getInstance();
// HOUR_OF_DAY 指示一天中的小时
calendar.set(Calendar.HOUR_OF_DAY,calendar.get(Calendar.HOUR_OF_DAY) - 1);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("当前的时间：" + df.format(new Date()));
System.out.println("一个小时前的时间：" + df.format(calendar.getTime()));
}
// 获取hibernate的实体类的主键名称
public String getPramaryName(Class entity) {
try {
Class<?> c = Class.forName(entity.getName());
Field[] fields = c.getDeclaredFields();
;
for (Field field : fields) {
field.isAnnotationPresent(Id.class);
String pkname = field.getName();
return pkname;
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
其中所需jar包地址：
汉字转化为拼音的jar包：汉字转化为拼音的jar包
json转换使用的google的json包：google-gson-21.-release