`

java 不用jni 也可以获得当前系统信息

JavaJNIperformanceWindowsSUN 
阅读更多

最近做个项目，就是要取得cpu占有率等等的系统信息，一开始以为要用动态链接库了，但后来发现可以像下面这样做，不去调用jni，这样省去了很多看新技术的时间o(∩_∩)o...

在Java中，可以获得总的物理内存、剩余的物理内存、已使用的物理内存等信息，下面例子可以取得这些信息，并且获得在Windows下的内存使用率。
     首先编写一个MonitorInfoBean类，用来装载监控的一些信息，包括物理内存、剩余的物理内存、已使用的物理内存、内存使用率等字段，该类的代码如下：

Java代码 复制代码
  1. package com.amgkaka.performance;   
  2.   
  3. /** *//**  
  4.  * 监视信息的JavaBean类.  
  5.  * @author  amg  
  6.  * @version 1.0   
  7.  * Creation date: 2008-4-25 - 上午10:37:00  
  8.  */  
  9. public class MonitorInfoBean {   
  10.     /** *//** 可使用内存. */  
  11.     private long totalMemory;   
  12.        
  13.     /** *//** 剩余内存. */  
  14.     private long freeMemory;   
  15.        
  16.     /** *//** 最大可使用内存. */  
  17.     private long maxMemory;   
  18.        
  19.     /** *//** 操作系统. */  
  20.     private String osName;   
  21.        
  22.     /** *//** 总的物理内存. */  
  23.     private long totalMemorySize;   
  24.        
  25.     /** *//** 剩余的物理内存. */  
  26.     private long freePhysicalMemorySize;   
  27.        
  28.     /** *//** 已使用的物理内存. */  
  29.     private long usedMemory;   
  30.        
  31.     /** *//** 线程总数. */  
  32.     private int totalThread;   
  33.        
  34.     /** *//** cpu使用率. */  
  35.     private double cpuRatio;   
  36.   
  37.     public long getFreeMemory() {   
  38.         return freeMemory;   
  39.     }   
  40.   
  41.     public void setFreeMemory(long freeMemory) {   
  42.         this.freeMemory = freeMemory;   
  43.     }   
  44.   
  45.     public long getFreePhysicalMemorySize() {   
  46.         return freePhysicalMemorySize;   
  47.     }   
  48.   
  49.     public void setFreePhysicalMemorySize(long freePhysicalMemorySize) {   
  50.         this.freePhysicalMemorySize = freePhysicalMemorySize;   
  51.     }   
  52.   
  53.     public long getMaxMemory() {   
  54.         return maxMemory;   
  55.     }   
  56.   
  57.     public void setMaxMemory(long maxMemory) {   
  58.         this.maxMemory = maxMemory;   
  59.     }   
  60.   
  61.     public String getOsName() {   
  62.         return osName;   
  63.     }   
  64.   
  65.     public void setOsName(String osName) {   
  66.         this.osName = osName;   
  67.     }   
  68.   
  69.     public long getTotalMemory() {   
  70.         return totalMemory;   
  71.     }   
  72.   
  73.     public void setTotalMemory(long totalMemory) {   
  74.         this.totalMemory = totalMemory;   
  75.     }   
  76.   
  77.     public long getTotalMemorySize() {   
  78.         return totalMemorySize;   
  79.     }   
  80.   
  81.     public void setTotalMemorySize(long totalMemorySize) {   
  82.         this.totalMemorySize = totalMemorySize;   
  83.     }   
  84.   
  85.     public int getTotalThread() {   
  86.         return totalThread;   
  87.     }   
  88.   
  89.     public void setTotalThread(int totalThread) {   
  90.         this.totalThread = totalThread;   
  91.     }   
  92.   
  93.     public long getUsedMemory() {   
  94.         return usedMemory;   
  95.     }   
  96.   
  97.     public void setUsedMemory(long usedMemory) {   
  98.         this.usedMemory = usedMemory;   
  99.     }   
  100.   
  101.     public double getCpuRatio() {   
  102.         return cpuRatio;   
  103.     }   
  104.   
  105.     public void setCpuRatio(double cpuRatio) {   
  106.         this.cpuRatio = cpuRatio;   
  107.     }   
  108. }  
package com.amgkaka.performance;

/** *//**
 * 监视信息的JavaBean类.
 * @author  amg
 * @version 1.0 
 * Creation date: 2008-4-25 - 上午10:37:00
 */
public class MonitorInfoBean {
    /** *//** 可使用内存. */
    private long totalMemory;
    
    /** *//** 剩余内存. */
    private long freeMemory;
    
    /** *//** 最大可使用内存. */
    private long maxMemory;
    
    /** *//** 操作系统. */
    private String osName;
    
    /** *//** 总的物理内存. */
    private long totalMemorySize;
    
    /** *//** 剩余的物理内存. */
    private long freePhysicalMemorySize;
    
    /** *//** 已使用的物理内存. */
    private long usedMemory;
    
    /** *//** 线程总数. */
    private int totalThread;
    
    /** *//** cpu使用率. */
    private double cpuRatio;

    public long getFreeMemory() {
        return freeMemory;
    }

    public void setFreeMemory(long freeMemory) {
        this.freeMemory = freeMemory;
    }

    public long getFreePhysicalMemorySize() {
        return freePhysicalMemorySize;
    }

    public void setFreePhysicalMemorySize(long freePhysicalMemorySize) {
        this.freePhysicalMemorySize = freePhysicalMemorySize;
    }

    public long getMaxMemory() {
        return maxMemory;
    }

    public void setMaxMemory(long maxMemory) {
        this.maxMemory = maxMemory;
    }

    public String getOsName() {
        return osName;
    }

    public void setOsName(String osName) {
        this.osName = osName;
    }

    public long getTotalMemory() {
        return totalMemory;
    }

    public void setTotalMemory(long totalMemory) {
        this.totalMemory = totalMemory;
    }

    public long getTotalMemorySize() {
        return totalMemorySize;
    }

    public void setTotalMemorySize(long totalMemorySize) {
        this.totalMemorySize = totalMemorySize;
    }

    public int getTotalThread() {
        return totalThread;
    }

    public void setTotalThread(int totalThread) {
        this.totalThread = totalThread;
    }

    public long getUsedMemory() {
        return usedMemory;
    }

    public void setUsedMemory(long usedMemory) {
        this.usedMemory = usedMemory;
    }

    public double getCpuRatio() {
        return cpuRatio;
    }

    public void setCpuRatio(double cpuRatio) {
        this.cpuRatio = cpuRatio;
    }
}

 

接着编写一个获得当前的监控信息的接口，该类的代码如下所示：

Java代码 复制代码
  1. package com.amgkaka.performance;   
  2.   
  3. /** *//**  
  4.  * 获取系统信息的业务逻辑类接口.  
  5.  * @author amg * @version 1.0   
  6.  * Creation date: 2008-3-11 - 上午10:06:06  
  7.  */  
  8. public interface IMonitorService {   
  9.     /** *//**  
  10.      * 获得当前的监控对象.  
  11.      * @return 返回构造好的监控对象  
  12.      * @throws Exception  
  13.      * @author amgkaka  
  14.      * Creation date: 2008-4-25 - 上午10:45:08  
  15.      */  
  16.     public MonitorInfoBean getMonitorInfoBean() throws Exception;   
  17.   
  18. }  
package com.amgkaka.performance;

/** *//**
 * 获取系统信息的业务逻辑类接口.
 * @author amg * @version 1.0 
 * Creation date: 2008-3-11 - 上午10:06:06
 */
public interface IMonitorService {
    /** *//**
     * 获得当前的监控对象.
     * @return 返回构造好的监控对象
     * @throws Exception
     * @author amgkaka
     * Creation date: 2008-4-25 - 上午10:45:08
     */
    public MonitorInfoBean getMonitorInfoBean() throws Exception;

}

  该类的实现类MonitorServiceImpl如下所示：

Java代码 复制代码
  1. package com.amgkaka.performance;   
  2.   
  3. import java.io.InputStreamReader;   
  4. import java.io.LineNumberReader;   
  5.   
  6. import sun.management.ManagementFactory;   
  7.   
  8. import com.sun.management.OperatingSystemMXBean;   
  9.   
  10. /** *//**  
  11.  * 获取系统信息的业务逻辑实现类.  
  12.  * @author amg * @version 1.0 Creation date: 2008-3-11 - 上午10:06:06  
  13.  */  
  14. public class MonitorServiceImpl implements IMonitorService {   
  15.     //可以设置长些，防止读到运行此次系统检查时的cpu占用率，就不准了   
  16.     private static final int CPUTIME = 5000;   
  17.   
  18.     private static final int PERCENT = 100;   
  19.   
  20.     private static final int FAULTLENGTH = 10;   
  21.   
  22.     /** *//**  
  23.      * 获得当前的监控对象.  
  24.      * @return 返回构造好的监控对象  
  25.      * @throws Exception  
  26.      * @author amg     * Creation date: 2008-4-25 - 上午10:45:08  
  27.      */  
  28.     public MonitorInfoBean getMonitorInfoBean() throws Exception {   
  29.         int kb = 1024;   
  30.            
  31.         // 可使用内存   
  32.         long totalMemory = Runtime.getRuntime().totalMemory() / kb;   
  33.         // 剩余内存   
  34.         long freeMemory = Runtime.getRuntime().freeMemory() / kb;   
  35.         // 最大可使用内存   
  36.         long maxMemory = Runtime.getRuntime().maxMemory() / kb;   
  37.   
  38.         OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory   
  39.                 .getOperatingSystemMXBean();   
  40.   
  41.         // 操作系统   
  42.         String osName = System.getProperty("os.name");   
  43.         // 总的物理内存   
  44.         long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;   
  45.         // 剩余的物理内存   
  46.         long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;   
  47.         // 已使用的物理内存   
  48.         long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb   
  49.                 .getFreePhysicalMemorySize())   
  50.                 / kb;   
  51.   
  52.         // 获得线程总数   
  53.         ThreadGroup parentThread;   
  54.         for (parentThread = Thread.currentThread().getThreadGroup(); parentThread   
  55.                 .getParent() != null; parentThread = parentThread.getParent())   
  56.             ;   
  57.         int totalThread = parentThread.activeCount();   
  58.   
  59.         double cpuRatio = 0;   
  60.         if (osName.toLowerCase().startsWith("windows")) {   
  61.             cpuRatio = this.getCpuRatioForWindows();   
  62.         }   
  63.            
  64.         // 构造返回对象   
  65.         MonitorInfoBean infoBean = new MonitorInfoBean();   
  66.         infoBean.setFreeMemory(freeMemory);   
  67.         infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize);   
  68.         infoBean.setMaxMemory(maxMemory);   
  69.         infoBean.setOsName(osName);   
  70.         infoBean.setTotalMemory(totalMemory);   
  71.         infoBean.setTotalMemorySize(totalMemorySize);   
  72.         infoBean.setTotalThread(totalThread);   
  73.         infoBean.setUsedMemory(usedMemory);   
  74.         infoBean.setCpuRatio(cpuRatio);   
  75.         return infoBean;   
  76.     }   
  77.   
  78.     /** *//**  
  79.      * 获得CPU使用率.  
  80.      * @return 返回cpu使用率  
  81.      * @author amg     * Creation date: 2008-4-25 - 下午06:05:11  
  82.      */  
  83.     private double getCpuRatioForWindows() {   
  84.         try {   
  85.             String procCmd = System.getenv("windir")   
  86.                     + "\\system32\\wbem\\wmic.exe process get Caption,CommandLine,"  
  87.                     + "KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount";   
  88.             // 取进程信息   
  89.             long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));   
  90.             Thread.sleep(CPUTIME);   
  91.             long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));   
  92.             if (c0 != null && c1 != null) {   
  93.                 long idletime = c1[0] - c0[0];   
  94.                 long busytime = c1[1] - c0[1];   
  95.                 return Double.valueOf(   
  96.                         PERCENT * (busytime) / (busytime + idletime))   
  97.                         .doubleValue();   
  98.             } else {   
  99.                 return 0.0;   
  100.             }   
  101.         } catch (Exception ex) {   
  102.             ex.printStackTrace();   
  103.             return 0.0;   
  104.         }   
  105.     }   
  106.   
  107.     /** *//**  
  108.      * 读取CPU信息.  
  109.      * @param proc  
  110.      * @return  
  111.      * @author amg     * Creation date: 2008-4-25 - 下午06:10:14  
  112.      */  
  113.     private long[] readCpu(final Process proc) {   
  114.         long[] retn = new long[2];   
  115.         try {   
  116.             proc.getOutputStream().close();   
  117.             InputStreamReader ir = new InputStreamReader(proc.getInputStream());   
  118.             LineNumberReader input = new LineNumberReader(ir);   
  119.             String line = input.readLine();   
  120.             if (line == null || line.length() < FAULTLENGTH) {   
  121.                 return null;   
  122.             }   
  123.             int capidx = line.indexOf("Caption");   
  124.             int cmdidx = line.indexOf("CommandLine");   
  125.             int rocidx = line.indexOf("ReadOperationCount");   
  126.             int umtidx = line.indexOf("UserModeTime");   
  127.             int kmtidx = line.indexOf("KernelModeTime");   
  128.             int wocidx = line.indexOf("WriteOperationCount");   
  129.             long idletime = 0;   
  130.             long kneltime = 0;   
  131.             long usertime = 0;   
  132.             while ((line = input.readLine()) != null) {   
  133.                 if (line.length() < wocidx) {   
  134.                     continue;   
  135.                 }   
  136.                 // 字段出现顺序：Caption,CommandLine,KernelModeTime,ReadOperationCount,   
  137.                 // ThreadCount,UserModeTime,WriteOperation   
  138.                 String caption = Bytes.substring(line, capidx, cmdidx - 1)   
  139.                         .trim();   
  140.                 String cmd = Bytes.substring(line, cmdidx, kmtidx - 1).trim();   
  141.                 if (cmd.indexOf("wmic.exe") >= 0) {   
  142.                     continue;   
  143.                 }   
  144.                 // log.info("line="+line);   
  145.                 if (caption.equals("System Idle Process")   
  146.                         || caption.equals("System")) {   
  147.                     idletime += Long.valueOf(   
  148.                             Bytes.substring(line, kmtidx, rocidx - 1).trim())   
  149.                             .longValue();   
  150.                     idletime += Long.valueOf(   
  151.                             Bytes.substring(line, umtidx, wocidx - 1).trim())   
  152.                             .longValue();   
  153.                     continue;   
  154.                 }   
  155.   
  156.                 kneltime += Long.valueOf(   
  157.                         Bytes.substring(line, kmtidx, rocidx - 1).trim())   
  158.                         .longValue();   
  159.                 usertime += Long.valueOf(   
  160.                         Bytes.substring(line, umtidx, wocidx - 1).trim())   
  161.                         .longValue();   
  162.             }   
  163.             retn[0] = idletime;   
  164.             retn[1] = kneltime + usertime;   
  165.             return retn;   
  166.         } catch (Exception ex) {   
  167.             ex.printStackTrace();   
  168.         } finally {   
  169.             try {   
  170.                 proc.getInputStream().close();   
  171.             } catch (Exception e) {   
  172.                 e.printStackTrace();   
  173.             }   
  174.         }   
  175.         return null;   
  176.     }   
  177.        
  178.     /** *//**  
  179.      * 测试方法.  
  180.      * @param args  
  181.      * @throws Exception  
  182.      * @author amg     * Creation date: 2008-4-30 - 下午04:47:29  
  183.      */  
  184.     public static void main(String[] args) throws Exception {   
  185.         IMonitorService service = new MonitorServiceImpl();   
  186.         MonitorInfoBean monitorInfo = service.getMonitorInfoBean();   
  187.         System.out.println("cpu占有率=" + monitorInfo.getCpuRatio());   
  188.            
  189.         System.out.println("可使用内存=" + monitorInfo.getTotalMemory());   
  190.         System.out.println("剩余内存=" + monitorInfo.getFreeMemory());   
  191.         System.out.println("最大可使用内存=" + monitorInfo.getMaxMemory());   
  192.            
  193.         System.out.println("操作系统=" + monitorInfo.getOsName());   
  194.         System.out.println("总的物理内存=" + monitorInfo.getTotalMemorySize() + "kb");   
  195.         System.out.println("剩余的物理内存=" + monitorInfo.getFreeMemory() + "kb");   
  196.         System.out.println("已使用的物理内存=" + monitorInfo.getUsedMemory() + "kb");   
  197.         System.out.println("线程总数=" + monitorInfo.getTotalThread() + "kb");   
  198.     }   
  199. }  
package com.amgkaka.performance;

import java.io.InputStreamReader;
import java.io.LineNumberReader;

import sun.management.ManagementFactory;

import com.sun.management.OperatingSystemMXBean;

/** *//**
 * 获取系统信息的业务逻辑实现类.
 * @author amg * @version 1.0 Creation date: 2008-3-11 - 上午10:06:06
 */
public class MonitorServiceImpl implements IMonitorService {
    //可以设置长些，防止读到运行此次系统检查时的cpu占用率，就不准了
    private static final int CPUTIME = 5000;

    private static final int PERCENT = 100;

    private static final int FAULTLENGTH = 10;

    /** *//**
     * 获得当前的监控对象.
     * @return 返回构造好的监控对象
     * @throws Exception
     * @author amg     * Creation date: 2008-4-25 - 上午10:45:08
     */
    public MonitorInfoBean getMonitorInfoBean() throws Exception {
        int kb = 1024;
        
        // 可使用内存
        long totalMemory = Runtime.getRuntime().totalMemory() / kb;
        // 剩余内存
        long freeMemory = Runtime.getRuntime().freeMemory() / kb;
        // 最大可使用内存
        long maxMemory = Runtime.getRuntime().maxMemory() / kb;

        OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory
                .getOperatingSystemMXBean();

        // 操作系统
        String osName = System.getProperty("os.name");
        // 总的物理内存
        long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;
        // 剩余的物理内存
        long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;
        // 已使用的物理内存
        long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb
                .getFreePhysicalMemorySize())
                / kb;

        // 获得线程总数
        ThreadGroup parentThread;
        for (parentThread = Thread.currentThread().getThreadGroup(); parentThread
                .getParent() != null; parentThread = parentThread.getParent())
            ;
        int totalThread = parentThread.activeCount();

        double cpuRatio = 0;
        if (osName.toLowerCase().startsWith("windows")) {
            cpuRatio = this.getCpuRatioForWindows();
        }
        
        // 构造返回对象
        MonitorInfoBean infoBean = new MonitorInfoBean();
        infoBean.setFreeMemory(freeMemory);
        infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize);
        infoBean.setMaxMemory(maxMemory);
        infoBean.setOsName(osName);
        infoBean.setTotalMemory(totalMemory);
        infoBean.setTotalMemorySize(totalMemorySize);
        infoBean.setTotalThread(totalThread);
        infoBean.setUsedMemory(usedMemory);
        infoBean.setCpuRatio(cpuRatio);
        return infoBean;
    }

    /** *//**
     * 获得CPU使用率.
     * @return 返回cpu使用率
     * @author amg     * Creation date: 2008-4-25 - 下午06:05:11
     */
    private double getCpuRatioForWindows() {
        try {
            String procCmd = System.getenv("windir")
                    + "\\system32\\wbem\\wmic.exe process get Caption,CommandLine,"
                    + "KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount";
            // 取进程信息
            long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));
            Thread.sleep(CPUTIME);
            long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));
            if (c0 != null && c1 != null) {
                long idletime = c1[0] - c0[0];
                long busytime = c1[1] - c0[1];
                return Double.valueOf(
                        PERCENT * (busytime) / (busytime + idletime))
                        .doubleValue();
            } else {
                return 0.0;
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            return 0.0;
        }
    }

    /** *//**
     * 读取CPU信息.
     * @param proc
     * @return
     * @author amg     * Creation date: 2008-4-25 - 下午06:10:14
     */
    private long[] readCpu(final Process proc) {
        long[] retn = new long[2];
        try {
            proc.getOutputStream().close();
            InputStreamReader ir = new InputStreamReader(proc.getInputStream());
            LineNumberReader input = new LineNumberReader(ir);
            String line = input.readLine();
            if (line == null || line.length() < FAULTLENGTH) {
                return null;
            }
            int capidx = line.indexOf("Caption");
            int cmdidx = line.indexOf("CommandLine");
            int rocidx = line.indexOf("ReadOperationCount");
            int umtidx = line.indexOf("UserModeTime");
            int kmtidx = line.indexOf("KernelModeTime");
            int wocidx = line.indexOf("WriteOperationCount");
            long idletime = 0;
            long kneltime = 0;
            long usertime = 0;
            while ((line = input.readLine()) != null) {
                if (line.length() < wocidx) {
                    continue;
                }
                // 字段出现顺序：Caption,CommandLine,KernelModeTime,ReadOperationCount,
                // ThreadCount,UserModeTime,WriteOperation
                String caption = Bytes.substring(line, capidx, cmdidx - 1)
                        .trim();
                String cmd = Bytes.substring(line, cmdidx, kmtidx - 1).trim();
                if (cmd.indexOf("wmic.exe") >= 0) {
                    continue;
                }
                // log.info("line="+line);
                if (caption.equals("System Idle Process")
                        || caption.equals("System")) {
                    idletime += Long.valueOf(
                            Bytes.substring(line, kmtidx, rocidx - 1).trim())
                            .longValue();
                    idletime += Long.valueOf(
                            Bytes.substring(line, umtidx, wocidx - 1).trim())
                            .longValue();
                    continue;
                }

                kneltime += Long.valueOf(
                        Bytes.substring(line, kmtidx, rocidx - 1).trim())
                        .longValue();
                usertime += Long.valueOf(
                        Bytes.substring(line, umtidx, wocidx - 1).trim())
                        .longValue();
            }
            retn[0] = idletime;
            retn[1] = kneltime + usertime;
            return retn;
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                proc.getInputStream().close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    
    /** *//**
     * 测试方法.
     * @param args
     * @throws Exception
     * @author amg     * Creation date: 2008-4-30 - 下午04:47:29
     */
    public static void main(String[] args) throws Exception {
        IMonitorService service = new MonitorServiceImpl();
        MonitorInfoBean monitorInfo = service.getMonitorInfoBean();
        System.out.println("cpu占有率=" + monitorInfo.getCpuRatio());
        
        System.out.println("可使用内存=" + monitorInfo.getTotalMemory());
        System.out.println("剩余内存=" + monitorInfo.getFreeMemory());
        System.out.println("最大可使用内存=" + monitorInfo.getMaxMemory());
        
        System.out.println("操作系统=" + monitorInfo.getOsName());
        System.out.println("总的物理内存=" + monitorInfo.getTotalMemorySize() + "kb");
        System.out.println("剩余的物理内存=" + monitorInfo.getFreeMemory() + "kb");
        System.out.println("已使用的物理内存=" + monitorInfo.getUsedMemory() + "kb");
        System.out.println("线程总数=" + monitorInfo.getTotalThread() + "kb");
    }
}

 

该实现类中需要用到一个自己编写byte的工具类，该类的代码如下所示：

Java代码 复制代码
  1. package com.amgkaka.performance;   
  2.   
  3. /** *//**  
  4.  * byte操作类.  
  5.  * @author amg * @version 1.0   
  6.  * Creation date: 2008-4-30 - 下午04:57:23  
  7.  */  
  8. public class Bytes {   
  9.     /** *//**  
  10.      * 由于String.subString对汉字处理存在问题（把一个汉字视为一个字节)，因此在  
  11.      * 包含汉字的字符串时存在隐患，现调整如下：  
  12.      * @param src 要截取的字符串  
  13.      * @param start_idx 开始坐标（包括该坐标)  
  14.      * @param end_idx   截止坐标（包括该坐标）  
  15.      * @return  
  16.      */  
  17.     public static String substring(String src, int start_idx, int end_idx){   
  18.         byte[] b = src.g
    分享到：
    | solr 1.3 安装步骤
    评论
    发表评论

    您还没有登录,请您登录后再发表评论

相关推荐

    Java_JNI_获得系统进程信息实例.doc

    在《Java_JNI_获得系统进程信息实例.doc》中，我们探索了一个利用Java Native Interface (JNI)来获取操作系统进程信息的示例项目。该项目由三个主要部分组成：`systemProcess.java`，`dataProcess.java`以及`process...

    java 通过jni接口获取当前机器硬盘ID（序列号）

    Java 通过JNI（Java Native Interface）接口获取当前机器硬盘ID，即序列号，是一种混合编程技术，它允许Java代码调用本地系统库，如DLL（动态链接库）来执行特定的系统级任务，这些任务在Java标准库中可能无法直接...

    java-JNI调用动态库获取硬件信息制作软件加密

    ### Java-JNI调用动态库获取硬件信息制作软件加密 #### 一、Java-JNI调用动态库原理 Java Native Interface (JNI) 是Java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI最常用于实现Java环境下的...

    java使用jni技术对硬件平台的资源进行监控

    在 Java 中，JNI 可以帮助我们获取操作系统级别的内存信息，例如总内存、已用内存和空闲内存。在 Windows 上，可以使用 `GlobalMemoryStatusEx` 函数；在 Unix 系统中，可以读取 `/proc/meminfo` 文件。 4. **网卡...

    JNI处理各种类型数据，不包含获取Java的HashMap

    6. 异常处理：在JNI中，使用`ExceptionOccurred`检查是否发生了异常，如果有，可以用`ExceptionDescribe`打印异常信息，`ExceptionClear`清除当前的异常。 7. 类和方法ID：在C/C++中，你需要先获取类的`jclass`，...

    java(jni)获得CPU、内存使用率 绝对可用

    在压缩包中的`jni获得硬盘信息.txt`文件可能包含了如何获取硬盘信息的示例，这同样可以通过JNI实现。获取硬盘使用率通常涉及到读取`/proc/diskstats`或`/sys/block`下的文件，解析其内容并计算磁盘读写速度及使用...

    JNI系统进程列表查询

    `/proc`是一个虚拟文件系统，它反映了当前系统的状态，包括进程信息。每个运行中的进程在`/proc`下都有一个对应的目录，例如`/proc/1234`代表进程ID为1234的进程。你可以读取`/proc/[pid]/stat`文件获取进程状态，...

    jni.rar_JNI编程_java jni_jni_site:www.pudn.com

    本地代码可以通过`ExceptionOccurred`检查是否有Java异常发生，使用`ExceptionDescribe`打印异常信息，`ExceptionClear`清除当前的异常。 8. **线程支持** JNI支持多线程编程，每个Java线程都有一个对应的本地线程...

    Java获取系统CPU、内存、硬盘等系统信息

    在Java编程中，获取系统资源的信息是常见...总的来说，Java虽然不能直接提供获取所有系统资源的通用方法，但通过标准库和其他辅助工具，我们可以获取到CPU、内存和硬盘等关键信息，为系统监控和性能优化提供数据支持。

    java读取服务器硬件信息（windowx+linux+Mac OS）

    例如，使用`System.getProperty("os.name")`获取当前操作系统的名称，然后根据名称创建并实例化对应的硬件信息提供者。 总结起来，Java通过多种方式可以读取Windows、Linux和Mac OS的硬件信息，包括JNI、shell命令...

    获取当前系统所有进程

    总结来说，获取当前系统所有进程可以通过Java直接调用操作系统命令或者使用JNI调用本地代码实现。前者简单且跨平台，但可能受到操作系统命令行工具的限制；后者更灵活，可以直接操作底层系统，但需要编写和管理本地...

    java-读取任务管理器信息

    "Java 读取任务管理器信息" 本文主要讨论了如何在 Java 中读取任务管理器信息，包括物理内存、剩余物理内存、已使用...java 中读取任务管理器信息可以帮助开发者更好地了解系统的当前状态，提高系统的性能和可维护性。

    java 获取usb外接设备信息整理。

    通过上述步骤，我们可以使用Java有效地获取和管理USB外接设备的信息。在实际项目中，可能需要根据具体需求对这些基础操作进行封装和扩展，例如创建一个设备管理器类，提供更高级别的接口来处理设备的连接、断开、...

    java 通过jni查看windows的CPU利用率的问题

    在Windows系统中，这个信息可以通过调用Windows API函数获取。Java本身并不直接支持这样的功能，因此我们需要借助JNI来实现。 首先，我们需要创建一个本地方法声明在Java类中，例如： ```java public class Cpu...

    安卓串口Socket通讯USB驱动jni相关-Android获取手机sim卡信息包含手机平台运营商等信息.rar

    这些方法返回的信息可以帮助我们了解设备当前连接的运营商和网络环境。 接下来，关于JNI，它是Java平台用来与C/C++原生代码交互的一种机制。在某些情况下，为了提高性能或者利用硬件特性，开发者可能需要编写原生...

    轻松学会JNI层多线程回调java方法

    在上述代码中，我们创建了一个新线程`nativeThreadFunc`，并在其中使用了`AttachCurrentThread()`来获取一个新的JNI环境，然后在这个新环境中调用Java方法。这样可以确保线程安全，避免因多线程环境下直接使用`...

    JNI官方规范中文

    1. **本地方法接口**：JNI提供了一套接口，使得Java虚拟机（JVM）能够调用本地（非Java）代码，同时本地代码也能调用Java对象和方法。这些接口包括`JNIEnv`指针，它是所有本地方法接口函数的入口点。 2. **注册本地...

    java获取浏览器代理设置

    总结来说，Java获取浏览器代理设置是一个涉及操作系统交互的过程，可以通过JNI或第三方库来实现。`registry.jar`和`ICE_JNIRegistry.dll`的组合提供了一种可能的实现途径，即通过读取Windows注册表来获取浏览器的...

    Java Native Interface(JNI)官方学习手册

    JNI在Java的发展历程中扮演了关键角色，特别是在需要高效性能、调用系统级库或者利用硬件特性时。以下是对JNI相关知识点的详细说明： 1. **JNI简介**： JNI是Java开发人员用来编写混合模式代码的接口，它可以调用...

Magicbox
Global site tag (gtag.js) - Google Analytics