How to delete registry Key value Using java

I need to delete a registry key value under HKLM\SOFTWARE\Policies\Google\Chrome\ExtensionInstallForcelist, "3". I need to delete key value. I found a code on http://www.rgagnon.com/javadetails/java-0630.html but when i'm trying to run it it's showing me Exception:

Exception in thread "main" java.lang.IllegalArgumentException: rc=5  key=SOFTWARE\Policies\Google\Chrome\ExtensionInstallForcelist  value=3
    at Forcast_DataFetch.WinRegistry.deleteValue(WinRegistry.java:253)
    at Forcast_DataFetch.WinRegistryTest.main(WinRegistryTest.java:12)

Code for reference:

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 WinRegistry {
    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 Preferences userRoot = Preferences.userRoot();
    private static Preferences systemRoot = Preferences.systemRoot();
    private static Class<? extends Preferences> userClass = userRoot.getClass();
    private static Method regOpenKey = null;
    private static Method regCloseKey = null;
    private static Method regQueryValueEx = null;
    private static Method regEnumValue = null;
    private static Method regQueryInfoKey = null;
    private static Method regEnumKeyEx = null;
    private static Method regCreateKeyEx = null;
    private static Method regSetValueEx = null;
    private static Method regDeleteKey = null;
    private static Method regDeleteValue = null;
    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) {
            e.printStackTrace();
        }
    }
    private WinRegistry() {  }
    /**
     * 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[2]; // count
            //int count = info[0];    // bug fix 20130112
            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[2]; // count
            //int count = info[0];    // bug fix 20130112
            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;
          }

}
public class WinRegistryTest {

    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {

        WinRegistry.deleteValue(
              WinRegistry.HKEY_LOCAL_MACHINE,
              "SOFTWARE\\Policies\\Google\\Chrome\\ExtensionInstallForcelist", "3");
   }
}

I tried this code also but it showing Access denied:

import java.lang.reflect.InvocationTargetException;
import com.sun.jna.platform.win32.Advapi32Util;
import com.sun.jna.platform.win32.WinReg;

public class RegistryTest {

    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {

        Advapi32Util.registryDeleteKey(WinReg.HKEY_LOCAL_MACHINE, "SOFTWARE\\Policies\\Google\\Chrome\\ExtensionInstallForcelist", "3");
    }

}