Android开发常用的工具类

在日常的工作中整理了一些常用的代码，把它们封装成了一个工具方便调用。

1.将一个实体对象反射成一个Map集合，比如说一个接口要传递的参数非常多，而这些参数本身就封装在一个实体对象里面，上传的参数又往往是使用一个Map集合来拼接接口，这样使用实体类转Map就显得方便了许多。

public class BeanUtils {

public static Map<String,String> beanToMap(Object object){
        Class c=object.getClass();
        Field[] fields=c.getDeclaredFields();
        Map<String,String> map=new HashMap<>();
for (Field field : fields) {
            String name=field.getName();
            String value=getValue(object,name)+"";
            map.put(name,value);
        }
return map;
    }
public static Object getValue(Object object,String key) {
        String name="get"+key.substring(0,1).toUpperCase()+key.substring(1);
try {
            Method method = object.getClass().getDeclaredMethod(name, new Class[0]);
return method.invoke(object, new Object[]{});
        } catch (Exception e) {
            e.printStackTrace();
        }
return null;
    }
}

2.图片相关的工具类

package com.lianjiu.b.common.utils;

import android.app.Activity;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;
import android.graphics.BlurMaskFilter;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.LinearGradient;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Shader;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.util.DisplayMetrics;
import android.view.Display;
import android.view.View;
import android.view.WindowManager;

import com.lianjiu.b.base.Constant;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Date;

public class BitmapUtil {
private final static String TAG = BitmapUtil.class.getSimpleName();
public static Uri uri;
public static String fileName = "";

/**
 * 计算缩放比例
 *
 * filename 图片路径 maxWidth 目标宽度 maxHeight 目标高度
 */
public static Bitmap scalePicture(String filename, int maxWidth, int maxHeight) {
        Bitmap bitmap = null;
try {
            Options opts = new Options();
            opts.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(filename, opts);
int srcWidth = opts.outWidth;
int srcHeight = opts.outHeight;
int desWidth = 0;
int desHeight = 0;

// 缩放比例
double ratio = 0.0;

if (srcWidth > srcHeight) {
                ratio = srcWidth / maxWidth;
                desWidth = maxWidth;
                desHeight = (int) (srcHeight / ratio);
            } else {
                ratio = srcHeight / maxHeight;
                desHeight = maxHeight;
                desWidth = (int) (srcWidth / ratio);
            }
// 设置输出宽度、高度
            Options newOpts = new Options();
            newOpts.inSampleSize = (int) (ratio) + 1;
            newOpts.inJustDecodeBounds = false;
            newOpts.outWidth = desWidth;
            newOpts.outHeight = desHeight;
            bitmap = BitmapFactory.decodeFile(filename, newOpts);

        } catch (Throwable e) {
            e.printStackTrace();
        }
return bitmap;
    }

/**
 * 计算缩放比例
 *
 * srcBitmap 原图 目标宽度 目标高度
 */
public static Bitmap scalePicture(Bitmap srcBitmap, int maxWidth, int maxHeight) {
try {
            Bitmap bitmap = null;
int srcWidth = srcBitmap.getWidth();
int srcHeight = srcBitmap.getHeight();
// 计算缩放率，新尺寸除原始尺寸
float scaleWidth = ((float) maxWidth) / srcWidth;
float scaleHeight = ((float) maxHeight) / srcHeight;

// 创建操作图片用的matrix对象
            Matrix matrix = new Matrix();
// 缩放图片动作
            matrix.postScale(scaleWidth, scaleHeight);
// 创建新的图片
            bitmap = Bitmap.createBitmap(srcBitmap, 0, 0, srcWidth, srcHeight, matrix, true);
return bitmap;
        } catch (Throwable t) {
            t.printStackTrace();
            System.gc();
        }
return srcBitmap;
    }

public static Bitmap createBitmap(String bmPath, Options opt) {
try {
            opt.inPreferredConfig = Config.RGB_565;
            opt.inPurgeable = true;
            opt.inInputShareable = true;
            FileInputStream fis = new FileInputStream(bmPath);
return BitmapFactory.decodeStream(fis, null, opt);
        } catch (Throwable t) {
            LogUtil.log(t);
        }
return null;
    }

public static Bitmap createBitmap(Context context, int resId) {
        Bitmap bmp;
        Resources res = context.getResources();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            bmp = BitmapFactory.decodeResource(res, resId);
        } else {
            Options opt = new Options();
            opt.inPreferredConfig = Config.RGB_565;
/**
 * 如果 inPurgeable 设为True的话表示使用BitmapFactory创建的Bitmap 用于存储Pixel的内存空间在系统内存不足时可以被回收，
 * 在应用需要再次访问Bitmap的Pixel时（如绘制Bitmap或是调用getPixel）， 系统会再次调用BitmapFactory decoder重新生成Bitmap的Pixel数组。
 * 为了能够重新解码图像，bitmap要能够访问存储Bitmap的原始数据。
 *
 * 在inPurgeable为false时表示创建的Bitmap的Pixel内存空间不能被回收， 这样BitmapFactory在不停decodeByteArray创建新的Bitmap对象，
 * 不同设备的内存不同，因此能够同时创建的Bitmap个数可能有所不同， 200个bitmap足以使大部分的设备重新OutOfMemory错误。 当isPurgable设为true时，系统中内存不足时，
 * 可以回收部分Bitmap占据的内存空间，这时一般不会出现OutOfMemory 错误。
 * API 21 时被忽略
 */
            opt.inPurgeable = true;
/**
 * 配合inPurgeable使用，决定bitmap是否可以共享加载图片数据的引用，如果是false重新创建时会使用深层拷贝
 */
            opt.inInputShareable = true;
            bmp = BitmapFactory.decodeResource(res, resId, opt);
        }
return bmp;
    }

public static Bitmap createBitmap(Bitmap oriBm) {
try {
return Bitmap.createBitmap(oriBm);
        } catch (OutOfMemoryError e) {
            System.gc();
            LogUtil.log(e);
try {
                LogUtil.e("System.out", "try to creat the bitmap again");
return Bitmap.createBitmap(oriBm);
            } catch (Throwable t) {
                LogUtil.log(t);
            }
        } catch (Throwable t) {
            LogUtil.log(t);
        } finally {
            System.gc();
        }
return null;
    }

public static Bitmap createBitmap(Bitmap source, int x, int y, int width, int height, Matrix m, boolean filter) {
try {
return Bitmap.createBitmap(source, x, y, width, height, m, filter);
        } catch (OutOfMemoryError e) {
            System.gc();
            LogUtil.log(e);
try {
                LogUtil.e("System.out", "try to creat the bitmap again");
return Bitmap.createBitmap(source, x, y, width, height, m, filter);
            } catch (Throwable t) {
                LogUtil.log(t);
            }
        } catch (Throwable t) {
            LogUtil.log(t);
        } finally {
            System.gc();
        }
return null;
    }

public static Bitmap createBitmap(int width, int height, Config config) {
try {
return Bitmap.createBitmap(width, height, config);
        } catch (OutOfMemoryError e) {
            System.gc();
            LogUtil.log(e);
try {
                LogUtil.e("System.out", "try to creat the bitmap again");
return Bitmap.createBitmap(width, height, config);
            } catch (Throwable t) {
                LogUtil.log(t);
            }
        } catch (Throwable t) {
            LogUtil.log(t);
        } finally {
            System.gc();
        }
return null;
    }

public static Bitmap createBitmap(Bitmap source, int x, int y, int width, int height) {
try {
return Bitmap.createBitmap(source, x, y, width, height);
        } catch (OutOfMemoryError e) {
            System.gc();
            LogUtil.log(e);
try {
                LogUtil.e("System.out", "try to creat the bitmap again");
return Bitmap.createBitmap(source, x, y, width, height);
            } catch (Throwable t) {
                LogUtil.log(t);
            }
        } catch (Throwable t) {
            LogUtil.log(t);
        } finally {
            System.gc();
        }
return null;
    }

public static Bitmap createBitmap(InputStream is) {
        Options opt = new Options();
        opt.inPreferredConfig = Config.RGB_565;
        opt.inPurgeable = true;
        opt.inInputShareable = true;
// opt.inSampleSize = 2;
return BitmapFactory.decodeStream(is, null, opt);
    }

/** 使用c层代码早图片 */
public static Bitmap createBitmap(String path) {
        FileInputStream fis = null;
try {
            fis = new FileInputStream(path);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
return createBitmap(fis);
    }

/** 回收不使用的bitmap */
public static void recyledBitmap(Bitmap bitmap) {
try {
if (bitmap != null) {
if (!bitmap.isRecycled()) {
                    bitmap.recycle();
                    bitmap = null;
                }
            }
            System.gc();
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

/** 获取指定View的截图 */
public static Bitmap captureView(View view) throws Throwable {
        view.setDrawingCacheEnabled(true);
        view.buildDrawingCache();
        Bitmap bmShare = view.getDrawingCache();
if (bmShare == null) {
// 使用反射，强制将mViewFlags设置为正确的数值
            Field mViewFlagsField = View.class.getDeclaredField("mViewFlags");
            mViewFlagsField.setAccessible(true);
            mViewFlagsField.set(view, Integer.valueOf(402685952));
            bmShare = view.getDrawingCache();
        }
return bmShare;
    }

/** 获取屏幕的截图 */
public static String captureView(Context context, String filename) {
        String path = Constant.TEMPORARY_FILE_PATH + filename;
try {

            WindowManager windowManager = ((Activity) context).getWindowManager();

            Display display = windowManager.getDefaultDisplay();

int w = display.getWidth();

int h = display.getHeight();

            Bitmap bmShare = Bitmap.createBitmap(w, h, Config.ARGB_8888);

// 2.获取屏幕

            View decorview = ((Activity) context).getWindow().getDecorView();

            decorview.setDrawingCacheEnabled(true);

            bmShare = decorview.getDrawingCache();
            CompressFormat format = CompressFormat.JPEG;
            OutputStream stream = new FileOutputStream(path);
            bmShare.compress(format, 100, stream);
        } catch (Exception e) {
            e.printStackTrace();
        }

return path;
    }

/**
 * 创建指定bitmap的倒影bitmap
 *
 * @param bitmap
 * 原始的图片
 * @param refMargin
 * 倒影和原图之间的距离
 * @param refLeng
 * 倒影的长度
 */
public static Bitmap getInvertedImage(Bitmap bitmap, int refMargin, int refLeng) {
int width = bitmap.getWidth();
int bmHeight = bitmap.getHeight();
int height = bmHeight + refMargin + refLeng;
        Bitmap bm = Bitmap.createBitmap(width, height, Config.ARGB_8888);

        Canvas canvas = new Canvas();
        canvas.setBitmap(bm);
        Paint paint = new Paint();
        canvas.drawBitmap(bitmap, 0, 0, paint);

if (refLeng > 0) {
            Matrix matrix = new Matrix();
            matrix.preScale(1, -1);
            Bitmap refBm = Bitmap.createBitmap(bitmap, 0, bmHeight - refLeng, width, refLeng, matrix, false);
            canvas.drawBitmap(refBm, 0, bmHeight + refMargin, paint);
            refBm.recycle();

            paint.setAntiAlias(true);
            LinearGradient gradient = new LinearGradient(0, bmHeight + refMargin, 0, height, 0xff000000, 0x0000000, Shader.TileMode.CLAMP);
            paint.setShader(gradient);
            paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
            canvas.drawRect(0, bmHeight + refMargin, width, height, paint);
        }

return bm;
    }

public static Bitmap getImageReflectionPart(Bitmap bitmap, int refLeng) {
int width = bitmap.getWidth();
int bmHeight = bitmap.getHeight();

        Bitmap bm = Bitmap.createBitmap(width, refLeng, Config.ARGB_8888);
        Canvas canvas = new Canvas();
        canvas.setBitmap(bm);
        Paint paint = new Paint();

        Matrix matrix = new Matrix();
        matrix.preScale(1, -1);
        Bitmap refBm = createBitmap(bitmap, 0, 0, width, bmHeight, matrix, true);
        canvas.drawBitmap(refBm, 0, 0, paint);
        refBm.recycle();

        paint.setAntiAlias(true);
        LinearGradient gradient = new LinearGradient(0, 0, 0, refLeng, 0xc0000000, 0x00000000, Shader.TileMode.CLAMP);
        paint.setShader(gradient);
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
        canvas.drawRect(0, 0, width, refLeng, paint);

return bm;
    }

/**
 * 生成阴影
 *
 * @param bitmap
 * @param shadow
 * @return
 */
public static Bitmap getShadowBitmap(Bitmap bitmap, int shadow) {
if (shadow <= 0) {
return bitmap;
        }

        BlurMaskFilter filter = new BlurMaskFilter(shadow, BlurMaskFilter.Blur.OUTER);
        Paint shadowPaint = new Paint();
        shadowPaint.setMaskFilter(filter);

int[] offsetXY = new int[] { shadow, shadow };
return bitmap.extractAlpha(shadowPaint, offsetXY);
    }

/**
 * 获取图片的分辨率
 *
 * @param path
 * @return
 * @throws Throwable
 */
public static int[] getBitmapSize(String path) throws Throwable {
        Options opt = new Options();
        opt.inJustDecodeBounds = true;
        opt.inPreferredConfig = Config.RGB_565;
        opt.inPurgeable = true;
        opt.inInputShareable = true;
        FileInputStream fis = new FileInputStream(path);
        BitmapFactory.decodeStream(fis, null, opt);
int[] size = new int[] { opt.outWidth, opt.outHeight };
return size;
    }

/**
 * TODO 图片按比例大小压缩方法（根据路径获取图片并压缩)
 *
 * @param srcPath
 * SD卡路径
 * @param reqWidth
 * 需要的宽度
 * @param reqHeight
 * 需要的高度
 * @return Bitmap
 */
public static Bitmap CompressImageByPath(String srcPath, int reqWidth, int reqHeight) {
        Options op = new Options();
        op.inJustDecodeBounds = true;// 只是读图片的属性
        BitmapFactory.decodeFile(srcPath, op);
if (reqWidth == 0 && reqHeight == 0) {
            reqWidth = op.outWidth;
            reqHeight = op.outHeight;
        }
        op.inSampleSize = computeSampleSize(op, -1, reqWidth * reqHeight);// 设置缩放比例
        op.inJustDecodeBounds = false;
        op.inPreferredConfig = Config.RGB_565;
return compressImage(BitmapFactory.decodeFile(srcPath, op), 80);// 压缩好比例大小后再进行质量压缩

    }

/**
 * 动态计算图片缩放大小的方法
 *
 * @param options
 * @param minSideLength
 * @param maxNumOfPixels
 * @return
 */
public static int computeSampleSize(Options options, int minSideLength, int maxNumOfPixels) {
int initialSize = computeInitialSampleSize(options, minSideLength, maxNumOfPixels);

int roundedSize;
if (initialSize <= 8) {
            roundedSize = 1;
while (roundedSize < initialSize) {
                roundedSize <<= 1;
            }
        } else {
            roundedSize = (initialSize + 7) / 8 * 8;
        }

return roundedSize;
    }

private static int computeInitialSampleSize(Options options, int minSideLength, int maxNumOfPixels) {
double w = options.outWidth;
double h = options.outHeight;

int lowerBound = (maxNumOfPixels == -1) ? 1 : (int) Math.ceil(Math.sqrt(w * h / maxNumOfPixels));
int upperBound = (minSideLength == -1) ? 128 : (int) Math.min(Math.floor(w / minSideLength), Math.floor(h / minSideLength));

if (upperBound < lowerBound) {
// return the larger one when there is no overlapping zone.
return lowerBound;
        }

if ((maxNumOfPixels == -1) && (minSideLength == -1)) {
return 1;
        } else if (minSideLength == -1) {
return lowerBound;
        } else {
return upperBound;
        }
    }

/**
 *
 * 质量压缩方法
 *
 * bitmap源 options开始压缩的质量 《=100
 *
 * @return 压缩之后的bitmap
 */
public static Bitmap compressImage(Bitmap bitmap, int options) {
        Bitmap bit = null;
try {
if (null == bitmap) {
return bit;
            }
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            bitmap.compress(CompressFormat.JPEG, options, bout);// 质量压缩
// 100
// 表示不压缩
            System.out.println("*****************大少****************:" + bout.toByteArray().length / 1024);
            ByteArrayInputStream isBm = new ByteArrayInputStream(bout.toByteArray());// 把压缩后的数据baos存放到ByteArrayInputStream中
            bit = BitmapFactory.decodeStream(isBm, null, null);// 把ByteArrayInputStream数据生成图片
            bout.flush();
            bout.close();
            isBm.close();

if (!bitmap.isRecycled()) {
                bitmap.recycle();// 记得释放资源，否则会内存溢出
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
return bit;
    }

public static boolean storageState() {
        String status = Environment.getExternalStorageState();
if (status.equals(Environment.MEDIA_MOUNTED)) {
return true;
        } else {
return false;
        }
    }

// 压缩并获得流用于上传
public static InputStream getISByBitmap(Bitmap bitmap) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 得到输出流
        bitmap.compress(CompressFormat.PNG, 100, baos);
// 转输入流
        InputStream isBm = new ByteArrayInputStream(baos.toByteArray());
return isBm;
    }

// 根据时间创建名字
public static String callTime() {

long backTime = new Date().getTime();

        Calendar cal = Calendar.getInstance();

        cal.setTime(new Date(backTime));

int year = cal.get(Calendar.YEAR);

int month = cal.get(Calendar.MONTH) + 1;

int date = cal.get(Calendar.DAY_OF_MONTH);

int hour = cal.get(Calendar.HOUR_OF_DAY);

int minute = cal.get(Calendar.MINUTE);

int second = cal.get(Calendar.SECOND);

        String time = "" + year + month + date + hour + minute + second;

return time;

    }

public static Bitmap getScreenBitmap(View v) {
        View view = v.getRootView();
        view.setDrawingCacheEnabled(true);
        view.buildDrawingCache();
        Bitmap bitmap = view.getDrawingCache();
        bitmap = compressImage(bitmap);
return bitmap;
    }

/**
 * 将Bitmap压缩到一定程度
 *
 * @param image
 * @return
 */
public static Bitmap compressImage(Bitmap image) {
        Bitmap bitmap;
try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            image.compress(CompressFormat.JPEG, 100, baos);// 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
int options = 100;
while (baos.toByteArray().length / 1024 > 100) { // 循环判断如果压缩后图片是否大于100kb,大于继续压缩
                baos.reset();// 重置baos即清空baos
                image.compress(CompressFormat.JPEG, options, baos);// 这里压缩options%，把压缩后的数据存放到baos中
                options -= 10;// 每次都减少10
            }
            ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());// 把压缩后的数据baos存放到ByteArrayInputStream中
            bitmap = BitmapFactory.decodeStream(isBm, null, null);// 把ByteArrayInputStream数据生成图片
            isBm.reset();
            isBm.close();
        } catch (Exception e) {
            bitmap = image;
        }

return bitmap;
    }

/**
 * 截图功能
 *
 * View v 返回byte[]
 */
public static byte[] shotScreen(View v) {
byte[] buff = null;
        Bitmap bitmap = getScreenBitmap(v);
if (bitmap != null) {
            ByteArrayOutputStream stream = new ByteArrayOutputStream();
            bitmap.compress(CompressFormat.JPEG, 100, stream);// (0 -
// 100)压缩文件
            buff = stream.toByteArray();
            System.out.println("bitmap got!");
return buff;
        } else {
return null;
        }

    }

public static byte[] bmpToByteArray(final Bitmap bmp, final boolean needRecycle) {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        bmp.compress(CompressFormat.PNG, 100, output);
if (needRecycle) {
            bmp.recycle();
        }

byte[] result = output.toByteArray();
try {
            output.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

return result;
    }

// byte(字节)根据长度转成kb(千字节)和mb(兆字节)
public static int bytes2kb(long bytes) {
        BigDecimal filesize = new BigDecimal(bytes);
        BigDecimal megabyte = new BigDecimal(1024 * 1024);
float returnValue = filesize.divide(megabyte, 2, BigDecimal.ROUND_UP).floatValue();
if (returnValue > 2) {
return 8;
        } else if (returnValue > 1) {
return 6;
        }
        BigDecimal kilobyte = new BigDecimal(1024);
        returnValue = filesize.divide(kilobyte, 2, BigDecimal.ROUND_UP).floatValue();
if (returnValue >= 700) {
return 4;
        } else if (returnValue >= 500) {
return 3;
        } else if (returnValue >= 300) {
return 2;
        } else {
return 1;
        }
    }

public static Bitmap compressImage(Bitmap image, int reqWidth, int reqHeight) {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        image.compress(CompressFormat.JPEG, 100, baos);
if (baos.toByteArray().length / 1024 > 1024) {// 判断如果图片大于1M,进行压缩避免在生成图片（BitmapFactory.decodeStream）时溢出
            baos.reset();// 重置baos即清空baos
            image.compress(CompressFormat.JPEG, 50, baos);// 这里压缩50%，把压缩后的数据存放到baos中
        }
        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
        Options newOpts = new Options();
// 开始读入图片，此时把options.inJustDecodeBounds 设回true了
        newOpts.inJustDecodeBounds = true;
        Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
        newOpts.inJustDecodeBounds = false;
int w = newOpts.outWidth;
int h = newOpts.outHeight;
// 现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
float hh = reqHeight;// 这里设置高度为800f
float ww = reqWidth;// 这里设置宽度为480f
// 缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
int be = 1;// be=1表示不缩放
if (w > h && w > ww) {// 如果宽度大的话根据宽度固定大小缩放
            be = (int) (newOpts.outWidth / ww);
        } else if (w < h && h > hh) {// 如果高度高的话根据宽度固定大小缩放
            be = (int) (newOpts.outHeight / hh);
        }
if (be <= 0)
            be = 1;
        newOpts.inSampleSize = be;// 设置缩放比例
// 重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
        isBm = new ByteArrayInputStream(baos.toByteArray());
        bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
return compressImage(bitmap);// 压缩好比例大小后再进行质量压缩
    }

// 写到sdcard中
public static void write(Bitmap bm) throws IOException {
if (bm == null) {
return;
        }
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bm.compress(CompressFormat.PNG, 100, baos);// png类型
        FileOutputStream out = new FileOutputStream(new File(Environment.getExternalStorageDirectory() + File.separator + "tesstttt.png"));
        out.write(baos.toByteArray());
        out.flush();
        out.close();
    }

/**
 *
 * @param x
 * 图像的宽度
 * @param y
 * 图像的高度
 * @param image
 * 源图片
 * @param outerRadiusRat
 * 圆角的大小
 * @return 圆角图片
 */
public static Bitmap createFramedPhoto(int x, int y, Bitmap image, float outerRadiusRat) {
// 根据源文件新建一个darwable对象
        Drawable imageDrawable = new BitmapDrawable(image);

// 新建一个新的输出图片
        Bitmap output = Bitmap.createBitmap(x, y, Config.ARGB_8888);
        Canvas canvas = new Canvas(output);

// 新建一个矩形
        RectF outerRect = new RectF(0, 0, x, y);

// 产生一个红色的圆角矩形
        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setColor(Color.RED);
        canvas.drawRoundRect(outerRect, outerRadiusRat, outerRadiusRat, paint);

// 将源图片绘制到这个圆角矩形上
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        imageDrawable.setBounds(0, 0, x, y);
        canvas.saveLayer(outerRect, paint, Canvas.ALL_SAVE_FLAG);
        imageDrawable.draw(canvas);
        canvas.restore();

return output;
    }

public static Bitmap revitionImageSize(String path) throws IOException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(new File(path)));

        Options options = new Options();
        options.inJustDecodeBounds = true;
// Bitmap btBitmap=BitmapFactory.decodeFile(path);
// System.out.println("原尺寸高度："+btBitmap.getHeight());
// System.out.println("原尺寸宽度："+btBitmap.getWidth());
        BitmapFactory.decodeStream(in, null, options);
        in.close();
int i = 0;
        Bitmap bitmap = null;
while (true) {
if ((options.outWidth >> i <= 800) && (options.outHeight >> i <= 800)) {
                in = new BufferedInputStream(new FileInputStream(new File(path)));
                options.inSampleSize = (int) Math.pow(2.0D, i);
                options.inJustDecodeBounds = false;
                bitmap = BitmapFactory.decodeStream(in, null, options);
break;
            }
            i += 1;
        }
// 当机型为三星时图片翻转
// bitmap = Photo.photoAdapter(path, bitmap);
// System.out.println("-----压缩后尺寸高度：" + bitmap.getHeight());
// System.out.println("-----压缩后尺寸宽度度：" + bitmap.getWidth());
return bitmap;
    }

public static Bitmap getLoacalBitmap(String url) {
try {
            FileInputStream fis = new FileInputStream(url);
return BitmapFactory.decodeStream(fis); // /把流转化为Bitmap图片

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

/** 手机截屏 */
public static Bitmap takeScreenShot(Activity activity) {
// View是你需要截图的View
        View view = activity.getWindow().getDecorView();
        view.setDrawingCacheEnabled(true);
        view.buildDrawingCache();
        Bitmap b1 = view.getDrawingCache();
// 获取状态栏高度
        Rect frame = new Rect();
        activity.getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
int statusBarHeight = frame.top;
        System.out.println(statusBarHeight);// 获取屏幕长和高
int width = activity.getWindowManager().getDefaultDisplay().getWidth();
int height = activity.getWindowManager().getDefaultDisplay().getHeight();// 去掉标题栏
// Bitmap b = Bitmap.createBitmap(b1, 0, 25, 320, 455);
        Bitmap b = Bitmap.createBitmap(b1, 0, statusBarHeight, width, height - statusBarHeight);
        view.destroyDrawingCache();
return b;
    }

/**
 * @param context
 * @return
 */
public static int getScreenHeight(Context context) {
if (null == context) {
return 0;
        }
        DisplayMetrics dm = new DisplayMetrics();
        dm = context.getApplicationContext().getResources().getDisplayMetrics();
return dm.heightPixels;
    }



//api4.2以上才能使用的毛玻璃效果图
/*private void blur(Context context,Bitmap bkg, View view, float radius) {
 Bitmap overlay = Bitmap.createBitmap(view.getMeasuredWidth(), view.getMeasuredHeight(), Bitmap.Config.ARGB_8888); 
 Canvas canvas = new Canvas(overlay); 
 canvas.drawBitmap(bkg, -view.getLeft(), -view.getTop(), null); 
 RenderScript rs = RenderScript.create(context); 
 Allocation overlayAlloc = Allocation.createFromBitmap(rs, overlay); 
 ScriptIntrinsicBlur blur = ScriptIntrinsicBlur.create(rs, overlayAlloc.getElement()); 
 blur.setInput(overlayAlloc); 
 blur.setRadius(radius); 
 blur.forEach(overlayAlloc); 
 overlayAlloc.copyTo(overlay); 
 view.setBackground(new BitmapDrawable(context.getResources(), overlay)); 
 rs.destroy(); 
 } */

/**毛玻璃效果图*/
public static Bitmap fastblur(Bitmap sentBitmap, int radius) {

// Stack Blur v1.0 from
// http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html
//
// Java Author: Mario Klingemann <mario at quasimondo.com>
// http://incubator.quasimondo.com
// created Feburary 29, 2004
// Android port : Yahel Bouaziz <yahel at kayenko.com>
// http://www.kayenko.com
// ported april 5th, 2012

// This is a compromise between Gaussian Blur and Box blur
// It creates much better looking blurs than Box Blur, but is
// 7x faster than my Gaussian Blur implementation.
//
// I called it Stack Blur because this describes best how this
// filter works internally: it creates a kind of moving stack
// of colors whilst scanning through the image. Thereby it
// just has to add one new block of color to the right side
// of the stack and remove the leftmost color. The remaining
// colors on the topmost layer of the stack are either added on
// or reduced by one, depending on if they are on the right or
// on the left side of the stack.
//
// If you are using this algorithm in your code please add
// the following line:
//
// Stack Blur Algorithm by Mario Klingemann <[e-mail]>

            Bitmap bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);

if (radius < 1) {
return (null);
            }

int w = bitmap.getWidth();
int h = bitmap.getHeight();

int[] pix = new int[w * h];
            bitmap.getPixels(pix, 0, w, 0, 0, w, h);

int wm = w - 1;
int hm = h - 1;
int wh = w * h;
int div = radius + radius + 1;

int r[] = new int[wh];
int g[] = new int[wh];
int b[] = new int[wh];
int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
int vmin[] = new int[Math.max(w, h)];

int divsum = (div + 1) >> 1;
            divsum *= divsum;
int dv[] = new int[256 * divsum];
for (i = 0; i < 256 * divsum; i++) {
                dv[i] = (i / divsum);
            }

            yw = yi = 0;

int[][] stack = new int[div][3];
int stackpointer;
int stackstart;
int[] sir;
int rbs;
int r1 = radius + 1;
int routsum, goutsum, boutsum;
int rinsum, ginsum, binsum;

for (y = 0; y < h; y++) {
                rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
for (i = -radius; i <= radius; i++) {
                    p = pix[yi + Math.min(wm, Math.max(i, 0))];
                    sir = stack[i + radius];
                    sir[0] = (p & 0xff0000) >> 16;
                    sir[1] = (p & 0x00ff00) >> 8;
                    sir[2] = (p & 0x0000ff);
                    rbs = r1 - Math.abs(i);
                    rsum += sir[0] * rbs;
                    gsum += sir[1] * rbs;
                    bsum += sir[2] * rbs;
if (i > 0) {
                        rinsum += sir[0];
                        ginsum += sir[1];
                        binsum += sir[2];
                    } else {
                        routsum += sir[0];
                        goutsum += sir[1];
                        boutsum += sir[2];
                    }
                }
                stackpointer = radius;

for (x = 0; x < w; x++) {

                    r[yi] = dv[rsum];
                    g[yi] = dv[gsum];
                    b[yi] = dv[bsum];

                    rsum -= routsum;
                    gsum -= goutsum;
                    bsum -= boutsum;

                    stackstart = stackpointer - radius + div;
                    sir = stack[stackstart % div];

                    routsum -= sir[0];
                    goutsum -= sir[1];
                    boutsum -= sir[2];

if (y == 0) {
                        vmin[x] = Math.min(x + radius + 1, wm);
                    }
                    p = pix[yw + vmin[x]];

                    sir[0] = (p & 0xff0000) >> 16;
                    sir[1] = (p & 0x00ff00) >> 8;
                    sir[2] = (p & 0x0000ff);

                    rinsum += sir[0];
                    ginsum += sir[1];
                    binsum += sir[2];

                    rsum += rinsum;
                    gsum += ginsum;
                    bsum += binsum;

                    stackpointer = (stackpointer + 1) % div;
                    sir = stack[(stackpointer) % div];

                    routsum += sir[0];
                    goutsum += sir[1];
                    boutsum += sir[2];

                    rinsum -= sir[0];
                    ginsum -= sir[1];
                    binsum -= sir[2];

                    yi++;
                }
                yw += w;
            }
for (x = 0; x < w; x++) {
                rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
                yp = -radius * w;
for (i = -radius; i <= radius; i++) {
                    yi = Math.max(0, yp) + x;

                    sir = stack[i + radius];

                    sir[0] = r[yi];
                    sir[1] = g[yi];
                    sir[2] = b[yi];

                    rbs = r1 - Math.abs(i);

                    rsum += r[yi] * rbs;
                    gsum += g[yi] * rbs;
                    bsum += b[yi] * rbs;

if (i > 0) {
                        rinsum += sir[0];
                        ginsum += sir[1];
                        binsum += sir[2];
                    } else {
                        routsum += sir[0];
                        goutsum += sir[1];
                        boutsum += sir[2];
                    }

if (i < hm) {
                        yp += w;
                    }
                }
                yi = x;
                stackpointer = radius;
for (y = 0; y < h; y++) {
// Preserve alpha channel: ( 0xff000000 & pix[yi] )
                    pix[yi] = ( 0xff000000 & pix[yi] ) | ( dv[rsum] << 16 ) | ( dv[gsum] << 8 ) | dv[bsum];

                    rsum -= routsum;
                    gsum -= goutsum;
                    bsum -= boutsum;

                    stackstart = stackpointer - radius + div;
                    sir = stack[stackstart % div];

                    routsum -= sir[0];
                    goutsum -= sir[1];
                    boutsum -= sir[2];

if (x == 0) {
                        vmin[y] = Math.min(y + r1, hm) * w;
                    }
                    p = x + vmin[y];

                    sir[0] = r[p];
                    sir[1] = g[p];
                    sir[2] = b[p];

                    rinsum += sir[0];
                    ginsum += sir[1];
                    binsum += sir[2];

                    rsum += rinsum;
                    gsum += ginsum;
                    bsum += binsum;

                    stackpointer = (stackpointer + 1) % div;
                    sir = stack[stackpointer];

                    routsum += sir[0];
                    goutsum += sir[1];
                    boutsum += sir[2];

                    rinsum -= sir[0];
                    ginsum -= sir[1];
                    binsum -= sir[2];

                    yi += w;
                }
            }

            bitmap.setPixels(pix, 0, w, 0, 0, w, h);

return (bitmap);
        }
/**将制定的Bitmap保存到文件*/
public  static void savePic(Bitmap b, String strFileName){
            FileOutputStream fos = null;
try {
                fos = new FileOutputStream(strFileName);
if (null != fos)
                {
                    b.compress(CompressFormat.PNG, 90, fos);
                    fos.flush();
                    fos.close();
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

}

3.数据相关的工具类

package com.lianjiu.b.common.utils;

import java.math.BigDecimal;
import java.math.RoundingMode;

public class DecimalUtil {

/**
 * 金钱乘法
 *
 * @param v1
 * @param v2
 * @return
 */
public static String add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);

return b1.add(b2).toString();
    }

/**
 * 金钱乘法
 *
 * @param v1
 * @param v2
 * @return
 */
public static String multiply(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);

return b1.multiply(b2).toString();
    }

/**
 * 乘法
 *
 * @param v1 乘数
 * @param v2 被乘数
 * @param scale 小数点保留位数
 * @return
 */
public static String multiplyWithScale(String v1, String v2, int scale) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        BigDecimal result = b1.multiply(b2);
        result = result.setScale(scale);
return result.toString();
    }

/**
 * 金钱除法
 *
 * @param v1
 * @param v2
 * @return
 */
public static String divide(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);

return b1.divide(b2).toString();
    }

/**
 * 如果除不断，产生无限循环小数，那么就会抛出异常，解决方法就是对小数点后的位数做限制
 *
 * @param v1
 * @param v2 小数模式 ，DOWN，表示直接不做四舍五入，参考{@link RoundingMode}
 * @return
 */
public static String divideWithRoundingDown(String v1, String v2) {
return divideWithRoundingMode(v1, v2, RoundingMode.DOWN);
    }

/** 选择小数部分处理方式 */
public static String divideWithRoundingMode(String v1, String v2,
                                                RoundingMode roundingMode) {
return divideWithRoundingModeAndScale(v1, v2, RoundingMode.DOWN, 0);
    }

/**
 * 选择小数点后部分处理方式，以及保留几位小数
 *
 * @param v1 除数
 * @param v2 被除数
 * @param roundingMode 小数处理模式
 * @param scale 保留几位
 * @return
 */
public static String divideWithRoundingModeAndScale(String v1, String v2,
                                                        RoundingMode roundingMode, int scale) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
return b1.divide(b2, scale, roundingMode).toString();
    }

/**
 * 金钱减法
 *
 * @param v1
 * @param v2
 * @return
 */
public static String subtract(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);

return b1.subtract(b2).toString();
    }


}

4.文件相关的工具类

package com.lianjiu.b.common.utils;

import android.annotation.TargetApi;
import android.app.Activity;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Environment;
import android.provider.DocumentsContract;
import android.provider.MediaStore;

import com.lianjiu.b.base.AppApplication;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.DecimalFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;


public class FileUtils {
private static String SDPATH = Environment.getExternalStorageDirectory() + "/";;

public static String getSDPATH() {
return SDPATH;
    }

/**
 * yckx图片存储的路径
 * */
public static String FILEPAHT="/sdcard/yckx/";
/**
 * yckx截屏临时文件
 * */
public static String SHARE_FILEName="yckx_screen_temp";

/**
 * 在SD卡上创建文件
 */
public File creatSDFile(String fileName) throws IOException {
        File file = new File(SDPATH + fileName);
        file.createNewFile();
return file;
    }

/**
 * 在SD卡上创建目录
 */
public static File creatSDDir(String dirName) {
        File dir = new File(SDPATH + dirName);
        dir.mkdir();
return dir;
    }

/**
 * 判断SD卡上的文件夹是否存在
 */
public static boolean isFileExist(String fileName) {
        File file = new File(fileName);
return file.exists();
    }

/** 删除目录 */
public static boolean deleteDirectory(File dir) {
        File[] bookFiles = dir.listFiles();
for (File bookFile : bookFiles) {
if (bookFile.isDirectory())
                deleteDirectory(bookFile);
            bookFile.delete();
        }
return dir.delete();
    }

/** 删除文件 */
public static boolean deleteFileByPath(String filePath) {
if (!StringUtils.isEmpty(filePath)) {
            File delFile = new File(filePath);
if (delFile.exists()) {
return delFile.delete();
            }
        }

return false;
    }

/**
 * 删除某一目录
 * 
 * @param path
 * 路径
 */
public static boolean deleteFolder(String path) {
        File file = new File(path);
return deleteFolder(file);
    }

/**
 * 删除某一目录
 * 
 * @param folder
 * 删除的路径文件
 */
public static boolean deleteFolder(File folder) {
boolean result = false;
try {

            String childs[] = folder.list();
if (childs == null || childs.length <= 0) {
if (folder.delete()) {
                    result = true;
                }
            } else {
for (int i = 0; i < childs.length; i++) {
                    String childName = childs[i];
                    String childPath = folder.getPath() + File.separator + childName;
                    File filePath = new File(childPath);
if (filePath.exists() && filePath.isFile()) {
if (filePath.delete()) {
                            result = true;
                        } else {
                            result = false;
break;
                        }
                    } else if (filePath.exists() && filePath.isDirectory()) {
if (deleteFolder(filePath)) {
                            result = true;
                        } else {
                            result = false;
break;
                        }
                    }
                }
                folder.delete();
            }
        } catch (Exception e) {
            e.printStackTrace();
            result = false;
        }
return result;
    }

/**
 * 将一个InputStream里面的数据写入到SD卡中
 */
public File write2SDFromInput(String path, String fileName, InputStream input) {
        File file = null;
        OutputStream output = null;
try// InputStream里面的数据写入到SD卡中的固定方法
        {
            creatSDDir(path);
            file = creatSDFile(path + fileName);
            output = new FileOutputStream(file);
byte buffer[] = new byte[4 * 1024];
while ((input.read(buffer)) != -1) {
                output.write(buffer);
            }
            output.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
try {
                output.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
return file;
    }

public static String getSizeKBString(int f) {
        DecimalFormat fmt = new DecimalFormat("0.#");
        String s = fmt.format(f) + "KB";
float f2 = f;
if (f2 > 1024) {
            f2 = f / 1024.0f;
            s = fmt.format(f2) + "MB";
        }
return s;
    }

public static String getSizeString(long f) {
        DecimalFormat fmt = new DecimalFormat("0.#");
float f1 = 1;
if (f >= 1024) {
            f1 = f / 1024.0f;
        }
        String s = fmt.format(f1) + "KB";
float f2 = 1;
if (f1 >= 1024) {
            f2 = f1 / 1024.0f;
            s = fmt.format(f2) + "MB";
        }
return s;
    }

public static boolean untieGzip(String GzipPath, String filePath) {
boolean mk = false;
try {
            GZIPInputStream in = new GZIPInputStream(new FileInputStream(GzipPath));
            OutputStream out = new FileOutputStream(filePath);
byte[] buf = new byte[1024];
int len;
while ((len = in.read(buf)) > 0) {
                out.write(buf, 0, len);
            }
            in.close();
            out.close();
            mk = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
return mk;
    }

/**
 * 获取常用文件储存路径
 * 
 * @return
 */
public static String getSavePath() {
return getPath(false);
    }

/**
 * 获取临时储存路径
 * 
 * @return
 */
public static String getTemporarySavePath() {
return getPath(true);
    }

/**
 * 获取储存路径
 * 
 * @param isTemporary
 * //是否是临时文件
 * @return
 */
public static String getPath(boolean isTemporary) {
        String sdDir = "";
        String childDir = isTemporary == true ? "/yckx/pro/" : "/yckx/";
boolean sdCardExist = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED); // 判断sd卡是否存在
if (sdCardExist) {
            sdDir = Environment.getExternalStorageDirectory() + childDir;// 获取跟目录
        } else {
            sdDir = AppApplication.getInstance().getFilesDir().getAbsolutePath() + childDir;
        }
        File file = new File(sdDir);
if (!file.exists()) {
            file.mkdir();
        }
return sdDir;
    }

/**
 * 获取系统的总内存（单位Byte）
 * 
 * @return
 */
public static long getTotalMemory() {
try {
            FileReader localFileReader = new FileReader("/proc/meminfo");
            BufferedReader localBufferedReader = new BufferedReader(localFileReader);
            String memTotal = localBufferedReader.readLine();
            localFileReader.close();

            String regEx = "\\d{1,}";
            Pattern p = Pattern.compile(regEx);
            Matcher m = p.matcher(memTotal);
if (m.find()) {
return (Long.parseLong(m.group(0)) * 1024);
            }
        } catch (Throwable e) {
            LogUtil.log(e);
        }
return -1;
    }

public static void writeFileToSD(InputStream is, String pathName, String fileName) {
        String sdStatus = Environment.getExternalStorageState();
if (!sdStatus.equals(Environment.MEDIA_MOUNTED)) {
            LogUtil.d("XXTIMG", "SD card is not avaiable/writeable right now.");
return;
        }
try {
            File path = new File(pathName);
            File file = new File(pathName + fileName);
if (!path.exists()) {
                LogUtil.d("XXTIMG", "Create the path:" + pathName);
                path.mkdir();
            }
if (!file.exists()) {
                LogUtil.d("XXTIMG", "Create the file:" + fileName);
                file.createNewFile();
            }
        } catch (Exception e) {
            LogUtil.e("XXTIMG", "Error on writeFilToSD.");
            e.printStackTrace();
        }
    }


/**
 * 根据文件路径，将图片文件存储到sdcard中
 *
 * */
public static void saveFileToSDcard(String filePath, Bitmap saveBitmap){
try {
            FileOutputStream b = null;
            File yckx_tempFile = new File("/sdcard/yckx/");
if (!yckx_tempFile.exists()) {
                yckx_tempFile.mkdirs();// 创建文件夹
            }
            File file = new File("/sdcard/yckx/" + filePath);
            b = new FileOutputStream(file);//写到存储卡
            saveBitmap.compress(Bitmap.CompressFormat.JPEG, 100, b);// 把数据写入文件
        }catch (FileNotFoundException e){
              e.printStackTrace();
        }

    }


/*
 * 根据Uri获取图片绝对路径，解决Android4.4以上版本Uri转换
 * @param activity
 * @param imageUri
 * @author yaoxing
 * @date 2014-10-12
 */
@TargetApi(19)
public static String getImageAbsolutePath(Activity context, Uri imageUri) {
if (context == null || imageUri == null)
return null;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(context, imageUri)) {
if (isExternalStorageDocument(imageUri)) {
                String docId = DocumentsContract.getDocumentId(imageUri);
                String[] split = docId.split(":");
                String type = split[0];
if ("primary".equalsIgnoreCase(type)) {
return Environment.getExternalStorageDirectory() + "/" + split[1];
                }
            } else if (isDownloadsDocument(imageUri)) {
                String id = DocumentsContract.getDocumentId(imageUri);
                Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
return getDataColumn(context,contentUri, null, null);
            } else if (isMediaDocument(imageUri)) {
                String docId = DocumentsContract.getDocumentId(imageUri);
                String[] split = docId.split(":");
                String type = split[0];
                Uri contentUri = null;
if ("image".equals(type)) {
                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
                } else if ("video".equals(type)) {
                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
                } else if ("audio".equals(type)) {
                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
                }
                String selection = MediaStore.Images.Media._ID + "=?";
                String[] selectionArgs = new String[] { split[1] };
return getDataColumn(context, contentUri, selection, selectionArgs);
            }
        } // MediaStore (and general)
else if ("content".equalsIgnoreCase(imageUri.getScheme())) {
// Return the remote address
if (isGooglePhotosUri(imageUri))
return imageUri.getLastPathSegment();
return getDataColumn(context, imageUri, null, null);
        }
// File
else if ("file".equalsIgnoreCase(imageUri.getScheme())) {
return imageUri.getPath();
        }
return null;
    }

public static String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs) {
        Cursor cursor = null;
        String column = MediaStore.Images.Media.DATA;
        String[] projection = { column };
try {
            cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
if (cursor != null && cursor.moveToFirst()) {
int index = cursor.getColumnIndexOrThrow(column);
return cursor.getString(index);
            }
        } finally {
if (cursor != null)
                cursor.close();
        }
return null;
    }

/**
 * @param uri The Uri to check.
 * @return Whether the Uri authority is ExternalStorageProvider.
 */
public static boolean isExternalStorageDocument(Uri uri) {
return "com.android.externalstorage.documents".equals(uri.getAuthority());
    }

/**
 * @param uri The Uri to check.
 * @return Whether the Uri authority is DownloadsProvider.
 */
public static boolean isDownloadsDocument(Uri uri) {
return "com.android.providers.downloads.documents".equals(uri.getAuthority());
    }

/**
 * @param uri The Uri to check.
 * @return Whether the Uri authority is MediaProvider.
 */
public static boolean isMediaDocument(Uri uri) {
return "com.android.providers.media.documents".equals(uri.getAuthority());
    }

/**
 * @param uri The Uri to check.
 * @return Whether the Uri authority is Google Photos.
 */
public static boolean isGooglePhotosUri(Uri uri) {
return "com.google.android.apps.photos.content".equals(uri.getAuthority());
    }


}

5.图片相关工具类（压缩）

package com.lianjiu.b.common.utils;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;

import com.lianjiu.b.base.Constant;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class ImageCompress {

    public static File scal(String path) {
        File outputFile = new File(path);
        if (outputFile.exists()) {
            long fileSize = outputFile.length();
            final long fileMaxSize = 200 * 1024;
            if (fileSize >= fileMaxSize) {
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inJustDecodeBounds = true;
                BitmapFactory.decodeFile(path, options);
                int height = options.outHeight;
                int width = options.outWidth;

                double scale = Math.sqrt((float) fileSize / fileMaxSize);
                options.outHeight = (int) (height / scale);
                options.outWidth = (int) (width / scale);
                options.inSampleSize = (int) (scale + 0.5);
                options.inJustDecodeBounds = false;

                Bitmap bitmap = BitmapFactory.decodeFile(path, options);
                outputFile = new File(Constant.TEMPORARY_FILE_PATH + "/" + System.currentTimeMillis() + ".jpg");
                FileOutputStream fos = null;
                try {
                    fos = new FileOutputStream(outputFile);
                    bitmap.compress(Bitmap.CompressFormat.JPEG, 50, fos);
                    fos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                Log.d("", "sss ok " + outputFile.length());
                if (!bitmap.isRecycled()) {
                    bitmap.recycle();
                }
            }
        }
        return outputFile;
    }
}

6.Json解析相关工具类（需要用到Gson的jar包）

package com.lianjiu.b.common.utils;

import com.google.gson.Gson;

import org.json.JSONException;
import org.json.JSONObject;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class JsonReponseHandler
{

/** listKey=pageEntity */
public static <T> List<T> getListFromJsonWithPageEntity(Object response, Type type)
    {
return getListFromJson(response, type, "pageEntity");
    }

/**
 * 将服务器返回的JSON转化为List，两层，
 * 
 * @param response
 * 服务器的HTTP响应，JSON数据，之所以用object，是希望将msg.obj直接传送过来
 * @param type
 * List的数据类型，如List<Comment>
 * @
 * 更新ListView的适配器
 *
 * 进度对话框
 * @author 陈福荣, 吴格非
 */
public static <T> List<T> getListFromJson(Object response, Type type, String listKey)
    {
if (response == null)
        {
return null;
        }
        JSONObject jo = null;
if (response instanceof JSONObject)
        {
            jo = (JSONObject) response;
        } else if (response instanceof String)
        {
try
            {
                jo = new JSONObject(response.toString());
            } catch (JSONException e)
            {
                e.printStackTrace();
            }
        }

        List<T> list = null;
try
        {
// 取list
if (jo != null && !jo.equals(""))
            {
                String json = String.valueOf(jo.getJSONArray(listKey));
                Gson gson = new Gson();
if (!"null".equals(json))
                {// 服务端可能返回null
                    list = gson.fromJson(json, type);
                }
if (list == null)
                {
                    list = new ArrayList<T>();
                }
            }

        } catch (JSONException e)
        {
            e.printStackTrace();
        }
return list;
    }

}

7.数据相关工具类

package com.lianjiu.b.common.utils;

import java.math.BigDecimal;
import java.text.NumberFormat;

/**
 * @Description 专门对数据进行数量
 * @Author Created by LinXZ on 2016/8/31 00:08.
 */
public class NumberUtils {




/***
 * double 数据保存小数操作
 *
 * */
public static double scaleNumber(double targetNumber,int scale){
       BigDecimal b1 = new BigDecimal(targetNumber);
return b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
   }


/**
 *
 * double 数据保留小数操作
 * */
public static String sacleNumber2(double targetNumber, int scale ){
        NumberFormat ddf1 = NumberFormat.getNumberInstance();
        ddf1.setMaximumFractionDigits(scale);
return ddf1.format(targetNumber);
    }

/**格式化距离*/
public static String formatNumberofDistance(float distance){
if(distance<1000){
return sacleNumber2(distance,1)+"m";
        }else{
return sacleNumber2(distance/1000,2)+"km";
        }
    }

/**数量格式化*/
public static String forNumberCount(int count){
if (count>1000){
            Double temp=Double.parseDouble(count+"");
return temp/10000+"万";
        }
return count+"";
    }

/***********************************高德地图与百度地图的经纬度转换*****************************/

/**
 *
 * http://blog.csdn.net/meegomeego/article/details/39927017
 *
 * 高德地图使用的是火星系坐标：GCJ-02
 * 百度地图使用的是百度坐标：在GCJ-02的基础上进行BD-09加密
 *
 * */

private static double x_pi = 3.14159265358979324 * 3000.0 / 180.0;
/**
 * 将 GCJ-02 坐标转换成 BD-09 坐标
 * GoogleMap和高德map用的是同一个坐标系GCJ-02（高德地图装成为百度地图）
 * */
public static double[] bd_encrypt(double gg_lat, double gg_lon) {
double bd_lat = 0.0;
double bd_lon = 0.0;
double location[] = new double[2];
double x = gg_lon, y = gg_lat;
double z = Math.sqrt(x * x + y * y) + 0.00002 * Math.sin(y * x_pi);
double theta = Math.atan2(y, x) + 0.000003 * Math.cos(x * x_pi);
        bd_lon = z * Math.cos(theta) + 0.0065;
        bd_lat = z * Math.sin(theta) + 0.006;
        location[0] = bd_lat;
        location[1] = bd_lon;
return location;
    }

/**
 * 将 BD-09 坐标转换成 GCJ-02 坐标
 * GoogleMap和高德map用的是同一个坐标系GCJ-02（百度地图转换高德地图）
 * */
public static double[] bd_decrypt(double bd_lat, double bd_lon) {
double gg_lat = 0.0;
double gg_lon = 0.0;
double location[] = new double[2];
double x = bd_lon - 0.0065, y = bd_lat - 0.006;
double z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * x_pi);
double theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * x_pi);
        gg_lon = z * Math.cos(theta);
        gg_lat = z * Math.sin(theta);
        location[0] = gg_lat;
        location[1] = gg_lon;
return location;
    }
}

8.手机应用相关的工具类

package com.lianjiu.b.common.utils;

import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.os.Build;
import android.os.Environment;
import android.telephony.TelephonyManager;
import android.text.InputType;
import android.view.ViewTreeObserver;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.widget.RelativeLayout;

import com.lianjiu.b.base.AppApplication;

import java.io.File;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;


/**
 * 手机基本信息
 *
 * @author Linxz
 */
public class PhoneUtil {
private TelephonyManager telephonyManager;
private Context context;
static PhoneUtil phoneinfo;
private Map<String, Object> infoMap;

public PhoneUtil(Context context) {
        telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
this.context = context;
        infoMap = new HashMap<String, Object>();
    }

public static PhoneUtil getInstance(Context context) {
if (phoneinfo == null) {
            phoneinfo = new PhoneUtil(context);
        }
return phoneinfo;
    }

/**
 * 手机型号
 *
 * @return
 * @time 2011-6-1 下午03:20:14
 * @author:linyg
 */
public String getModel() {
        String model = "";
if (infoMap.containsKey("get_model")) {
            model = (String) infoMap.get("get_model");
        } else {
            model = Build.MODEL;
            infoMap.put("get_model", model);
        }
return model;
    }


/**
 * 获取设备唯一码
 *
 * @param
 * @return
 */
public String getIMEI() {
boolean invalidDeviceID = false;
// 获取imei号
        String deviceID = telephonyManager.getDeviceId();
        LogUtil.i("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", deviceID);
if (deviceID == null) {
            invalidDeviceID = true;
        } else if (deviceID.length() == 0 || deviceID.startsWith("000000") || deviceID.equals
                ("0") || deviceID.startsWith("111111")
                || deviceID.startsWith("222222") || deviceID.startsWith("333333") || deviceID
                .startsWith("333333")
                || deviceID.startsWith("444444") || deviceID.startsWith("555555") || deviceID
                .startsWith("666666")
                || deviceID.startsWith("777777") || deviceID.startsWith("888888") || deviceID
                .startsWith("999999")
                || deviceID.startsWith("123456") || deviceID.startsWith("abcdef") || deviceID
                .equals("unknown")) {
            invalidDeviceID = true;
        }

// 如果未获取到 2.2以上的系统才能使用
if (invalidDeviceID && Integer.parseInt(Build.VERSION.SDK) >= 9) {
try {
                Class<?> c = Class.forName("android.os.SystemProperties");
                Method get = c.getMethod("get", String.class, String.class);
                deviceID = (String) (get.invoke(c, "ro.serialno", "unknown"));
            } catch (Exception e) {
            }
            LogUtil.i("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", deviceID);
if (deviceID == null) {
                invalidDeviceID = true;
            } else if (deviceID.length() == 0 || deviceID.startsWith("000000") || deviceID.equals
                    ("0") || deviceID.startsWith("111111")
                    || deviceID.startsWith("222222") || deviceID.startsWith("333333") || deviceID
                    .startsWith("333333")
                    || deviceID.startsWith("444444") || deviceID.startsWith("555555") || deviceID
                    .startsWith("666666")
                    || deviceID.startsWith("777777") || deviceID.startsWith("888888") || deviceID
                    .startsWith("999999")
                    || deviceID.startsWith("123456") || deviceID.startsWith("abcdef") || deviceID
                    .equals("unknown")) {
                invalidDeviceID = true;
            } else {
                invalidDeviceID = false;
            }
        }

// 以上都无法获取到，则从sharepreference和SD卡
if (invalidDeviceID) {
            String spDeviceId = SharedPreferenceUtil.getInstance(context).getString
                    (SharedPreferenceUtil.IMEI);
if (spDeviceId != null && !spDeviceId.equals("")) {
                deviceID = spDeviceId;
            }
if (deviceID == null) {
                invalidDeviceID = true;
            } else if (deviceID.length() == 0 || deviceID.startsWith("000000") || deviceID.equals
                    ("0") || deviceID.startsWith("111111")
                    || deviceID.startsWith("222222") || deviceID.startsWith("333333") || deviceID
                    .startsWith("333333")
                    || deviceID.startsWith("444444") || deviceID.startsWith("555555") || deviceID
                    .startsWith("666666")
                    || deviceID.startsWith("777777") || deviceID.startsWith("888888") || deviceID
                    .startsWith("999999")
                    || deviceID.startsWith("123456") || deviceID.startsWith("abcdef") || deviceID
                    .equals("unknown")) {
                invalidDeviceID = true;
            } else {
                invalidDeviceID = false;
            }
        }

// 自动生成，并将保存在本地
if (invalidDeviceID) {
            deviceID = UUID.randomUUID().toString();
        }
if (!StringUtils.isEmpty(deviceID)) {
            SharedPreferenceUtil.getInstance(context).putString(SharedPreferenceUtil.IMEI,
                    deviceID);
        }
        LogUtil.i("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", deviceID);
return deviceID;
    }

/**
 * 手机号读取
 */
public String getNativePhoneNumber() {
        telephonyManager = (TelephonyManager) context
                .getSystemService(Context.TELEPHONY_SERVICE);
        String nativePhoneNumber = null;
        nativePhoneNumber = telephonyManager.getLine1Number();
return nativePhoneNumber;
    }


/**
 * 获取是否debug模式
 *
 * @return
 */
public static boolean isApkDebugable() {
try {
            ApplicationInfo info = AppApplication.getInstance().getApplicationInfo();
return (info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
        } catch (Exception e) {

        }
return false;
    }

/**
 * 获取sd卡路径
 *
 * @return
 */
public static String getSDPath() {
        String sdDir = "";
boolean sdCardExist = Environment.getExternalStorageState().equals(Environment
                .MEDIA_MOUNTED); // 判断sd卡是否存在
if (sdCardExist) {
            sdDir = Environment.getExternalStorageDirectory() + "/dbgs/";// 获取跟目录
        } else {
            sdDir = "/data/data/dbgs/";
        }
        File file = new File(sdDir);
if (!file.exists()) {
            file.mkdir();
        }
return sdDir;
    }

/**
 * 打卡手机软键盘
 */
public  void openSoftkeyboard(Context context, EditText editText) {
        InputMethodManager imm = (InputMethodManager) context.getSystemService(Context
                .INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS);
        editText.setFocusableInTouchMode(true);
        editText.requestFocus();
//设置光标在文本的最后一个字
        String draft =editText.getText().toString().trim();
        editText.setSelection(draft.length());//set cursor to the end
    }


/* */

/**
 * 关闭软键盘
 *//*
 public static void keyBoardCancle(BaseActivity context) {
 View view = context.getWindow().peekDecorView();
 if (view != null) {
 InputMethodManager inputmanger = (InputMethodManager) context.getSystemService
 (Context.INPUT_METHOD_SERVICE);
 inputmanger.hideSoftInputFromWindow(view.getWindowToken(), 0);
 }
 }

 /**
 * 监听软件盘的打开关闭状态
 */
public void openOrCloseSoftboard(final EditText editText, final RelativeLayout
            mainLayout) {
        editText.setInputType(InputType.TYPE_NUMBER_FLAG_DECIMAL);
        editText.setFocusableInTouchMode(true);
        editText.requestFocus();
        InputMethodManager inputManager = (InputMethodManager) editText.getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.showSoftInput(editText, 0);
        mainLayout.getViewTreeObserver().addOnGlobalLayoutListener(
new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
int heightDiff = mainLayout.getRootView().getHeight() - mainLayout
                                .getHeight();
if (heightDiff > 100) { // 说明键盘是弹出状态
//ToastUtil.show(getApplicationContext(), "弹出", 2000);
                        } else {
                            editText.setInputType(InputType.TYPE_NULL);
                            editText.setFocusableInTouchMode(false);
//ToastUtil.show(getApplicationContext(), "隐藏", 2000);
                        }
                    }
                });
    }

/**
 * 获取手机屏幕分辨率
 */
public static float getDensity(Context context) {
return context.getResources().getDisplayMetrics().density;
    }

/**
 * 获取当前包名
 */
public String getAppPakage() {
try {
            String pkName = context.getPackageName();
return pkName;
        } catch (Exception e) {
        }
return "";
    }

/**
 * 获取APP版本号
 */
public int getAppVersionCode() {
try {
            String pkName = context.getPackageName();
int versionCode = context.getPackageManager()
                    .getPackageInfo(pkName, 0).versionCode;
return versionCode;
        } catch (Exception e) {
        }
return 0;
    }

/**
 * 获取APP版本名称
 */
public String getAppVersionName() {
try {
            String pkName = context.getPackageName();
            String versionName = context.getPackageManager().getPackageInfo(
                    pkName, 0).versionName;
return versionName;
        } catch (Exception e) {
        }
return "";
    }

/**
 * 判断是否需要版本更新
 *
 * @return
 */
public boolean checkAppVersionName(String serverVersionName) {
        String appVersionName = getAppVersionName();
int appVersion = Integer.parseInt(appVersionName.replace(".", ""));
int serverVersion = Integer.parseInt(serverVersionName.replace(".", ""));
if (appVersion > serverVersion) {
return false;
        } else if (appVersion == serverVersion) {
return false;
        } else {
return true;
        }

    }


}

9.手机SharePreference存储工具类

package com.lianjiu.b.common.utils;

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

import com.google.gson.Gson;
import com.lianjiu.b.module.entity.bean.CustBaseinfo;
import com.lianjiu.b.module.entity.bean.UserInfo;

public class SharedPreferenceUtil {
private static SharedPreferenceUtil sharedPreferenceUtil;

private static SharedPreferences sharedPreferences;//用户资料
public final static String CUSTBASEINFO="CustBaseInfo";//登录注册下的数据
public final static String CUSTBASEINFO_STORE="CustBaseInfo_Store";//商家门店信息
public final static String PHONENUM="PhoneNum";//用户注册的环信手机号
public final static String PASSWORD="PassWord";//用户注册环信密码

private final static String KEY = "dbgs_sharedpreferences";
public final static String GUIDE = "guide"; // 引导页

public final static String IMEI = "imei"; // 设备唯一码

public final static String TOKEN = "token"; // 用户token
public final static String SETMSG = "setmsg"; // 用户消息设置缓存

public final static String IMTOKEN = "imtoken"; // 用户imtoken
public final static String XGTOKEN = "xgtoken"; // 用户xgtoken
public final static String LBSSearchResponse = "LBSSearchResponse";

public final static String KEY_PUSH = "Key_push";

public final static String COMPANY_APPLY = "company_apply";

public final static String SEARCH_RECORD = "search_cord";//商家搜索记录

/**
 * 搜索页面记录。 <br/><br/>Author: Create by Yu.Yao on 2016/9/26。
 */
public final static String SEARCH_HISTORY = "search_history";

private SharedPreferenceUtil(Context context) {
        sharedPreferences = context.getSharedPreferences(KEY, Context.MODE_PRIVATE);
    }

public static SharedPreferenceUtil getInstance(Context context) {
if (sharedPreferenceUtil == null) {
            sharedPreferenceUtil = new SharedPreferenceUtil(context);
        }
return sharedPreferenceUtil;
    }

/**
 * 设置String类型值
 *
 * @param key
 * @param value
 */
public void putString(String key, String value) {
        Editor editor = sharedPreferences.edit();
        editor.putString(key, value);
        editor.commit();
    }

/**
 * 设置long类型值
 *
 * @param key
 * @param value
 */
public void putLong(String key, long value) {
        Editor editor = sharedPreferences.edit();
        editor.putLong(key, value);
        editor.commit();
    }

/**
 * 设置int类型值
 *
 * @param key
 * @param value
 */
public void putInt(String key, int value) {
        Editor editor = sharedPreferences.edit();
        editor.putInt(key, value);
        editor.commit();
    }

/**
 * 设置Boolean类型值
 *
 * @param key
 * @param value
 */
public void putBoolean(String key, boolean value) {
        Editor editor = sharedPreferences.edit();
        editor.putBoolean(key, value);
        editor.commit();
    }

/**
 * 设置Float类型值
 *
 * @param key
 * @param value
 */
public void putFloat(String key, float value) {
        Editor editor = sharedPreferences.edit();
        editor.putFloat(key, value);
        editor.commit();
    }

/**
 * 读取String类型值，默认为""
 *
 * @param key
 */
public String getString(String key) {
return sharedPreferences == null ? "" : sharedPreferences.getString(key, "");
    }

/**
 * 读取boolean类型值，默认为false;
 *
 * @param key
 * @return
 */
public boolean getBoolean(String key, boolean deafultValue) {
return sharedPreferences.getBoolean(key, deafultValue);
    }

/**
 * 读取int类型值，默认为0
 *
 * @param key
 * @return
 */
public int getInt(String key) {
return sharedPreferences.getInt(key, 0);
    }

/**
 * 读取long类型值，默认为0
 *
 * @param key
 * @return
 */
public long getLong(String key) {
return sharedPreferences.getLong(key, 0);
    }

/**
 * 读取float类型值，默认为0
 *
 * @param key
 * @return
 */
public float getFloat(String key) {
return sharedPreferences.getFloat(key, 0);
    }

/**
 * 判断是否存在此字段
 */
public boolean has(String key) {
return sharedPreferences.contains(key);
    }

// 移除某个字段
public void remove(String key) {
        Editor editor = sharedPreferences.edit();
        editor.remove(key);
        editor.commit();
    }

private final static String USER="user";
/**保存当前用户信息*/
/* public void saveUser(User user){
 if (user!=null){
 putString(USER,new Gson().toJson(user));
 String token=user.getToken();
 putString(TOKEN,token);
 }
 }

 *//**获取当前用户信息*//*
 public User getUser(){
 String userJSON=getString(USER);
 if (!StringUtils.isEmpty(userJSON))
 return new Gson().fromJson(userJSON,User.class);
 else
 return null;
 }*/

public static boolean isLogin(Context context) {
        String token = SharedPreferenceUtil.getInstance(context).getString(TOKEN);
if (StringUtils.isEmpty(token))
return false;
else
return true;
    }

public void cleanUserCookie() {
        Editor editor = sharedPreferences.edit();
        editor.clear();
        editor.commit();
    }

/**获取用户商家对于的商家ID*/
public static String getCustId(Context context){
       String userStringInfo=SharedPreferenceUtil.getInstance(context).getString(CUSTBASEINFO);
        UserInfo userInfo=new Gson().fromJson(userStringInfo,UserInfo.class);
if (userInfo!=null)
return userInfo.getCustid();
return "";
    }

/**获取商家基本信息*/
public static CustBaseinfo getCustBseInf(Context context){
        String userStringInfo=SharedPreferenceUtil.getInstance(context).getString(CUSTBASEINFO_STORE);
if (userStringInfo!=null){
            CustBaseinfo custBaseinfo=new Gson().fromJson(userStringInfo,CustBaseinfo.class);
return custBaseinfo;
        }
return null;
    }

/**获取用户Id*/
public static String getUserId(Context context){
        String userInfoString=SharedPreferenceUtil.getInstance(context).getString(CUSTBASEINFO);
if (userInfoString!=null){
            UserInfo userInfo=new Gson().fromJson(userInfoString,UserInfo.class);
if (userInfo!=null)
return userInfo.getUserid();
        }
return "";
    }


}

10.字符串工具类

package com.lianjiu.b.common.utils;


import java.math.BigDecimal;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Various String utility functions. Most of the functions herein are
 * re-implementations of the ones in apache commons StringUtils.
 */
public class StringUtils {

public static final String ERROR_TOAST = "网络环境不给力，请检查网络";
public static final String NO_MORE_DATE = "没有更多数据";
public static final String EMPTY = "";
public static final String SUCCESSCODE = "200";
public static final String SUCCESSDESC = "请求成功";

public static final String EMPTYNUM = "0";

public static final String BLANK_SPACE = " ";

public static String trim(String text) {
if (text == null)
return "";
return text.trim();
    }

/**
 * @param text
 * @return
 * @Description 判断字符串是否为空
 * @author Created by qinxianyuzou on 2014-12-11.
 */
public static boolean isEmpty(String text) {
return text == null || text.trim().compareTo("") == 0 || text.equals("null");
    }

/**
 * Description: 返回字符串本身，防空指针.<br/><br/>
 * Author: Create by Yu.Yao on 2016/9/13.<br/><br/>
 */
public static String removalNull(String defaultString, String text) {
if (isEmpty(text)) {
return defaultString;
        }
return text;
    }

/**
 * Checks if a String is whitespace, empty ("") or null.</p>
 */
public static boolean isBlank(String str) {
int strLen;
if (str == null || (strLen = str.length()) == 0) {
return true;
        }
for (int i = 0; i < strLen; i++) {
if ((Character.isWhitespace(str.charAt(i)) == false)) {
return false;
            }
        }
return true;
    }


public static String listToString(List<String> list, String separator) {
if (list == null || list.size() == 0)
return "";

        StringBuilder string = new StringBuilder();
for (int i = 0; i < list.size(); i++) {
            string.append(list.get(i));
if (i < list.size() - 1) {
                string.append(separator);
            }
        }

return string.toString();
    }

public static String stringArrayToString(String[] array, String separator) {
if (array == null || array.length == 0)
return "";
        StringBuilder string = new StringBuilder();
for (int i = 0; i < array.length; i++) {
            string.append(array[i]).append(separator);
        }
return string.toString();
    }

public final static int getIntValue(String str) {
if (str != null && str.length() > 0) {
try {
return Integer.parseInt(str);
            } catch (Exception e) {
            }
        }
return 0;
    }

public final static long getLongValue(String str) {
if (str != null && str.length() > 0) {
try {
return Long.parseLong(str);
            } catch (Exception e) {
            }
        }
return 0;
    }

public static String removeEmptyChar(String src) {
if (src == null || src.length() == 0)
return src;
return src.replaceAll("[\r]*[\n]*[　]*[ ]*", "");
    }

public static String getFileNameFromUrl(String url) {

// 名字不能只用这个
// 通过 ‘？’ 和 ‘/’ 判断文件名
        String extName = "";
        String filename;
int index = url.lastIndexOf('?');
if (index > 1) {
            extName = url.substring(url.lastIndexOf('.') + 1, index);
        } else {
            extName = url.substring(url.lastIndexOf('.') + 1);
        }
        filename = hashKeyForDisk(url) + "." + extName;
return filename;
    }

/**
 * 一个散列方法,改变一个字符串(如URL)到一个散列适合使用作为一个磁盘文件名。
 */
public static String hashKeyForDisk(String key) {
        String cacheKey;
try {
final MessageDigest mDigest = MessageDigest.getInstance("MD5");
            mDigest.update(key.getBytes());
            cacheKey = bytesToHexString(mDigest.digest());
        } catch (NoSuchAlgorithmException e) {
            cacheKey = String.valueOf(key.hashCode());
        }

return cacheKey;
    }

private static String bytesToHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(0xFF & bytes[i]);
if (hex.length() == 1) {
                sb.append('0');
            }
            sb.append(hex);
        }
return sb.toString();
    }

public static String Md5(String string) {
if (string != null && !string.equals("")) {
try {
                MessageDigest md5 = MessageDigest.getInstance("MD5");
char[] HEX = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
byte[] md5Byte = md5.digest(string.getBytes("UTF8"));
                StringBuffer sb = new StringBuffer();
for (int i = 0; i < md5Byte.length; i++) {
                    sb.append(HEX[(int) (md5Byte[i] & 0xff) / 16]);
                    sb.append(HEX[(int) (md5Byte[i] & 0xff) % 16]);
                }
                string = sb.toString();
            } catch (Exception e) {
            }
        }
return string;
    }

/**
 * 根据各国的手机号码规则，检测输入
 *
 * @param code
 * @param number
 * @return
 * @time 2011-7-22 上午09:41:04
 * @author:linyg
 */
public static boolean phoneNumberValid(String code, String number) {
// 手机号固定在5-20范围内
if (number.length() < 5 || number.length() > 20) {
return false;
        }

        String match = "";
if ("86".equals(code)) {// 中国
if (number.length() != 11) {
return false;
            } else {
                match = "^[1]{1}[0-9]{2}[0-9]{8}$";
            }
        }

// 正则匹配
if (!"".equals(match)) {
return number.matches(match);
        }
return true;
    }

public static boolean phoneNumberValid(String number) {
// 手机号固定在5-20范围内
if (number.length() < 5 || number.length() > 20) {
return false;
        }

        String match = "";
if (number.length() != 11) {
return false;
        } else {
// match = "^[1]{1}[0-9]{2}[0-9]{8}$";
// match = "^(13[0-9]|14[5|7]|15[0-9]|17[0-9]|18[0-9])\\d{8}$";
            match = "^(1[3456789])\\d{9}$";

        }

// 正则匹配
if (!"".equals(match)) {
return number.matches(match);
        }
return true;
    }

/**
 * 判断邮箱地址是否有效限
 */
public static boolean isEmailAddValid(String address) {
if (address != null && address.length() > 0) {
char[] cAddress = address.toCharArray();
for (char c : cAddress) {
if (c > 127) {
return false;
                }
            }

            Pattern p = Pattern.compile("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*");
            Matcher m = p.matcher(address);
return m.matches();
        }
return false;
    }

/**
 * 判断密码是否有效
 * <p>
 * 0 -- 非法；1 -- 正确； 2 -- 不一致
 */
public static int isPasswordValid(String password, String repeated) {
if (password != null) {
int len = password.length();
if (len >= 6 && len <= 16) {
char[] cPsw = password.toCharArray();
boolean wrongChar = false;
for (char c : cPsw) {
if (c >= 128) { // 找到非ascii码
                        wrongChar = true;
break;
                    }
                }
if (!wrongChar) {
return password.equals(repeated) ? 1 : 2;
                }
            }
        }
return 0;
    }

/**
 * 过滤掉 \r 换行 \n回车
 *
 * @param str
 * @return
 */
public static String replaceBlank(String str) {
        String dest = "";
if (str != null) {
            Pattern p = Pattern.compile("\\r+|\n+");
            Matcher m = p.matcher(str);
            dest = m.replaceAll(" ");// .replaceAll(" +", " ");
        }
return dest;
    }

// 半角字符与全角字符混乱所致：这种情况一般就是汉字与数字、英文字母混用,可以避免由于占位导致的排版混乱问题了
public static String ToDBC(String input) {
char[] c = input.toCharArray();
for (int i = 0; i < c.length; i++) {
if (c[i] == 12288) {
                c[i] = (char) 32;
continue;
            }
if (c[i] > 65280 && c[i] < 65375)
                c[i] = (char) (c[i] - 65248);
        }
return new String(c);
    }

public static String ListTOString(ArrayList<String> dataList) {
if (null == dataList || dataList.size() == 0) {
return "";
        }
        StringBuilder str_b = new StringBuilder();
for (String ss : dataList) {
            str_b.append(ss);
            str_b.append("$");
        }
return str_b.substring(0, str_b.length() - 1);

    }

public static <T> boolean isEmptyData(List<T> newData) {
if (newData == null) {
return true;
        } else {
if (newData.size() == 0) {
return true;
            } else {
return false;
            }
        }
    }

/**
 * 方法名称:transMapToString
 * 传入参数:map
 * 返回值:String 形如 username'chenziwen^password'1234
 */
public static String transMapToString(Map map) {
        Map.Entry entry;
        StringBuffer sb = new StringBuffer();
for (Iterator iterator = map.entrySet().iterator(); iterator.hasNext(); ) {
            entry = (Map.Entry) iterator.next();
            sb.append(entry.getKey().toString()).append("'").append(null == entry.getValue() ? "" :
                    entry.getValue().toString()).append(iterator.hasNext() ? "^" : "");
        }
return sb.toString();
    }

/**
 * 方法名称:transStringToMap
 * 传入参数:mapString 形如 username'chenziwen^password'1234
 * 返回值:Map
 */
public static Map transStringToMap(String mapString) {
        Map map = new HashMap();
        StringTokenizer items;
for (StringTokenizer entrys = new StringTokenizer(mapString, "^"); entrys.hasMoreTokens();
             map.put(items.nextToken(), items.hasMoreTokens() ? ((Object) (items.nextToken())) : null))
            items = new StringTokenizer(entrys.nextToken(), "'");
return map;
    }

/**
 * 判断字符串是不是全是数字
 */
public static boolean isNumeric(String str) {
for (int i = str.length(); --i >= 0; ) {
if (!Character.isDigit(str.charAt(i))) {
return false;
            }
        }
return true;
    }

/**
 * 距离格式化
 */
public static String formatDistance(float distance) {
        DecimalFormat df = new DecimalFormat("0.#");
if (distance < 1000) {
return df.format(distance) + "m";
        }
return df.format(distance / 1000) + "km";
    }

public static String formatDistance(double distance) {
        DecimalFormat df = new DecimalFormat("0.#");
if (distance < 1000) {
return df.format(distance) + "m";
        }
return df.format(distance / 1000) + "km";
    }

/*
 校验过程： 
1、从卡号最后一位数字开始，逆向将奇数位(1、3、5等等)相加。 
2、从卡号最后一位数字开始，逆向将偶数位数字，先乘以2（如果乘积为两位数，将个位十位数字相加，即将其减去9），再求和。 
3、将奇数位总和加上偶数位总和，结果应该可以被10整除。 
 */

/**
 * 校验银行卡卡号
 */
public static boolean checkBankCard(String bankCard) {
if (bankCard.length() < 15 || bankCard.length() > 19) {
return false;
        }
char bit = getBankCardCheckCode(bankCard.substring(0, bankCard.length() - 1));
if (bit == 'N') {
return false;
        }
return bankCard.charAt(bankCard.length() - 1) == bit;
    }

/**
 * 从不含校验位的银行卡卡号采用 Luhm 校验算法获得校验位
 *
 * @param nonCheckCodeBankCard
 * @return
 */
public static char getBankCardCheckCode(String nonCheckCodeBankCard) {
if (nonCheckCodeBankCard == null || nonCheckCodeBankCard.trim().length() == 0
                || !nonCheckCodeBankCard.matches("\\d+")) {
//如果传的不是数据返回N
return 'N';
        }
char[] chs = nonCheckCodeBankCard.trim().toCharArray();
int luhmSum = 0;
for (int i = chs.length - 1, j = 0; i >= 0; i--, j++) {
int k = chs[i] - '0';
if (j % 2 == 0) {
                k *= 2;
                k = k / 10 + k % 10;
            }
            luhmSum += k;
        }
return (luhmSum % 10 == 0) ? '0' : (char) ((10 - luhmSum % 10) + '0');
    }

/**
 * 得到一个字符串的长度,显示的长度,一个汉字或日韩文长度为2,英文字符长度为1
 *
 * @param s 需要得到长度的字符串
 * @return int 得到的字符串长度
 */
public static int getStrLength(String s) {
if (s == null)
return 0;
char[] c = s.toCharArray();
int len = 0;
for (int i = 0; i < c.length; i++) {
            len++;
if (!isLetter(c[i])) {
                len++;
            }
        }
return len;
    }


public static boolean isLetter(char c) {
int k = 0x80;
return c / k == 0 ? true : false;
    }




/**
 * 对字符串进行格式化，最多显示长度为length，超过时，其后的内容使用“...代替”
 *
 * @param str
 * @param length
 * @return
 */
public static String regexString(String str, int length) {
if (str.length() > length) {
return str.substring(0, length - 4) + "...";
        }
return str;
    }

/**
 * 对URL进行格式化：构造形式为URL/XXX/XXX
 *
 * @param params
 * @param url
 * @return
 */
public static String formatUrl(List<Object> params, String url) {
        StringBuilder builder = new StringBuilder();
        builder.append(url);
for (Object param : params) {
            builder.append("/" + param);
        }
return builder.toString();
    }


/** 拼接链接完整URL */
public static String generateUrl(String url, Map<String, Object> params) {
        StringBuilder urlBuilder = new StringBuilder(url);
// web接口: url?key=val&key=val&key=val;
if (null != params) {
            urlBuilder.append("?");
            Iterator<Map.Entry<String, Object>> iterator = params.entrySet().iterator();
while (iterator.hasNext()) {
                Map.Entry<String, Object> param = iterator.next();
                String key = param.getKey();
                Object value = param.getValue();
                urlBuilder.append(key).append('=').append(value);
if (iterator.hasNext()) {
                    urlBuilder.append('&');
                }
            }
        }
return urlBuilder.toString();
    }

/**
 * 用于字符串为null会报错的控件
 */
public static String getNoNUllString(String txt) {
if (txt == null)
return "";
return txt;
    }


/**金额为分的格式 */
public static final String CURRENCY_FEN_REGEX = "\\-?[0-9]+";
/**
 * 分转为元
 * @param fen
 * @return
 */
public static String fromFenToYuan(int fen){
if(!String.valueOf(fen).matches(CURRENCY_FEN_REGEX)) {
return "金额格式有误";
        }
        String yuan = BigDecimal.valueOf(fen).divide(new BigDecimal(100)).toString();
return yuan;
    }




}

11.时间倒计时工具类

package com.lianjiu.b.common.utils;

import android.os.Handler;
import android.os.Message;

import java.util.Timer;
import java.util.TimerTask;

/**
 * 时间倒计时工具类
 * 
 * */
public class TimerUtil {

private static TimerUtil instance;
private MyTimer timer;
/**倒计时时间，默认60s*/
private int TIME_DEF=60;
/***/
private int showTime;
/**是否正在进行倒计时*/
private boolean isRunning;

private TimerUtil(){

    }

synchronized public static TimerUtil getInstance(){
if (instance==null)
            instance=new TimerUtil();
return instance;
    }


public void setTime(int time){
this.TIME_DEF=time;
    }


public MyTimer startRunning(){
        showTime=TIME_DEF;
        timer=new MyTimer();
final TimerTask timerTask=new TimerTask() {
@Override
public void run() {
                showTime--;
                Message msg=new Message();
                msg.what=showTime;
                showTimeHandler.sendMessage(msg);
            }
        };
        timer.schedule(timerTask, 1000, 1000);
return timer;
    }

    class MyTimer extends Timer {
public void resCancel(){
this.cancel();
        };
    }


private Handler showTimeHandler=new Handler(){
public void handleMessage(Message msg) {
if (msg.what<=0) {
if(timer!=null)
                    timer.cancel();
                timer=null;
if (mTimerCallBack!=null)
                    mTimerCallBack.donInFinishTime(msg.what);
                isRunning=false;
            }else{
if (mTimerCallBack!=null)
                    mTimerCallBack.doInRunTime(msg.what);
            }
        };
    };


public interface TimerCallBack{
public void doInRunTime(int time);
public void donInFinishTime(int time);
    }

private TimerCallBack mTimerCallBack;
public void setTimerCallBack(TimerCallBack timerCallBack){
this.mTimerCallBack=timerCallBack;
    }


}

12.时间相关工具类

package com.lianjiu.b.common.utils;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class TimeUtil {

/**
 * 格式化时间 如：12小时前
 * 
 * @param timestr
 * 秒
 */
public static String fmttoCN(String timestr) {
        String timeText = null;
if (null == timestr || "".equals(timestr)) {
return "";
        }

long time = Long.valueOf(timestr);
// SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMddHHmmss");
// try {
// time = dateFormat.parse(timestr).getTime();
// } catch (ParseException e) {
// e.printStackTrace();
// }

        Date dt = new Date();
long nowSec = dt.getTime();
long timediff = (nowSec - time) / 1000;
if (timediff < 60) {
// 小与1分钟显示 ‘刚刚’
            timeText = "刚刚";
        } else if (timediff >= 60 && timediff < 60 * 60) {
// 小于1小时 显示‘分钟’
            timeText = String.valueOf((int) timediff / 60) + "分钟前";
        } else if (timediff >= 60 * 60 && timediff < 24 * 60 * 60) {
// 小于24小时，则显示‘时’
            timeText = String.valueOf((int) timediff / (60 * 60)) + "小时前";
        } else if (timediff >= 24 * 60 * 60 && timediff < 30 * 24 * 60 * 60) {
// 小于1个月，则显示‘天’
            timeText = String.valueOf((int) timediff / (24 * 60 * 60)) + "天前";
        } else if (timediff >= 30 * 24 * 60 * 60 && timediff < 12 * 30 * 24 * 60 * 60) {
// 小于1年，则显示‘月’
            timeText = String.valueOf((int) timediff / (30 * 24 * 60 * 60)) + "个月前";
        } else if (timediff >= 12 * 30 * 24 * 60 * 60) {
// 大于1年显示‘年’
            timeText = String.valueOf((int) timediff / (12 * 30 * 24 * 60 * 60)) + "年前";
        }

return timeText;

    }

/**
 * 时间转换
 * @param dataFormat
 * @param timeStamp
 * @return
 */
public static String formatData(String dataFormat, long timeStamp) {
if (timeStamp == 0) {
return "";
        }
        timeStamp = timeStamp * 1000;
        String result = "";
        SimpleDateFormat format = new SimpleDateFormat(dataFormat);
        result = format.format(new Date(timeStamp));
return result;
    }


// public static String timeToStr(String timestr) {
// String timeText = null;
// if (null == timestr || "".equals(timestr)) {
// return "";
// }
// long time = Long.valueOf(timestr);
// if(isSameDay(time)){
// timeText = "今天"+longToTime(time, "kk:mm");
// }else{
// 
// }
// Date dt = new Date();
// long nowSec = dt.getTime();
// long timediff = (nowSec - time) / 1000;
// if (timediff < 24 * 60 * 60) {
// timeText = "今天"+longToTime(time, "kk:mm");
// } else if (timediff >= 24 * 60 * 60 && timediff < 2 * 24 * 60 * 60) {
// timeText = "昨天"+longToTime(time, "kk:mm");
// } else{
// timeText = longToTime(time, "yyyy-MM-dd kk:mm");
// }
// return timeText;
// }

/**
 * @author LuoB.
 * @param oldTime 较小的时间
 * @param newTime 较大的时间 (如果为空 默认当前时间 ,表示和当前时间相比)
 * @return -1 ：同一天. 0：昨天 . 1 ：至少是前天.
 * @throws ParseException 转换异常
 */
public static String timeToStr(String oldTime){


try {
            Date today;
//将下面的 理解成 yyyy-MM-dd 00：00：00 更好理解点
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            String todayStr = format.format(new Date());
            today = format.parse(todayStr);
long time = Long.valueOf(oldTime);
            Date olddate  =  new Date(time);
//昨天 86400000=24*60*60*1000 一天
if((today.getTime()-olddate.getTime())>0 && (today.getTime()-olddate.getTime())<=86400000) {
return "昨天"+longToTime(time, "HH:mm");
            }
else if((today.getTime()-olddate.getTime())<=0){ //至少是今天
return "今天"+longToTime(time, "HH:mm");
            }
else{ //至少是前天
return longToTime(time, "yyyy-MM-dd HH:mm");
            }
        } catch (ParseException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
        }

return "";
    }


/**
 * @param time
 * 时间
 * @param level
 * 参考Calendar
 * @return "yyyy-MM-dd kk:mm:ss" 格式的时间
 */
public static String longToTime(long time, int level) {
        String format = "yyyy-MM-dd HH:mm:ss";
switch (level) {
case Calendar.MINUTE: {
            format = "yyyy-MM-dd HH:mm";
        }
break;
case Calendar.HOUR: {
            format = "yyyy-MM-dd HH";
        }
break;
case Calendar.DATE: {
            format = "yyyy-MM-dd";
        }
break;
case Calendar.MONTH: {
            format = "yyyy-MM";
        }
break;
case Calendar.YEAR: {
            format = "yyyy";
        }
break;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
return sdf.format(time);
    }

public static String longToTime(long time, String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
return sdf.format(time);
    }

/** 时间转换为long */
public static long timeToSecond(String time, int level) {
        String format = "yyyy-MM-dd HH:mm:ss";
switch (level) {
case Calendar.MINUTE: {
            format = "yyyy-MM-dd HH:mm";
        }
break;
case Calendar.HOUR: {
            format = "yyyy-MM-dd HH";
        }
break;
case Calendar.DATE: {
            format = "yyyy-MM-dd";
        }
break;
case Calendar.MONTH: {
            format = "yyyy-MM";
        }
break;
case Calendar.YEAR: {
            format = "yyyy";
        }
break;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date date = null;
long second = 0;
try {
            date = sdf.parse(time);
        } catch (ParseException e) {
            e.printStackTrace();
        }
if (date != null) {
            second = date.getTime();
        }
return second;
    }


/** 时间转换为long */
public static long timeToSecond2(String time, int level) {
        String format = "yyyy年MM月dd日HH时:mm分:ss秒";
switch (level) {
case Calendar.MINUTE: {
            format = "yyyy年MM月dd日HH时mm分";
        }
break;
case Calendar.HOUR: {
            format = "yyyy年MM月dd日HH时";
        }
break;
case Calendar.DATE: {
            format = "yyyy年MM月dd日";
        }
break;
case Calendar.MONTH: {
            format = "yyyy年MM月";
        }
break;
case Calendar.YEAR: {
            format = "yyyy年";
        }
break;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date date = null;
long second = 0;
try {
            date = sdf.parse(time);
        } catch (ParseException e) {
            e.printStackTrace();
        }
if (date != null) {
            second = date.getTime();
        }
return second;
    }

/** 时间转换为long */
public static long timeToSecond3(String time, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date date = null;
long second = 0;
try {
            date = sdf.parse(time);
        } catch (ParseException e) {
            e.printStackTrace();
        }
if (date != null) {
            second = date.getTime();
        }
return second;
    }

public static String longToTime2(long time) {
        String format = "yyyy/MM/dd";
        SimpleDateFormat sdf = new SimpleDateFormat(format);
return sdf.format(time);
    }



/**
 * 将秒转换为时间格式（00：00）
 * 
 * @param s
 * 秒数
 * @return
 */
public static String secToTime(int s) {
        String time = null;

int m = s / 60; // 分
        s = s - (m * 60); // 秒

        time = String.format("%02d:%02d", m, s);

return time;
    }

// date
public static String getMonth(long time) {
        Date date = new Date(time);
        SimpleDateFormat formatter = new SimpleDateFormat("M");
        formatter.format(date);
return formatter.format(date);
    }

// date
public static String getDay(long time) {
        Date date = new Date(time);
        SimpleDateFormat formatter = new SimpleDateFormat("d");
        formatter.format(date);
return formatter.format(date);
    }

// date
public static String getWeek(long time) {
        Date date = new Date(time);
        SimpleDateFormat formatter = new SimpleDateFormat("EEEE");
        formatter.format(date);
return formatter.format(date);
    }

public static String[] getDatas() {
        String[] datas = new String[60];
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat format = new SimpleDateFormat("MM月dd日 EEEE");
        datas[0] = format.format(calendar.getTime());
for (int i = 1; i < 60; i++) {
            calendar.add(Calendar.DATE, 1);
            datas[i] = format.format(calendar.getTime());
        }

return datas;

    }

public static String formatAmPmToCN(long time) {
        SimpleDateFormat sdf = new SimpleDateFormat("MM月dd日ahh时mm分");
return sdf.format(new Date(time));
    }
public static String formatAmPmToCN2(long time) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
return sdf.format(new Date(time));
    }
public static String formatAllAmPmToCN(long time) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 a hh时mm分ss秒");
return sdf.format(new Date(time));
    }


/**今天时间*/
public static String todayTime(String pattern){
        SimpleDateFormat sdf=new SimpleDateFormat(pattern);
return sdf.format(new Date());
    }

/**
 * 字符串转换成日期
 * @param str:time
 * @param pattern:格式
 * @return date：date
 */
public static Date StrToDate(String str, String pattern) {

        SimpleDateFormat format = new SimpleDateFormat(pattern);
        Date date = null;
try {
            date = format.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
return date;
    }

/**格式化时间*/
public static String fmTime(Date date, String pattern){
        SimpleDateFormat sdf=new SimpleDateFormat(pattern);
return sdf.format(date);
    }

/**比较两个时间那个前，哪个后
 *
 * @param DATE1:开始时间
 *
 * @param DATE2:结束时间
 *
 * @param pattern:时间格式，如："yyyy年MM月dd日"
 * 
 * @return 
 * 1:DATE1在DATE2之前
 * -1:DATE1在DATE2之后
 * 0:DATE1、DATE2同一时间
 * 
 * */
public static int compare_date(String DATE1, String DATE2, String pattern) {
        DateFormat df = new SimpleDateFormat(pattern);
try {
            Date dt1 = df.parse(DATE1);
            Date dt2 = df.parse(DATE2);
if (dt1.getTime() > dt2.getTime()) {
return 1;
            } else if (dt1.getTime() < dt2.getTime()) {
return -1;
            } else {
return 0;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
return 0;
    }

/**
 * 判断当前时间是否在上午9点到下午9点内
 * @return
 */
public static boolean compareIn9(){
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

try {
            String today = todayTime("yyyy-MM-dd");
            Date dt1 = df.parse(today+" 09:00:00");
            Date dt2 = df.parse(today+" 20:00:00");
            Date now = new Date();
if (now.getTime() >= dt1.getTime() && now.getTime() <=dt2.getTime()) {
return true;
            } else {
return false;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
return false;
    }

public static String hasTimeNow(long time){
long today = new Date().getTime();
long mis = today - time;

int hour = (int)(mis/(3600*1000));
int mu = (int) (mis/(60*1000));
return hour>0?hour+"小时":mu+"分钟";        
    }
}

12.Toast相关工具类

package com.lianjiu.b.common.utils;

import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.widget.Toast;

public class ToastHelper {
private static Handler handler = new Handler(Looper.getMainLooper());
private static ToastHelper toast;
private static Toast toast1 = null;
private Context context;
private static Object synObj = new Object();
public static ToastHelper getInstance() {
if (toast == null) {
            toast = new ToastHelper();
        }
return toast;
    }

public void init(Context context) {
this.context = context;
    }

public Toast _toast(String str) {
return displayToastShort(str);
    }

/**
 * 显示Toast，duration为short
 *
 *
 * {@link Context} 当前窗体的上下文
 * @param str
 * {@link String} 消息主体
 *
 */
public Toast displayToastShort(String str) {
        Toast toast = Toast.makeText(context, str, Toast.LENGTH_SHORT);
        toast.show();
return toast;
    }

/**
 * 显示Toast，duration为long
 *
 *
 * {@link Context} 当前窗体的上下文
 * @param str
 * {@link String} 消息主体
 *
 */
public void displayToastLong(String str) {
        Toast.makeText(context, str, Toast.LENGTH_LONG).show();
    }
/**
 * 快速关闭toast
 * 不停的疯狂的点击某个按钮，触发了toast以后，toast内容会一直排着队的显示出来，不能很快的消失。这样可能会影响用户的使用。
 *
 *
 * {@link Context} 当前窗体的上下文
 * @param str
 * {@link String} 消息主体
 *
 * */

public  void displayToastWithQuickClose(
final String str) {
new Thread(new Runnable() {

public void run() {
                handler.post(new Runnable() {

public void run() {
synchronized (synObj) {
if (toast1 != null) {
                                toast1.setText(str);
                                toast1.setDuration(Toast.LENGTH_SHORT);
                            } else {
                                toast1 = Toast.makeText(context, str,
                                        Toast.LENGTH_SHORT);
                            }
                            toast1.show();
                        }
                    }
                });
            }
        }).start();
    }
}

13.UI相关工具类：

/**
 * 获取屏幕分辨率：宽
 *
 * @param context
 * @return
 */
public static int getScreenPixWidth(Context context) {
        DisplayMetrics dm = new DisplayMetrics();
if (!(context instanceof Activity)) {
            dm = context.getResources().getDisplayMetrics();
return dm.widthPixels;
        }

        WindowManager wm = ((Activity) context).getWindowManager();
if (wm == null) {
            dm = context.getResources().getDisplayMetrics();
return dm.widthPixels;
        }

        wm.getDefaultDisplay().getMetrics(dm);
return dm.widthPixels;
    }

/**
 * 获取屏幕分辨率：高
 *
 * @param context
 * @return
 */
public static int getScreenPixHeight(Context context) {
        DisplayMetrics dm = new DisplayMetrics();
if (!(context instanceof Activity)) {
            dm = context.getResources().getDisplayMetrics();
return dm.heightPixels;
        }

        WindowManager wm = ((Activity) context).getWindowManager();
if (wm == null) {
            dm = context.getResources().getDisplayMetrics();
return dm.heightPixels;
        }

        wm.getDefaultDisplay().getMetrics(dm);
return dm.heightPixels;

    }


/**
 * 获取当前手机的独立像素
 *
 * @param context
 * @return
 */
public static float getDensity(Context context) {
return context.getResources().getDisplayMetrics().density;
    }

/**
 * dp2px
 */
public static int dip2px(float dipValue) {
return (int) (dipValue * getDensity(AppApplication.getInstance()) + 0.5f);
    }

/**
 * px2dp
 */
public static int px2dip(float pxValue) {
return (int) (pxValue / getDensity(AppApplication.getInstance()) + 0.5f);
    }

public static void openBrowser(Context context, String url) {
        Intent intent = new Intent();
        intent.setAction(Intent.ACTION_VIEW);
        LogUtil.d("down", "" + url);
        Uri content_url = Uri.parse(url);
        intent.setData(content_url);
        context.startActivity(intent);
    }

public static void cancleAllNotification(Context context) {
        NotificationManager nm = (NotificationManager)     context.getSystemService(Context.NOTIFICATION_SERVICE);
        nm.cancelAll();
    }

/**
 * 版本更新，显示加载的进度框
 */
public static void showProgress(Context context,int maxProgress,OnDialogClickListener loadListener)
    {
        ProgressDialog progressDialog=new ProgressDialog(context);
        progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);//设置水平的进度
        progressDialog.setMax(maxProgress);
        progressDialog.show();
        loadListener.onClick();
    }

//使用Glide加载图片，需要Glide的jar包
/**带默认图*/
public static void imageNet(Context context, String url, ImageView view, boolean isLocal, int defaltIcon) {
if (!StringUtils.isEmpty(url) && url.startsWith("http")) {
            imageNet2(context, url, view, isLocal, defaltIcon);
        } else {
            Glide.with(context).load(isLocal ? url : getImgUrl(url)).diskCacheStrategy(DiskCacheStrategy.SOURCE).dontAnimate().placeholder(defaltIcon).into(view);
        }

    }

/**不带默认图*/
public static void imageNet(Context context, String url, ImageView view, boolean isLocal) {
if (!StringUtils.isEmpty(url) && url.startsWith("http")) {
            imageNet2(context, url, view, isLocal);
        } else {
            Glide.with(context).load(isLocal ? url : getImgUrl(url)).diskCacheStrategy(DiskCacheStrategy.SOURCE).dontAnimate().into(view);
        }

    }

public static void imageNet2(Context context, String url, ImageView view, boolean isLocal, int defaltIcon) {
        Glide.with(context).load(isLocal ? url : url).diskCacheStrategy(DiskCacheStrategy.SOURCE).dontAnimate().placeholder(defaltIcon).into(view);
    }

/**不带默认图*/
public static void imageNet2(Context context, String url, ImageView view, boolean isLocal ) {
        Glide.with(context).load(isLocal ? url : url).diskCacheStrategy(DiskCacheStrategy.SOURCE).dontAnimate().into(view);
    }

public static String getImgUrl(String url) {
// return Config.TEST_IMG_BASE_URL + url;
return "";
    }

/*
 * 按正方形裁切图片
 */
public static Bitmap ImageCrop(Bitmap bitmap) {
int w = bitmap.getWidth(); // 得到图片的宽，高
int h = bitmap.getHeight();

if (w == h) {
return bitmap;
        } else {
int wh = w > h ? h : w;// 裁切后所取的正方形区域边长

int retX = w > h ? (w - h) / 2 : 0;// 基于原图，取正方形左上角x坐标
int retY = w > h ? 0 : (h - w) / 2;

// 下面这句是关键
return Bitmap.createBitmap(bitmap, retX, retY, wh, wh, null, false);
        }

    }

public static void deleteAllFiles(File root) {
        File files[] = root.listFiles();
if (files != null)
for (File f : files) {
if (f.isDirectory()) { // 判断是否为文件夹
                    deleteAllFiles(f);
try {
                        f.delete();
                    } catch (Exception e) {
                    }
                } else {
if (f.exists()) { // 判断是否存在
                        deleteAllFiles(f);
try {
                            f.delete();
                        } catch (Exception e) {
                        }
                    }
                }
            }
    }

/**
 * TextView非空校验
 */
public static boolean checkTv(BaseActivity activity, TextView ...tv) {
for (TextView textView:tv){
            String temp = textView.getText().toString().trim();
if (StringUtils.isEmpty(temp)) {
return false;
            }
        }

return true;
    }

/**
 * TextView非空校验，空则吐司提示
 */
public static boolean checkTv(BaseActivity activity, TextView tv, String msg) {
        String temp = tv.getText().toString().trim();
if (StringUtils.isEmpty(temp)) {
            activity.showToast(msg);
return false;
        }
return true;
    }


/**
 * TextView非空校验，空则添加晃动动画效果+吐司提示
 * */
public static boolean checkTvWithAnim(BaseActivity activity, TextView tv, String msg) {
        String temp = tv.getText().toString().trim();
if (StringUtils.isEmpty(temp)) {
            startShakeAnimation(tv);
            activity.showToast(msg);
return false;
        }
return true;
    }

/**验证TextView中的文本长度至少N个字符*/
public static boolean checkTvLimit(BaseActivity activity,TextView tv,int limit,String msg){
        String temp = tv.getText().toString().trim();
if (temp.length()<limit){
            startShakeAnimation(tv);
            activity.showToast(msg);
return false;
        }
return true;
    }

/**验证TextView中的文本长度至少N个字符*/
public static boolean checkTvLimit(BaseActivity activity,TextView tv,int limitlef,int limitright,String msg){
        String temp = tv.getText().toString().trim();
if (temp.length()<limitlef||temp.length()>limitright){
            startShakeAnimation(tv);
            activity.showToast(msg);
return false;
        }
return true;
    }


/**
 * 开始晃动动画
 */
public static void startShakeAnimation(TextView textView) {
if (textView.getAnimation() == null) {
            textView.setAnimation(shakeAnimation(4));
        }
        textView.startAnimation(textView.getAnimation());
    }

/**
 * 晃动动画
 *
 * @param counts 0.5秒钟晃动多少下
 */
public static Animation shakeAnimation(int counts) {
        TranslateAnimation animation = new TranslateAnimation(0, 10, 0, 0);
        animation.setInterpolator(new CycleInterpolator(counts));
        animation.setDuration(500);
return animation;
    }


/**验证手机号码是否正确，不正确则提示，并晃动窗口*/
public static boolean checkPhoneNumberAvailable(BaseActivity activity,TextView phoneView){
        String phoneNum=phoneView.getText().toString().trim();
if (StringUtils.isEmpty(phoneNum)){
            activity.showToast("手机号不能为空");
            startShakeAnimation(phoneView);
return false;
        }else if (!StringUtils.phoneNumberValid(phoneNum)){
            activity.showToast("请输入正确的手机号");
            startShakeAnimation(phoneView);
return false;
        }
return true;
    }

/**
 * 判断密码是否一致
 */
public static boolean checkPwdSame(BaseActivity activity,TextView tv,TextView tvConfirm,String msg){
        String temp=tv.getText().toString().trim();
        String tempConfirm=tvConfirm.getText().toString().trim();
if(temp.equals(tempConfirm)){
return true;
        }
        activity.showToast(msg);
return false;
    }