1

我正在为我的应用程序构建一个帮助系统。帮助系统由带有工具栏树和浏览器窗格的外壳组成。树将文件加载到节点中，单击该链接时会在浏览器中打开一个 HTML 文件。当单击工具栏上的按钮时，调用 text = browser.getText() 并通过缓冲区将文本加载到 HTML 标签剥离器，该标签剥离器被收集在三个数组中，然后解析给 styledtext 编辑器的样式创建器。

  • 缓冲区集成在标签阅读器类中，我想创建一个全局类以在应用程序中的任何地方需要时使用它，但在解析到 buffer.class 时遇到常量字符字符串等问题

  • 该数组由三个数组组成，其中填充了阅读器找到的标签，我希望 add 方法在全局范围内工作，以便在需要的应用程序中使用它。

  • 我可以使用 List list = new ArrayList(); 但为了便于开销和更好的理解，我尝试只使用数组。

    public class XMLHtmlTagReader {
 private static  char startchar = '<';
 private static  char endchar= '>';
 private static  char[] closingchar ={'<','/'};
 private static  String startTag;
 private static  String endTag;
 private static  String tagValue;
 static String[] starttaglist = new String[]{"first","second","third","fourth"};
 static String[]tagvaluelist;// = new String[1];
 static String[] endtaglist;// = new String[1];
 int tagcount=0;
 static char newchar;
 static char newchar1;
 static int i=0;
 static int startcharint = -1;
 static int endcharint = -1; 
 static int closingcharint = -1;
 static int level=0;
 static int elm=0;
 boolean closing = false;
 static Object store[] = new Object[26];
 Object[][][] megastore = new Object[50][50][50];
 int storeCounter = 0;
 int count=-1;
 int Wmstore=0,WstoreCounter=0,Wv=0;
 int Rmstore=0;
 static int RstoreCounter=0;
 static int Rv=0;
 static int Rtmp;
 int Omstore=0;
 static int OstoreCounter=0;
 static int Ov=0;
 int mstore=0;
 long time =   3087;

public static void main(String[] args) {
     XMLHtmlTagReader run=new XMLHtmlTagReader();
 }

 XMLHtmlTagReader(){
     long memstart = (Runtime.getRuntime().totalMemory()-       Runtime.getRuntime().freeMemory());
 System.out.println("Memory at start:"+memstart);
 long startTime = System.nanoTime();
 getStream("<html><title>hallo de titel ...</title><p>Dit is de text.</p><b>dikke text</b></html>");
 //for(int t=0;t<100000;t++){new com.pim.Buffer(endchar);}
 long estimatedTime = (System.nanoTime() - startTime);  
     //(System.currentTimeMillis() - startTime);
     //(System.nanoTime() - startTime)/1000000;
     //long calc = (estimatedTime/time)*100;
 System.out.println(memstart+"memstart  "+"execution time = "+estimatedTime+" is % sneller/langzamer  = "+(estimatedTime/time)*100+"Memory = "+(Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory()));
bufferWrite('E');
 }

public static String getStream(String input) {

     while(input != null){
                        i++;
            try {
                newchar = input.charAt(i);
                }
            catch (java.lang.StringIndexOutOfBoundsException exception){
                break;
                }
            if(newchar!=closingchar[1]&&input.charAt(i-1)==startchar){
                startcharint=i;
                        level++;
            }
            if(newchar==closingchar[1]&&input.charAt(i-1)==startchar) {
                closingcharint=i;
                tagValue = input.substring(endcharint+1,closingcharint-1);
                if(tagValue!=null){log("valuetag ["+tagValue+"]->"+endcharint+" ->"+closingcharint);}
            }
             if(newchar==endchar)  {
                                        endcharint=i;
                                        if(startcharint>=0){
                                            startTag = input.substring(startcharint-1,endcharint+1);
                                                log("starttag "+startTag);
                                        }
                                        else {startTag=" no Start tag found "; }
                                        if(closingcharint>0){
                                            endTag = input.substring(closingcharint-1,endcharint+1);
                                            level--;
                                                log("endtag->"+endTag);
                                                log("level->"+level);
                                        }
                                        else {  endTag=" no end tag found "; }
                                        closingcharint=0;
                                        startcharint=-1;
                                    }   
                }
    startchar = 0;
    endchar = 0;
    closingchar = null;
    newchar = 0;
    newchar1 = 0;
    return input;
}
private static  void addElementToArray(String string){
    String[] tmpArray;
    int length = starttaglist.length;
    tmpArray = new String[length+1];
    System.arraycopy(starttaglist, 0,tmpArray , 0, length);
    tmpArray[length] = new String(string);
    starttaglist = null;
    starttaglist = new String[length+1];
    System.arraycopy(tmpArray, 0,starttaglist , 0, length+1);
    for(String tmp:starttaglist){
        System.out.println("Elements in Array  "+tmp);
        }
    tmpArray = null;
}
public static String[] getStartTag(){
    return starttaglist;
}
public static  String[] getTagValue(){
    for(String tmp:tagvaluelist){

    }
    return tagvaluelist;
}
public static  String[] getEndTag(){
    return endtaglist;
}


static Object bufferWrite(char value){
    store[OstoreCounter] =  new Object();
    store[OstoreCounter] = value;
    //System.out.println("bufferWrite=["+OstoreCounter+"] storeValue=["+store[OstoreCounter]+"] Ov="+Ov);
    if(Ov==30&&store[RstoreCounter] == null){
        Rtmp=Ov;
        Ov=0;
        }
    if(Ov==40){
        OstoreCounter++;
        Ov=0;
        }
        Ov++;
         char tmp  = (char)  bufferRead();
         return tmp;
}

 static Object bufferRead(){
    Object tmp = store[RstoreCounter];
    //System.out.println("bufferRead=["+RstoreCounter+"] storeValue= ["+store[RstoreCounter]+"] Rv="+Rv);
    store[RstoreCounter] =  null;
    if(Rv==Rtmp){
        Rv=0;
        }
    if(Rv==40){
            RstoreCounter++;
            Rv=0;
            }
    //System.out.println("bufferRead reads till end of int"+Rtmp);
        Rv++;
        return tmp;
}




 static void log(String txt){
            System.out.println(txt);
            }
}
4

6 回答 6

0

我无法完成解析对该方法的数组引用

        private void addElementToArray(String string, String[] obj);

相反，我将代码包含在 main 方法中，它不是最干净的方法，但效果很好。 

        tagValue = input.substring(endcharint+1,closingcharint-1);
        tmpArray = new String[tagvaluelist.length+1];
        System.arraycopy(tagvaluelist, 0,tmpArray , 0, tagvaluelist.length);
        tmpArray[tagvaluelist.length] = new String(tagValue);
        tagvaluelist = null;
        tagvaluelist = new String[tmpArray.length];
        System.arraycopy(tmpArray, 0, tagvaluelist , 0, tmpArray.length);
        tmpArray = null;

对于除原始字符之外的 Buffer 类，我找到了一种将 char 作为对象解析为 Buffer 类的解决方案，并且它可以工作，但希望它符合 java 规则。

            newchar1 = input.charAt(i);
        Buffer buffer =  new Buffer(newchar1);
        buffer.buffer(newchar1);
            newchar = newchar1; // to test its going through the buffer

缓冲类：

     package com.test;


    public class Buffer {
         Object store[] = new Object[26];
         Object[][][] megastore = new Object[50][50][50];
         int Wmstore=0,WstoreCounter=0,Wv=0;
         int Rmstore=0,RstoreCounter=0,Rv=0,Rtmp;
         int Omstore=0,OstoreCounter=0,Ov=0;
         int mstore=0;
     public Object buffer(Object obj){
        return new Buffer(obj);}
 public Buffer(Object obj){
                bufferWrite(obj);
                store = null;
                megastore = null;
    }
Object bufferWrite(Object obj){
        store[OstoreCounter] =  new Object();
        store[OstoreCounter] = obj;
        System.out.println("bufferWrite=["+OstoreCounter+"] storeValue=["+store[OstoreCounter]+"]");// Ov="+Ov);
        if(Ov==30&&store[RstoreCounter] == null){
            Rtmp=Ov;
            Ov=0;
            }
        if(Ov==40){
            OstoreCounter++;
            Ov=0;
            }
            Ov++;
             Object tmp  =   bufferRead();
             return tmp;
    }

     Object bufferRead(){
        Object tmp = store[RstoreCounter];
        System.out.println("bufferRead=["+RstoreCounter+"] storeValue=["+store[RstoreCounter]+"]");// Rv="+Rv);
        store[RstoreCounter] =  null;
        if(Rv==Rtmp){
            Rv=0;
            }
        if(Rv==40){
                RstoreCounter++;
                Rv=0;
                }
        //System.out.println("bufferRead reads till end of int"+Rtmp);
            Rv++;
            return tmp;
    }
     void log(String txt){
                System.out.println(txt);
                }
      }
于 2012-11-11T11:13:08.723 回答
0

int 不是对象

试试看

Integer i = new Integer[10];

这会起作用

于 2012-11-09T06:14:46.170 回答
0

int不是的子类Object，Integer是。

于 2012-11-09T06:16:16.647 回答
0

Object不是原始 like 的超类int，而是 type的超类Integer。另一个问题是您的声明。使用长度或初始值，而不是两者：

Integer[] i = new Integer[] {0, 1, 2, null, null, null, null, null, null, null};
Integer[] i = new Integer[10];

要编写通用方法，您需要使用泛型：

void <T> add(T object , T[] lateral);

下一个问题是，数组具有固定长度，不能扩展。索引必须始终在 [0..length-1] 范围内，而不是 length 或 length+1。为此，您应该使用List：

List<T> lateral = new ArrayList<Integer>();

void <T> add(T object , List<T> lateral) {
  literal.add(object);
}

对数组做这种事情的唯一机会是将新值放在第一个非空位置：

void <T> add(T object , T[] lateral) {
  for (int i = 0; i < lateral.length; ++i) {
    if (lateral[i] == null) {
      lateral[i] = object;
      return;
    }
  }
  throw new IllegalStateException("array to short, no null value found to insert " + object);
}

PS：这都是 Java 5 代码，不适用于早期版本！

于 2012-11-09T06:22:02.673 回答
0 
int is not a subclass of Object

但是在java 5之后，有一个概念被称为auto Boxing将您的原始数据类型转换为相应的包装类。所以在这种情况下。
add(6, i);

6会自动转换成那里的包装类Integer。但问题在于i，因为您的函数采用对象数组，但i它的整数数组。这不能由 JVM 使用 AutoBoxing 转换。

因此，如果您尝试add(6, string);，则不会显示任何错误。

于 2012-11-09T06:22:59.400 回答
0

-首先int, char, boolean, byte,short等是原始类型。

-我们拥有Wrapper Object上述内容，primitives并且随着Java 5的到来，该功能被调用Auto-Boxing并Un-Boxing开始存在。

例如：

int i = 5;

Integer intObj = new Integer(i);

现在方法定义：

public <T extends Object> void doIt(ArrayList<T> arr){}

或者

public void doIt(ArrayList<? extends Object> arr){}

于 2012-11-09T06:23:42.627 回答