java获取window系统注册表中某项的值

最新推荐文章于 2021-02-24 21:59:41 发布
最新推荐文章于 2021-02-24 21:59:41 发布
阅读量323 收藏 1
点赞数
文章标签： java 操作系统
原文链接：https://my.oschina.net/bysu/blog/1519205
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

本文永久地址：https://my.oschina.net/bysu/blog/1519205

由于公司的网络必须使用代理才能访问外网，从注册表里面把自动更改上网策略(是否使用代理)的注册表项的值已经清空了，以为这样就万事大吉了，谁知道第二天上班，开电脑又不能访问外网了。于是第一时间去看代理是否被取消了，果然不出所料，一切被恢复原状了。估计是电脑里面的杀毒软件或者某个安全策略设置了，电脑重启就重置了上网的策略。由于不知道是哪里的问题，再加上权限问题，就算找到估计也无法更改，还好现在还有注册表可以动，那么就从注册表入手吧~

先把获取注册表的java代码铺出来吧~

下面代码转自：https://stackoverflow.com/questions/62289/read-write-to-windows-registry-using-java

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.ArrayList;
import java.util.List;
import java.util.prefs.Preferences;

public class GetRegeditValue{
	public static final int HKEY_CURRENT_USER = 0x80000001;
	public static final int HKEY_LOCAL_MACHINE = 0x80000002;
	public static final int REG_SUCCESS = 0;
	public static final int REG_NOTFOUND = 2;
	public static final int REG_ACCESSDENIED = 5;

	private static final int KEY_ALL_ACCESS = 0xf003f;
	private static final int KEY_READ = 0x20019;
	private static final Preferences userRoot = Preferences.userRoot();
	private static final Preferences systemRoot = Preferences.systemRoot();
	private static final Class<? extends Preferences> userClass = userRoot.getClass();
	private static final Method regOpenKey;
	private static final Method regCloseKey;
	private static final Method regQueryValueEx;
	private static final Method regEnumValue;
	private static final Method regQueryInfoKey;
	private static final Method regEnumKeyEx;
	private static final Method regCreateKeyEx;
	private static final Method regSetValueEx;
	private static final Method regDeleteKey;
	private static final Method regDeleteValue;

	static {
		try {
			regOpenKey = userClass.getDeclaredMethod("WindowsRegOpenKey",new Class[] { int.class, byte[].class, int.class });
			regOpenKey.setAccessible(true);
			regCloseKey = userClass.getDeclaredMethod("WindowsRegCloseKey",new Class[] { int.class });
			regCloseKey.setAccessible(true);
			regQueryValueEx = userClass.getDeclaredMethod("WindowsRegQueryValueEx",new Class[] { int.class, byte[].class });
			regQueryValueEx.setAccessible(true);
			regEnumValue = userClass.getDeclaredMethod("WindowsRegEnumValue",new Class[] { int.class, int.class, int.class });
			regEnumValue.setAccessible(true);
			regQueryInfoKey = userClass.getDeclaredMethod("WindowsRegQueryInfoKey1",new Class[] { int.class });
			regQueryInfoKey.setAccessible(true);
			regEnumKeyEx = userClass.getDeclaredMethod("WindowsRegEnumKeyEx", new Class[] { int.class, int.class,int.class });  
			regEnumKeyEx.setAccessible(true);
			regCreateKeyEx = userClass.getDeclaredMethod("WindowsRegCreateKeyEx", new Class[] { int.class,byte[].class });  
			regCreateKeyEx.setAccessible(true);  
			regSetValueEx = userClass.getDeclaredMethod("WindowsRegSetValueEx", new Class[] { int.class,byte[].class, byte[].class });  
			regSetValueEx.setAccessible(true); 
			regDeleteValue = userClass.getDeclaredMethod("WindowsRegDeleteValue", new Class[] { int.class,byte[].class });  
			regDeleteValue.setAccessible(true); 
			regDeleteKey = userClass.getDeclaredMethod("WindowsRegDeleteKey", new Class[] { int.class,byte[].class });  
			regDeleteKey.setAccessible(true); 
    }
    catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  private GetRegeditValue() {  }

  /**
   * Read a value from key and value name
   * @param hkey   HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
   * @param key
   * @param valueName
   * @return the value
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   */
  public static String readString(int hkey, String key, String valueName) 
    throws IllegalArgumentException, IllegalAccessException,InvocationTargetException {
		
		if (hkey == HKEY_LOCAL_MACHINE) {
		  return readString(systemRoot, hkey, key, valueName);
		}
		else if (hkey == HKEY_CURRENT_USER) {
		  return readString(userRoot, hkey, key, valueName);
		}
		else {
		  throw new IllegalArgumentException("hkey=" + hkey);
		}
  }

  /**
  *读取某个项的下一级子项
   * Read value(s) and value name(s) form given key 
   * @param hkey  HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
   * @param key
   * @return the value name(s) plus the value(s)
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   */
  public static Map<String, String> readStringValues(int hkey, String key) throws IllegalArgumentException, IllegalAccessException,InvocationTargetException {
    if (hkey == HKEY_LOCAL_MACHINE) {
      return readStringValues(systemRoot, hkey, key);
    }
    else if (hkey == HKEY_CURRENT_USER) {
      return readStringValues(userRoot, hkey, key);
    }
    else {
      throw new IllegalArgumentException("hkey=" + hkey);
    }
  }

  /**
   * Read the value name(s) from a given key
   * @param hkey  HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
   * @param key
   * @return the value name(s)
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   */
  public static List<String> readStringSubKeys(int hkey, String key) throws IllegalArgumentException, IllegalAccessException,InvocationTargetException {
    if (hkey == HKEY_LOCAL_MACHINE) {
      return readStringSubKeys(systemRoot, hkey, key);
    }
    else if (hkey == HKEY_CURRENT_USER) {
      return readStringSubKeys(userRoot, hkey, key);
    }
    else {
      throw new IllegalArgumentException("hkey=" + hkey);
    }
  }

  /**
   * Create a key
   * @param hkey  HKEY_CURRENT_USER/HKEY_LOCAL_MACHINE
   * @param key
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   */
  public static void createKey(int hkey, String key) throws IllegalArgumentException, IllegalAccessException,InvocationTargetException 
  {
    int [] ret;
    if (hkey == HKEY_LOCAL_MACHINE) {
      ret = createKey(systemRoot, hkey, key);
      regCloseKey.invoke(systemRoot, new Object[] { new Integer(ret[0]) });
    }
    else if (hkey == HKEY_CURRENT_USER) {
      ret = createKey(userRoot, hkey, key);
      regCloseKey.invoke(userRoot, new Object[] { new Integer(ret[0]) });
    }
    else {
      throw new IllegalArgumentException("hkey=" + hkey);
    }
    if (ret[1] != REG_SUCCESS) {
      throw new IllegalArgumentException("rc=" + ret[1] + "  key=" + key);
    }
  }

  /**给某项添加值
   * Write a value in a given key/value name
   * @param hkey
   * @param key
   * @param valueName
   * @param value
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   */
  public static void writeStringValue(int hkey, String key, String valueName, String value) throws IllegalArgumentException, IllegalAccessException,InvocationTargetException{
    if (hkey == HKEY_LOCAL_MACHINE) {
      writeStringValue(systemRoot, hkey, key, valueName, value);
    }
    else if (hkey == HKEY_CURRENT_USER) {
      writeStringValue(userRoot, hkey, key, valueName, value);
    }
    else {
      throw new IllegalArgumentException("hkey=" + hkey);
    }
  }

  /**删除一个键
   * Delete a given key
   * @param hkey
   * @param key
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   */
  public static void deleteKey(int hkey, String key) 
    throws IllegalArgumentException, IllegalAccessException,
    InvocationTargetException 
  {
    int rc = -1;
    if (hkey == HKEY_LOCAL_MACHINE) {
      rc = deleteKey(systemRoot, hkey, key);
    }
    else if (hkey == HKEY_CURRENT_USER) {
      rc = deleteKey(userRoot, hkey, key);
    }
    if (rc != REG_SUCCESS) {
      throw new IllegalArgumentException("rc=" + rc + "  key=" + key);
    }
  }

  /**删除一个键的值
   * delete a value from a given key/value name
   * @param hkey
   * @param key
   * @param value
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   */
  public static void deleteValue(int hkey, String key, String value) 
    throws IllegalArgumentException, IllegalAccessException,
    InvocationTargetException 
  {
    int rc = -1;
    if (hkey == HKEY_LOCAL_MACHINE) {
      rc = deleteValue(systemRoot, hkey, key, value);
    }
    else if (hkey == HKEY_CURRENT_USER) {
      rc = deleteValue(userRoot, hkey, key, value);
    }
    if (rc != REG_SUCCESS) {
      throw new IllegalArgumentException("rc=" + rc + "  key=" + key + "  value=" + value);
    }
  }

  // =====================

  private static int deleteValue
    (Preferences root, int hkey, String key, String value)
    throws IllegalArgumentException, IllegalAccessException,
    InvocationTargetException 
  {
    int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
        new Integer(hkey), toCstr(key), new Integer(KEY_ALL_ACCESS) });
    if (handles[1] != REG_SUCCESS) {
      return handles[1];  // can be REG_NOTFOUND, REG_ACCESSDENIED
    }
    int rc =((Integer) regDeleteValue.invoke(root,  
        new Object[] { 
          new Integer(handles[0]), toCstr(value) 
          })).intValue();
    regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
    return rc;
  }

  private static int deleteKey(Preferences root, int hkey, String key) 
    throws IllegalArgumentException, IllegalAccessException,
    InvocationTargetException 
  {
    int rc =((Integer) regDeleteKey.invoke(root,  
        new Object[] { new Integer(hkey), toCstr(key) })).intValue();
    return rc;  // can REG_NOTFOUND, REG_ACCESSDENIED, REG_SUCCESS
  }

  private static String readString(Preferences root, int hkey, String key, String value)
    throws IllegalArgumentException, IllegalAccessException,
    InvocationTargetException 
  {
    int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
        new Integer(hkey), toCstr(key), new Integer(KEY_READ) });
    if (handles[1] != REG_SUCCESS) {
      return null; 
    }
    byte[] valb = (byte[]) regQueryValueEx.invoke(root, new Object[] {
        new Integer(handles[0]), toCstr(value) });
    regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
    return (valb != null ? new String(valb).trim() : null);
  }

  private static Map<String,String> readStringValues(Preferences root, int hkey, String key)throws IllegalArgumentException, IllegalAccessException,InvocationTargetException {
    HashMap<String, String> results = new HashMap<String,String>();
    int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
        new Integer(hkey), toCstr(key), new Integer(KEY_READ) });
    if (handles[1] != REG_SUCCESS) {
      return null;
    }
    int[] info = (int[]) regQueryInfoKey.invoke(root,new Object[] { new Integer(handles[0]) });

    int count = info[0]; // count  
    int maxlen = info[3]; // value length max
    for(int index=0; index<count; index++)  {
      byte[] name = (byte[]) regEnumValue.invoke(root, new Object[] {
          new Integer(handles[0]), new Integer(index), new Integer(maxlen + 1)});
		  String value = readString(hkey, key, new String(name));
		  results.put(new String(name).trim(), value);
    }
    regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
    return results;
  }

  
  //获取某项下一级所有的子项名字
  private static List<String> readStringSubKeys(Preferences root, int hkey, String key)throws IllegalArgumentException, IllegalAccessException,InvocationTargetException {
    List<String> results = new ArrayList<String>();
    int[] handles = (int[]) regOpenKey.invoke(root, new Object[] {
        new Integer(hkey), toCstr(key), new Integer(KEY_READ)});
    if (handles[1] != REG_SUCCESS) {
      return null;
    }
    int[] info = (int[]) regQueryInfoKey.invoke(root,new Object[] { new Integer(handles[0])});

    int count  = info[0]; // Fix: info[2] was being used here with wrong results. Suggested by davenpcj, confirmed by Petrucio
    int maxlen = info[3]; // value length max
    for(int index=0; index<count; index++)  {
      byte[] name = (byte[]) regEnumKeyEx.invoke(root, new Object[] {
        new Integer(handles[0]), new Integer(index), new Integer(maxlen + 1)});
		results.add(new String(name).trim());
    }
    regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
    return results;
  }

  private static int [] createKey(Preferences root, int hkey, String key)throws IllegalArgumentException, IllegalAccessException,InvocationTargetException {
    return  (int[]) regCreateKeyEx.invoke(root,
        new Object[] { new Integer(hkey), toCstr(key) });
  }

  private static void writeStringValue(Preferences root, int hkey, String key, String valueName, String value) throws IllegalArgumentException, IllegalAccessException,InvocationTargetException{
    int[] handles = (int[])regOpenKey.invoke(root, new Object[] {
        new Integer(hkey), toCstr(key), new Integer(KEY_ALL_ACCESS) });

		regSetValueEx.invoke(root,new Object[] { 
			new Integer(handles[0]), toCstr(valueName), toCstr(value)}); 
			regCloseKey.invoke(root, new Object[] { new Integer(handles[0]) });
  }

  // utility
  private static byte[] toCstr(String str) {
    byte[] result = new byte[str.length() + 1];

    for (int i = 0; i < str.length(); i++) {
      result[i] = (byte) str.charAt(i);
    }
    result[str.length()] = 0;
    return result;
  }

}

根据我对注册表的观察，注册表中各项跟IE局域网(LAN)设置中的各项对应如下图

简略说明如下：

AutoConfigProxy:为空时，那么就不勾选；

AutoConfigURL：为空或者不存在时，不勾选；

ProxyEnable：值为1是勾选；

ProxyServer：值为代理服务器的ip和端口，譬如：10.10.10.10::8080

ProxyOverride:值为<local>时为勾选。

那么知道了以上这些，通过上面的代码，更改对应的值即可.

我的代码如下

TestGetRegeditvalue.java

import java.lang.reflect.InvocationTargetException;

/** 
 * @author 苏宝伢 E-mail:by.su@qq.com 
 * @version 创建时间： 2017年8月15日 上午10:24:45
 */
 
public class TestGetRegeditValue{
	public static void main(String[] args)throws IllegalAccessException,InvocationTargetException{
		String[] values = {"AutoConfigProxy","AutoConfigURL","ProxyEnable","ProxyServer","ProxyOverride"};
		String value = "";
		for(String str:values){
			switch(str){
				case "AutoConfigProxy":
					value = GetRegeditValue.readString(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str);
					if(value != ""&&value != null){
						GetRegeditValue.deleteValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str);
						System.out.println("delete successful"); 
					}
					break;
				case "AutoConfigURL":
					value = GetRegeditValue.readString(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str);
					if(value != ""&&value != null){
						GetRegeditValue.deleteValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str);
						System.out.println("delete successful"); 
					}
					break;
				case "ProxyEnable":
					value = GetRegeditValue.readString(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str);
					System.out.println("ProxyEnable: " + value);
					if(value!=null){
						if(!value.equals("1")){
							//GetRegeditValue.deleteValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str);
							GetRegeditValue.writeStringValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str,"1");
							System.out.println("change successful"); 
						}
					}else{
						GetRegeditValue.writeStringValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str,"1");
						System.out.println("change successful"); 
					}
					break;
				case "ProxyServer":
					value = GetRegeditValue.readString(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str);
					System.out.println("ProxyServer: " + value);
					if(value != null){
						if(!value.equals("10.17.1xx.11:8080")){
							//GetRegeditValue.deleteValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str);
							GetRegeditValue.writeStringValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str,"10.17.1xx.11:8080");
							System.out.println("change successful"); 
						}
					}else{
						GetRegeditValue.writeStringValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str,"10.17.1xx.11:8080");
							System.out.println("change successful"); 
					}
					break;
				case "ProxyOverride":
					value = GetRegeditValue.readString(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str);
					System.out.println("ProxyOverride: " + value);
					if(value != null){
						if(!value.equals("<local>")){
							//GetRegeditValue.deleteValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str);
							GetRegeditValue.writeStringValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str,"<local>");
							System.out.println("change successful"); 
						}
					}else{
						GetRegeditValue.writeStringValue(GetRegeditValue.HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",str,"<local>");
						System.out.println("change successful"); 
					}
					break;
			}
		}
		System.out.println("修改完毕~！");   
	}
}

 

---------------更新时间：2017年9月4日15:54:23---------------------------

以上看似很完美，至少当时搞完以为能达到自己需要想要的目的，但是随后很沮丧地发现，通过java操作注册表是成功了，但是需要手动逐步打开代理设置的窗口，修改注册表才生效。去请教那些资深网管，除了让我装一个代理软件，也别无他法。

于是只能先放下，直至今天，意外发现直接导入注册表方式修改网络代理值则可以直接生效。既然这样，那就好办了。先把已经设置了网络代理的注册表相关项导出到本地(我这里命名为：proxy.reg)，然后待网络被某软件还原回去之后，执行上面的java代码，接着通过批处理导入proxy.reg文件(这一步主要就是让修改后的网络代理生效)。所以上述执行java代码，导入注册表通过一个批处理就直接搞定了。批处理如下：

@echo off

:1
echo "进行代理替换"
cd "D:\bysu\WorkSpace\java\proxy\"
java TestGetRegeditValue

regedit /s "proxy.reg"

ping -n 600 127.0.0.1  >nul
goto 1

现在是10分钟自动执行一次，后续通过java代码判断AutoConfigURL的值来控制。

 

 

 

 

 

 

 

 

转载于:https://my.oschina.net/bysu/blog/1519205

weixin_33712987
关注
java8 注册表_Java通过CMD方式读取注册表任意键值对代码实践
weixin_39822673的博客
02-13 230
需要读取如图所示注册表【HKEY_LOCAL_MACHINE\SOFTWARE\EasyDrv7】节点下的【DateTime】的值直接上代码：package com.beibei.common.util.cmd;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;impo...
java 读取注册表信息_java读取注册表中的信息
weixin_29340419的博客
02-25 572
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class GetReg {public static void main(String[] args) {try {Process ps = null;ps = Runtime.getRuntime()....
JAVA读取注册表中的值
帅帅的困哒哒
04-17 1502
需求：java动态读取注册表来调用第三方应用程序（如：qq、微信、网易云音乐等）启动，为什么说动态呢，因为使用绝对路径，每个人的电脑安装的路径并不一定相同，但注册表中的路径一般都相同，所以只要获取注册表中的程序路径即可打开。 关于这方面的内容，网上一直有两个方法，一个是使用JRegistry或者JNIRegistry来操作注册表，但需引入jar包，操作之前最好先备份一下， 以免操作不当系统崩溃，...
java 获取注册表值_java -获取注册表中的key值
weixin_39815329的博客
02-19 362
查阅了好多资料都木有找到这个问题的答案，因为在registry类中没有访问注册表的key值，而只是通过key值来寻找value值。而做项目时需要获取key值。贴上代码仅供参考，(*^__^*) ……public String getStr(String string) {//string为查询语句，像regquery HKEY_CURRENT_USER/softwareString[] aStr...
java读取windows注册表
yulongblue的专栏
07-11 937
import com.registry.RegistryKey; import com.registry.RegistryValue; public class RegeditTest { public static void readRegedit(){ RegistryKey rk = RegistryKey.listRoots()[RegistryKey.HKEY_LOCAL_MACHINE_INDEX]; /*RegistryKey hardware = new Reg
java的注册表在win10_java 使用Preferences操作注册表
weixin_39595085的博客
02-24 614
使用java操作windows注册表，有两种方式：使用java自带的Preferences类。优点：在使用了网上找的大神写的操作类，就可以轻松的对注册表进行增删改查！缺点：操作注册表范围有限；(但使用了大神写的操作类，就可以解决这个问题了。)Preferences.userRoot()的操作路径在[HKEY_CURRENT_USER\Software\JavaSoft\Prefs]Preferen...
java调用windows系统api_Java中怎么调用Windows的API - yuanyuan
weixin_29442031的博客
02-24 1689
Java中怎么调用Windows的API 1.建TestAPI.java public class TestAPI { public static void testshow(String msg) { testshow0(msg); } private static native int testshow0(String msg); static { System.loadLibrary( Te...
Java获取Windows系统指定软件进程号及启动软件
loongshawn的博客
11-02 1万+
Java获取Windows系统指定软件进程号及启动软件的方法
java获取硬盘序列号的两种方法
06-15
在Java编程语言中，获取硬盘序列号是一项常见的需求，...综上所述，Java获取硬盘序列号可以通过WMI查询或访问注册表来实现，但要注意平台兼容性和API稳定性问题。在实际开发中，根据项目需求和目标平台选择合适的方法。
Java中高级面试题总览(一)
热门推荐
击水三千里的专栏
03-29 2万+
高频面试题深入剖析
java读取注册表信息
10-27
java语言读取注册表信息，源码，jar包
java 读取注册表 很好用的
12-02
调用runtime来执行注册表查询 private static final String PERSONAL_FOLDER_CMD = REGQUERY_UTIL + "\"HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\" + "Explorer\\Shell Folders\" /v Personal"; private static final String CPU_SPEED_CMD = REGQUERY_UTIL + "\"HKLM\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0\"" + " /v ~MHz"; private static final String CPU_NAME_CMD = REGQUERY_UTIL + "\"HKLM\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0\"" + " /v ProcessorNameString"; private static final String HTTP_DEFAULT_BROWSERURI = REGQUERY_UTIL + "\"HKEY_CLASSES_ROOT\\http\\shell\\open\\command\"" +"" ;//http\\shell\\open\\ddeexec\\Topic private static final String HTTP_DEFAULT_BROWSERNAME = REGQUERY_UTIL + "\"HkEY_CLASSES_ROOT\\http\\shell\\open\\ddeexec\\Topic\"" +"" ;
java读取注册表的简单方法
12-07
详情请参考http://blog.csdn.net/a8_8a/article/details
Java修改注册表
04-17
用Java实现注册表的修改
Java读取注册表总结之读取的简单方法
萧枫的专栏
12-07 5696
============================================================= 【注】 注册表非常非常重要，如果操作不当，极有可能使系统崩溃。所以在操作之前，请备份完整的注册表数据。以备不时之需。 备份方法： http://jingyan.baidu.com/article/19020a0a3a446f529d2842e6.html =
java 获取注册表键值
u012389890的专栏
11-17 1118
/**      *      * @param location path in the registry      * @param key registry key      * @return registry value or null if not found      */ public static final String readRegistry(String l
java读取客户端注册表_JAVA获取客户端注册表键值
weixin_39733948的博客
02-13 262
展开全部public final class WinRegisterUtil {// root key value defined by windowspublic static final int HKEY_CLASSES_ROOT = 0x80000000;public static final int HKEY_CURRENT_USER = 0x80000001;public static ...
java读取客户端注册表_Java读取注册表的三种方法
weixin_39955925的博客
02-17 1369
近期项目需要使用java读取注册表,所以就认真的研究了一下,现把研究成果与大家分享一下.====================================================================================【注】注册表非常非常重要，如果操作不当，极有可能使系统崩溃。所以在操作之前，请备份完整的注册表数据。以备不时之需。===============...
java读取注册表中的信息
无意摘花
09-20 5917
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class GetReg { public static void main(String[] args) { try { Process ps = null; p
java获取window系统一秒中有百分之多少的时间用于I/O操做
最新发布
03-31
Java无法直接获取Windows系统一秒钟中用于I/O操作的时间百分比。这是因为Java虚拟机是跨平台的，不仅仅运行在Windows上，还可以运行在其他操作系统上。因此，Java不能直接访问操作系统的底层资源。 如果你想获取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值