這是一個自己寫的Android下的ping的簡單工具類，主要是通過ping獲取到返回字串之後擷取資訊得到自己想要的資料。不多說，上原始碼

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;
import java.util.regex.Pattern;

import android.support.v4.util.ArrayMap;

/**
 * 類描述:手機ping工具類<br>
 * 許可權 <uses-permission android:name="android.permission.INTERNET"/> <br>
 * 由於涉及網路，建議非同步操作<br>
 * 建立人：liangkuan<br>
 * 建立時間：2016/4/23 14:05<br>
 */
public class PingUtil
{

    private static final String ipRegex =
        "((?:(?:25[0-5]|2[0-4]\\d|((1\\d{2})|([1-9]?\\d)))\\.){3}(?:25[0-5]|2[0-4]\\d|((1\\d{2})|([1-9]?\\d))))";

    /**
     * 獲取由ping url得到的IP地址
     *
     * @param url 需要ping的url地址
     * @return url的IP地址 如 192.168.0.1
     */
    public static String getIPFromUrl(String url)
    {
        String domain = getDomain(url);
        if (null == domain)
        {
            return null;
        }
        if (isMatch(ipRegex, domain))
        {
            return domain;
        }
        String pingString = ping(createSimplePingCommand(1, 100, domain));
        if (null != pingString)
        {
            try
            {
                String tempInfo = pingString.substring(pingString.indexOf("from") + 5);
                return tempInfo.substring(0, tempInfo.indexOf("icmp_seq") - 2);
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 獲取ping最小RTT值
     *
     * @param url 需要ping的url地址
     * @return 最小RTT值，單位 ms 注意：-1是預設值，返回-1表示獲取失敗
     */
    public static int getMinRTT(String url)
    {
        return getMinRTT(url, 1, 100);
    }

    /**
     * 獲取ping的平均RTT值
     *
     * @param url 需要ping的url地址
     * @return 平均RTT值，單位 ms 注意：-1是預設值，返回-1表示獲取失敗
     */
    public static int getAvgRTT(String url)
    {
        return getAvgRTT(url, 1, 100);
    }

    /**
     * 獲取ping的最大RTT值
     *
     * @param url 需要ping的url地址
     * @return 最大RTT值，單位 ms 注意：-1是預設值，返回-1表示獲取失敗
     */
    public static int getMaxRTT(String url)
    {
        return getMaxRTT(url, 1, 100);
    }

    /**
     * 獲取ping的RTT的平均偏差
     *
     * @param url 需要ping的url地址
     * @return RTT平均偏差，單位 ms 注意：-1是預設值，返回-1表示獲取失敗
     */
    public static int getMdevRTT(String url)
    {
        return getMdevRTT(url, 1, 100);
    }

    /**
     * 獲取ping url的最小RTT
     *
     * @param url 需要ping的url地址
     * @param count 需要ping的次數
     * @param timeout 需要ping的超時，單位ms
     * @return 最小RTT值，單位 ms 注意：-1是預設值，返回-1表示獲取失敗
     */
    public static int getMinRTT(String url, int count, int timeout)
    {
        String domain = getDomain(url);
        if (null == domain)
        {
            return -1;
        }
        String pingString = ping(createSimplePingCommand(count, timeout, domain));
        if (null != pingString)
        {
            try
            {
                String tempInfo = pingString.substring(pingString.indexOf("min/avg/max/mdev") + 19);
                String[] temps = tempInfo.split("/");
                return Math.round(Float.valueOf(temps[0]));
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 獲取ping url的平均RTT
     *
     * @param url 需要ping的url地址
     * @param count 需要ping的次數
     * @param timeout 需要ping的超時時間，單位 ms
     * @return 平均RTT值，單位 ms 注意：-1是預設值，返回-1表示獲取失敗
     */
    public static int getAvgRTT(String url, int count, int timeout)
    {
        String domain = getDomain(url);
        if (null == domain)
        {
            return -1;
        }
        String pingString = ping(createSimplePingCommand(count, timeout, domain));
        if (null != pingString)
        {
            try
            {
                String tempInfo = pingString.substring(pingString.indexOf("min/avg/max/mdev") + 19);
                String[] temps = tempInfo.split("/");
                return Math.round(Float.valueOf(temps[1]));
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 獲取ping url的最大RTT
     *
     * @param url 需要ping的url地址
     * @param count 需要ping的次數
     * @param timeout 需要ping的超時時間，單位ms
     * @return 最大RTT值，單位 ms 注意：-1是預設值，返回-1表示獲取失敗
     */
    public static int getMaxRTT(String url, int count, int timeout)
    {
        String domain = getDomain(url);
        if (null == domain)
        {
            return -1;
        }
        String pingString = ping(createSimplePingCommand(count, timeout, domain));
        if (null != pingString)
        {
            try
            {
                String tempInfo = pingString.substring(pingString.indexOf("min/avg/max/mdev") + 19);
                String[] temps = tempInfo.split("/");
                return Math.round(Float.valueOf(temps[2]));
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 獲取RTT的平均偏差
     *
     * @param url 需要ping的url
     * @param count 需要ping的次數
     * @param timeout 需要ping的超時時間，單位ms
     * @return RTT平均偏差，單位 ms 注意：-1是預設值，返回-1表示獲取失敗
     */
    public static int getMdevRTT(String url, int count, int timeout)
    {
        String domain = getDomain(url);
        if (null == domain)
        {
            return -1;
        }
        String pingString = ping(createSimplePingCommand(count, timeout, domain));
        if (null != pingString)
        {
            try
            {
                String tempInfo = pingString.substring(pingString.indexOf("min/avg/max/mdev") + 19);
                String[] temps = tempInfo.split("/");
                return Math.round(Float.valueOf(temps[3].replace(" ms", "")));
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 獲取ping url的丟包率，浮點型
     *
     * @param url 需要ping的url地址
     * @return 丟包率 如50%可得 50，注意：-1是預設值，返回-1表示獲取失敗
     */
    public static float getPacketLossFloat(String url)
    {
        String packetLossInfo = getPacketLoss(url);
        if (null != packetLossInfo)
        {
            try
            {
                return Float.valueOf(packetLossInfo.replace("%", ""));
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 獲取ping url的丟包率，浮點型
     *
     * @param url 需要ping的url地址
     * @param count 需要ping的次數
     * @param timeout 需要ping的超時時間，單位 ms
     * @return 丟包率 如50%可得 50，注意：-1是預設值，返回-1表示獲取失敗
     */
    public static float getPacketLossFloat(String url, int count, int timeout)
    {
        String packetLossInfo = getPacketLoss(url, count, timeout);
        if (null != packetLossInfo)
        {
            try
            {
                return Float.valueOf(packetLossInfo.replace("%", ""));
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 獲取ping url的丟包率
     *
     * @param url 需要ping的url地址
     * @return 丟包率 x%
     */
    public static String getPacketLoss(String url)
    {
        return getPacketLoss(url, 1, 100);
    }

    /**
     * 獲取ping url的丟包率
     *
     * @param url 需要ping的url地址
     * @param count 需要ping的次數
     * @param timeout 需要ping的超時時間，單位ms
     * @return 丟包率 x%
     */
    public static String getPacketLoss(String url, int count, int timeout)
    {
        String domain = getDomain(url);
        if (null == domain)
        {
            return null;
        }
        String pingString = ping(createSimplePingCommand(count, timeout, domain));
        if (null != pingString)
        {
            try
            {
                String tempInfo = pingString.substring(pingString.indexOf("received,"));
                return tempInfo.substring(9, tempInfo.indexOf("packet"));
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        return null;
    }

    // ********************以下是一些輔助方法********************//
    private static String getDomain(String url)
    {
        String domain = null;
        try
        {
            domain = URI.create(url).getHost();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return domain;
    }

    private static boolean isMatch(String regex, String string)
    {
        return Pattern.matches(regex, string);
    }

    private static String ping(String command)
    {
        Process process = null;
        try
        {
            process = Runtime.getRuntime().exec(command);
            InputStream is = process.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(is));
            StringBuilder sb = new StringBuilder();
            String line;
            while (null != (line = reader.readLine()))
            {
                sb.append(line);
                sb.append("\n");
            }
            reader.close();
            is.close();
            return sb.toString();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != process)
            {
                process.destroy();
            }
        }
        return null;
    }

    private static String createSimplePingCommand(int count, int timeout, String domain)
    {
        return "/system/bin/ping -c " + count + " -w " + timeout + " " + domain;
    }

    private static String createPingCommand(ArrayMap<String, String> map, String domain)
    {
        String command = "/system/bin/ping";
        int len = map.size();
        for (int i = 0; i < len; i++)
        {
            command = command.concat(" " + map.keyAt(i) + " " + map.get(map.keyAt(i)));
        }
        command = command.concat(" " + domain);
        return command;
    }
}