Java 为链表类的子字符串开发替换方法

我有一个类LString，它模仿标准的Java字符串和StringBuilder类。我在开始实现替换方法以将子字符串“LString”中的字符替换为“lStr”中的字符时遇到问题。我的replace方法位于代码的底部

如果start==end，则会给出特殊情况，这将在LString中的给定位置插入“lStr”。如果start==end==this.length（），则在这个LString的末尾追加lStr

public class LString {

    node front;
    int length;
    LString next;

    // create node class
    public class node {
        char data;
        node next;

        public node(char newData) {
            data = newData;
        }

        public node(char newData, node newNext) {
            data = newData;
            next = newNext;
        }
    }

    // LString constructor
    // constructs LString object representing empty list of chars
    public LString(){
        this.length = 0;
        this.front = null;
    }

    // Construct LString copy of original parameter
    public LString(String original){
        //assign first char to front
        node curr = this.front;
        this.length = original.length();
        // loop through
        for (int i = 0; i < original.length(); i++) {
            if (i==0) {
                front = new node(original.charAt(i), null);
                curr = front;
            }else{
                curr.next = new node(original.charAt(i), null);
                curr = curr.next;
            }
        }
    }

    // return length in this LString
    // can use in LString constructor
    public int length(){
        return this.length;
    }

    //create and return string with contents of LString
    public String toString(){
        // use string builder to meet time limit
        StringBuilder builder = new StringBuilder();
        if(front == null){
            return "";
        }else{
            node curr = front;
            while(curr != null){
                builder.append(curr.data);
                curr = curr.next;

            }
            return builder.toString();
        }
    }

    //compares string lists 0 if equal -1 if less, and 1 if greater
    public int compareTo(LString anotherLString){
        //save lowest length of strings
        int minLength;
        // get front spots
        node curr = this.front;
        node otherCurr = anotherLString.front;
        // get lengths
        int thisString = length();
        int otherString = anotherLString.length();
        // get shortest length of 2 strings
        if(thisString < otherString){
            minLength = thisString;
        }else {
            minLength = otherString;
        }
        //go through characters in each string and compare for lexicographic order
        int iterate = 0;
        while(iterate < minLength){
            char string1Char = curr.data;
            char string2Char = otherCurr.data;
            if  (string1Char != string2Char) {
                return string1Char - string2Char;
            }
            iterate++;
            curr = curr.next;
            otherCurr = otherCurr.next;
        }
        return thisString - otherString;
    }

    //Return true if LString represents the same list of characters as other
    @Override
    public boolean equals(Object other) {
        if (other == null || !(other instanceof LString))
            return false;
        else{
            // use compareTo to determine if strings are the same
            LString otherLString = (LString)other;
            if(compareTo(otherLString) == 0){
                return true;
            }else{
                return false;
            }
        }
    }

    //Return the char at the given index in this LString.
    public char charAt(int index){
        int length = this.length();
        // check for index out of bounds
        if(index < 0 || index >= length){
            throw new IndexOutOfBoundsException();
        }
        // returns char at index
        node curr = front;
        for (int i = 0; i < index; i++) {
            curr = curr.next;
        }
        return curr.data;
    }

    //Set the char at the given index in this LString to ch.
    public void setCharAt(int index, char ch){
        // check for index out of bounds
        int length = this.length();
        if(index < 0 || index >= length){
            throw new IndexOutOfBoundsException();
        }
        // replaces char at index
        node curr = front;
        for (int i = 0; i < index; i++){
            curr = curr.next;
        }
        curr.next = new node(curr.data,curr.next);
        curr.data = ch;
    }

    //Returns a new LString that is a sub-string of this LString.
    public LString substring(int start, int end) {
        LString newLString = new LString();
        // handle exceptions
        if (start < 0 || start > end) {
            throw new IndexOutOfBoundsException();
        } else if (end > this.length()) {
            throw new IndexOutOfBoundsException();
            //return null in special case (empty LString)
        } else if (start == end) {
            //&& end == this.length()
            return newLString;
        } else {
            node node = this.front;
            for (int i = 0; i < start; i++) {
                node = node.next;
                // insert substring
            }
            node copy = new node(node.data);
            newLString.front = copy;
            for (int i = start + 1; i < end; i++) {
                node = node.next;
                copy = copy.next = new node(node.data);
            }
            return newLString;
        }
    }

    // Replaces this characters in a sub-string of this LString with the characters in lStr.
    public LString  replace(int start, int end, LString lStr) {

        // handle exceptions
        if(start <0 || start >end) {
            throw new IndexOutOfBoundsException();
        } else if (end > this.length()) {
            throw new IndexOutOfBoundsException();
    }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        return null;
} // end class
        /*
                // create new LString
        LString newLString = new LString();

        node node = this.front;
        // to copy
        node copy = new node(node.data);
        // for node to replace
        node replace = lStr.front;

        if (start == end) {
            LString newLStr = new LString();
            return newLStr;
        }
        if (start == end && start == this.length()) {
            LString newLStr = new LString();
            return newLStr;
        */

    }
/*
//append / prepend methods for linked list
    //append
    public void append(int data){
        if (front == null){
            front = new node(data);
            end = front;
        }
        else {
            end.next = new node(data);
            end = end.next;
        }
        length++;
    }

    //prepend
    public void prepend(int data){
        if (front == null){
            end = new node(data);
            front = end;
        }
        else {
            front = new node(data,front);
        }
        length++;
    }
*/

公共类LString{
节点锋；
整数长度；
下一步；
//创建节点类
公共类节点{
字符数据；
节点下一步；
公共节点（char newData）{
数据=新数据；
}
公共节点（char newData，node newNext）{
数据=新数据；
next=newNext；
}
}
//LString构造函数
//构造表示空字符列表的LString对象
公共电话号码（）{
这个长度=0；
this.front=null；
}
//构造原始参数的LString副本
公共LString（原始字符串）{
//将第一个字符分配到前面
节点curr=this.front；
this.length=原始的.length（）；
//循环通过
对于（int i=0；i=长度）{
抛出新的IndexOutOfBoundsException（）；
}
//返回索引处的字符
节点电流=前端；
对于（int i=0；i=长度）{
抛出新的IndexOutOfBoundsException（）；
}
//在索引处替换字符
节点电流=前端；
对于（int i=0；i结束）{
抛出新的IndexOutOfBoundsException（）；
}else if（end>this.length（））{
抛出新的IndexOutOfBoundsException（）；
//特殊情况下返回null（空LString）
}else if（开始==结束）{
//&&end==this.length（）
返回newLString；
}否则{
node=this.front；
对于（int i=0；ipublic LString replace(int start, int end, LString replacement){
   //Do exception checks for start/end values here

   LString replacedLs = new LString();
   replacedLs.append(substring(0, start));
   replacedLs.append(replacement);
   replacedLs.append(substring(end, this.length));
   return replacedLs;
}

private int insert(LString s, int index ) {
    node 
            n1 = front,
            n2 = null;        
    for (int i = 0; i < index-1; i++) {
        n1 = n1.next;
    }
    n2 = n1.next;
    if (n2 == null) return -1;
    int inserted = 0;
    for (char c : s.toString().toCharArray()) {
        n1.next = new node(c);
        n1 = n1.next;
        inserted++;
    }
    n1.next = n2;
    return inserted;
  }


private int remove(int from, int to) {
    node n1 = front,n2 = null;
    for (int i = 0; i < to+1; i++) {
        if (i<from) {
            n1=n1.next;
        } else if (i==from) n2=n1.next;
        else n2=n2.next;
    }
    n1.next = n2;
    return -1; // or whatever
}

public LString  replace(int start, int end, LString lStr) {
    int inserted = insert(lStr,start);
    int removed = remove(inserted+start-1,inserted+end-1);
    return this;
}