WifiManager wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
WifiInfo wifiInfo = wifiManager.getConnectionInfo();

public static boolean isWifi5G(Context context) {
    int freq = 0;
    WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
    WifiInfo wifiInfo = wifiManager.getConnectionInfo();
    if (android.os.Build.VERSION.SDK_INT > android.os.Build.VERSION_CODES.LOLLIPOP) {
        freq = wifiInfo.getFrequency();
    } else {
        String ssid = wifiInfo.getSSID();
        if (ssid != null && ssid.length() > 2) {
            String ssidTemp = ssid.substring(1, ssid.length() - 1);
            List<ScanResult> scanResults = wifiManager.getScanResults();
            for (ScanResult scanResult : scanResults) {
                if (scanResult.SSID.equals(ssidTemp)) {
                    freq = scanResult.frequency;
                    break;
                }
            }
        }
    }
    LgqLogPlus.e("WiFi====fff   "+freq);
    return freq > 4900 && freq < 5900;
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

 2.4G和5G以及单双频WiFi判断

<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />

 public Context mContext;
    private List<WIFIBean> wifiBeans = new ArrayList<>();
    private List<WIFIBean> wifiBeans2 = new ArrayList<>();
    private List<WIFIBean> wifiBeans3 = new ArrayList<>();

    public void isWifi5G(){
        WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);

        List<ScanResult> scanResults = wifiManager.getScanResults();
        LgqLogutil.e("WiFi====fff   "+"....."+scanResults.size());

        for (int c = 0;c<scanResults.size();c++) {
            LgqLogutil.e("WiFi====fff   " + scanResults.get(c).SSID + "....." + scanResults.get(c).frequency);
            if (!scanResults.get(c).SSID.isEmpty()){
                WIFIBean wifiBean = new WIFIBean();
                wifiBean.names = scanResults.get(c).SSID;
                int fre = scanResults.get(c).frequency;
                if (fre>5000){
                    wifiBean.types = 5;
                }else {
                    wifiBean.types = 2;
                }
                wifiBeans.add(wifiBean);
                wifiBeans2.add(wifiBean);

            }
        }
//        LgqLogPlus.e("WiFi====fff   "+"....."+MyByteUtil.parseObjToJsonStr(wifiBeans));

        for (int a = 0;a<wifiBeans.size();a++){
            for (int k = 0;k<wifiBeans2.size();k++){
                if (wifiBeans.get(a).names.equals(wifiBeans2.get(k).names)){
                    if (wifiBeans.get(a).types!=wifiBeans2.get(k).types){
                        WIFIBean wifiBean = new WIFIBean();
                        wifiBean.names = wifiBeans.get(a).names;
                        wifiBean.types = 1;
                        wifiBeans.set(a,wifiBean);
                    }
                }
            }
        }


        for (int x= 0 ;x<wifiBeans.size();x++){
            if (wifiBeans3.isEmpty()){
                wifiBeans3.add(wifiBeans.get(x));
            }else {
                boolean ifok=false;
                for (int y =0;y<wifiBeans3.size();y++){
                    if (wifiBeans.get(x).names.equals(wifiBeans3.get(y).names)){
                        ifok = true;
                        break;
                    }else {
                        ifok = false;
                    }
                }
                if (!ifok){
                    LgqLogutil.e("gggg----"+wifiBeans.get(x).names+"........"+wifiBeans.get(x).types);
                    wifiBeans3.add(wifiBeans.get(x));
                }
            }
        }
//        wifiAdapter.setNewData(wifiBeans3);
    }

 获取已连接的WiFi名称

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

//获取SSID
//完美解决9.0的机型，必须请求GPS权限并打开GPS才可以正确获取到WIFI名称
private String getNetConfListForSSID() {
    String ssid = "";
    WifiManager mWifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
    if (mWifiManager != null) {
        WifiInfo info = mWifiManager.getConnectionInfo();

        //android10.0需要申请新添加的隐私权限ACCESS_FINE_LOCATION，如果还需要后台获取或者使用wifi api则还需要申请后台使用定位权限ACCESS_BACKGROUND_LOCATION
        //链接：https://www.jianshu.com/p/7c05a99f94da

        if(!IsNullString(info.getSSID())){
            ssid = info.getSSID();
            Log.e("lgq","---直接获取ssid:"+ssid);
        }else{
            int networkId = info.getNetworkId();
            @SuppressLint("MissingPermission")
            List<WifiConfiguration> netConfList = mWifiManager.getConfiguredNetworks();
            if(netConfList==null){
                return "";
            }
            for (WifiConfiguration wificonf:netConfList){
                if(wificonf.networkId == networkId){
                    Log.e("lgq","---间接获取ssid："+ssid);
                }
            }
        }
    }

    if (ssid!=null && ssid.startsWith("\"")) {
        ssid = ssid.substring(1);
    }
    if (ssid!=null && ssid.endsWith("\"")) {
        ssid = ssid.substring(0, ssid.length() - 1);
    }

    return ssid;
}

//判断字符是否为空或者没数据
public static boolean IsNullString(String str) {
    if (str != null && !TextUtils.isEmpty(str) && !TextUtils.equals("", str.trim())) {
        return false;
    } else {
        return true;
    }
}

获取wifi的mac地址

public class D2WifiAdminSimple {

   private final Context mContext;
   public D2WifiAdminSimple(Context context) {
      mContext = context;
   }
   //获取SSID
   //完美解决9.0的机型，必须请求GPS权限并打开GPS才可以正确获取到WIFI名称
   public String getWifiConnectedSsid() {
      String  ssid="";
      WifiManager mWifiManager=(WifiManager)mContext.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
      if(mWifiManager!=null){
         WifiInfo info=mWifiManager.getConnectionInfo();
         int networkId=info.getNetworkId();
         List<WifiConfiguration> netConfList=mWifiManager.getConfiguredNetworks();
         for (WifiConfiguration wificonf:netConfList){
            if(wificonf.networkId == networkId){
               ssid=wificonf.SSID;
            }
         }

      }
      if (ssid!=null && ssid.startsWith("\"")) {
         ssid = ssid.substring(1);
      }
      if (ssid!=null && ssid.endsWith("\"")) {
         ssid = ssid.substring(0, ssid.length() - 1);
      }

      return ssid;
   }
   
   public String getWifiConnectedBssid() {
      WifiInfo mWifiInfo = getConnectionInfo();
      String bssid = null;
      if (mWifiInfo != null && isWifiConnected()) {
         bssid = mWifiInfo.getBSSID();
      }
      return bssid;
   }

   // get the wifi info which is "connected" in wifi-setting
   private WifiInfo getConnectionInfo() {
      WifiManager mWifiManager = (WifiManager) mContext.getApplicationContext()
            .getSystemService(Context.WIFI_SERVICE);
      WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
      return wifiInfo;
   }

   private boolean isWifiConnected() {
      NetworkInfo mWiFiNetworkInfo = getWifiNetworkInfo();
      boolean isWifiConnected = false;
      if (mWiFiNetworkInfo != null) {
         isWifiConnected = mWiFiNetworkInfo.isConnected();
      }
      return isWifiConnected;
   }

   private NetworkInfo getWifiNetworkInfo() {
      ConnectivityManager mConnectivityManager = (ConnectivityManager) mContext.getApplicationContext()
            .getSystemService(Context.CONNECTIVITY_SERVICE);
      NetworkInfo mWiFiNetworkInfo = mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
      return mWiFiNetworkInfo;
   }
}

private D2WifiAdminSimple mWifiAdmin;

String strWifiBSSID = mWifiAdmin.getWifiConnectedBssid();

 监听网络状态

//实时监听网络变化
private void listenConnectChance() {
   try {
      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
         ConnectivityManager connectivityManager = (ConnectivityManager) AppContext1.getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
         // 请注意这里会有一个版本适配bug，所以请在这里添加非空判断
         if (connectivityManager != null) {
            connectivityManager.requestNetwork(new NetworkRequest.Builder().build(), new ConnectivityManager.NetworkCallback() {
               /**
                * 网络可用的回调
                * 可用状态，判断手机网络，2.4G和5G
                * */
               @Override
               public void onAvailable(Network network) {
                  super.onAvailable(network);
                  LgqLogPlus.e("onAvailable 网络切换在线");

               }

               /**
                * 网络丢失的回调
                * 丢失状态，提示没网络
                * */
               @Override
               public void onLost(Network network) {
                  super.onLost(network);
                  //调onLost时，如果发现还有wifi或者移动网络时，会再次调onAvailable方法
                  LgqLogPlus.e("onLost网络切换离线4444");
                  EventBus.getDefault().post(new EBFragment(EBConstant.MAIN_HOME_NETWORK_OFF, null));

               }

               @Override
               public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
                  super.onLinkPropertiesChanged(network, linkProperties);
                  AppLog.Loge("onLinkPropertiesChanged");
               }

               @Override
               public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {
                  super.onCapabilitiesChanged(network, networkCapabilities);
                  AppLog.Loge("onCapabilitiesChanged");
               }

               @Override
               public void onLosing(Network network, int maxMsToLive) {
                  super.onLosing(network, maxMsToLive);
                  AppLog.Loge("onLosing");
               }

               @Override
               public void onUnavailable() {
                  super.onUnavailable();
                  AppLog.Loge("onUnavailable");
               }

            });
         }
      }
   } catch (Exception e) {
      CrashReport.postCatchedException(e);  // bugly会将这个throwable上报
   }

}

1、添加权限

<uses-permission android:name="android.permission.INTERNET"/>
<!-- 网络状态 -->
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />

2、创建监听广播NetWorkChangReceiver

public class NetWorkChangReceiver extends BroadcastReceiver {

    /**
     * 获取连接类型
     *
     * @param type
     * @return
     */
    private String getConnectionType(int type) {
        String connType = "";
        if (type == ConnectivityManager.TYPE_MOBILE) {
            connType = "3G网络数据";
        } else if (type == ConnectivityManager.TYPE_WIFI) {
            connType = "WIFI网络";
        }
        return connType;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {// 监听wifi的打开与关闭，与wifi的连接无关
            int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
            Log.e("lgqTAG", "wifiState:" + wifiState);
            switch (wifiState) {
                case WifiManager.WIFI_STATE_DISABLED:
                    break;
                case WifiManager.WIFI_STATE_DISABLING:
                    break;
            }
        }
        // 监听网络连接，包括wifi和移动数据的打开和关闭,以及连接上可用的连接都会接到监听
        if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
            //获取联网状态的NetworkInfo对象
            NetworkInfo info = intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
            if (info != null) {
                //如果当前的网络连接成功并且网络连接可用
                if (NetworkInfo.State.CONNECTED == info.getState() && info.isAvailable()) {
                    if (info.getType() == ConnectivityManager.TYPE_WIFI || info.getType() == ConnectivityManager.TYPE_MOBILE) {
                        Log.i("lgqTAG", getConnectionType(info.getType()) + "连上");
                    }
                } else {
                    Log.i("lgqTAG", getConnectionType(info.getType()) + "断开");
                }
            }
        }
    }
}

3、配置广播

<!--监听网络状态-->
<receiver android:name=".NetWorkChangReceiver" >
    <intent-filter>
        <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
        <action android:name="android.net.wifi.WIFI_STATE_CHANGED" />
        <action android:name="android.net.wifi.STATE_CHANGE" />
    </intent-filter>
</receiver>

4、注册广播

private NetWorkChangReceiver netWorkChangReceiver;

netWorkChangReceiver = new NetWorkChangReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
registerReceiver(netWorkChangReceiver, filter);

 5、退出时

 unregisterReceiver(netWorkChangReceiver);

2、判断网络连接方式——wifi。2G，3G。4G。5G

public class Constants {
    /**
     * Unknown network class
     */
    public static final int NETWORK_CLASS_UNKNOWN = 0;

    /**
     * wifi net work
     */
    public static final int NETWORK_WIFI = 1;

    /**
     * "2G" networks
     */
    public static final int NETWORK_CLASS_2_G = 2;

    /**
     * "3G" networks
     */
    public static final int NETWORK_CLASS_3_G = 3;

    /**
     * "4G" networks
     */
    public static final int NETWORK_CLASS_4_G = 4;

}

public static int getNetWorkClass(Context context) {
    TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);

    switch (telephonyManager.getNetworkType()) {
        case TelephonyManager.NETWORK_TYPE_GPRS:
        case TelephonyManager.NETWORK_TYPE_EDGE:
        case TelephonyManager.NETWORK_TYPE_CDMA:
        case TelephonyManager.NETWORK_TYPE_1xRTT:
        case TelephonyManager.NETWORK_TYPE_IDEN:
            return Constants.NETWORK_CLASS_2_G;

        case TelephonyManager.NETWORK_TYPE_UMTS:
        case TelephonyManager.NETWORK_TYPE_EVDO_0:
        case TelephonyManager.NETWORK_TYPE_EVDO_A:
        case TelephonyManager.NETWORK_TYPE_HSDPA:
        case TelephonyManager.NETWORK_TYPE_HSUPA:
        case TelephonyManager.NETWORK_TYPE_HSPA:
        case TelephonyManager.NETWORK_TYPE_EVDO_B:
        case TelephonyManager.NETWORK_TYPE_EHRPD:
        case TelephonyManager.NETWORK_TYPE_HSPAP:
            return Constants.NETWORK_CLASS_3_G;

        case TelephonyManager.NETWORK_TYPE_LTE:
            return Constants.NETWORK_CLASS_4_G;

        default:
            return Constants.NETWORK_CLASS_UNKNOWN;
    }
}

public static int getNetWorkStatus(Context context) {//等于1时是wifi网络，等于4是4G网络，等于3是3G网络
    int netWorkType = Constants.NETWORK_CLASS_UNKNOWN;

    ConnectivityManager connectivityManager = (ConnectivityManager) context
            .getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();

    if (networkInfo != null && networkInfo.isConnected()) {
        int type = networkInfo.getType();

        if (type == ConnectivityManager.TYPE_WIFI) {
            netWorkType = Constants.NETWORK_WIFI;
        } else if (type == ConnectivityManager.TYPE_MOBILE) {
            netWorkType = getNetWorkClass(context);
        }
    }

    return netWorkType;
}

3、判断网络是否连接

/**
 * 判断是否有网络连接
 * @param context
 * @return
 */
public static boolean isNetworkConnected(Context context) {//true是链接，false是没链接
    if (context != null) {
        ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo mNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
        if (mNetworkInfo != null) {
            return mNetworkInfo.isAvailable();
        }
    }
    return false;
}

9.0网络访问方法：application添加 android:usesCleartextTraffic="true" 即可 

private static boolean isWIFIConnection(Context context) {
    ConnectivityManager manager = (ConnectivityManager) context.getApplicationContext()
            .getSystemService(Context.CONNECTIVITY_SERVICE);

    NetworkInfo networkInfo = manager
            .getNetworkInfo(ConnectivityManager.TYPE_WIFI);
    if (networkInfo != null) {
        return networkInfo.isConnected();
    }
    return false;
}

startActivity(new Intent(Settings.ACTION_WIFI_SETTINGS));

public String getLocalIpAddress(Context context) {
    WifiManager wifiManager = (WifiManager) context.getApplicationContext().
            getSystemService(Context.WIFI_SERVICE);
    //判断wifi是否开启
    if (!wifiManager.isWifiEnabled()) {
        wifiManager.setWifiEnabled(true);
    }
    WifiInfo wifiInfo = wifiManager.getConnectionInfo();
    int ipAddress = wifiInfo.getIpAddress();
    String ip = intTo255Ip(ipAddress);
    return ip;
}

private String intTo255Ip(int i) {
    return (i & 0xFF) + "." +
            ((i >> 8) & 0xFF) + "." +
            ((i >> 16) & 0xFF) + "." +
            (i >> 24 & 0xFF);
}