[JVM] - 继10进制的java.lang.Object查看之后

cmd清除命令:cls

之后查阅了其它博客,发现这位大神同样也在做JVM,并且我很希望用它的10进制转16进制类来测试一下该解析的10进制是否对应着Object的16进制呢?

这位大神的10进制转16进制代码:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;

public class Test {
    public static String txt2String(File file){
        StringBuilder result = new StringBuilder();
        try{
            BufferedReader br = new BufferedReader(new FileReader(file));//构造一个BufferedReader类来读取文件
            String s = null;
            while((s = br.readLine())!=null){//使用readLine方法，一次读一行
                result.append(System.lineSeparator()+s);
            }
            br.close();
        }catch(Exception e){
            e.printStackTrace();
        }
        return result.toString();
    }
    public static int hixTo(StringBuffer sb){
        int sum=0;
        if(sb.charAt(0)>=48&&sb.charAt(0)<=57){
            sum+=(sb.charAt(0)-48)*16;
        }else{
            sum+=((sb.charAt(0)-96)+9)*16;
        }
        if(sb.charAt(1)>=48&&sb.charAt(1)<=57){
            sum+=(sb.charAt(1)-48);
        }else{
            sum+=((sb.charAt(1)-96)+9);
        }
        return sum;
    }
    public static void main(String[] arts){
        File file = new File("D:\\yff.txt");
        String str=txt2String(file);
        StringBuffer sbBefore=new StringBuffer(str);
        StringBuffer sbAfter=new StringBuffer();
        for(int i=0;i<sbBefore.length();i++){
            if((sbBefore.charAt(i)>=48&&sbBefore.charAt(i)<=57)||(sbBefore.charAt(i)>=97&&sbBefore.charAt(i)<=122)){
                //System.out.print(sbBefore.charAt(i));
                sbAfter.append(sbBefore.charAt(i));
            }
        }
        System.out.println(sbAfter);
        System.out.println();
        for(int i=0;i<sbAfter.length();i=i+2){
            System.out.print(hixTo(new StringBuffer(""+sbAfter.charAt(i)+sbAfter.charAt(i+1)))+" ");
            if(i!=0&&i%100==0)
                System.out.println();
        }
    }
}

这样精湛的代码着实让人敬佩,我翻看了下之前我写的一些类似算法的解析:

import java.util.ArrayList;
public class Fracts {

    public static String convertFrac(long[][] lst) {
        long bigFrac = 1;
        long result = 1;
//        int count = 0;//计算是否还可以
        int fracNum = 0;//原始分母数量
        int maxDLen = 0;
        ArrayList<long[]> divisor = new ArrayList();
        ArrayList<Long> members = new ArrayList<Long>();
        ArrayList<Long> fracs = new ArrayList<Long>();
        // lst是个long型的二维数组,里面的每组元素是分子和分母的组合形式
        // 获取其分母的公共分母,(分子也按需更改),返回三组数据的字符串形式
        for (int i = 0; i < lst.length; i++) {
            for (int j = 0; j < 2; j++) {
                if(j==1) { //开始获取分母
                    //从上面if 开始进来了 所有的分母  多个数的最小公倍数求法:
                    //是素数的保持素数,不是素数的分解
                    long[] fracArray = new long[1];
                    long[] fracArray2 = new long[1];
                    int q;
                    int lastIndex = 0;
                    //分解质因数
                    long frac = lst[i][j];//获取了每个二维数组的元素
                    fracs.add(frac);
                    int count = 0; //[计数]看看这个数有共几个质因数
                    for(q=2;q<frac;q++) {

                        if(frac%q==0) {
                            //如果一个数能分解,就必定还有另一个因数,所以数组大小必须大于长度1
//                            System.out.println("q:"+q);
                            //得到了这个质因数的值(多个,需要数组存放)
                            //如果对每个数值的质因数,生成不同的数组或集合存放呢?
                            count++;//有一个因数分解时,count就递增

//                            System.out.println(""+fracArray.length+":"+count);
                            if(fracArray.length<=count) {
                                fracArray = new long[count+1];//变更数组大小
                                lastIndex=count;
                                for(int h=0;h<fracArray2.length;h++) {
                                    fracArray[h] = fracArray2[h];
                                }
                            }

                            fracArray[count-1] = q; //将质因数添加到数组
//                            System.out.println("q:"+q);
                            fracArray2 = fracArray;
                            frac = frac/q;
//                            System.out.println("frac:"+frac);
                            q=q/q;

//                            

                        }

                    }
                    //将最后的因数装入数组最后
          fracArray2[lastIndex] =q;
                    if(count==0) {
                        //这是个素数
                        fracArray2[0]=frac;
                    }

                    divisor.add(fracArray2);
                    if(fracArray2.length>maxDLen) {
                        maxDLen = fracArray2.length;
                    }

                }
                if(j==0) {
                    long mem = lst[i][j];
                    members.add(mem);
                }

            }

        }
        long[][] resultMatrixArr = new long[lst.length][maxDLen];
        long[][] resultMatrixArr2 = new long[maxDLen][lst.length];
        //将多个分母的分解的质因数装入二维数组,以最长质因数数组长度为二维矩阵宽度.原lst.length为高度.
        for(int l=0;l<lst.length;l++) {
            for(int p=0;p<divisor.get(l).length;p++) {
                    resultMatrixArr[l][p]=divisor.get(l)[p];
            }
        }

        for(int aa=0;aa<lst.length;aa++) {//矩阵高
//            System.out.println(resultMatrixArr[aa]);
            int grow = 0;
            for(int cc=0;cc<maxDLen;cc++) {//矩阵宽
                //获取每行的unique的集合,去除每行存在的重复数字,保留唯一一个.
                long[] rowNum = resultMatrixArr[aa]; //0,0; 0,1; 0,2
                grow=cc;
                while((grow+1)<rowNum.length) {//如果cc+1不是最大数组下标 则+1
                    grow++;
                    if(rowNum[cc]==rowNum[grow]) {
                        resultMatrixArr[aa][grow]=0;
                    }
                }
                //将二维数组倒置装入另一个
                resultMatrixArr2[cc][aa] = resultMatrixArr[aa][cc];
            }
        }

        //竖向去除