工具类(时间操作，网络状态)

1、时间操作类

import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class DateTimeUtil {
    // 获取当前时间n[]之后的时间的日期时间字符串（N的单位为Calendar的那些表示时间的常量）
    public static String getNLaterDateTimeString(int nType, int n) {
        Date date = new Date();
        Calendar c = new GregorianCalendar();
        c.setTime(date);
        c.add(nType, n);

        return CalendarToString(c);
    }

    // millis to datetime
    public static String getDateTimeStringFromMillis(long millis) {
        Date date = new Date(millis);
        return (DateToString(date));
    }

    // 把日期时间字符串的时间转换成毫秒值（RTC）
    public static long stringToMillis(String dateTime) {
        Calendar c = StringToGregorianCalendar(dateTime);

        return c.getTimeInMillis();
    }

    // 获取两个日期时间字符串表示的时间之间的毫秒差值
    public static long getDifMillis(String dateTime1, String dateTime2) {
        return (stringToMillis(dateTime1) - stringToMillis(dateTime2));
    }

    // 输入一个表示日期或时间的整型数，输出"01"或"23"这样格式的字符串
    public static String getDoubleNumString(int n) {
        int num = n % 60;

        if (num < 10) {
            return "0" + num;
        } else {
            return num + "";
        }
    }

    // 获取标准日期时间字符串的整型的日期值，如："2015-01-21 00:00:00"，返回：21
    public static int getDayOfMonth(String dateTime) {
        Calendar c = StringToGregorianCalendar(dateTime);
        int day = c.get(Calendar.DAY_OF_MONTH);

        return day;
    }

    // 获取当前时间的日期时间字符串，格式："yyyy-MM-dd HH:mm:ss"
    public static String getCurrentDateTimeString() {
        Date date = new Date();
        return DateToString(date);
    }

    // 获取当前的"yyyy-MM-dd"日期格式字符串
    public static String getCurrentDateString() {
        Date date = new Date();
        return DateToString(date).substring(0, 10);
    }

    // 获取当前的"yyyy-MM"日期格式字符串
    public static String getCurrentMonthString() {
        Date date = new Date();
        return DateToString(date).substring(0, 7);
    }

    // 获取当前的"HH:mm"时间格式字符串
    public static String getCurrentTimeString() {
        Date date = new Date();
        return DateToString(date).substring(11, 16);
    }

    // 获取当前的"HH:mm:ss"时间格式字符串
    public static String getCurrentTimeLongString() {
        Date date = new Date();
        return DateToString(date).substring(11, 19);
    }

    // 由日期时间字符串生成“11月1日 星期一”这样格式的字符串
    public static String getShortDateTimeOfWeek(String dateTime) {
        Calendar c = StringToGregorianCalendar(dateTime);

        int month = c.get(Calendar.MONTH) + 1;
        int day = c.get(Calendar.DAY_OF_MONTH);

        String[] weekStr = new String[] { "星期日", "星期一", "星期二", "星期三", "星期四",
                "星期五", "星期六" };
        String week = weekStr[c.get(Calendar.DAY_OF_WEEK) - 1];

        String result = month + "月" + day + "日" + "  " + week;

        return result;
    }

    // 由日期时间字符串生成“2015年11月1日 星期一”这样格式的字符串
    public static String getDateTimeOfWeek(String dateTime) {
        Calendar c = StringToGregorianCalendar(dateTime);

        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int day = c.get(Calendar.DAY_OF_MONTH);

        String[] weekStr = new String[] { "星期日", "星期一", "星期二", "星期三", "星期四",
                "星期五", "星期六" };
        String week = weekStr[c.get(Calendar.DAY_OF_WEEK) - 1];

        String result = year + "年" + month + "月" + day + "日" + "  " + week;

        return result;
    }

    // 由日期时间字符串生成“2015年11月1日 05:43”这样格式的字符串
    public static String getDateTimeOfHourMinute(String dateTime) {
        String result = "";
        String date = dateTime.split(" ")[0];
        String time = dateTime.split(" ")[1];
        String[] dateArr = date.split("-");
        String[] timeArr = time.split(":");

        int year = Integer.parseInt(dateArr[0]);
        int month = Integer.parseInt(dateArr[1]);
        int day = Integer.parseInt(dateArr[2]);

        result = year + "年" + month + "月" + day + "日" + "  " + timeArr[0] + ":"
                + timeArr[1];

        return result;
    }

    // 用年月日生成日期字符串，month取值范围：[0,13]
    public static String getDateString(int year, int month, int day) {
        String m;
        String d;

        if (month >= 9) {
            m = (month + 1) + "";
        } else {
            m = "0" + (month + 1);
        }

        if (day >= 10) {
            d = day + "";
        } else {
            d = "0" + day;
        }

        String dateString = year + "-" + m + "-" + d;
        return dateString;
    }

    // 用年月生成年月日期字符串，month取值范围：[0,13]
    public static String getDateString(int year, int month) {
        String m;
        String d;

        if (month >= 9) {
            m = (month + 1) + "";
        } else {
            m = "0" + (month + 1);
        }

        String dateString = year + "-" + m;
        return dateString;
    }

    // 用时、分生成时间字符串
    public static String getTimeString(int hour, int minute) {
        String h;
        String m;

        if (hour >= 10) {
            h = hour + "";
        } else {
            h = "0" + hour;
        }

        if (minute >= 10) {
            m = minute + "";
        } else {
            m = "0" + minute;
        }

        return h + ":" + m;
    }

    // 用时、分、秒生成时间字符串
    public static String getTimeString(int hour, int minute, int second) {
        String h;
        String m;
        String c;

        if (hour >= 10) {
            h = hour + "";
        } else {
            h = "0" + hour;
        }

        if (minute >= 10) {
            m = minute + "";
        } else {
            m = "0" + minute;
        }

        if (second >= 10) {
            c = second + "";
        } else {
            c = "0" + second;
        }

        return h + ":" + m + ":" + c;
    }

    // 该内部类是用于对日期时间字符串数组进行排序的
    public class DateTimeString implements Comparable<DateTimeString> {
        private String mDateTimeStr;

        public DateTimeString(String dateTimeStr) {
            mDateTimeStr = dateTimeStr;
        }

        @Override
        public int compareTo(DateTimeString another) {
            return compareDateTimeString(mDateTimeStr.toString(),
                    another.toString());
        }

        @Override
        public String toString() {
            return mDateTimeStr;
        }

    }

    // 对日期时间字符串数组进行排序,返回排序后的数组（排序后的顺序是从小到大）
    public static String[] sortDateTimeStringArray(String[] dateTimeStringArray) {
        // 将日期时间字符串数组转换成DateTimeString类型数组，DateTimeString实现了Comparable接口，可以进行排序
        DateTimeString[] tmpArray = new DateTimeString[dateTimeStringArray.length];

        // 生成tmpArray数组
        int i = 0;
        DateTimeUtil tmpUtil = new DateTimeUtil();
        for (String str : dateTimeStringArray) {
            tmpArray[i++] = tmpUtil.new DateTimeString(str);
        }

        // 对tmpArray进行排序
        Arrays.sort(tmpArray);

        String[] result = new String[tmpArray.length];
        i = 0;
        for (DateTimeString str : tmpArray) {
            result[i++] = str.toString();
        }
        return result;
    }

    // 比较两个日期时间字符串的大小，如果str1比str2早，则返回-1，如果相等返回0，否则返回1
    public static int compareDateTimeString(String str1, String str2) {
        Date d1 = StringToDate(str1);
        Date d2 = StringToDate(str2);
        if (d1.getTime() - d2.getTime() < 0) {
            return -1;
        } else if (d1.getTime() - d2.getTime() > 0) {
            return 1;
        } else {
            return 0;
        }

    }

    // 时间日期字符串转换成Date对象
    // 注：dateTimeStr带不带前导0都是可以的，比如"2011-01-01 01:02:03"和"2011-1-1 1:2:3"都是合法的
    public static Date StringToDate(String dateTimeStr) {
        Date date = new Date();
        // DateFormat fmt = DateFormat.getDateTimeInstance();
        DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            date = fmt.parse(dateTimeStr);
            return date;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    // Date对象转换成日期时间字符串
    public static String DateToString(Date date) {
        String dateTimeStr = null;
        // DateFormat fmt = DateFormat.getDateTimeInstance();
        DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        dateTimeStr = fmt.format(date);
        return dateTimeStr;
    }

    // 字符串转换成Calendar
    public static Calendar StringToGregorianCalendar(String dateTimeStr) {
        Date date = StringToDate(dateTimeStr);
        Calendar calendar = new GregorianCalendar();

        calendar.setTime(date);
        return calendar;
    }

    // Calendar转换成String
    public static String CalendarToString(Calendar calendar) {
        Date date = ((GregorianCalendar) calendar).getTime();
        return DateToString(date);
    }

    // 获取日期时间格式字符串表示的两日期时间之间相隔的天数（天数可为浮点型） AC
    public static double getDayNumDif(String str1, String str2) {
        // DateFormat fmt = DateFormat.getDateTimeInstance();
        DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date d1 = fmt.parse(str1);
            Date d2 = fmt.parse(str2);
            long dif = Math.abs(d1.getTime() - d2.getTime());
            double dayDif = (double) (dif) / 1000 / (24 * 60 * 60);

            // 保留两位小数
            DecimalFormat df = new DecimalFormat("0.00");
            return Double.parseDouble(df.format(dayDif));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return -1;
    }

    // 求算术平均值函数，保留2位小数
    public static double getAverage(double[] data) {
        double sum = 0;
        for (int i = 0; i < data.length; i++) {
            sum += data[i];
        }

        DecimalFormat df = new DecimalFormat("0.00");
        return Double.parseDouble(df.format(sum / data.length));
    }

    // 输入一个时间日期字符串（格式：“yyyy-MM-dd HH:mm:ss”），输出num天后的时间日期字符串（num可为浮点数）
    public static String getNDayLatterDateTime(String str, double num) {
        // 创建日期时间格式对象fmt
        // DateFormat fmt = DateFormat.getDateTimeInstance();
        DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date curDate = fmt.parse(str);
            GregorianCalendar calendar = new GregorianCalendar();
            calendar.setTime(curDate);

            calendar.add(Calendar.SECOND, (int) (num * (24 * 60 * 60)));

            Date newDate = calendar.getTime();
            String newDateStr = fmt.format(newDate);
            return newDateStr;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return "";
    }

}

2、Android获取网络状态类

public class NetStateUtils {

    /**
     * 判断当前网络是否是移动网络
     *
     * @param context
     * @return boolean
     */
    public static boolean is3G(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
        if (activeNetInfo != null
                && activeNetInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
            return true;
        }
        return false;
    }

    /**
     * 判断当前网络是否是wifi网络
     *
     * @param context
     * @return boolean
     */
    public static boolean isWifi(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
        if (activeNetInfo != null
                && activeNetInfo.getType() == ConnectivityManager.TYPE_WIFI) {
            return true;
        }
        return false;
    }

    /**
     * 判断当前网络是否是2G网络
     *
     * @param context
     * @return boolean
     */
    public static boolean is2G(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
        if (activeNetInfo != null
                && (activeNetInfo.getSubtype() == TelephonyManager.NETWORK_TYPE_EDGE
                || activeNetInfo.getSubtype() == TelephonyManager.NETWORK_TYPE_GPRS || activeNetInfo
                .getSubtype() == TelephonyManager.NETWORK_TYPE_CDMA)) {
            return true;
        }
        return false;
    }

    /**
     * wifi是否打开
     */
    public static boolean isWifiEnabled(Context context) {
        ConnectivityManager mgrConn = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        TelephonyManager mgrTel = (TelephonyManager) context
                .getSystemService(Context.TELEPHONY_SERVICE);
        return ((mgrConn.getActiveNetworkInfo() != null && mgrConn
                .getActiveNetworkInfo().getState() == NetworkInfo.State.CONNECTED) || mgrTel
                .getNetworkType() == TelephonyManager.NETWORK_TYPE_UMTS);
    }

    /**
     * 判断是否有网络连接
     *
     * @param context
     * @return
     */
    public static boolean isNetworkConnected(Context context) {
        if (context != null) {
            // 获取手机所有连接管理对象(包括对wi-fi,net等连接的管理)
            ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                    .CONNECTIVITY_SERVICE);
            // 获取NetworkInfo对象
            NetworkInfo networkInfo = manager.getActiveNetworkInfo();
            //判断NetworkInfo对象是否为空
            if (networkInfo != null)
                return networkInfo.isAvailable();
        }
        return false;
    }

    /**
     * 判断MOBILE网络是否可用
     *
     * @param context
     * @param context
     * @return
     */
    public static boolean isMobileConnected(Context context) {
        if (context != null) {
            //获取手机所有连接管理对象(包括对wi-fi,net等连接的管理)
            ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                    .CONNECTIVITY_SERVICE);
            //获取NetworkInfo对象
            NetworkInfo networkInfo = manager.getActiveNetworkInfo();
            //判断NetworkInfo对象是否为空 并且类型是否为MOBILE
            if (networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE)
                return networkInfo.isAvailable();
        }
        return false;
    }

    /**
     * 获取当前网络连接的类型信息
     * 原生
     *
     * @param context
     * @return
     */
    public static int getConnectedType(Context context) {
        if (context != null) {
            //获取手机所有连接管理对象
            ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                    .CONNECTIVITY_SERVICE);
            //获取NetworkInfo对象
            NetworkInfo networkInfo = manager.getActiveNetworkInfo();
            if (networkInfo != null && networkInfo.isAvailable()) {
                //返回NetworkInfo的类型
                return networkInfo.getType();
            }
        }
        return -1;
    }

    /**
     * 获取当前的网络状态 ：没有网络-0：WIFI网络1：4G网络-4：3G网络-3：2G网络-2
     * 自定义
     *
     * @param context
     * @return
     */
    public static int getAPNType(Context context) {
        //结果返回值
        int netType = 0;
        //获取手机所有连接管理对象
        ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                .CONNECTIVITY_SERVICE);
        //获取NetworkInfo对象
        NetworkInfo networkInfo = manager.getActiveNetworkInfo();
        //NetworkInfo对象为空 则代表没有网络
        if (networkInfo == null) {
            return netType;
        }
        //否则 NetworkInfo对象不为空 则获取该networkInfo的类型
        int nType = networkInfo.getType();
        if (nType == ConnectivityManager.TYPE_WIFI) {
            //WIFI
            netType = 1;
        } else if (nType == ConnectivityManager.TYPE_MOBILE) {
            int nSubType = networkInfo.getSubtype();
            TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService
                    (Context.TELEPHONY_SERVICE);
            //3G   联通的3G为UMTS或HSDPA 电信的3G为EVDO
            if (nSubType == TelephonyManager.NETWORK_TYPE_LTE
                    && !telephonyManager.isNetworkRoaming()) {
                netType = 4;
            } else if (nSubType == TelephonyManager.NETWORK_TYPE_UMTS
                    || nSubType == TelephonyManager.NETWORK_TYPE_HSDPA
                    || nSubType == TelephonyManager.NETWORK_TYPE_EVDO_0
                    && !telephonyManager.isNetworkRoaming()) {
                netType = 3;
                //2G 移动和联通的2G为GPRS或EGDE，电信的2G为CDMA
            } else if (nSubType == TelephonyManager.NETWORK_TYPE_GPRS
                    || nSubType == TelephonyManager.NETWORK_TYPE_EDGE
                    || nSubType == TelephonyManager.NETWORK_TYPE_CDMA
                    && !telephonyManager.isNetworkRoaming()) {
                netType = 2;
            } else {
                netType = 2;
            }
        }
        return netType;
    }

    /**
     * 判断GPS是否打开
     * ACCESS_FINE_LOCATION权限
     *
     * @param context
     * @return
     */
    public static boolean isGPSEnabled(Context context) {
        //获取手机所有连接LOCATION_SERVICE对象
        LocationManager locationManager = ((LocationManager) context.getSystemService(Context
                .LOCATION_SERVICE));
        return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
    }

    /**
     * 获得本机ip地址
     *
     * @return
     */
    public static String GetHostIp() {
        try {
            for (Enumeration<NetworkInterface> en = NetworkInterface
                    .getNetworkInterfaces(); en.hasMoreElements(); ) {
                NetworkInterface intf = en.nextElement();
                for (Enumeration<InetAddress> ipAddr = intf.getInetAddresses(); ipAddr
                        .hasMoreElements(); ) {
                    InetAddress inetAddress = ipAddr.nextElement();
                    if (!inetAddress.isLoopbackAddress()) {
                        return inetAddress.getHostAddress();
                    }
                }
            }
        } catch (SocketException ex) {
        } catch (Exception e) {
        }
        return null;
    }

    /**
     * 获取本机串号imei
     *
     * @param context
     * @return
     */
    public static String getIMEI(Context context) {
        TelephonyManager telephonyManager = (TelephonyManager) context
                .getSystemService(Context.TELEPHONY_SERVICE);
        return telephonyManager.getDeviceId();
    }

    /***
     * 判断是否有外网连接（普通方法不能判断外网的网络是否连接，比如连接上局域网）
     *
     * @return
     */

    public static final boolean ping() {

        String result = null;
        try {
            String ip = "www.baidu.com";// ping 的地址，可以换成任何一种可靠的外网
            Process p = Runtime.getRuntime().exec("ping -c 3 -w 100 " + ip);// ping网址3次
            // 读取ping的内容，可以不加
            InputStream input = p.getInputStream();
            BufferedReader in = new BufferedReader(new InputStreamReader(input));
            StringBuffer stringBuffer = new StringBuffer();
            String content = "";
            while ((content = in.readLine()) != null) {
                stringBuffer.append(content);
            }
            Log.d("------ping-----", "result content : " + stringBuffer.toString());
            // ping的状态
            int status = p.waitFor();
            if (status == 0) {
                result = "success";
                return true;
            } else {
                result = "failed";
            }
        } catch (IOException e) {
            result = "IOException";
        } catch (InterruptedException e) {
            result = "InterruptedException";
        } finally {
            Log.d("----result---", "result = " + result);
        }
        return false;

    }
}