Question

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

缓冲区集成在标记阅读器类中，我想创建一个全局类，以便在应用程序的任何地方需要时使用它，但在解析为buffer.class时遇到constantinating char字符串等的问题
该数组由三个数组组成，其中填充了读者找到的标签，我希望全局工作的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);
            }
}

Answer 1

int不是对象

尝试

Integer i = new Integer[10];

这样可行

Answer 2

int 不是Object的子类，Integer是。

Answer 3

Object不是像int这样的基元的超类，而是类型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]范围内，从不长度或长度+ 1。为此，您应该使用List：

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

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

使用数组执行此类操作的唯一机会是将新值放在第一个非null位置：

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代码，不适用于早期版本！

Answer 4

int is not a subclass of Object

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

6将自动转换为包装类Integer。但问题出在i，因为你的函数使用了Array of Object而i是整数数组。 JVM无法使用AutoBoxing转换它。

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

Answer 5

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

- 我们有上述Wrapper Object的{{1}}以及 Java 5 的到来，名为primitives和{ {1}}出现了。

<强>例如

Auto-Boxing

现在方法定义：

Un-Boxing

或

int i = 5; Integer intObj = new Integer(i);

Answer 6

我无法完成解析方法

的数组引用

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

代替我将主要方法中的代码包含在其中并不是最干净的方法，但它运作良好。

        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;

对于除了原始char之外的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);
                }
      }

对象作为文字的父级

6 个答案: