Android 工具类收集(持续更新...)

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.net.URLEncoder;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONTokener;

import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.LinearGradient;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.PorterDuff.Mode;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.Shader.TileMode;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.os.Build;
import android.telephony.TelephonyManager;
import android.util.Base64;
import android.util.Log;

/**
 * 工具类集
 * 
 * @ClassName: Tools
 * @Description: TODO
 * @author Lijc
 * @date 2015年2月9日 下午1:34:38
 *
 */
public class Tools {
	/**
	 * String 工具类
	 * 
	 * @ClassName: StrTools
	 * @Description: TODO
	 * @author Lijc
	 * @date 2015年2月9日 下午1:40:16
	 *
	 */
	public static class T_String {
		/**
		 * String 是否为null
		 * 
		 * @Title: isNull
		 * @Description: TODO
		 * @param @param str
		 * @param @return
		 * @return boolean true==为空 false==不为空
		 * @throws
		 */
		public static boolean isNull(String string) {
			if (null == string || "".equals(string) || "null".equals(string)
					|| "NULL".equals(string) || "Null".equals(string)) {
				return true;
			} else {
				return false;
			}
		}

		/**
		 * 手机号
		 * 
		 * @Title: IsHandset
		 * @Description: TODO
		 * @param @param str
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		public static boolean IsPhoneNum(String str) {
			String regex = "^(13|15|18|14)[0-9]\\d{8}$";
			return match(regex, str);
		}

		/**
		 * 数字或字母
		 * 
		 * @Title: IsNumOrLetter
		 * @Description: TODO
		 * @param @param str
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		public static boolean IsNumOrLetter(String str) {
			String regex = "^[A-Za-z0-9]{6}$";
			return match(regex, str);
		}

		/**
		 * 邮箱
		 * 
		 * @Title: IsEmail
		 * @Description: TODO
		 * @param @param email
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		public static boolean IsEmail(String str) {
			String regex = "^([a-zA-Z0-9]*[-_]?[a-zA-Z0-9]+)*@([a-zA-Z0-9]*[-_]?[a-zA-Z0-9]+)+[\\.][A-Za-z]{2,3}([\\.][A-Za-z]{2})?$";
			return match(regex, str);
		}

		/**
		 * 全数字
		 * 
		 * @Title: IsAllNum
		 * @Description: TODO
		 * @param @param username
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		public static boolean IsAllNum(String str) {
			String regex = "\\d*";
			return match(regex, str);
		}

		/**
		 * 
		 * @Title: match
		 * @Description: TODO
		 * @param @param regex
		 * @param @param str
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		private static boolean match(String regex, String str) {
			Pattern pattern = Pattern.compile(regex);
			Matcher matcher = pattern.matcher(str);
			return matcher.matches();
		}

		/**
		 * 转换为内存容量
		 * 
		 * @Title: prettyBytes
		 * @Description: TODO 如：21MB
		 * @param @param value
		 * @param @return
		 * @return String
		 * @throws
		 */
		public static String prettyBytes(long value) {
			String args[] = { "B", "KB", "MB", "GB", "TB" };
			StringBuilder sb = new StringBuilder();
			int i;
			if (value < 1024L) {
				sb.append(String.valueOf(value));
				i = 0;
			} else if (value < 1048576L) {
				sb.append(String.format("%.1f", value / 1024.0));
				i = 1;
			} else if (value < 1073741824L) {
				sb.append(String.format("%.2f", value / 1048576.0));
				i = 2;
			} else if (value < 1099511627776L) {
				sb.append(String.format("%.3f", value / 1073741824.0));
				i = 3;
			} else {
				sb.append(String.format("%.4f", value / 1099511627776.0));
				i = 4;
			}
			sb.append(' ');
			sb.append(args[i]);
			return sb.toString();
		}
		/**
		 * 字符转换为UTF-8
		* @Title: Str2UTF8 
		* @Description: TODO
		* @param @param str
		* @param @return
		* @return String
		* @throws
		 */
		public static String Str2UTF8(String str) {
			if (!isNull(str) && str.getBytes().length != str.length()) {
				try {
					return URLEncoder.encode(str, "UTF-8");
				} catch (UnsupportedEncodingException e) {
					throw new RuntimeException("UnsupportedEncodingException occurred. ", e);
				}
			}
			return str;
		}
		/**
		 * 
		* @Title: Str2UTF8 
		* @Description: TODO 如果失败 则返回默认值defultReturn
		* @param @param str
		* @param @param defultReturn
		* @param @return
		* @return String
		* @throws
		 */
		public static String Str2UTF8(String str, String defultReturn) {
			if (!isNull(str) && str.getBytes().length != str.length()) {
				try {
					return URLEncoder.encode(str, "UTF-8");
				} catch (UnsupportedEncodingException e) {
					return defultReturn;
				}
			}
			return str;
		}
	}

	/**
	 * Bitmap 工具类
	 * 
	 * @ClassName: T_Bitmap
	 * @Description: TODO
	 * @author Lijc
	 * @date 2015年2月9日 下午1:54:47
	 *
	 */
	public static class T_Bitmap {
		/**
		 * 缩放图片(Bitmap)
		 * 
		 * @Title: scaleImg
		 * @Description: TODO
		 * @param @param bm
		 * @param @param newWidth
		 * @param @param newHeight
		 * @param @return
		 * @return Bitmap
		 * @throws
		 */
		public static Bitmap zoom(Bitmap bm, int newWidth, int newHeight) {
			int width = bm.getWidth();
			int height = bm.getHeight();
			int newWidth1 = newWidth;
			int newHeight1 = newHeight;
			float scaleWidth = ((float) newWidth1) / width;
			float scaleHeight = ((float) newHeight1) / height;
			Matrix matrix = new Matrix();
			matrix.postScale(scaleWidth, scaleHeight);
			Bitmap newbm = Bitmap.createBitmap(bm, 0, 0, width, height, matrix,
					true);
			return newbm;
		}

		/**
		 * 缩放图片(Drawable)
		 * 
		 * @Title: zoomDrawable
		 * @Description: TODO
		 * @param @param drawable
		 * @param @param w
		 * @param @param h
		 * @param @return
		 * @return Drawable
		 * @throws
		 */
		@SuppressWarnings("deprecation")
		public static Drawable zoom(Drawable drawable, int w, int h) {
			int width = drawable.getIntrinsicWidth();
			int height = drawable.getIntrinsicHeight();
			Bitmap oldbmp = drawableToBitmap(drawable); // drawable转换成bitmap
			Matrix matrix = new Matrix(); // 创建操作图片用的Matrix对象
			float scaleWidth = ((float) w / width); // 计算缩放比例
			float scaleHeight = ((float) h / height);
			matrix.postScale(scaleWidth, scaleHeight); // 设置缩放比例
			Bitmap newbmp = Bitmap.createBitmap(oldbmp, 0, 0, width, height,
					matrix, true); // 建立新的bitmap，其内容是对原bitmap的缩放后的图
			return new BitmapDrawable(newbmp); // 把bitmap转换成drawable并返回
		}

		/**
		 * Drawable 转为 Bitmap
		 * 
		 * @Title: drawableToBitmap
		 * @Description: TODO
		 * @param @param drawable
		 * @param @return
		 * @return Bitmap
		 * @throws
		 */
		public static Bitmap drawableToBitmap(Drawable drawable) {
			Bitmap bitmap = Bitmap
					.createBitmap(
							drawable.getIntrinsicWidth(),
							drawable.getIntrinsicHeight(),
							drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888
									: Bitmap.Config.RGB_565);
			Canvas canvas = new Canvas(bitmap);
			drawable.setBounds(0, 0, drawable.getIntrinsicWidth(),
					drawable.getIntrinsicHeight());
			drawable.draw(canvas);
			return bitmap;
		}

		/**
		 * Bitmap 转 Drawable
		 * 
		 * @Title: bitmap2Drawable
		 * @Description: TODO
		 * @param @param bitmap
		 * @param @return
		 * @return Drawable
		 * @throws
		 */
		@SuppressWarnings("deprecation")
		public static Drawable bitmap2Drawable(Bitmap bitmap) {
			Drawable drawable = new BitmapDrawable(bitmap);
			return drawable;
		}

		/**
		 * 图片创建倒影
		 * 
		 * @Title: createReflectedImage
		 * @Description: TODO
		 * @param @param originalImage
		 * @param @param number
		 * @param @return
		 * @return Bitmap
		 * @throws
		 */
		public static Bitmap createReflectedImage(Bitmap originalImage,
				int number) {
			final int reflectionGap = 0; // 倒影和原图片间的距离
			int width = originalImage.getWidth();
			int height = originalImage.getHeight();

			Matrix matrix = new Matrix();
			matrix.preScale(1, -1);

			double reflectHeight = number / 100.00;

			number = (int) (height * reflectHeight);
			// 倒影部分
			Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0,
					number, width, number, matrix, false);
			// 要返回的倒影图片
			Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
					(height + number), Config.ARGB_8888);

			Canvas canvas = new Canvas(bitmapWithReflection);
			// 画原来的图片
			canvas.drawBitmap(originalImage, 0, 0, null);

			// Paint defaultPaint = new Paint();
			// //倒影和原图片间的距离
			// canvas.drawRect(0, height, width, height + reflectionGap,
			// defaultPaint);
			// 画倒影部分
			canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);

			Paint paint = new Paint();
			LinearGradient shader = new LinearGradient(0,
					originalImage.getHeight(), 0,
					bitmapWithReflection.getHeight() + reflectionGap,
					0x70ffffff, 0x00ffffff, TileMode.MIRROR);
			paint.setShader(shader);
			paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
			canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
					+ reflectionGap, paint);
			return bitmapWithReflection;
		}

		/**
		 * 为图片增加边框
		 * 
		 * @Title: addFrame
		 * @Description: TODO
		 * @param @param bitmap
		 * @param @param color
		 * @param @return
		 * @return Bitmap
		 * @throws
		 */
		public static Bitmap addFrame(Bitmap bitmap, int color) {
			Bitmap bitmap2 = Bitmap.createBitmap(bitmap.getWidth(),
					bitmap.getHeight(), Config.ARGB_8888);
			Canvas canvas = new Canvas(bitmap2);
			Rect rect = canvas.getClipBounds();
			rect.bottom--;
			rect.right--;
			Paint recPaint = new Paint();
			recPaint.setColor(color);
			recPaint.setStyle(Paint.Style.STROKE);
			canvas.drawRect(rect, recPaint);
			canvas.drawBitmap(bitmap, 0, 0, null);
			return bitmap2;
		}

		/**
		 * 字节转图片
		 * 
		 * @Title: getBitmap
		 * @Description: TODO
		 * @param @param data
		 * @param @return
		 * @return Bitmap
		 * @throws
		 */
		public static Bitmap getBitmap(byte[] data) {
			return BitmapFactory.decodeByteArray(data, 0, data.length);
		}

		/**
		 * 图片转字节
		 * 
		 * @Title: getBytes
		 * @Description: TODO
		 * @param @param bitmap
		 * @param @return
		 * @return byte[]
		 * @throws
		 */
		public static byte[] getBytes(Bitmap bitmap) {
			ByteArrayOutputStream baops = new ByteArrayOutputStream();
			bitmap.compress(CompressFormat.PNG, 0, baops);
			return baops.toByteArray();
		}

		/**
		 * Bitmap转为Base64
		 * 
		 * @Title: bitmapToBase64
		 * @Description: TODO
		 * @param @param bitmap
		 * @param @return
		 * @return String
		 * @throws
		 */
		public static String bitmap2Base64(Bitmap bitmap) {
			String result = null;
			ByteArrayOutputStream baos = null;
			try {
				if (bitmap != null) {
					baos = new ByteArrayOutputStream();
					// 获得图片的宽高
					int width = bitmap.getWidth();
					int height = bitmap.getHeight();
					float scaleWidth = 0.5f;
					float scaleHeight = 0.5f;
					if (height >= width) {
						if (height >= 3000) {
							scaleWidth = 0.3f;
							scaleHeight = 0.3f;
						} else if (3000 > height && height > 2000) {
							scaleWidth = 0.5f;
							scaleHeight = 0.5f;
						} else if (2000 >= height && height >= 1000) {
							scaleWidth = 0.7f;
							scaleHeight = 0.7f;
						}
					} else {
						if (width >= 3000) {
							scaleWidth = 0.3f;
							scaleHeight = 0.3f;
						} else if (3000 > width && width > 2000) {
							scaleWidth = 0.5f;
							scaleHeight = 0.5f;
						} else if (2000 >= width && width >= 1000) {
							scaleWidth = 0.7f;
							scaleHeight = 0.7f;
						}
					}
					// 取得想要缩放的matrix参数
					Matrix matrix = new Matrix();
					matrix.postScale(scaleWidth, scaleHeight);
					// 得到新的图片后压缩进流中
					Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix,
							true)
							.compress(Bitmap.CompressFormat.JPEG, 50, baos);
					// bitmap.compress(Bitmap.CompressFormat.JPEG, 50, baos);
					baos.flush();
					baos.close();
					byte[] bitmapBytes = baos.toByteArray();
					result = Base64.encodeToString(bitmapBytes, Base64.DEFAULT);
				}
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				try {
					if (baos != null) {
						baos.flush();
						baos.close();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return result;
		}

		/**
		 * Base64转为Bitmap
		 * 
		 * @Title: base642Bitmap
		 * @Description: TODO
		 * @param @param base64Data
		 * @param @return
		 * @return Bitmap
		 * @throws
		 */
		public static Bitmap base642Bitmap(String base64Data) {
			byte[] bytes = Base64.decode(base64Data, Base64.DEFAULT);
			return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
		}

	}

	/**
	 * 网络工具类
	 * 
	 * @ClassName: T_Network
	 * @Description: TODO
	 * @author Lijc
	 * @date 2015年2月9日 下午2:09:58
	 *
	 */
	public static class T_Network {
		/**
		 * 检测手机是否开启GPRS网络,需要调用ConnectivityManager,TelephonyManager 服务.
		 * 
		 * @Title: checkGprsNetwork
		 * @Description: TODO
		 * @param @param context
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		public static boolean checkGprsNetwork(Context context) {
			boolean has = false;
			ConnectivityManager connectivity = (ConnectivityManager) context
					.getSystemService(Context.CONNECTIVITY_SERVICE);
			TelephonyManager mTelephony = (TelephonyManager) context
					.getSystemService(Context.TELEPHONY_SERVICE);
			NetworkInfo info = connectivity.getActiveNetworkInfo();
			int netType = info.getType();
			int netSubtype = info.getSubtype();
			if (netType == ConnectivityManager.TYPE_MOBILE
					&& netSubtype == TelephonyManager.NETWORK_TYPE_UMTS
					&& !mTelephony.isNetworkRoaming()) {
				has = info.isConnected();
			}
			return has;

		}

		/**
		 * 检测手机是否开启WIFI网络,需要调用ConnectivityManager服务.
		 * 
		 * @Title: checkWifiNetwork
		 * @Description: TODO
		 * @param @param context
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		@SuppressWarnings("unused")
		public static boolean checkWifiNetwork(Context context) {
			boolean has = false;
			ConnectivityManager connectivity = (ConnectivityManager) context
					.getSystemService(Context.CONNECTIVITY_SERVICE);
			NetworkInfo info = connectivity.getActiveNetworkInfo();
			int netType = info.getType();
			int netSubtype = info.getSubtype();
			if (netType == ConnectivityManager.TYPE_WIFI) {
				has = info.isConnected();
			}
			return has;
		}

		/**
		 * 检测当前手机是否联网
		 * 
		 * @Title: isNetworkAvailable
		 * @Description: TODO
		 * @param @param context
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		public static boolean isNetworkAvailable(Context context) {
			ConnectivityManager connectivity = (ConnectivityManager) context
					.getSystemService(Context.CONNECTIVITY_SERVICE);
			if (connectivity == null) {
				return false;
			} else {
				NetworkInfo[] info = connectivity.getAllNetworkInfo();
				if (info != null) {
					for (int i = 0; i < info.length; i++) {
						if (info[i].getState() == NetworkInfo.State.CONNECTED) {
							return true;
						}
					}
				}
			}
			return false;
		}

		/**
		 * 手机是否处在漫游
		 * 
		 * @Title: isNetworkRoaming
		 * @Description: TODO
		 * @param @param mCm
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		public static boolean isNetworkRoaming(Context c) {
			ConnectivityManager connectivity = (ConnectivityManager) c
					.getSystemService(Context.CONNECTIVITY_SERVICE);
			if (connectivity == null) {
				return false;
			}
			NetworkInfo info = connectivity.getActiveNetworkInfo();
			boolean isMobile = (info != null && info.getType() == ConnectivityManager.TYPE_MOBILE);
			TelephonyManager mTm = (TelephonyManager) c
					.getSystemService(Context.TELEPHONY_SERVICE);
			boolean isRoaming = isMobile && mTm.isNetworkRoaming();
			return isRoaming;
		}
	}

	/**
	 * Json工具类
	 * 
	 * @ClassName: T_Json
	 * @Description: TODO 可用于解析Json
	 * @author Lijc
	 * @date 2015年2月9日 下午2:28:04
	 *
	 */
	public static class T_Json {

		private static Map<Class<?>, ArrayList<fieldEntity>> method_map = new HashMap<Class<?>, ArrayList<fieldEntity>>();

		/**
		 * json字符串转换为bean
		 * 
		 * @Title: JsonToBean
		 * @Description: TODO
		 * @param @param clazz
		 * @param @param json
		 * @param @return
		 * @return T
		 * @throws
		 */
		@SuppressWarnings("unchecked")
		public static <T> T Json2Bean(Class<?> clazz, String json) {
			getMethod(clazz);
			T object = null;
			try {
				object = (T) Json2Bean(json, clazz.newInstance());
			} catch (Exception e) {
			}
			return object;
		}

		/**
		 * Json字符串转化为集合
		 * 
		 * @Title: JsonToCollection
		 * @Description: TODO
		 * @param @param str
		 * @param @return
		 * @return T
		 * @throws
		 */
		@SuppressWarnings("unchecked")
		public static <T> T JsonToCollection(String str) {
			T object = null;
			try {
				object = (T) Json2HashMap(str);
			} catch (Exception e) {
			}
			return object;
		}

		/**
		 * Json字符串转化为集合
		 * 
		 * @Title: Json2HashMap
		 * @Description: TODO
		 * @param @param str
		 * @param @return
		 * @return Object
		 * @throws
		 */
		private static Object Json2HashMap(String str) {
			LinkedHashMap<String, Object> json = new LinkedHashMap<String, Object>();
			try {
				Object object = new JSONTokener(str).nextValue();
				if (object instanceof JSONArray) {
					JSONArray root = new JSONArray(str);
					ArrayList<Object> list = new ArrayList<Object>();
					if (root.length() > 0) {
						for (int i = 0; i < root.length(); i++) {
							list.add(JsonToCollection(root.getString(i)));
						}
						return list;
					}
					return list.add(str);
				} else if (object instanceof JSONObject) {
					JSONObject root = new JSONObject(str);
					if (root.length() > 0) {
						@SuppressWarnings("unchecked")
						Iterator<String> rootName = root.keys();
						String name;
						while (rootName.hasNext()) {
							name = rootName.next();
							json.put(name,
									JsonToCollection(root.getString(name)));
						}
					}
					return json;
				} else {
					return str;
				}
			} catch (JSONException e) {
				T_Log.d("错误字符串：" + str);
				return str;
			}
		}

		/**
		 * Json转为对象
		 * 
		 * @Title: Json2Bean
		 * @Description: TODO
		 * @param @param str
		 * @param @param entity
		 * @param @return
		 * @return Object
		 * @throws
		 */
		@SuppressWarnings({ "unchecked", "rawtypes" })
		private static Object Json2Bean(String str, Object entity) {
			try {
				Object object = new JSONTokener(str).nextValue();
				if (object instanceof JSONArray) {
					JSONArray root = new JSONArray(str);
					if (root.length() > 0) {
						ArrayList<Object> list = new ArrayList<Object>();
						for (int i = 0; i < root.length(); i++) {
							Object value = new JSONTokener(root.getString(i))
									.nextValue();
							if (classes.contains(value.getClass())) {
								list.add(root.getString(i));
							} else {
								list.add(Json2Bean(root.getString(i), entity
										.getClass().newInstance()));
							}
						}
						return list;
					}
					T_Log.e("数组" + entity + "解析出错");
					return null;
				} else if (object instanceof JSONObject) {
					JSONObject root = new JSONObject(str);
					if (root.length() > 0) {
						Iterator<String> rootName = root.keys();
						String name;
						while (rootName.hasNext()) {
							name = rootName.next();
							boolean isHas = false;
							Class template = entity.getClass();
							while (template != null
									&& !classes.contains(template)) {
								ArrayList<fieldEntity> arrayList = method_map
										.get(template);
								for (fieldEntity fieldEntity : arrayList) {
									fieldEntity.field.setAccessible(true);
									Object obj = null;
									if (name.equals(fieldEntity.field.getName())) {
										isHas = true;
										if (fieldEntity.clazz == null) {
											Class clazz = fieldEntity.field
													.getType();
											if (clazz == String.class) {
												obj = root.getString(name);
											}
											if (clazz == int.class) {
												obj = root.getInt(name);
											}
											if (clazz == boolean.class) {
												obj = root.getBoolean(name);
											}
										} else {
											Object obj2 = new JSONTokener(
													root.getString(name))
													.nextValue();
											Class value_class = fieldEntity.field
													.getType();
											if (classes.contains(value_class)) {
												JSONArray array = (JSONArray) obj2;
												ArrayList<Object> list = new ArrayList<Object>();
												for (int i = 0; i < array
														.length(); i++) {
													if (fieldEntity.clazz == String.class) {
														obj = array.get(i)
																.toString();
													}
													if (fieldEntity.clazz == int.class) {
														obj = Integer
																.valueOf(array
																		.get(i)
																		.toString());
													}
													if (fieldEntity.clazz == boolean.class) {
														obj = Boolean
																.valueOf(array
																		.get(i)
																		.toString());
													}
													list.add(obj);
												}
												obj = list;
											} else {
												try {
													obj = Json2Bean(
															root.getString(name),
															fieldEntity.clazz
																	.newInstance());
												} catch (Exception e) {
													e.printStackTrace();
												}
											}
										}
										try {
											fieldEntity.field.set(entity, obj);
										} catch (Exception e) {
											e.printStackTrace();
										}
									}
								}
								template = template.getSuperclass();
							}

							if (!isHas) {
								T_Log.e("字段" + name + "在实体类" + entity + "不存在");
							}
						}
					} else {
						T_Log.e("数据长度不对 解析出错");
					}
					return entity;
				} else {
					return entity;
				}
			} catch (Exception e) {
				T_Log.d("错误字符串：" + str);
				return entity;
			}
		}

		@SuppressWarnings({ "rawtypes", "serial" })
		static HashSet<Class> classes = new HashSet<Class>() {
			{
				add(Object.class);
				add(Double.class);
				add(Float.class);
				add(Integer.class);
				add(Long.class);
				add(String.class);
				add(int.class);
				add(boolean.class);
			}
		};

		private static void getMethod(Class<?> clazz) {

			Class<?> template = clazz;
			while (template != null && template != Object.class) {
				if (method_map.get(template) != null
						&& method_map.get(template).size() > 0) {
					return;
				}
				template = template.getSuperclass();
			}
			template = clazz;
			while (template != null && !classes.contains(template)) {
				// -----------------------------------解析变量------------------------------------------------
				ArrayList<fieldEntity> entities = new ArrayList<fieldEntity>();
				for (Field m : template.getDeclaredFields()) {
					Type type = m.getGenericType();
					int modifiers = m.getModifiers();
					if (Modifier.isStatic(modifiers)) {
						continue;
					}
					if (type instanceof ParameterizedType) {
						Type[] types = ((ParameterizedType) type)
								.getActualTypeArguments();
						for (Type type2 : types) {
							if (!classes.contains(m.getType())) {
								getMethod((Class<?>) type2);
								entities.add(new fieldEntity(m,
										(Class<?>) type2));
							} else {
								entities.add(new fieldEntity(m, null));
							}
							break;
						}
						continue;
					}
					if (!classes.contains(m.getType())) {
						getMethod((Class<?>) type);
						entities.add(new fieldEntity(m, (Class<?>) type));
					} else {
						entities.add(new fieldEntity(m, null));
					}
				}
				method_map.put(template, entities);
				// -----------------------------------解析完毕------------------------------------------------
				template = template.getSuperclass();
			}
		}

		/**
		 * 解析内部类
		 * 
		 * @ClassName: fieldEntity
		 * @Description: TODO
		 * @author Lijc
		 * @date 2015年2月9日 下午2:24:16
		 *
		 */
		public static class fieldEntity {
			public Field field;
			public Class<?> clazz;

			public fieldEntity(Field field, Class<?> clazz) {
				this.field = field;
				this.clazz = clazz;
			}

			@Override
			public String toString() {
				return "fieldEntity [field=" + field.getName() + ", clazz="
						+ clazz + "]";
			}

		}
	}

	/**
	 * 日志工具类
	 * 
	 * @ClassName: T_Log
	 * @Description: TODO
	 * @author Lijc
	 * @date 2015年2月9日 下午2:21:50
	 *
	 */
	public static class T_Log {
		public static boolean isDebug = true;// 是否需要打印bug，可以在application的onCreate函数里面初始化
		private static final String TAG = "Tools_DeBug";

		/**
		 * Log.i
		 * 
		 * @Title: i
		 * @Description: TODO
		 * @param @param msg
		 * @return void
		 * @throws
		 */
		public static void i(String msg) {
			if (isDebug)
				Log.i(TAG, msg);
		}

		/**
		 * Log.d
		 * 
		 * @Title: d
		 * @Description: TODO
		 * @param @param msg
		 * @return void
		 * @throws
		 */
		public static void d(String msg) {
			if (isDebug)
				Log.d(TAG, msg);
		}

		/**
		 * Log.e
		 * 
		 * @Title: e
		 * @Description: TODO
		 * @param @param msg
		 * @return void
		 * @throws
		 */
		public static void e(String msg) {
			if (isDebug)
				Log.e(TAG, msg);
		}

		/**
		 * Log.v
		 * 
		 * @Title: v
		 * @Description: TODO
		 * @param @param msg
		 * @return void
		 * @throws
		 */
		public static void v(String msg) {
			if (isDebug)
				Log.v(TAG, msg);
		}

		/**
		 * Log.i
		 * 
		 * @Title: i
		 * @Description: TODO
		 * @param @param tag
		 * @param @param msg
		 * @return void
		 * @throws
		 */
		public static void i(String tag, String msg) {
			if (isDebug)
				Log.i(tag, msg);
		}

		/**
		 * Log.d
		 * 
		 * @Title: d
		 * @Description: TODO
		 * @param @param tag
		 * @param @param msg
		 * @return void
		 * @throws
		 */
		public static void d(String tag, String msg) {
			if (isDebug)
				Log.d(tag, msg);
		}

		/**
		 * Log.e
		 * 
		 * @Title: e
		 * @Description: TODO
		 * @param @param tag
		 * @param @param msg
		 * @return void
		 * @throws
		 */
		public static void e(String tag, String msg) {
			if (isDebug)
				Log.e(tag, msg);
		}

		/**
		 * Log.v
		 * 
		 * @Title: v
		 * @Description: TODO
		 * @param @param tag
		 * @param @param msg
		 * @return void
		 * @throws
		 */
		public static void v(String tag, String msg) {
			if (isDebug)
				Log.v(tag, msg);
		}
	}

	/**
	 * SharedPreferences工具类
	 * 
	 * @ClassName: T_Preferences
	 * @Description: TODO
	 * @author Lijc
	 * @date 2015年2月9日 下午2:41:43
	 *
	 */
	public static class T_Preferences {
		/**
		 * 保存在手机里面的文件名
		 */
		public static final String FILE_NAME = "share_data";

		/**
		 * 保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法
		 * 
		 * @param context
		 * @param key
		 * @param object
		 */
		public static void put(Context context, String key, Object object) {

			SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
					Context.MODE_PRIVATE);
			SharedPreferences.Editor editor = sp.edit();

			if (object instanceof String) {
				editor.putString(key, (String) object);
			} else if (object instanceof Integer) {
				editor.putInt(key, (Integer) object);
			} else if (object instanceof Boolean) {
				editor.putBoolean(key, (Boolean) object);
			} else if (object instanceof Float) {
				editor.putFloat(key, (Float) object);
			} else if (object instanceof Long) {
				editor.putLong(key, (Long) object);
			} else {
				editor.putString(key, object.toString());
			}

			SharedPreferencesCompat.apply(editor);
		}

		/**
		 * 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值
		 * 
		 * @param context
		 * @param key
		 * @param defaultObject
		 * @return
		 */
		public static Object get(Context context, String key,
				Object defaultObject) {
			SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
					Context.MODE_PRIVATE);

			if (defaultObject instanceof String) {
				return sp.getString(key, (String) defaultObject);
			} else if (defaultObject instanceof Integer) {
				return sp.getInt(key, (Integer) defaultObject);
			} else if (defaultObject instanceof Boolean) {
				return sp.getBoolean(key, (Boolean) defaultObject);
			} else if (defaultObject instanceof Float) {
				return sp.getFloat(key, (Float) defaultObject);
			} else if (defaultObject instanceof Long) {
				return sp.getLong(key, (Long) defaultObject);
			}

			return null;
		}

		/**
		 * 移除某个key值已经对应的值
		 * 
		 * @param context
		 * @param key
		 */
		public static void remove(Context context, String key) {
			SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
					Context.MODE_PRIVATE);
			SharedPreferences.Editor editor = sp.edit();
			editor.remove(key);
			SharedPreferencesCompat.apply(editor);
		}

		/**
		 * 清除所有数据
		 * 
		 * @param context
		 */
		public static void clear(Context context) {
			SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
					Context.MODE_PRIVATE);
			SharedPreferences.Editor editor = sp.edit();
			editor.clear();
			SharedPreferencesCompat.apply(editor);
		}

		/**
		 * 查询某个key是否已经存在
		 * 
		 * @param context
		 * @param key
		 * @return
		 */
		public static boolean contains(Context context, String key) {
			SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
					Context.MODE_PRIVATE);
			return sp.contains(key);
		}

		/**
		 * 返回所有的键值对
		 * 
		 * @param context
		 * @return
		 */
		public static Map<String, ?> getAll(Context context) {
			SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
					Context.MODE_PRIVATE);
			return sp.getAll();
		}

		/**
		 * 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类
		 * 
		 * @author zhy
		 * 
		 */
		private static class SharedPreferencesCompat {
			private static final Method sApplyMethod = findApplyMethod();

			/**
			 * 反射查找apply的方法
			 * 
			 * @return
			 */
			@SuppressWarnings({ "unchecked", "rawtypes" })
			private static Method findApplyMethod() {
				try {
					Class clz = SharedPreferences.Editor.class;
					return clz.getMethod("apply");
				} catch (NoSuchMethodException e) {
				}

				return null;
			}

			/**
			 * 如果找到则使用apply执行，否则使用commit
			 * 
			 * @param editor
			 */
			public static void apply(SharedPreferences.Editor editor) {
				try {
					if (sApplyMethod != null) {
						sApplyMethod.invoke(editor);
						return;
					}
				} catch (IllegalArgumentException e) {
				} catch (IllegalAccessException e) {
				} catch (InvocationTargetException e) {
				}
				editor.commit();
			}
		}
	}

	/**
	 * 系統相关工具类
	 * 
	 * @ClassName: T_System
	 * @Description: TODO
	 * @author Lijc
	 * @date 2015年2月9日 下午2:44:23
	 *
	 */
	public static class T_System {
		/**
		 * 获取应用程序名称
		 * 
		 * @Title: getAppName
		 * @Description: TODO
		 * @param @param context
		 * @param @return
		 * @return String
		 * @throws
		 */
		public static String getAppName(Context context) {
			try {
				PackageManager packageManager = context.getPackageManager();
				PackageInfo packageInfo = packageManager.getPackageInfo(
						context.getPackageName(), 0);
				int labelRes = packageInfo.applicationInfo.labelRes;
				return context.getResources().getString(labelRes);
			} catch (NameNotFoundException e) {
				e.printStackTrace();
			}
			return null;
		}

		/**
		 * 获取应用程序版本名称信息
		 * 
		 * @Title: getVersionName
		 * @Description: TODO
		 * @param @param context
		 * @param @return
		 * @return String
		 * @throws
		 */
		public static String getVersionName(Context context) {
			try {
				PackageManager packageManager = context.getPackageManager();
				PackageInfo packageInfo = packageManager.getPackageInfo(
						context.getPackageName(), 0);
				return packageInfo.versionName;

			} catch (NameNotFoundException e) {
				e.printStackTrace();
			}
			return null;
		}

		/**
		 * 获取应用程序版本号
		 * 
		 * @Title: getVersionCode
		 * @Description: TODO
		 * @param @param context
		 * @param @return
		 * @return int
		 * @throws
		 */
		public static int getVersionCode(Context context) {
			try {
				return context.getPackageManager().getPackageInfo(
						context.getPackageName(), 0).versionCode;
			} catch (NameNotFoundException e) {
				e.printStackTrace();
			}
			return -1;
		}

		/**
		 * 安裝APK
		 * 
		 * @Title: installApp
		 * @Description: TODO
		 * @param @param context
		 * @param @param downloadedApkPath
		 * @return void
		 * @throws
		 */
		public static void installApp(Context context, String apkPath) {
			Uri uri = Uri.fromFile(new File(apkPath));
			Intent intent = new Intent(Intent.ACTION_VIEW);
			intent.setDataAndType(uri, "applicationnd.android.package-archive");
			context.startActivity(intent);
		}

		/**
		 * 判断是否是模拟器
		 * 
		 * @Title: isEmulator
		 * @Description: TODO
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		public static boolean isEmulator() {
			return Build.MODEL.equals("sdk")
					|| Build.MODEL.equals("google_sdk");
		}

		/**
		 * 获取SDK版本
		 * 
		 * @Title: getSdkVersion
		 * @Description: TODO
		 * @param @return
		 * @return int
		 * @throws
		 */
		public static int getSdkVersion() {
			try {
				return Build.VERSION.class.getField("SDK_INT").getInt(null);
			} catch (Exception e) {
				T_Log.e(e.getMessage());
				return 3;
			}
		}

		/**
		 * 去应用市场给软件评分
		 * 
		 * @Title: marketScore
		 * @Description: TODO
		 * @param @param c
		 * @return void
		 * @throws
		 */
		public static void marketScore(Context c) {
			String uriStr = "market://details?id=" + c.getPackageName();
			Uri uri = Uri.parse(uriStr);
			Intent intent = new Intent(Intent.ACTION_VIEW, uri);
			intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
			c.startActivity(intent);
		}

		/**
		 * 分享文本到第三方软件
		 * 
		 * @Title: shareText
		 * @Description: TODO
		 * @param @param c
		 * @param @param content
		 * @return void
		 * @throws
		 */
		public static void shareText(Context c, String content) {
			Intent sendIntent = new Intent();
			sendIntent.setAction(Intent.ACTION_SEND);
			sendIntent.setType("text/*");
			sendIntent.putExtra(Intent.EXTRA_TEXT, content);
			c.startActivity(sendIntent);
		}
	}

	/**
	 * 时间日期工具类
	 * 
	 * @ClassName: T_Date
	 * @Description: TODO
	 * @author Lijc
	 * @date 2015年2月10日 上午9:42:09
	 *
	 */
	public static class T_Date {
		public final static String FORMAT_DATE = "yyyy-MM-dd";
		public final static String FORMAT_TIME = "hh:mm";
		public final static String FORMAT_DATE_TIME = "yyyy-MM-dd hh:mm";
		public final static String FORMAT_MONTH_DAY_TIME = "MM月dd日 hh:mm";
		private static SimpleDateFormat sdf = new SimpleDateFormat();
		private static final int YEAR = 365 * 24 * 60 * 60;// 年
		private static final int MONTH = 30 * 24 * 60 * 60;// 月
		private static final int DAY = 24 * 60 * 60;// 天
		private static final int HOUR = 60 * 60;// 小时
		private static final int MINUTE = 60;// 分钟
		public static final String[] zodiacArr = { "猴", "鸡", "狗", "猪", "鼠",
				"牛", "虎", "兔", "龙", "蛇", "马", "羊" };

		/**
		 * 根据日期获取生肖
		 * 
		 * @Title: date2Zodica
		 * @Description: TODO
		 * @param @param time
		 * @param @return
		 * @return String
		 * @throws
		 */
		public static String date2Zodica(Calendar time) {
			return zodiacArr[time.get(Calendar.YEAR) % 12];
		}

		/**
		 * 根据生日获取星座
		 * 
		 * @Title: getAstro
		 * @Description: TODO
		 * @param @param birth
		 * @param @return
		 * @return String
		 * @throws
		 */
		public static String getAstro(String birth) {
			if (!isDate(birth)) {
				birth = "2000" + birth;
			}
			if (!isDate(birth)) {
				return "";
			}
			int month = Integer.parseInt(birth.substring(
					birth.indexOf("-") + 1, birth.lastIndexOf("-")));
			int day = Integer
					.parseInt(birth.substring(birth.lastIndexOf("-") + 1));
			String s = "魔羯水瓶双鱼牡羊金牛双子巨蟹狮子处女天秤天蝎射手魔羯";
			int[] arr = { 20, 19, 21, 21, 21, 22, 23, 23, 23, 23, 22, 22 };
			int start = month * 2 - (day < arr[month - 1] ? 2 : 0);
			return s.substring(start, start + 2) + "座";
		}

		/**
		 * 判断日期是否有效,包括闰年的情况
		 * 
		 * @Title: isDate
		 * @Description: TODO
		 * @param @param date
		 * @param @return
		 * @return boolean
		 * @throws
		 */
		public static boolean isDate(String date) {
			StringBuffer reg = new StringBuffer(
					"^((\\d{2}(([02468][048])|([13579][26]))-?((((0?");
			reg.append("[13578])|(1[02]))-?((0?[1-9])|([1-2][0-9])|(3[01])))");
			reg.append("|(((0?[469])|(11))-?((0?[1-9])|([1-2][0-9])|(30)))|");
			reg.append("(0?2-?((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][12");
			reg.append("35679])|([13579][01345789]))-?((((0?[13578])|(1[02]))");
			reg.append("-?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))");
			reg.append("-?((0?[1-9])|([1-2][0-9])|(30)))|(0?2-?((0?[");
			reg.append("1-9])|(1[0-9])|(2[0-8]))))))");
			Pattern p = Pattern.compile(reg.toString());
			return p.matcher(date).matches();
		}

		/**
		 * 根据时间戳获取描述性时间
		 * 
		 * @Title: getDescriptionTimeFromTimestamp
		 * @Description: TODO 如3分钟前，1天前
		 * @param @param timestamp 时间戳 单位为毫秒
		 * @param @return
		 * @return String 时间字符串
		 * @throws
		 */
		public static String getDescriptionTimeFromTimestamp(long timestamp) {
			long currentTime = System.currentTimeMillis();
			long timeGap = (currentTime - timestamp) / 1000;// 与现在时间相差秒数
			System.out.println("timeGap: " + timeGap);
			String timeStr = null;
			if (timeGap > YEAR) {
				timeStr = timeGap / YEAR + "年前";
			} else if (timeGap > MONTH) {
				timeStr = timeGap / MONTH + "个月前";
			} else if (timeGap > DAY) {// 1天以上
				timeStr = timeGap / DAY + "天前";
			} else if (timeGap > HOUR) {// 1小时-24小时
				timeStr = timeGap / HOUR + "小时前";
			} else if (timeGap > MINUTE) {// 1分钟-59分钟
				timeStr = timeGap / MINUTE + "分钟前";
			} else {// 1秒钟-59秒钟
				timeStr = "刚刚";
			}
			return timeStr;
		}

		/**
		 * 距离截止日期还有多长时间
		 * 
		 * @Title: fromDeadline
		 * @Description: TODO
		 * @param @param date 截至日期
		 * @param @return
		 * @return String
		 * @throws
		 */
		public static String fromDeadline(Date date) {
			long deadline = date.getTime() / 1000;
			long now = (new Date().getTime()) / 1000;
			long remain = deadline - now;
			if (remain <= HOUR)
				return "只剩下" + remain / MINUTE + "分钟";
			else if (remain <= DAY)
				return "只剩下" + remain / HOUR + "小时" + (remain % HOUR / MINUTE)
						+ "分钟";
			else {
				long day = remain / DAY;
				long hour = remain % DAY / HOUR;
				long minute = remain % DAY % HOUR / MINUTE;
				return "只剩下" + day + "天" + hour + "小时" + minute + "分钟";
			}

		}

		/**
		 * 根据时间戳获取指定格式的时间
		 * 
		 * @Title: getFormatTimeFromTimestamp
		 * @Description: TODO 如2011-11-30 08:40
		 * @param @param timestamp 时间戳 单位为毫秒
		 * @param @param format 指定格式 如果为null或空串则使用默认格式"yyyy-MM-dd HH:MM"
		 * @param @return
		 * @return String 时间字符串
		 * @throws
		 */
		public static String getFormatTimeFromTimestamp(long timestamp,
				String format) {
			if (format == null || format.trim().equals("")) {
				sdf.applyPattern(FORMAT_DATE);
				int currentYear = Calendar.getInstance().get(Calendar.YEAR);
				int year = Integer.valueOf(sdf.format(new Date(timestamp))
						.substring(0, 4));
				System.out.println("currentYear: " + currentYear);
				System.out.println("year: " + year);
				if (currentYear == year) {// 如果为今年则不显示年份
					sdf.applyPattern(FORMAT_MONTH_DAY_TIME);
				} else {
					sdf.applyPattern(FORMAT_DATE_TIME);
				}
			} else {
				sdf.applyPattern(format);
			}
			Date date = new Date(timestamp);
			return sdf.format(date);
		}

		/**
		 * 根据时间戳获取时间字符串，并根据指定的时间分割数partionSeconds来自动判断返回描述性时间还是指定格式的时间
		 * 
		 * @Title: getMixTimeFromTimestamp
		 * @Description: TODO
		 * @param @param timestamp 时间戳 单位是毫秒
		 * @param @param partionSeconds
		 *        时间分割线，当现在时间与指定的时间戳的秒数差大于这个分割线时则返回指定格式时间，否则返回描述性时间
		 * @param @param format
		 * @param @return
		 * @return String
		 * @throws
		 */
		public static String getMixTimeFromTimestamp(long timestamp,
				long partionSeconds, String format) {
			long currentTime = System.currentTimeMillis();
			long timeGap = (currentTime - timestamp) / 1000;// 与现在时间相差秒数
			if (timeGap <= partionSeconds) {
				return getDescriptionTimeFromTimestamp(timestamp);
			} else {
				return getFormatTimeFromTimestamp(timestamp, format);
			}
		}

		/**
		 * 获取当前日期的指定格式的字符串
		 * 
		 * @Title: getCurrentTime
		 * @Description: TODO
		 * @param @param format 指定的日期时间格式，若为null或""则使用指定的格式"yyyy-MM-dd HH:MM"
		 * @param @return
		 * @return String
		 * @throws
		 */
		public static String getCurrentTime(String format) {
			if (format == null || format.trim().equals("")) {
				sdf.applyPattern(FORMAT_DATE_TIME);
			} else {
				sdf.applyPattern(format);
			}
			return sdf.format(new Date());
		}

		/**
		 * 将日期字符串以指定格式转换为Date
		 * 
		 * @Title: getTimeFromString
		 * @Description: TODO
		 * @param @param timeStr 日期字符串
		 * @param @param format 指定的日期格式，若为null或""则使用指定的格式"yyyy-MM-dd HH:MM"
		 * @param @return
		 * @return Date
		 * @throws
		 */
		public static Date getTimeFromString(String timeStr, String format) {
			if (format == null || format.trim().equals("")) {
				sdf.applyPattern(FORMAT_DATE_TIME);
			} else {
				sdf.applyPattern(format);
			}
			try {
				return sdf.parse(timeStr);
			} catch (ParseException e) {
				return new Date();
			}
		}

		/**
		 * 将Date以指定格式转换为日期时间字符串
		 * 
		 * @Title: getStringFromTime
		 * @Description: TODO
		 * @param @param time 日期
		 * @param @param format 指定的日期时间格式，若为null或""则使用指定的格式"yyyy-MM-dd HH:MM"
		 * @param @return
		 * @return String
		 * @throws
		 */
		public static String getStringFromTime(Date time, String format) {
			if (format == null || format.trim().equals("")) {
				sdf.applyPattern(FORMAT_DATE_TIME);
			} else {
				sdf.applyPattern(format);
			}
			return sdf.format(time);
		}
	}

}

更新时间：2015/2/10