Java中一些常用的代码

总结一下最近程序中用到的代码吧，大部分不是自己写的，放到这里，备份一下，以后忘记了来看一下；

 //正则表达式验证手机号
	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