非常适用的转换：计算两点间的距离以及 byte数组转2进制字符串、转int等

package com.ysp.cyclingclub.utils;

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DecimalFormat;
import java.util.ArrayList;

public class MathUtils {

	private static double EARTH_RADIUS = 6378.137;// 地球半径 km

	private static double rad(double d) {
		return d * Math.PI / 180.0;
	}

	/**
	 * 通过坐标点计算两点间的距离
	 * 
	 * @param lat1
	 * @param lng1
	 * @param lat2
	 * @param lng2
	 * @return km
	 */
	public static double getDistance(double lat1, double lng1, double lat2,
			double lng2) {
		double radLat1 = rad(lat1);
		double radLat2 = rad(lat2);
		double a = radLat1 - radLat2;
		double b = rad(lng1) - rad(lng2);
		double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2)
				+ Math.cos(radLat1) * Math.cos(radLat2)
				* Math.pow(Math.sin(b / 2), 2)));
		s = s * EARTH_RADIUS;
		// s = Math.round(s * 10000) / 10000;
		return s;
	}

	public static ArrayList<String> getName(String s) {
		ArrayList<String> list = new ArrayList<String>();
		String[] str = s.split(" ");
		for (int i = 0; i < str.length; i++) {
			int hex = Integer.parseInt(str[i], 16);
			while (str[i].length() < 4) {
				str[i] = "0" + str[i];
			}
			String h = str[i].substring(0, 2);
			String e = str[i].substring(2);
			list.add(e);
			list.add(h);
		}
		return list;
	}

	public static String string2Unicode(String s) {
		try {
			StringBuffer out = new StringBuffer("");
			byte[] bytes = s.getBytes("unicode");
			for (int i = 2; i < bytes.length - 1; i += 2) {
				// out.append("u");
				String str = Integer.toHexString(bytes[i + 1] & 0xff);
				String str1 = Integer.toHexString(bytes[i] & 0xff);
				if (str.length() < 2) {
					str = "0" + str;
				}
				if (str1.length() < 2) {
					str1 = "0" + str1;
				}
				out.append(str);
				out.append(str1);
				out.append(" ");
			}
			return out.toString().toUpperCase();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			return "";
		}
	}

	/**
	 * byte数组转2进制字符串
	 * 
	 * @param b
	 * @return
	 */
	public static String byte2hex(byte[] b) {
		char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
				'B', 'C', 'D', 'E', 'F' };
		char[] out = new char[b.length * 2];
		for (int i = 0; i < b.length; i++) {
			byte c = b[i];
			out[i * 2] = Digit[(c >>> 4) & 0X0F];
			out[i * 2 + 1] = Digit[c & 0X0F];
		}
		return new String(out);
	}

	/**
	 * byte数组转16进制字符串
	 * 
	 * @param src
	 * @return
	 */
	public static String bytesToHexString(byte[] src) {
		StringBuilder stringBuilder = new StringBuilder("");
		if (src == null || src.length <= 0) {
			return null;
		}
		for (int i = 0; i < src.length; i++) {
			int v = src[i] & 0xFF;
			String hv = Integer.toHexString(v);
			if (hv.length() < 2) {
				stringBuilder.append(0);
			}
			stringBuilder.append(hv + " ");
		}
		return stringBuilder.toString();
	}

	/**
	 * 16字符串数组转串转int
	 * 
	 * @param hexs
	 * @return
	 */
	public static int[] HexsToInts(String[] hexs) {
		int[] in = new int[hexs.length];
		for (int i = 0; i < hexs.length; i++) {
			String str = hexs[i];
			String myStr[] = { "a", "b", "c", "d", "e", "f" };
			int result = 0;
			int n = 1;
			for (int k = str.length() - 1; k >= 0; k--) {
				String param = str.substring(k, k + 1);
				for (int j = 0; j < myStr.length; j++) {
					if (param.equalsIgnoreCase(myStr[j])) {
						param = "1" + String.valueOf(j);
					}
				}
				result += Integer.parseInt(param) * n;
				n *= 16;
			}
			in[i] = result;
		}
		return in;
	}

	/**
	 * 16进制
	 * 
	 * @param hex
	 * @return
	 */
	public static int HexToInt(String hex) {
		String str = hex;
		String myStr[] = { "a", "b", "c", "d", "e", "f" };
		int result = 0;
		int n = 1;
		for (int i = str.length() - 1; i >= 0; i--) {
			String param = str.substring(i, i + 1);
			for (int j = 0; j < myStr.length; j++) {
				if (param.equalsIgnoreCase(myStr[j])) {
					param = "1" + String.valueOf(j);
				}
			}
			result += Integer.parseInt(param) * n;
			n *= 16;
		}
		return result;
	}

	public static String[] StringTohex(String str) {
		String[] ss = str.split(" ");
		String[] result = new String[ss.length - 5];
		for (int i = 0; i < result.length; i++) {
			result[i] = ss[i + 4];
		}
		return result;
	}

	public static byte[] intToByte(int[] i) {
		byte[] b = new byte[i.length];
		for (int j = 0; j < b.length; j++) {
			b[j] = (byte) i[j];
		}
		return b;
	}

	public static byte[] hexStringToBytes(String hexString) {
		if (hexString == null || hexString.equals("")) {
			return null;
		}
		hexString = hexString.toUpperCase();
		int length = hexString.length() / 2;
		char[] hexChars = hexString.toCharArray();
		byte[] d = new byte[length];
		for (int i = 0; i < length; i++) {
			int pos = i * 2;
			d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
		}
		return d;
	}

	private static byte charToByte(char c) {
		return (byte) "0123456789ABCDEF".indexOf(c);
	}

	/**
	 * byte[] 转换 int
	 * 
	 * @param buf
	 * @return
	 */
	public static int byteToInt(byte[] buf) {
		int i = 0;
		try {
			ByteArrayInputStream bintput = new ByteArrayInputStream(buf);
			DataInputStream dintput = new DataInputStream(bintput);
			i = dintput.readInt();
			return i;
		} catch (IOException e) {
			e.printStackTrace();
		}
		return i;
	}

	/**
	 * byte[]转换int(4个字节) 本方法适用于(高位在前，低位在后)的顺序
	 * 
	 * @param data
	 * @return
	 */
	public static long byte4ToInt(byte[] data) {
		byte b1 = data[0];
		byte b2 = data[1];
		byte b3 = data[2];
		byte b4 = data[3];
		long i1 = b1 & 0xff;
		long i2 = b2 & 0xff;
		long i3 = b3 & 0xff;
		long i4 = b4 & 0xff;
		// int i5 = (i3 << 32) + (i1 << 16) + (i2 << 8) + i3;
		long i5 = (i1 << 24) + (i2 << 16) + (i3 << 8) + i4;
		return i5;
	}

	/**
	 * byte[]转换int(2个字节)本方法适用于(高位在前，低位在后)的顺序
	 * 
	 * @param data
	 * @return
	 */
	public static int byte2ToInt(byte[] data) {
		byte b1 = data[0];
		byte b2 = data[1];
		int i1 = (b1 & 0xff);
		int i2 = b2 & 0xff;
		int i4 = (i1 << 8) + i2;
		return i4;
	}

	/**
	 * byte[]转换int(4个字节) 本方法适用于(低位在前，高位在后)的顺序
	 * 
	 * @param data
	 * @return
	 */
	public static long byte4ToInt_tohight(byte[] data) {
		byte b1 = data[0];
		byte b2 = data[1];
		byte b3 = data[2];
		byte b4 = data[3];
		long i1 = b1 & 0xff;
		long i2 = b2 & 0xff;
		long i3 = b3 & 0xff;
		long i4 = b4 & 0xff;
		// long i5 = (i1 << 24) + (i2 << 16) + (i3 << 8) + i4;

		long i5 = (i4 << 8) + (i3 << 16) + (i2 << 24) + i1;
		return i5;
	}

	/**
	 * byte[]转换int(2个字节)本方法适用于(低位在前，高位在后)的顺序
	 * 
	 * @param data
	 * @return
	 */
	public static int byte2ToInt_tohight(byte[] data) {
		byte b1 = data[0];
		byte b2 = data[1];
		int i1 = (b1 & 0xff);
		int i2 = b2 & 0xff;
		int i4 = (i2 << 8) + i1;
		return i4;
	}

	/**
	 * 替换指定位置的字符
	 * 
	 * @param index
	 * @param res
	 * @param str
	 * @return
	 */
	public static String replaceIndex(int index, String res, String str) {
		return res.substring(0, index) + str + res.substring(index + 1);
	}

	/**
	 * 厘米转换英寸
	 * 
	 * @param cm
	 * @return
	 */
	public static int cmToIn(int cm) {
		double ft = cm * 0.0328084;
		return (int) ft * 12 + (int) (ft % (int) ft * 12 + 0.5);
	}

	/**
	 * 厘米转换英尺
	 * 
	 * @param cm
	 * @return int{英尺,英寸 };
	 */
	public static int[] cmToFt(int cm) {
		int[] FT = new int[2];
		double ft = cm * 0.0328084;
		int f = (int) (cm * 0.0328084);
		int in = (int) (ft % (int) ft * 12 + 0.5);
		FT[0] = f;
		FT[1] = in;
		return FT;
	}

	/**
	 * 英尺转厘米
	 * 
	 * @param ft
	 *            eg:6'6"
	 * @return
	 */
	public static int ftToCm(String ft) {
		int cm = 0;
		int f = Integer.parseInt(ft.substring(0, ft.lastIndexOf("'")));
		int i = Integer.parseInt(ft.substring(ft.lastIndexOf("'") + 1,
				ft.length() - 1));
		int in = f * 12 + i;
		cm = (int) (in * 2.54 + 0.5);
		return cm;
	}

	/**
	 * 英尺转英寸
	 * 
	 * @param ft
	 *            eg:6'11"
	 * @return
	 */
	public static int ftToIn(String ft) {
		int f = Integer.parseInt(ft.substring(0, ft.lastIndexOf("'")));
		int i = Integer.parseInt(ft.substring(ft.lastIndexOf("'") + 1,
				ft.length() - 1));
		int in = f * 12 + i;
		return in;
	}

	/**
	 * 英寸转英尺
	 * 
	 * @param in
	 * @return
	 */
	public static String inToFt(int in) {
		String ft = null;
		int f = (int) (in * 0.0833333);
		int i = (int) ((in * 0.0833333 - f) * 12 + 0.5);
		ft = f + "'" + i + "\"";
		return ft;
	}

	/**
	 * 英寸转厘米
	 * 
	 * @param in
	 * @return
	 */
	public static int inToCm(int in) {
		int cm = (int) (in * 2.54 + 0.5);
		return cm;
	}

	/**
	 * 公斤转磅
	 * 
	 * @param kg
	 *            60.5
	 * @return
	 */
	public static int[] kgTolbs(String kg) {
		int[] lbs = new int[2];
		double KG = Double.parseDouble(kg);
		double LBS = KG * 2.2046226;
		String l = LBS + "";
		int k = Integer.parseInt(l.substring(0, l.lastIndexOf(".")));
		int g = Integer.parseInt(l.substring(l.lastIndexOf(".") + 1,
				l.lastIndexOf(".") + 2));
		g++;
		if (g > 9) {
			k++;
			g = 0;
		}
		lbs[0] = k;
		lbs[1] = g;
		return lbs;
	}

	/**
	 * 磅转公斤
	 * 
	 * @param lbs
	 *            60.5
	 * @return
	 */
	public static int[] lbsToKg(String lbs) {
		int[] kg = new int[2];
		double LBS = Double.parseDouble(lbs);
		double KG = LBS * 0.4535924;
		String k = KG + "";
		int K = Integer.parseInt(k.substring(0, k.lastIndexOf(".")));
		int G = Integer.parseInt(k.substring(k.lastIndexOf(".") + 1,
				k.lastIndexOf(".") + 2));
		kg[0] = K;
		kg[1] = G;
		return kg;
	}

	/**
	 * 米转英里
	 * 
	 * @param m
	 * @return
	 */
	public static double mToMi(double m) {
		double mi = m * 0.0006214;
		BigDecimal bg = new BigDecimal(mi);
		double MI = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
		return MI;
	}

	/**
	 * 保留小数位
	 * 
	 * @param d
	 * @param number
	 *            保留几位小数
	 * @return
	 */
	public static double keepDecimal(double d, int number) {
		BigDecimal bg = new BigDecimal(d);
		double dou = bg.setScale(number, BigDecimal.ROUND_DOWN).doubleValue();
		return dou;
	}

	public static String keep2Decimal(double d) {
		DecimalFormat df = new DecimalFormat("0");
		return df.format(d);
	}

	public static String keep2De(double d) {
		DecimalFormat formater = new DecimalFormat("#0.##");
		return formater.format(d);
	}

	/**
	 * 加密字符串
	 * 
	 * @param str
	 *            需要加密的数据
	 * @param method
	 *            加密方式:如:MD5
	 * @return
	 */
	public static String encode(String str, String method) {
		MessageDigest md = null;
		String dstr = null;
		try {
			md = MessageDigest.getInstance(method);
			md.update(str.getBytes());
			dstr = new BigInteger(1, md.digest()).toString(16);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return dstr;
	}

	/**
	 * 计算距离
	 * 
	 * @param height
	 *            米,身高
	 * @param step
	 *            步数
	 * @param sex
	 *            性别0:男,1:女
	 * @return
	 */
	public static double distance(double height, int step, String sex) {
		int distance = 0;
		double x = 0;
		if (sex.equals("0")) {
			x = 0.415;
		} else if (sex.equals("1")) {
			x = 0.413;
		}
		double leng = height * x;
		distance = (int) (leng * step);
		return distance;
	}

}