package com.j2se.base;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Properties;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;
import java.util.Map.Entry;

/* 不是故意賣弄而是展示各個知識點
 * Title: XXXX DRIVER 3.0
 *Description: XXXX DRIVER 3.0
 *Copyright: Copyright (c) 2003
 *Company:XXXX有限公司
 *@deprecated
 *@since JDK1.2  可以執行的環境
 *
 * html標籤 http://www.w3school.com.cn/tags/tag_blockquote.asp
 * @link標記
 語法：{@link package.class#member label}
 Label為連結文字。
 package.class#member將被自動轉換成指向package.class的member檔案的URL。
 * 
 * */
/* 虛擬碼   * @docRoot    @see   @seriaData   @serialField
 * 這是我為大家演示的一個javadco的例子，目的是讓你們一下就能熟悉javadoc
 * <p>
 * 這個<code>JavadocDemo</code>是一個基類，將實現介面和繼承抽象類，會對一些極少的操作
 * 屬性和方法列舉出來，主要是為了掃清知識死角
 * <p> javadoc是支援html標記格式的，
 * <pre><blockquote>
 *   public void show()
 *   {
 *      System.out.println(new Data());
 *   }
 * </blockquote>
 * </pre>
 *  * <ol>
 * <li>
 * <li>
 * </ol>
 * 
 * 這裡採用XX，詳請 @see java.util.List#method
 * 
 * @version 1.0 建立時間 2013-04-14
 * @author   張林 
 
[email protected]
 * @since JDK1.3
 * 
 * */

/*
 * 注意javadoc 只能為public（公共）和protected（受保護）成員處理註釋文件。
 * “private”（私有）和“友好”（成員的註釋會被忽略，
 * 不要將<h1>或<hr>這樣的標題當作嵌入HTML 使用，因為
 javadoc 會插入自己的標題，我們給出的標題會與之衝撞。
 所有型別的註釋文件——類、變數和方法——都支援嵌入HTML。
 * */

/*檔案多執行緒、網路放在下一篇寫*/

public class JavadocDemo {
	public enum OperatorType {
		all, mathOperator, bigMathOperator, bitOperator, listOperator, systemOperator, stringOperator, md5Operator
	}

	public static int rsCount = 0; // 記錄遞迴的次數，放在接口裡面

	/*
	 * @param a 傳值
	 * 
	 * @return 執行的狀態
	 * 
	 * @exception 沒有異常丟擲或者有
	 */

	public static boolean mathOperator() {
		rsCount = rsCount + 1;

		Random rnd = new Random();// 產生0到1之間的隨機數

		int intRnd = (new Random()).nextInt(Integer.MAX_VALUE % 1000);// 等同於這個rnd.nextInt(10);
		// 整形的要在括號裡面給種子
		double dblRnd = rnd.nextLong() * intRnd;// long, float
		// double獲得隨機數都是在外圍*一個常數

		pln("第" + rsCount + "次遞迴的 隨機值：" + intRnd); // 遞迴是先釋放最外層的然後再釋放裡面層

		boolean isSuccess = (intRnd < 500) ? mathOperator() : true; // 三元表示式遞迴
		// ，右邊一定要返回值
		if (isSuccess) {
			// 分割用正則表示式
			char chrArr[] = itbi(intRnd).toCharArray();// 將整形轉為二進位制再給字元陣列
			StringBuffer strBin = new StringBuffer("二進位制碼：");

			for (char chrTemp : chrArr) {
				strBin.append(chrTemp + ",");
			}
			pln(strBin.toString());
			// StringTolen將,拆分為空格，也可以用split函式
			StringTokenizer stoke = new StringTokenizer(strBin.toString(), ",");
			List<String> lisStoke = new ArrayList<String>();
			while (stoke.hasMoreElements()) // 判斷是否還有元素
			{
				// nextToken() 返回字串，nextElement返回 物件
				lisStoke.add(stoke.nextElement().toString());
			}
			// ListIterator有hasPrevious()和previous()方法，可以實現逆向（順序向前）遍歷。物件的修改set()方法可以實現。
			// 另一個地方有，有一定條件向前，在一定條件向後，排序吧
			ListIterator<String> itStoke = lisStoke.listIterator();
			while (itStoke.hasNext()) {
				pln(itStoke.next().toString() + " ");
			}

		}
		return isSuccess;

	}

	public static void bitOperator() {
		int intNum = 124 % (-846 % 1000); // 負數求模是 (1000-864) 求法 7 -2 ≡ 7 + 10
		// (mod 12)
		float fltNum = 124.10f;
		do {
			// 正數求反碼是加負號還減1，如果是負數求反碼是絕對值-1
			pln(" 整數後一位小數保留一位 127.0f%3=" + (127.0f % 3) + "   有兩位小數保留浮點位精度："
					+ fltNum + "%3=" + (fltNum % 3));
			pln("正數的原碼、反碼、補碼都是一致的");
			pln(intNum + "  的原碼值:" + String.format("%025d", 0) + itbi(intNum));
			pln(intNum + "  的反碼值:" + String.format("%025d", 0) + itbi(intNum));
			pln(intNum + "  的補碼值:" + String.format("%025d", 0) + itbi(intNum));
			pln("負數的原碼最高位為1、反碼(在其原碼的基礎上, 符號位不變，其餘各個位取反)、\n補碼(在其原碼的基礎上, 符號位不變, 其餘各位取反, 最低位+1)");
			pln((-intNum) + " 的原碼值:1" + String.format("%024d", 0)
					+ itbi(intNum));
			pln((~intNum + 1) + " 的反碼值:" + itbi((~intNum) + 1));
			pln((~intNum + 1) + " 的補碼值:" + itbi((~intNum) + 2));

			pln("位移的運算   1.左移後，低位會被自動補零（0）  2.右移如果原值是正數，則高位補上0；如果原值是負數，高位補1。");

			pln(intNum + "位移操作前的二進位制碼是       " + itbi(intNum));
			pln(intNum + "位移操作前的八進位制碼是       " + Integer.toOctalString(intNum));
			pln(intNum + "位移操作前十六進位制碼是       " + Integer.toHexString(intNum));
			pln(intNum + "位移操作前的二進位制碼是       " + itbi(intNum));
			pln(intNum + ">>有符號右移一位" + (intNum >> 1) + "  二進位制碼         "
					+ itbi(intNum >> 1));
			pln(intNum + ">>有符號左移一位" + (intNum << 1) + " 二進位制碼    "
					+ itbi(intNum << 1));
			pln("八進位制174轉十進位制是:" + Integer.valueOf("174", 8) + " 十六進位制7C轉十進位制是:"
					+ Integer.valueOf("7C", 16));
			pln("採用0補充，意思就是說，無論是正號還是負號，都在高位補0");
			pln(intNum + ">>>無符號右移一位" + (intNum >>> 1) + " 二進位制碼         "
					+ itbi(intNum >>> 1));

		} while (false);
	}

	// 取到記憶體中的類，快取，並修改後然後呼叫改變資料型別 動態代理 回撥，遞迴，迭代 類載入器
	// stack用法 list ,map的例子，陣列
	// 介面，反射類的方法做 訪問許可權 組合，繼承 runtime ,system.getp 代理放到後面 匿名類 instance，
	// 連結串列，遞迴，排序 多維陣列 位疑惑許可權， ，物件的比較

	/*
	 * 如果我們看到了implements子句。正如我們看到的，Comparable類通常被定義為可以同自己比較的。而且他們的子類
	 * 也可以同他們的父類比較。從另一個方面將，Enum實現了Comparable介面不是為了他本身，而是為了他的子類 E。 treeMap stack
	 * hashTable 寫一個自己排序的方向 資料逆向反轉
	 * 
	 * 大資料查詢排序 請使用LinkedList來模擬一個佇列（先進先出的特性）。擁有 放入物件的方法void put(Object o)、
	 * 取出物件的方法Object get()、 判斷隊列當中是否為空的方法boolean isEmpty()；
	 * 並且，編寫測試程式碼，驗證你的佇列是否正確。 Calendar 字元轉換，轉碼 Expression
	 */

	public static void listOperator() {
		// 通過list介面向下擴充套件類
		Class<List> clst = List.class;
		// 上界
		Class<? extends List> subList = LinkedList.class.asSubclass(clst);
		// Class.forName("java.lang.LinkedList").asSubclass(clist)
		// .newInstance(); // 這樣載入一個物件
		Stack<?> st = new Stack();
		Iterator<?> it = st.iterator();

		Array ar;
		List v = new Vector();
		List lst = new ArrayList();
		Set hSet = new HashSet();
		Set tSet = new TreeSet();

		Map<?, ?> tmap = new TreeMap();
		Map hMap = new HashMap();
		Map htMap = new Hashtable();

		Iterator it1;
		ListIterator lit;
	}

	// 高精度運算，浮點等等 指數 貨幣轉換 科學計演算法 記憶體互動 模擬矩陣 解方程

	/*
	 * java.math是一個包,執行任意精度整數演算法 (BigInteger)和任意精度小數演算法 (BigDecimal)類用於專業數學運算.
	 * java.lang.Math是一個類，類包含基本的數字操作，如指數、對數、平方根和三角函式。貨幣
	 */
	public static void bigMathOperator() {
		// ceil向上取整，返回double floor向下取整，返回double rint 返回近似數
		// round 是對其加0.5四捨五入求整
		// int number = 10 + (int) (Math.random() * 10); 如果要得到一個(10, 20]之間的隨機整數：
		double maxValue = Math.max(Math.floor(Math.ceil(Math.tan(Math.sin(50)
				/ Math.cos(30)))
				+ Math.rint(Math.round(Math.PI) + Math.E)), (10 + (int) (Math
				.random() * 10)));
		double expValue = Math.pow(Math.E, 2);// Math.E的二次方
		// 指數用對數表示 Math.exp求e的任意次方 log_8(2)對數表示為 Math.log(8)/Math.log(2)
		pln("exp(Math.PI)=" + Math.exp(Math.PI)
				+ "  Math.pow(2,Math.PI*log_2(E))="
				+ Math.pow(2, Math.PI * (Math.log(Math.E) / Math.log(2))));

		/*
		 * java.math.BigInteger(大整數) java.math.BigDecimal(大浮點數)
		 * BigDecimal.setScale()方法用於格式化小數點 setScale(1)表示保留一位小數，預設用四捨五入方式
		 * setScale(1,BigDecimal.ROUND_DOWN)直接刪除多餘的小數位，如2.35會變成2.3
		 * setScale(1,BigDecimal.ROUND_UP)進位處理，2.35變成2.4
		 * setScale(1,BigDecimal.ROUND_HALF_UP)四捨五入，2.35變成2.4
		 * setScaler(1,BigDecimal.ROUND_HALF_DOWN)四捨五入，2.35變成2.3，如果是5則向下舍
		 */
		BigDecimal bdValue = new BigDecimal(Double.MAX_VALUE);
		pln("直接刪除三位以後的小數位："
				+ (new BigDecimal(Math.PI)).setScale(3, BigDecimal.ROUND_DOWN));
		pln("列印double的全部值並加兩個小位數：" + bdValue.setScale(2).toEngineeringString());

		pln("(大精度運算) Math.PI*Math.E = " + mul(Math.PI, Math.E));
		pln("(大精度運算) Double.MAX_VALUE/Float.MAX_VALUE = "
				+ new BigDecimal(div(Double.MAX_VALUE, Float.MAX_VALUE, 3)));

		// DecimalFormat 與科學計演算法 E20後面表示的10的20次方  如果是E-20則表是是 10的(1/N)次方
		 
        pln("分解科學計演算法表示的：3.1415E-20的值="+new BigDecimal("3.1415E-20").toPlainString() );
        pln("分解科學計演算法表示的：3.1415E20 的值="+new BigDecimal("3.1415E20").toPlainString() );
	    //分解科學計演算法表示的：3.1415E-20的值=0.000000000000000000031415
        //分解科學計演算法表示的：3.1415E20 的值=0.000000000000000000031415
	}

	/**
	 * 提供精確的乘法運算。
	 * 
	 * @param v1
	 *            被乘數
	 * @param v2
	 *            乘數
	 * @return 兩個引數的積
	 */

	public static double mul(double v1, double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.multiply(b2).doubleValue();
	}

	/**
	 * 提供（相對）精確的除法運算。當發生除不盡的情況時，由scale引數指 定精度，以後的數字四捨五入。
	 * 
	 * @param v1
	 *            被除數
	 * @param v2
	 *            除數
	 * @param scale
	 *            表示表示需要精確到小數點以後幾位。
	 * @return 兩個引數的商
	 */

	public static double div(double v1, double v2, int scale) {
		if (scale < 0) {
			throw new IllegalArgumentException(
					"The   scale   must   be   a   positive   integer   or   zero");
		}
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
	}

	// Thread t = new ShutdownHookThread ( "Here I am !!!" );

	// Runtime.getRuntime().addShutdownHook ( t );

	// System.out.println ( "Now shut me down …");
	public static void md5Operator() {
		// 加密後，然後解密
	}

	public static void stringOperator() {
		Charset dCharset = java.nio.charset.Charset.defaultCharset();
		pln("當前環境編碼：" + dCharset.name());
		StringBuilder sber = new StringBuilder("StringBuilder是非執行緒安全的,");
		sber.append("StringBuffer是執行緒安全的");
		sber.append("兩種用法差不多,很多方法與string一樣");
		sber.append("如果不考慮執行緒安全用StringBuiler ");

		CharSequence chrSeq = sber.subSequence(60, sber.length() - 1);
		pln(chrSeq.toString());
		String strTemp = "53 48 07 03 0B 43 50 C6 00 00 67";// 一條機器執行狀態返回指令
		String testResult = ((strTemp.indexOf("C6") >= 0) ? true : false) ? "執行成功"
				: "執行失敗";
		String isOkCode = strTemp.split(" ")[(strTemp.lastIndexOf("C6") / 3) % 21];
		pln("這次測試".concat(testResult.intern()) + " 正確程式碼：" + isOkCode);
		pln("儀器型號："
				+ strTemp.substring(strTemp.indexOf("53"), strTemp
						.indexOf("48")));
		pln("指令幀長:" + strTemp.charAt(7));
		pln(" 指令效驗合:" + strTemp.substring(strTemp.lastIndexOf("00") + 3));

	}

	// secrurity rmi net beans 合用一個例子
	// Preferences pf = Preferences.systemRoot(); pln(pf.absolutePath());//
	public static void systemOperator() {
		String temp = "自1970年1月1日到現在的毫秒數:";
		pln(temp + System.currentTimeMillis());
		Properties sysPorp = System.getProperties(); // 獲得系統屬性
		Set<Entry<Object, Object>> sysSet = sysPorp.entrySet(); // 1.用Set的entry方式取資訊
		// 2.用map的方式讀取 通過下界萬用字元定義 key值
		Map<? super String, Object> sysMap = new HashMap<String, Object>();

		Iterator<Entry<Object, Object>> sysIt = sysSet.iterator();// 同理：sysMap.entrySet().iterator();
		for (; sysIt.hasNext();) {
			Map.Entry<Object, Object> sysEt = (Entry<Object, Object>) sysIt
					.next();
			sysMap.put(sysEt.getKey().toString(), sysEt.getValue());
		}
		// 2.用map的方式讀取 通過上界萬用字元定義
		Enumeration<? extends Object> sysEm = sysPorp.propertyNames();
		while (sysEm.hasMoreElements()) {
			Object obj = sysEm.nextElement();
			// pln(obj + "=" + sysPorp.get(obj));// 通過列舉列印所有的系統引數
		}
		// new Properties(System.getProperties()).list(System.out); 3.用輸出流的方法
		// scanner一般都是掃描控制檯或者掃描檔案
		Scanner scer = new Scanner(System.in);

		do {
			System.out.println("請輸入命令是否要繼續下面的操作(1/0)：");
			Scanner scer1 = new Scanner("張林,好人嘛,你只能在這輸入1才能繼續下面的操作");
			scer1.useDelimiter(",");
			while (scer1.hasNext())
				pln(scer1.next());
			String line = scer.nextLine();
			if (line.equals("1"))
				break;
			pln(">>>" + line);
		} while (true);

		try {
			Thread.currentThread();
			Thread.sleep((new Random()).nextInt(1000));
			try {
				String[] cmd = { "cmd", "/C", "copy exe1 exe2" };
				Process proc = Runtime.getRuntime().exec(cmd);

				// int exitVal = proc.waitFor();
				// System.out.println("Process exitValue: " + exitVal);
				// Runtime.getRuntime().exit(0); 這個是直接結束jvm，不會執行finally
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} finally {
			// Calendar.getInstance() 是靜態方法，可以直接呼叫，不用new
			pln(temp + Calendar.getInstance().getTimeInMillis());
			Runtime rt = Runtime.getRuntime();
			pln("系統記憶體大小清理前：" + rt.totalMemory() + " 空閒記憶體大小清理前："
					+ rt.freeMemory());
			rt.gc(); // 手工垃圾清理
			pln("系統記憶體大小清理後：" + rt.totalMemory() + " 空閒記憶體大小清理後："
					+ rt.freeMemory());

		}

	}

	public static void main(String args[]) {
		// + " 進入函式時間：" + System.currentTimeMillis() +
		// new JavadocDemo().testMath(); // 匿名呼叫，不用例項呼叫
		// bitOperator();// 用位置到最後，邏輯異或。走到偶數位,科學計數
		// listOperator();
		// systemOperator();
		// 匿名類內部類 知識點只是希望大家能夠知道有這些知識點，然後有興趣去深入
		// 這裡需要一個字串操作的類，spilt的正則表示式方法
		// java 加密解碼 這樣省字元 這裡加上抽象介面，並用上代理，工廠模式
		switchOperator(OperatorType.bigMathOperator);
	}

	// 通過二進位制位置確定操作那幾個方法 ，與或關係來解決
	public static void switchOperator(OperatorType opt) {
		switch (opt) { // 條件只是整型或者字元型 列舉可以，浮點型不行
		case all:// 可以帶表示式，但不能是變數
			break;
		case mathOperator:
			mathOperator();
			break;
		case bitOperator:
			bitOperator();
			break;
		case listOperator:
			listOperator();
			break;
		case systemOperator:
			systemOperator();
			break;
		case stringOperator:
			stringOperator();
			break;
		case md5Operator:
			md5Operator();
			break;
		case bigMathOperator:
			bigMathOperator();
			break;
		default:
			System.out.println("沒有該型別的操作");
		}
	}

	public static void pln(String str) {
		System.out.println(str);
	}

	public static String itbi(int x) {
		return Integer.toBinaryString(x);
	}

	protected void finalize() {
		System.out.println("清理系統垃圾");
	}
}

// 動態建立了兩個物件 (一個s物件，一個"This is a string"物件)
// String s = new String("This is a string");
/*
 * 使用靜態方式建立的字串，在堆記憶體的緩衝池中只會產生唯一的一個字串物件。
 * 當使用該方式產生同樣一個字串時，堆記憶體中不再開闢另外一塊空間，而是兩個引用變數指向同一個字串物件。
 */

// 所謂數float,double據長度是指像465465.4 這是八個資料長度0.465465是八個資料長度、
// 所以 小數點後多少位並不是很準確 ,整數位和小數位總長是8位
// char cValue = (char) (iValue + '1'); // 先將'1'轉化為49
// /（因為char是16位，int是32位，所以one會轉化為int 1值,而不會同C、C++那樣轉為asci的49）
// (char)(3+49)=ansi(52)=4

/*
 * 上界萬用字元： – 泛型中只允許類自身或者其子類作為引數傳入。 – 表示方式為：泛型型別<? extends 父類> 。 • 下界萬用字元： –
 * 泛型中只允許類自身或者該類的父類作為引數傳入。 – 表示方式為：泛型型別<? super 子類>。
 */

// utf-8是3個位元組

// UTF-32 是4個位元組 32位 'A' utf-8 與 uft-16 表示 'a' a的ascii是0X61 utf-8為[0X61]
// uft-16 [0x00,0X61]

// unicode是國際通用編碼 這是最統一的編碼，可以用來表示所有語言的字元，而且是定長雙位元組（也有四位元組的）編碼
// .utf-8編碼是unicode編碼在網路之間（主要是網頁）傳輸時的一種“變通”和“橋樑”編碼。
// utf-8在網路之間傳輸時可以節約資料量。所以，使用作業系統無法搜尋出txt文字。
// 。其中gbk編碼能夠用來同時表示繁體字和簡體字，而gb2312只能表示簡體字，gbk是相容gb2312編碼的。
// 執行時型別資訊（RunTime Type Information，RTTI）使得你在程式執行時發現和使用型別
// 資訊。RTTI主要用來執行時獲取向上轉型之後的物件到底是什麼具體的型別。
// Class物件的建立發生在類載入（java.lang.ClassLoader）的時候。
// java.lang.Class類實現了Serializable、GenericDeclaration、Type、AnnotatedElement四個介面，
// 分別實現了可序列化、泛型定義、型別、元資料（註解）的功能。
// Class只有一個私有的無參構造方法，也就是說Class的物件建立只有JVM可以完成。 通過代理實現
// 如何通過jndi連線資料來源 string 格式化輸出 正則表示式 java命名規範 談談編碼規範
// extends T是我們熟悉的上界繫結：這意味著T或者其子類。? super T比較少用：這意味著T或者他的超類。

/*
 * double maxValue = Double.MAX_VALUE; float fValue = 0.465465f; // 可以是 465465.4
 * 也可以是0.465465的精度，是由長長度決定的共7七位 double dValue = 3.1415926; //
 * 帶小數位沒有f,d則預設為double型別也就是預設加 d 整 型 變 量 的 類 型 有 byte、 short、 int、 long四 種 byte
 * 1(位元組) short 2 int 4 long 8 float 4 double 8 char 2
 */
class SystemInfo {
	/* Windows security masks */
	private final static int KEY_QUERY_VALUE = 1;

	/* Constants used to interpret returns of native functions */
	private final static int NATIVE_HANDLE = 0;
	private final static int ERROR_CODE = 1;

	/* Windows error codes. */
	private final static int ERROR_SUCCESS = 0;

	private static String absolutePath() {
		return "/";
	}

	private static byte[] windowsAbsolutePath(byte[] WINDOWS_ROOT_PATH) {
		ByteArrayOutputStream bstream = new ByteArrayOutputStream();
		bstream.write(WINDOWS_ROOT_PATH, 0, WINDOWS_ROOT_PATH.length - 1);
		StringTokenizer tokenizer = new StringTokenizer(absolutePath(), "/");
		while (tokenizer.hasMoreTokens()) {
			bstream.write((byte) '\\');
			String nextName = tokenizer.nextToken();
			byte[] windowsNextName = toWindowsName(nextName);
			bstream.write(windowsNextName, 0, windowsNextName.length - 1);
		}
		bstream.write(0);
		return bstream.toByteArray();
	}

	public static String getValue(int hkey, byte[] WINDOWS_ROOT_PATH, String key)
			throws Exception {
		Class theClass = Class.forName("java.util.prefs.WindowsPreferences");

		int[] result = openKey1(hkey, windowsAbsolutePath(WINDOWS_ROOT_PATH),
				KEY_QUERY_VALUE);
		if (result[ERROR_CODE] != ERROR_SUCCESS) {
			throw new Exception("Path   not   found!");
		}
		int nativeHandle = result[NATIVE_HANDLE];

		Method m = theClass.getDeclaredMethod("WindowsRegQueryValueEx",
				new Class[] { int.class, byte[].class });
		m.setAccessible(true);
		byte[] windowsName = toWindowsName(key);
		Object value = m.invoke(null, new Object[] { new Integer(nativeHandle),
				windowsName });
		WindowsRegCloseKey(nativeHandle);
		if (value == null) {
			throw new Exception("Path   found.     Key   not   found.");
		}

		byte[] origBuffer = (byte[]) value;
		byte[] destBuffer = new byte[origBuffer.length - 1];
		System.arraycopy(origBuffer, 0, destBuffer, 0, origBuffer.length - 1);

		return new String(destBuffer);
	}

	public static int WindowsRegCloseKey(int nativeHandle) throws Exception {
		Class theClass = Class.forName("java.util.prefs.WindowsPreferences");
		Method m = theClass.getDeclaredMethod("WindowsRegCloseKey",
				new Class[] { int.class });
		m.setAccessible(true);
		Object ret = m.invoke(null, new Object[] { new Integer(nativeHandle) });
		return ((Integer) ret).intValue();
	}

	private static byte[] toWindowsName(String javaName) {
		StringBuffer windowsName = new StringBuffer();
		for (int i = 0; i < javaName.length(); i++) {
			char ch = javaName.charAt(i);
			if ((ch < 0x0020) || (ch > 0x007f)) {
				throw new RuntimeException(
						"Unable   to   convert   to   Windows   name");
			}
			if (ch == '\\') {
				windowsName.append("//");
			} else if (ch == '/') {
				windowsName.append('\\');
			} else if ((ch >= 'A') && (ch <= 'Z')) {
				windowsName.append("/" + ch);
			} else {
				windowsName.append(ch);
			}
		}
		return stringToByteArray(windowsName.toString());
	}

	public static int[] openKey1(int hkey, byte[] windowsAbsolutePath,
			int securityMask) throws Exception {
		Class theClass = Class.forName("java.util.prefs.WindowsPreferences");
		Method m = theClass.getDeclaredMethod("WindowsRegOpenKey", new Class[] {
				int.class, byte[].class, int.class });
		m.setAccessible(true);
		Object ret = m.invoke(null, new Object[] { new Integer(hkey),
				windowsAbsolutePath, new Integer(securityMask) });
		return (int[]) ret;
	}

	private static byte[] stringToByteArray(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;
	}

}