hienlt0610
5/25/2019 - 7:21 PM

Android Utils

package dev.yong.wheel.utils;

import android.app.Activity;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.os.Build;
import android.support.annotation.ColorInt;
import android.support.v7.app.ActionBar;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;

/**
 * @author coderyong
 */
public class StatusBarUtils {

    /**
     * 沉浸状态栏
     *
     * @param activity 需要设置的activity
     * @param color    状态栏颜色值
     */
    public static void setColor(Activity activity, @ColorInt int color) {
        setColor(activity, color, false);
    }

    /**
     * 沉浸状态栏
     *
     * @param activity 需要设置的activity
     * @param color    状态栏颜色值
     */
    public static void setColor(Activity activity, @ColorInt int color, boolean isLight) {
        if (color != 0) {
            // 绘制一个和状态栏一样高的矩形
            View statusView = new View(activity);
            statusView.setBackgroundColor(color);
            setView(activity, statusView, isLight);
        }
    }

    /**
     * 设置一个假的状态栏
     *
     * @param activity   需要设置的activity
     * @param statusView 状态栏View
     */
    public static void setView(Activity activity, View statusView) {
        setView(activity, statusView, false);
    }

    /**
     * 设置一个假的状态栏
     *
     * @param activity   需要设置的activity
     * @param statusView 状态栏View
     */
    public static void setView(Activity activity, View statusView, boolean isLight) {
        //去除 ActionBar 阴影
        if (hasActionBar(activity)) {
            if (activity instanceof AppCompatActivity) {
                ActionBar actionBar = ((AppCompatActivity) activity).getSupportActionBar();
                if (actionBar != null) {
                    actionBar.setElevation(0);
                }
            } else {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                    android.app.ActionBar actionBar = activity.getActionBar();
                    if (actionBar != null) {
                        actionBar.setElevation(0);
                    }
                }
            }
        }
        translucent(activity, false, isLight);
        ViewGroup contentLayout = activity.findViewById(android.R.id.content);
        // 设置Activity layout的fitsSystemWindows
        View child = contentLayout.getChildAt(0);
        if (child != null) {
            child.setFitsSystemWindows(true);
        }

        ViewGroup.LayoutParams params = new ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.MATCH_PARENT, getHeight(activity));

        contentLayout.addView(statusView, params);
    }

    /**
     * 设置状态栏透明
     *
     * @param activity 需要设置的activity
     */
    public static void translucent(Activity activity, boolean addBarHeight) {
        translucent(activity, addBarHeight, false);
    }

    /**
     * 设置状态栏透明
     *
     * @param activity 需要设置的activity
     */
    public static void translucent(Activity activity, boolean addBarHeight, boolean isLight) {
        Window window = activity.getWindow();
        //4.4 全透明状态栏
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            window.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
        }
        //5.0 全透明实现
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
            int visibility = View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                    | (isLight && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ? View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR : 0);
            window.getDecorView().setSystemUiVisibility(visibility);
            window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
            window.setStatusBarColor(Color.TRANSPARENT);
        }
        if (addBarHeight) {
            int barHeight = getHeight(activity);
            if (hasActionBar(activity)) {
                barHeight += getActionBarHeight(activity);
            }
            ViewGroup rootView = window.getDecorView().findViewById(android.R.id.content);
            rootView.setPadding(0, barHeight, 0, 0);
        }
    }

    private static boolean hasActionBar(Activity activity) {
        if (activity instanceof AppCompatActivity) {
            return ((AppCompatActivity) activity).getSupportActionBar() != null;
        } else {
            return activity.getActionBar() != null;
        }
    }

    private static int getActionBarHeight(Activity activity) {
        TypedArray attrs = activity.obtainStyledAttributes(new int[]{
                android.R.attr.actionBarSize
        });
        attrs.recycle();
        return (int) attrs.getDimension(0, 0);
    }

    /**
     * 获取状态栏高度
     *
     * @param activity 需要设置的activity
     */
    public static int getHeight(Activity activity) {
        // 获得状态栏高度
        int resourceId = activity.getResources().getIdentifier("status_bar_height", "dimen", "android");
        return activity.getResources().getDimensionPixelSize(resourceId);
    }

    /**
     * 隐藏状态栏
     *
     * @param activity 需要设置的activity
     */
    public static void hide(Activity activity) {
        activity.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
    }
}
package dev.yong.wheel.utils;

import android.support.annotation.IntDef;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

/**
 * @author CoderYong
 */
public class TimeUtils {

    private static final String DEFAULT_FORMAT = "yyyy-MM-dd HH:mm:ss";

    public static final int MILLISECOND = 1;
    public static final int SECOND = 1000;
    public static final int MINUTE = 60000;
    public static final int HOUR = 3600000;
    public static final int DAY = 86400000;

    @IntDef({MILLISECOND, SECOND, MINUTE, HOUR, DAY})
    @Retention(RetentionPolicy.SOURCE)
    public @interface Unit {
    }

    private TimeUtils() {
        throw new UnsupportedOperationException("Cannot be created");
    }

    /**
     * 获默认格式日期当前日期(默认格式为 年-月-日 时:分:秒)
     * <p>默认格式为 yyyy-MM-dd HH:mm:ss</p>
     *
     * @return 字符串日期
     */
    public static String getCurrentDate() {
        return getDate(System.currentTimeMillis(), DEFAULT_FORMAT);
    }

    /**
     * 获指定格式当前日期(默认格式为 年-月-日 时:分:秒)
     * <p>默认格式为 yyyy-MM-dd HH:mm:ss</p>
     *
     * @return 字符串日期
     */
    public static String getCurrentDate(String strFormat) {
        return getDate(System.currentTimeMillis(), strFormat);
    }

    /**
     * 获默认格式日期(默认格式为 年-月-日 时:分:秒)
     * <p>默认格式为 yyyy-MM-dd HH:mm:ss</p>
     *
     * @param millis 毫秒时间戳
     * @return 字符串日期
     */
    public static String getDate(long millis) {
        return getDate(millis + "", DEFAULT_FORMAT);
    }

    /**
     * 获默认格式日期(默认格式为 年-月-日 时:分:秒)
     * <p>默认格式为 yyyy-MM-dd HH:mm:ss</p>
     *
     * @param millisStr 字符串毫秒时间戳
     * @return 字符串日期
     */
    public static String getDate(String millisStr) {
        return getDate(millisStr, DEFAULT_FORMAT);
    }

    /**
     * 获取格式日期(默认格式为 年-月-日 时:分:秒)
     * <p>默认格式为 yyyy-MM-dd HH:mm:ss</p>
     *
     * @param millis    毫秒时间戳
     * @param strFormat 日期格式
     * @return 字符串日期
     */
    public static String getDate(long millis, String strFormat) {
        return getDate(millis + "", strFormat);
    }

    /**
     * 获取格式日期(默认格式为 年-月-日 时:分:秒)
     * <p>默认格式为 yyyy-MM-dd HH:mm:ss</p>
     *
     * @param millisStr 字符串毫秒时间戳
     * @param strFormat 日期格式
     * @return 字符串日期
     */
    public static String getDate(String millisStr, String strFormat) {
        try {
            SimpleDateFormat format = new SimpleDateFormat(strFormat, Locale.getDefault());
            return format.format(new Date(Long.parseLong(millisStr)));
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalStateException("Invalid timestamp");
        }
    }

    /**
     * 获取默认时间戳(默认格式为 年-月-日 时:分:秒)
     * <p>默认格式为 yyyy-MM-dd HH:mm:ss</p>
     *
     * @param date 日期
     * @return 时间戳
     */
    public static long getMillis(String date) {
        return getMillis(date, DEFAULT_FORMAT);
    }

    /**
     * 获取时间戳(默认格式为 年-月-日 时:分:秒)
     * <p>默认格式为 yyyy-MM-dd HH:mm:ss</p>
     *
     * @param date      日期
     * @param strFormat 日期格式
     * @return 时间戳
     */
    public static long getMillis(String date, String strFormat) {
        SimpleDateFormat format = new SimpleDateFormat(strFormat, Locale.getDefault());
        try {
            return format.parse(date).getTime();
        } catch (ParseException e) {
            throw new IllegalStateException("Invalid date");
        }
    }

    /**
     * 获取指定日期与当前时间的间隔时间
     *
     * @param date 日期
     * @param unit 跨度单位
     *             <ul>
     *             <li>{@link #MILLISECOND}</li>
     *             <li>{@link #SECOND }</li>
     *             <li>{@link #MINUTE }</li>
     *             <li>{@link #HOUR}</li>
     *             <li>{@link #DAY }</li>
     *             </ul>
     * @return 返回间隔时间
     */
    public static long getTimeSpanByNow(String date, @Unit int unit) {
        return getTimeSpan(System.currentTimeMillis(), getMillis(date), unit);
    }

    /**
     * 获取指定日期与当前时间的间隔时间
     *
     * @param date      日期
     * @param strFormat 日期格式
     * @param unit      跨度单位
     *                  <ul>
     *                  <li>{@link #MILLISECOND}</li>
     *                  <li>{@link #SECOND }</li>
     *                  <li>{@link #MINUTE }</li>
     *                  <li>{@link #HOUR}</li>
     *                  <li>{@link #DAY }</li>
     *                  </ul>
     * @return 返回间隔时间
     */
    public static long getTimeSpanByNow(String date, String strFormat, @Unit int unit) {
        return getTimeSpan(getMillis(getCurrentDate(strFormat)), getMillis(date, strFormat), unit);
    }

    /**
     * 获取指定时间与当前时间的间隔时间
     *
     * @param millis 毫秒时间戳
     * @param unit   跨度单位
     *               <ul>
     *               <li>{@link #MILLISECOND}</li>
     *               <li>{@link #SECOND }</li>
     *               <li>{@link #MINUTE }</li>
     *               <li>{@link #HOUR}</li>
     *               <li>{@link #DAY }</li>
     *               </ul>
     * @return 返回间隔时间
     */
    public static long getTimeSpanByNow(long millis, @Unit int unit) {
        return getTimeSpan(System.currentTimeMillis(), millis, unit);
    }

    /**
     * 获取间隔时间
     *
     * @param date1 日期1
     * @param date2 日期2
     * @param unit  跨度单位
     *              <ul>
     *              <li>{@link #MILLISECOND}</li>
     *              <li>{@link #SECOND }</li>
     *              <li>{@link #MINUTE }</li>
     *              <li>{@link #HOUR}</li>
     *              <li>{@link #DAY }</li>
     *              </ul>
     * @return 返回间隔时间
     */
    public static long getTimeSpan(String date1, String date2, @Unit int unit) {
        return millis2TimeSpan(Math.abs(getMillis(date1) - getMillis(date2)), unit);
    }

    /**
     * 获取间隔时间
     *
     * @param date1     日期1
     * @param date2     日期2
     * @param strFormat 日期格式
     * @param unit      跨度单位
     *                  <ul>
     *                  <li>{@link #MILLISECOND}</li>
     *                  <li>{@link #SECOND }</li>
     *                  <li>{@link #MINUTE }</li>
     *                  <li>{@link #HOUR}</li>
     *                  <li>{@link #DAY }</li>
     *                  </ul>
     * @return 返回间隔时间
     */
    public static long getTimeSpan(String date1, String date2, String strFormat, @Unit int unit) {
        return millis2TimeSpan(Math.abs(
                getMillis(date1, strFormat) - getMillis(date2, strFormat)), unit);
    }

    /**
     * 获取间隔时间
     *
     * @param millis1 毫秒时间戳1
     * @param millis2 毫秒时间戳2
     * @param unit    跨度单位
     *                <ul>
     *                <li>{@link #MILLISECOND}</li>
     *                <li>{@link #SECOND}</li>
     *                <li>{@link #MINUTE}</li>
     *                <li>{@link #HOUR}</li>
     *                <li>{@link #DAY}</li>
     *                </ul>
     * @return 返回间隔时间
     */
    public static long getTimeSpan(long millis1, long millis2, @Unit int unit) {
        return millis2TimeSpan(Math.abs(millis1 - millis2), unit);
    }

    private static long timeSpan2Millis(long timeSpan, @Unit int unit) {
        return timeSpan * unit;
    }

    private static long millis2TimeSpan(long millis, @Unit int unit) {
        return millis / unit;
    }

    /**
     * 获取指定日期与当前时间带有精确单位的时间间隔
     *
     * @param date 日期
     * @param unit 跨度单位
     *             <ul>
     *             <li>{@link #DAY} return 天</li>
     *             <li>{@link #HOUR} return 天, 小时</li>
     *             <li>{@link #MINUTE} return 天, 小时, 分钟</li>
     *             <li>{@link #SECOND}return 天, 小时, 分钟, 秒</li>
     *             <li>{@link #MILLISECOND} return 天, 小时, 分钟, 秒, 毫秒</li>
     *             </ul>
     * @return 返回间隔时间
     */
    public static String getFitTimeSpanByNow(String date, @Unit int unit) {
        return getFitTimeSpan(System.currentTimeMillis(), getMillis(date), unit);
    }

    /**
     * 获取指定日期与当前时间带有精确单位的时间间隔
     *
     * @param date 日期
     * @param unit 跨度单位
     *             <ul>
     *             <li>{@link #DAY} return 天</li>
     *             <li>{@link #HOUR} return 天, 小时</li>
     *             <li>{@link #MINUTE} return 天, 小时, 分钟</li>
     *             <li>{@link #SECOND}return 天, 小时, 分钟, 秒</li>
     *             <li>{@link #MILLISECOND} return 天, 小时, 分钟, 秒, 毫秒</li>
     *             </ul>
     * @return 返回间隔时间
     */
    public static String getFitTimeSpanByNow(String date, String strFormat, @Unit int unit) {
        return getFitTimeSpan(getMillis(getCurrentDate(strFormat), strFormat), getMillis(date, strFormat), unit);
    }

    /**
     * 获取指定时间与当前时间带有精确单位的时间间隔
     *
     * @param millis 毫秒时间戳
     * @param unit   跨度单位
     *               <ul>
     *               <li>{@link #DAY} return 天</li>
     *               <li>{@link #HOUR} return 天, 小时</li>
     *               <li>{@link #MINUTE} return 天, 小时, 分钟</li>
     *               <li>{@link #SECOND}return 天, 小时, 分钟, 秒</li>
     *               <li>{@link #MILLISECOND} return 天, 小时, 分钟, 秒, 毫秒</li>
     *               </ul>
     * @return 返回间隔时间
     */
    public static String getFitTimeSpanByNow(long millis, @Unit int unit) {
        return getFitTimeSpan(System.currentTimeMillis(), millis, unit);
    }

    /**
     * 获取带有精确单位的时间间隔
     *
     * @param date1 日期1
     * @param date2 日期2
     * @param unit  跨度单位
     *              <ul>
     *              <li>{@link #DAY} return 天</li>
     *              <li>{@link #HOUR} return 天, 小时</li>
     *              <li>{@link #MINUTE} return 天, 小时, 分钟</li>
     *              <li>{@link #SECOND}return 天, 小时, 分钟, 秒</li>
     *              <li>{@link #MILLISECOND} return 天, 小时, 分钟, 秒, 毫秒</li>
     *              </ul>
     * @return 返回间隔时间
     */
    public static String getFitTimeSpan(String date1, String date2, @Unit int unit) {
        return millis2FitTimeSpan(Math.abs(getMillis(date1) - getMillis(date2)), unit);
    }

    /**
     * 获取带有精确单位的时间间隔
     *
     * @param date1     日期1
     * @param date2     日期2
     * @param strFormat 日期格式
     * @param unit      跨度单位
     *                  <ul>
     *                  <li>{@link #DAY} return 天</li>
     *                  <li>{@link #HOUR} return 天, 小时</li>
     *                  <li>{@link #MINUTE} return 天, 小时, 分钟</li>
     *                  <li>{@link #SECOND}return 天, 小时, 分钟, 秒</li>
     *                  <li>{@link #MILLISECOND} return 天, 小时, 分钟, 秒, 毫秒</li>
     *                  </ul>
     * @return 返回间隔时间
     */
    public static String getFitTimeSpan(String date1, String date2, String strFormat, @Unit int unit) {
        return millis2FitTimeSpan(Math.abs(getMillis(date1, strFormat) - getMillis(date2, strFormat)), unit);
    }

    /**
     * 获取带有精确单位的时间间隔
     *
     * @param millis1 毫秒时间戳1
     * @param millis2 毫秒时间戳2
     * @param unit    跨度单位
     *                <ul>
     *                <li>{@link #DAY} return 天</li>
     *                <li>{@link #HOUR} return 天, 小时</li>
     *                <li>{@link #MINUTE} return 天, 小时, 分钟</li>
     *                <li>{@link #SECOND}return 天, 小时, 分钟, 秒</li>
     *                <li>{@link #MILLISECOND} return 天, 小时, 分钟, 秒, 毫秒</li>
     *                </ul>
     * @return 返回间隔时间
     */
    public static String getFitTimeSpan(long millis1, long millis2, @Unit int unit) {
        return millis2FitTimeSpan(Math.abs(millis1 - millis2), unit);
    }

    private static int[] UNITS = {DAY, HOUR, MINUTE, SECOND, MILLISECOND};
    private static String millis2FitTimeSpan(long millis, @Unit int unit) {
        int precision = 4;
        for (int i = 0; i < UNITS.length; i++) {
            if (unit == UNITS[i]) {
                precision = i;
                break;
            }
        }
        String[] units = {"天", "小时", "分钟", "秒", "毫秒"};
        if (millis == 0) {
            return 0 + units[precision];
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < precision + 1; i++) {
            if (millis >= UNITS[i]) {
                long mode = millis / UNITS[i];
                millis -= mode * UNITS[i];
                sb.append(mode).append(units[i]);
            }
        }
        return sb.toString();
    }

    /**
     * 获取指定日期与当前时间间隔状态
     *
     * @param date 日期
     * @return 时间间隔状态
     * <ul>
     * <li>如果小于 1 秒钟内,显示刚刚</li>
     * <li>如果在 1 分钟内,显示 XXX秒前</li>
     * <li>如果在 1 小时内,显示 XXX分钟前</li>
     * <li>如果在 1 小时外的今天内,显示今天15:32</li>
     * <li>如果是昨天的,显示昨天15:32</li>
     * <li>其余显示,2016-10-15</li>
     * <li>时间不合法的情况全部日期和时间信息,如星期六 十月 27 14:21:20 CST 2007</li>
     * </ul>
     */
    public static String getTimeSpanStatusByNow(String date) {
        return getTimeSpanStatusByNow(getMillis(date));
    }

    /**
     * 获取指定日期与当前时间间隔状态
     *
     * @param date      日期
     * @param strFormat 日期格式
     * @return 时间间隔状态
     * <ul>
     * <li>如果小于 1 秒钟内,显示刚刚</li>
     * <li>如果在 1 分钟内,显示 XXX秒前</li>
     * <li>如果在 1 小时内,显示 XXX分钟前</li>
     * <li>如果在 1 小时外的今天内,显示今天15:32</li>
     * <li>如果是昨天的,显示昨天15:32</li>
     * <li>其余显示,2016-10-15</li>
     * <li>时间不合法的情况全部日期和时间信息,如星期六 十月 27 14:21:20 CST 2007</li>
     * </ul>
     */
    public static String getTimeSpanStatusByNow(String date, String strFormat) {
        return getTimeSpanStatusByNow(getMillis(date, strFormat));
    }

    /**
     * 获取指定时间与当前时间间隔状态
     *
     * @param millis 毫秒时间戳
     * @return 时间间隔状态
     * <ul>
     * <li>如果小于 1 秒钟内,显示刚刚</li>
     * <li>如果在 1 分钟内,显示 XXX秒前</li>
     * <li>如果在 1 小时内,显示 XXX分钟前</li>
     * <li>如果在 1 小时外的今天内,显示今天15:32</li>
     * <li>如果是昨天的,显示昨天15:32</li>
     * <li>其余显示,2016-10-15</li>
     * <li>时间不合法的情况全部日期和时间信息,如星期六 十月 27 14:21:20 CST 2007</li>
     * </ul>
     */
    public static String getTimeSpanStatusByNow(long millis) {
        long now = System.currentTimeMillis();
        long span = now - millis;
        if (span < 0) {
            return String.format("%tc", millis);
        }
        if (span < 1000) {
            return "刚刚";
        } else if (span < MINUTE) {
            return String.format(Locale.getDefault(), "%d秒前", span / SECOND);
        } else if (span < HOUR) {
            return String.format(Locale.getDefault(), "%d分钟前", span / MINUTE);
        }
        // 获取当天 00:00
        long wee = getTodayZero();
        if (millis >= wee) {
            return String.format("今天%tR", millis);
        } else if (millis >= wee - DAY) {
            return String.format("昨天%tR", millis);
        } else {
            return String.format("%tF", millis);
        }
    }

    /**
     * 获取指定日期在指定时间间隔的时间戳
     *
     * @param date     指定日期
     * @param timeSpan 指定时间间隔
     * @param unit     跨度单位
     *                 <ul>
     *                 <li>{@link #MILLISECOND}</li>
     *                 <li>{@link #SECOND }</li>
     *                 <li>{@link #MINUTE }</li>
     *                 <li>{@link #HOUR}</li>
     *                 <li>{@link #DAY }</li>
     *                 </ul>
     * @return 返回间隔获取的时间戳
     */
    public static long getMillis(String date, long timeSpan, @Unit final int unit) {
        return getMillis(date) + timeSpan2Millis(timeSpan, unit);
    }

    /**
     * 获取指定日期在指定时间间隔的时间戳
     *
     * @param date      指定日期
     * @param strFormat 日期格式
     * @param timeSpan  指定时间间隔
     * @param unit      跨度单位
     *                  <ul>
     *                  <li>{@link #MILLISECOND}</li>
     *                  <li>{@link #SECOND }</li>
     *                  <li>{@link #MINUTE }</li>
     *                  <li>{@link #HOUR}</li>
     *                  <li>{@link #DAY }</li>
     *                  </ul>
     * @return 返回间隔获取的时间戳
     */
    public static long getMillis(String date, String strFormat, long timeSpan, @Unit int unit) {
        return getMillis(date, strFormat) + timeSpan2Millis(timeSpan, unit);
    }

    /**
     * 获取指定时间在指定时间间隔的时间戳
     *
     * @param millis   指定时间戳
     * @param timeSpan 指定时间间隔
     * @param unit     跨度单位
     *                 <ul>
     *                 <li>{@link #MILLISECOND}</li>
     *                 <li>{@link #SECOND }</li>
     *                 <li>{@link #MINUTE }</li>
     *                 <li>{@link #HOUR}</li>
     *                 <li>{@link #DAY }</li>
     *                 </ul>
     * @return 返回间隔获取的时间戳
     */
    public static long getMillis(long millis, long timeSpan, @Unit int unit) {
        return millis + timeSpan2Millis(timeSpan, unit);
    }

    /**
     * 获取指定时间在指定时间间隔的日期
     *
     * @param millis   指定时间戳
     * @param timeSpan 指定时间间隔
     * @param unit     跨度单位
     *                 <ul>
     *                 <li>{@link #MILLISECOND}</li>
     *                 <li>{@link #SECOND }</li>
     *                 <li>{@link #MINUTE }</li>
     *                 <li>{@link #HOUR}</li>
     *                 <li>{@link #DAY }</li>
     *                 </ul>
     * @return 返回间隔获取的时间戳
     */
    public static String getDate(long millis, long timeSpan, @Unit int unit) {
        return getDate(getMillis(millis, timeSpan, unit), DEFAULT_FORMAT);
    }

    /**
     * 获取指定时间在指定时间间隔的日期
     *
     * @param millis    指定时间戳
     * @param strFormat 日期格式
     * @param timeSpan  指定时间间隔
     * @param unit      跨度单位
     *                  <ul>
     *                  <li>{@link #MILLISECOND}</li>
     *                  <li>{@link #SECOND }</li>
     *                  <li>{@link #MINUTE }</li>
     *                  <li>{@link #HOUR}</li>
     *                  <li>{@link #DAY }</li>
     *                  </ul>
     * @return 返回间隔获取的时间戳
     */
    public static String getDate(long millis, String strFormat, long timeSpan, @Unit int unit) {
        return getDate(getMillis(millis, timeSpan, unit), strFormat);
    }

    /**
     * 获取指定日期在指定时间间隔的日期
     *
     * @param date     指定时间戳
     * @param timeSpan 指定时间间隔
     * @param unit     跨度单位
     *                 <ul>
     *                 <li>{@link #MILLISECOND}</li>
     *                 <li>{@link #SECOND }</li>
     *                 <li>{@link #MINUTE }</li>
     *                 <li>{@link #HOUR}</li>
     *                 <li>{@link #DAY }</li>
     *                 </ul>
     * @return 返回间隔获取的时间戳
     */
    public static String getDate(String date, long timeSpan, @Unit int unit) {
        return getDate(getMillis(date, timeSpan, unit));
    }

    /**
     * 获取指定日期在指定时间间隔的日期
     *
     * @param date      指定时间戳
     * @param strFormat 日期格式
     * @param timeSpan  指定时间间隔
     * @param unit      跨度单位
     *                  <ul>
     *                  <li>{@link #MILLISECOND}</li>
     *                  <li>{@link #SECOND }</li>
     *                  <li>{@link #MINUTE }</li>
     *                  <li>{@link #HOUR}</li>
     *                  <li>{@link #DAY }</li>
     *                  </ul>
     * @return 返回间隔获取的时间戳
     */
    public static String getDate(String date, String strFormat, long timeSpan, @Unit int unit) {
        return getDate(getMillis(date, strFormat, timeSpan, unit));
    }

    /**
     * 获取当前时间在指定时间间隔的时间戳
     *
     * @param timeSpan 指定时间间隔
     * @param unit     跨度单位
     *                 <ul>
     *                 <li>{@link #MILLISECOND}</li>
     *                 <li>{@link #SECOND }</li>
     *                 <li>{@link #MINUTE }</li>
     *                 <li>{@link #HOUR}</li>
     *                 <li>{@link #DAY }</li>
     *                 </ul>
     * @return 返回间隔获取的时间戳
     */
    public static long getMillisByNow(long timeSpan, @Unit int unit) {
        return getMillis(System.currentTimeMillis(), timeSpan, unit);
    }

    /**
     * 获取当前时间在指定时间间隔的日期
     *
     * @param timeSpan 指定时间间隔
     * @param unit     跨度单位
     *                 <ul>
     *                 <li>{@link #MILLISECOND}</li>
     *                 <li>{@link #SECOND }</li>
     *                 <li>{@link #MINUTE }</li>
     *                 <li>{@link #HOUR}</li>
     *                 <li>{@link #DAY }</li>
     *                 </ul>
     * @return 返回间隔获取的时间戳
     */
    public static String getDateByNow(long timeSpan, @Unit int unit) {
        return getDate(getMillisByNow(timeSpan, unit));
    }

    /**
     * 获取当前时间在指定时间间隔的日期
     *
     * @param strFormat 日期格式
     * @param timeSpan  指定时间间隔
     * @param unit      跨度单位
     *                  <ul>
     *                  <li>{@link #MILLISECOND}</li>
     *                  <li>{@link #SECOND }</li>
     *                  <li>{@link #MINUTE }</li>
     *                  <li>{@link #HOUR}</li>
     *                  <li>{@link #DAY }</li>
     *                  </ul>
     * @return 返回间隔获取的时间戳
     */
    public static String getDateByNow(String strFormat, long timeSpan, @Unit int unit) {
        return getDate(getMillisByNow(timeSpan, unit), strFormat);
    }

    /**
     * 判断指定日期是否是今天
     *
     * @param date 毫秒时间戳
     * @return {@code true}: yes<br>{@code false}: no
     */
    public static boolean isToday(String date) {
        return isToday(getMillis(date));
    }

    /**
     * 判断指定日期是否是今天
     *
     * @param date 毫秒时间戳
     * @return {@code true}: yes<br>{@code false}: no
     */
    public static boolean isToday(String date, String strFormat) {
        return isToday(getMillis(date, strFormat));
    }

    /**
     * Return whether it is today.
     *
     * @param date The date.
     * @return {@code true}: yes<br>{@code false}: no
     */
    public static boolean isToday(final Date date) {
        return isToday(date.getTime());
    }

    /**
     * 判断指定时间是否是今天
     *
     * @param millis 毫秒时间戳
     * @return {@code true}: yes<br>{@code false}: no
     */
    public static boolean isToday(long millis) {
        long wee = getTodayZero();
        return millis >= wee && millis < wee + DAY;
    }

    /**
     * 是否是闰年
     * <p>默认日期格式 yyyy-MM-dd HH:mm:ss</p>
     *
     * @param date 日期
     * @return {@code true}: yes<br>{@code false}: no
     */
    public static boolean isLeapYear(String date) {
        return isLeapYear(getMillis(date, DEFAULT_FORMAT));
    }

    /**
     * 是否是闰年
     *
     * @param date      日期
     * @param strFormat 日期格式
     * @return {@code true}: yes<br>{@code false}: no
     */
    public static boolean isLeapYear(String date, String strFormat) {
        return isLeapYear(getMillis(date, strFormat));
    }

    /**
     * 是否是闰年
     *
     * @param millis 毫秒时间戳
     * @return {@code true}: yes<br>{@code false}: no
     */
    public static boolean isLeapYear(long millis) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(millis);
        int year = cal.get(Calendar.YEAR);
        return isLeapYear(year);
    }

    /**
     * 是否是闰年
     *
     * @param year 年份
     * @return {@code true}: yes<br>{@code false}: no
     */
    public static boolean isLeapYear(int year) {
        return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
    }

    /**
     * 获取指定日期为周几
     *
     * @param date 日期
     * @return 周几
     */
    public static String getWeek(String date) {
        return getWeek(getMillis(date));
    }

    /**
     * 获取指定日期为周几
     *
     * @param date      日期
     * @param strFormat 日期格式
     * @return 周几
     */
    public static String getWeek(String date, String strFormat) {
        return getWeek(getMillis(date, strFormat));
    }

    /**
     * 获取指定时间为周几
     *
     * @param millis 毫秒时间戳
     * @return 周几
     */
    public static String getWeek(long millis) {
        return new SimpleDateFormat("E", Locale.getDefault()).format(new Date(millis));
    }

    public static long getTodayZero() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTimeInMillis();
    }

    public static int getValueByCalendarField(String date, int field) {
        return getValueByCalendarField(getMillis(date), field);
    }

    public static int getValueByCalendarField(String time, String strFormat, int field) {
        return getValueByCalendarField(getMillis(time, strFormat), field);
    }

    public static int getValueByCalendarField(long millis, int field) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(millis);
        return cal.get(field);
    }

    /**
     * 获取当天某时的毫秒值
     *
     * @param hour 小时
     * @return 当天某时对应时间戳
     */
    public static long getTodayHour(int hour) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.set(Calendar.HOUR_OF_DAY, hour);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return calendar.getTimeInMillis();
    }

    /**
     * 获取当月天数
     *
     * @return 当月天数
     */
    public static int getCurrentMonthDayCount() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        //获取指定年份中指定月份有几天
        return calendar.getActualMaximum(Calendar.DATE);
    }

    /**
     * 获取当月第一天的时间戳
     * <p>0时0分0秒</p>
     *
     * @return 当月第一天的时间戳
     */
    public static long getCurrentMonthFirstDayTime() {
        // 获取当前日期
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        // 设置为1号,当前日期既为本月第一天
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return calendar.getTimeInMillis();
    }

    /**
     * 获取当月最后一天的时间戳
     * <p>23时59分59秒</p>
     *
     * @return 当月最后一天的时间戳
     */
    public static long getCurrentMonthLastDayTime() {
        // 获取当前日期
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DATE));
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        return calendar.getTimeInMillis();
    }

    /**************************************** 十二星座 ****************************************/

    private static final int[] CONSTELLATIONS_FLAGS = {20, 19, 21, 21, 21, 22, 23, 23, 23, 24, 23, 22};
    private static final String[] CONSTELLATIONS = {
            "水瓶座", "双鱼座", "白羊座", "金牛座", "双子座", "巨蟹座",
            "狮子座", "处女座", "天秤座", "天蝎座", "射手座", "魔羯座"
    };

    /**
     * 获取指定日期的星座
     *
     * @param date 日期
     * @return 星座 {@link #CONSTELLATIONS}
     */
    public static String getConstellations(String date) {
        return getConstellations(getMillis(date));
    }

    /**
     * 获取指定日期的星座
     *
     * @param date      日期
     * @param strFormat 日期格式
     * @return 星座 {@link #CONSTELLATIONS}
     */
    public static String getConstellations(String date, String strFormat) {
        return getConstellations(getMillis(date, strFormat));
    }

    /**
     * 获取星座
     *
     * @param millis 毫秒时间戳
     * @return 星座 {@link #CONSTELLATIONS}
     */
    public static String getConstellations(long millis) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(millis);
        int month = cal.get(Calendar.MONTH) + 1;
        int day = cal.get(Calendar.DAY_OF_MONTH);
        return getConstellations(month, day);
    }

    /**
     * 获取星座
     *
     * @param month 月份
     * @param day   日
     * @return 星座 {@link #CONSTELLATIONS}
     */
    public static String getConstellations(int month, int day) {
        return CONSTELLATIONS[day >= CONSTELLATIONS_FLAGS[month - 1]
                ? month - 1
                : (month + 10) % 12];
    }
}
package com.bchat.commonUtils;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;

import com.bchat.application.BChatApplication;

import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.List;
import java.util.Map;

public class NetworkUtil {

    public static String url(String baseUrl, String relativePath) {
        if (relativePath == null || relativePath.length() == 0) {
            return relativePath;
        }

        if (relativePath.contains("://") ||
            relativePath.matches("(?s)^[a-zA-Z][a-zA-Z0-9+-.]*:.*$")) { // matches Non-relative URI; see rfc3986
            return relativePath;
        }

        if (relativePath.charAt(0) == '/') {
            int index = baseUrl.indexOf("://");
            index = baseUrl.indexOf("/", index + 3);
            if (index == -1) {
                return baseUrl + relativePath;
            } else {
                return baseUrl.substring(0, index) + relativePath;
            }
        } else {
            int index = baseUrl.lastIndexOf('/'); // FIXME: if (baseUrl.charAt(baseUrl.length() - 1) == '/')
            while (index > 0 && relativePath.startsWith("../")) {
                index = baseUrl.lastIndexOf('/', index - 1);
                relativePath = relativePath.substring(3);
            }
            return baseUrl.substring(0, index + 1) + relativePath;
        }
    }

    public static boolean hasParameter(String url, String name) {
        int index = url.lastIndexOf('/') + 1;
        if (index == -1 || index >= url.length()) {
            return false;
        }
        index = url.indexOf('?', index);
        while (index != -1) {
            int start = index + 1;
            if (start >= url.length()) {
                return false;
            }
            int eqIndex = url.indexOf('=', start);
            if (eqIndex == -1) {
                return false;
            }
            if (url.substring(start, eqIndex).equals(name)) {
                return true;
            }
            index = url.indexOf('&', start);
        }
        return false;
    }

    public static String appendParameter(String url, String name, String value) {
        if (name == null || value == null) {
            return url;
        }
        value = value.trim();
        if (value.length() == 0) {
            return url;
        }
        try {
            value = URLEncoder.encode(value, "utf-8");
        } catch (UnsupportedEncodingException e) {}
        int index = url.indexOf('?', url.lastIndexOf('/') + 1);
        char delimiter = (index == -1) ? '?' : '&';
        while (index != -1) {
            final int start = index + 1;
            final int eqIndex = url.indexOf('=', start);
            index = url.indexOf('&', start);
            if (eqIndex != -1 && url.substring(start, eqIndex).equals(name)) {
                final int end = (index != -1 ? index : url.length());
                if (url.substring(eqIndex + 1, end).equals(value)) {
                    return url;
                } else {
                    return new StringBuilder(url).replace(eqIndex + 1, end, value).toString();
                }
            }
        }
        return new StringBuilder(url).append(delimiter).append(name).append('=').append(value).toString();
    }

    public static String hostFromUrl(String url) {
        String host = url;
        int index = host.indexOf("://");
        if (index != -1) {
            host = host.substring(index + 3);
        }
        index = host.indexOf("/");
        if (index != -1) {
            host = host.substring(0, index);
        }
        return host;
    }

    public static String getUserAgent() {
        return "TINYpulse/" + PlatformUtil.getVersionName() + "(java)";
    }

    public static String getUserAgentInfo() {

        String rs = String.format(
            "TINYpulse-Android(Version=%1$s, Build No = %2$s) Device(%3$s - %4$s)", PlatformUtil.getVersionName(), PlatformUtil.getVersionCode(), PlatformUtil.getDeviceName(), PlatformUtil.getDeviceOS());
        return rs;
    }

    public static String getCoverThumnailUrl(String originUrl, String size) {
        URL url = null;
        try {
            url = new URL(originUrl);
        } catch (MalformedURLException e) {
            e.printStackTrace();
            return originUrl;
        }

        return "http://" + url.getHost() + "/cache/" + size + url.getPath();
    }

    public static boolean isNetworkAvailable() {
        Context context = BChatApplication.getAppContext();

        ConnectivityManager connectivity = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (connectivity != null) {
            NetworkInfo[] info = connectivity.getAllNetworkInfo();
            if (info != null) {
                for (int i = 0; i < info.length; i++) {
                    if (info[i].getState() == NetworkInfo.State.CONNECTED) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public static String urlEncodeUTF8(String s) {
        try {
            return URLEncoder.encode(s, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new UnsupportedOperationException(e);
        }
    }

    public static String urlEncodeUTF8(Map < String, String > map) {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry < String, String > entry: map.entrySet()) {
            if (sb.length() > 0) {
                sb.append("&");
            }
            String value = entry.getValue();
            value = StringUtil.isEmpty(value) ? "empty" : value;
            sb.append(String.format("%s=%s",
                urlEncodeUTF8(entry.getKey()),
                urlEncodeUTF8(value)
            ));
        }

        return "?" + sb.toString();
    }

    public static String urlEncodeUTF8(Map < String, String > map, String key, List < String > stringList) {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry < String, String > entry: map.entrySet()) {
            if (sb.length() > 0) {
                sb.append("&");
            }
            String value = entry.getValue();
            value = StringUtil.isEmpty(value) ? "empty" : value;
            sb.append(String.format("%s=%s",
                urlEncodeUTF8(entry.getKey()),
                urlEncodeUTF8(value)
            ));
        }

        if (StringUtil.isNotEmpty(key) && stringList != null) {
            for (String str: stringList) {
                if (StringUtil.isEmpty(str)) {
                    continue;
                }

                if (sb.length() > 0) {
                    sb.append("&");
                }
                String value = str;
                value = StringUtil.isEmpty(value) ? "empty" : value;
                sb.append(String.format("%s=%s",
                    urlEncodeUTF8(key),
                    urlEncodeUTF8(value)
                ));
            }
        }


        return "?" + sb.toString();
    }
}
package dev.yong.wheel.utils;

import android.os.Environment;
import android.text.TextUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.text.DecimalFormat;

import dev.yong.wheel.AppManager;

/**
 * @author CoderYong
 */
public class FileUtils {

    private FileUtils() {
        throw new UnsupportedOperationException("Cannot be created");
    }

    public static String APP_PATH = "";

    /**
     * 获取SD卡DaBai路径
     *
     * @return 默认SD卡路径
     */
    public static String getSDPath() {
        return getSDPath(APP_PATH);
    }

    /**
     * 获取SD卡指定文件夹路径
     *
     * @param parent 指定文件夹
     * @return 指定SD卡路径
     */
    public static String getSDPath(String parent) {
        String path;
        String state = Environment.getExternalStorageState();
        if (state.equals(Environment.MEDIA_MOUNTED)) {
            // 已挂载
            File pic = Environment.getExternalStorageDirectory();
            path = pic + File.separator + parent;
        } else {
            File cacheDir = AppManager.getInstance().getApplication().getCacheDir();
            path = cacheDir + File.separator + parent;
        }
        return create(path) == null ? "" : path;
    }

    /**
     * 创建文件
     *
     * @param parent 文件存放路径
     * @param name   文件名
     * @return 文件,文件路径无效时返回null
     */
    public static File create(String parent, String name) {
        if (!parent.endsWith("/")) {
            parent += "/";
        }
        return create(parent + name);
    }

    /**
     * 创建文件
     *
     * @param absolutePath 文件绝对路径
     * @return 文件,文件路径无效时返回null
     */
    public static File create(String absolutePath) {
        File file = new File(absolutePath);
        if (!file.exists()) {
            return file.mkdirs() ? file : null;
        }
        return file;
    }

    /**
     * 检测文件是否存在
     *
     * @param parent 文件存放路径
     * @param name   文件名
     * @return {@link File#exists()}
     */
    public static boolean exists(String parent, String name) {
        return new File(parent, name).exists();
    }

    /**
     * 检测文件是否存在
     *
     * @param absolutePath 文件绝对路径
     * @return {@link File#exists()}
     */
    public static boolean exists(String absolutePath) {
        return new File(absolutePath).exists();
    }

    /**
     * 删除文件
     *
     * @param file 文件
     * @return 是否删除
     */
    public static boolean delete(File file) {
        if (file != null && file.exists()) {
            if (file.isFile()) {
                return file.delete();
            } else if (file.isDirectory()) {
                //声明目录下所有的文件 files[];
                File[] files = file.listFiles();
                if (files != null) {
                    //遍历目录下所有的文件
                    for (File f : files) {
                        //把每个文件用这个方法进行迭代
                        delete(f);
                    }
                }
                //删除文件夹
                return file.delete();
            }
        }
        return true;
    }

    /**
     * 删除文件
     *
     * @param absolutePath 文件绝对路径
     * @return 是否删除
     */
    public static boolean delete(String absolutePath) {
        return delete(new File(absolutePath));
    }

    /**
     * 文件大小格式化
     *
     * @param length
     * @return
     */
    public static String formatFileSize(long length) {
        DecimalFormat df = new DecimalFormat("#.00");
        String size;
        if (length < 1024) {
            size = df.format((double) length) + "B";
        } else if (length < 1048576) {
            size = df.format((double) length / 1024) + "K";
        } else if (length < 1073741824) {
            size = df.format((double) length / 1048576) + "M";
        } else {
            size = df.format((double) length / 1073741824) + "G";
        }
        return size;
    }

    /**
     * 文件md5
     */
    private static final char[] HEX_DIGITS =
            {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    /**
     * 把byte[]数组转换成十六进制字符串表示形式
     *
     * @param tmp 要转换的byte[]
     * @return 十六进制字符串表示形式
     */
    private static String byteToHexString(byte[] tmp) {

        // 用字节表示就是 16 个字节
        // 每个字节用 16 进制表示的话,使用两个字符,
        char[] c = new char[16 * 2];

        // 所以表示成 16 进制需要 32 个字符
        // 表示转换结果中对应的字符位置
        int k = 0;
        // 从第一个字节开始,对 MD5 的每一个字节
        for (int i = 0; i < 16; i++) {

            // 转换成 16 进制字符的转换
            // 取第 i 个字节
            byte byte0 = tmp[i];
            // 取字节中高 4 位的数字转换,
            c[k++] = HEX_DIGITS[byte0 >>> 4 & 0xf];

            // >>> 为逻辑右移,将符号位一起右移
            // 取字节中低 4 位的数字转换
            c[k++] = HEX_DIGITS[byte0 & 0xf];
        }
        // 换后的结果转换为字符串
        return new String(c);
    }

    public static String getMD5(File file) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            FileInputStream in = new FileInputStream(file);
            byte[] buffer = new byte[2048];
            int length;
            while ((length = in.read(buffer)) != -1) {
                md.update(buffer, 0, length);
            }
            byte[] b = md.digest();
            in.close();
            return byteToHexString(b);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 文件重命名
     *
     * @param file 原文件
     * @param name 新文件名
     *             <P>不带后缀</P>
     * @return 新文件名
     */
    public static String rename(File file, String name) {
        return rename(file, name);
    }


    /**
     * 文件重命名
     *
     * @param file 原文件
     * @param path 新文件路径
     * @param name 新文件名
     *             <P>不带后缀</P>
     * @return 新文件名
     */
    public static String rename(File file, String path, String name) {
        if (file != null && file.exists()) {
            //创建新的文件名
            name = name + getSuffix(file.getAbsolutePath());
            //如果新的文件名与原文件名不相同则不做操作
            if (!name.equals(file.getName())) {
                String parent = TextUtils.isEmpty(path) ? file.getParent() : path;
                File newFile = new File(parent, name);
                if (newFile.exists()) {
                    newFile.delete();
                }
                return file.renameTo(newFile) ? name : file.getName();
            }
        }
        return "";
    }

    /**
     * 复制文件
     *
     * @param fromFile 原文件
     * @param toFile   新文件
     */
    public static void copy(File fromFile, File toFile) {
        try {
            FileInputStream ins = new FileInputStream(fromFile);
            FileOutputStream out = new FileOutputStream(toFile);
            byte[] b = new byte[1024];
            int n;
            while ((n = ins.read(b)) != -1) {
                out.write(b, 0, n);
            }
            ins.close();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 文件移动
     *
     * @param file 原文件
     * @param path 新文件路径
     */

    public static File move(File file, String path) {
        if (file != null && file.exists() && !path.equals(file.getParent())) {
            File newFile = new File(path, file.getName());
            newFile.deleteOnExit();
            return file.renameTo(newFile) ? newFile : file;
        }
        return file;
    }

    /**
     * 获取文件后缀
     *
     * @param path 文件绝对路径
     */
    public static String getSuffix(String path) {
        return path.substring(path.lastIndexOf("."), path.length());
    }
}