StringBuilder Дублирует последний символ в удалении

Aug 15 2020

Я не знаю сайт и задал здесь только один вопрос. Понятия не имею - как решить проблему с кодом. Я много пробовал - но исправить не смог. Я использую StringBuilder - из-за его преимуществ в соответствии со стандартной строкой

Я хочу удалить первый символ в строке, но символ, который появляется в последнем месте, дублируется - в последних двух местах.

например: у меня есть String abcdef, когда я удаляю - первый instace - 'a': я получил обратно String bcdeff хорошо, я пытаюсь - установить длину String на исходную длину минус один - но это не дает никакого результата . Я также пытаюсь - установить строку в новую строку - и после этого - отправить строку, которую я сохранил в строке tmp - но это тоже помогает.


    public void appendBuffer(StringBuilder dictionary)
    {
        for (int i = 0; i < appendToWindowBuffer; i++) {
            if(dictionary.length() == windowSize)
            {
                dictionary.deleteCharAt(0);
            }
            if(nextByteIndex<source.length  )
            {
                dictionary.append((char)source[nextByteIndex]);
                nextByteIndex++;
            }
            else
            {
                currentLookaheadBufferSize--;
            }
            if(currentSearchBufferSize < searchBufferSize)
            {
                currentSearchBufferSize++;
            }
            
        }
        appendToWindowBuffer = 0;
    }

полный код:

основной класс

import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException
    {
        System.out.println("main");
        String inPath = "C:\\Users\\avraam\\Documents\\final-assignment\\LZ77\\source.txt";
        String outPath = "C:\\Users\\avraam\\Documents\\final-assignment\\LZ77\\encoded.txt";
        String decompressedPath = "C:\\Users\\avraam\\Documents\\final-assignment\\LZ77\\decoded.txt";
        int windowSize = 14;
        int lookaheadBufferSize = 6;
        LZ77 compress = new LZ77(inPath,outPath,windowSize,lookaheadBufferSize);
        compress.compress();
        
    }
}

класс соответствия


public class Match {
    protected int length;
    protected int offset;
    protected String value;
    
    public Match(int length, int offset, String value)
    {
        this.length=length;
        this.offset=offset;
        this.value = value;
    }
    
    public void SetOffset(int offset) { this.offset = offset; }
    public void SetLength(int length) { this.length = length; }
    public void SetValue(String value) { this.value = value; }
    public void AddValue(char value) { this.value += value; }
    
    public void Reset()
    {
        this.offset = 0;
        this.length = 0;
        this.value = "";
    }
}

LZ77 класс

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Arrays;

public class LZ77 {
    private String inPath = null;
    private String outPath = null;
    private File inFile;
    private File outFile;
    private final int windowSize;
    private final int lookaheadBufferSize;  
    private final int searchBufferSize;
    private int nextByteIndex = 0;
    //private int lookAheadIndex = 0; //not always should be (windowsize - lookaheadBufferSize.) in the end maybr will be less character in the lookAhead buffer. the index when LookAhead start is equel to the length of SearchBuffer
    private int currentSearchBufferSize = 0;
    private int currentLookaheadBufferSize = 0;
    private int appendToWindowBuffer = 0;
    private byte[] source = null;
    
    public LZ77(String inPath,String outPath,int windowSize,int lookaheadBufferSize) throws IOException
    {
        this.inPath = inPath;
        this.outPath = outPath;
        this.inFile = new File(inPath);
        this.outFile = new File(outPath);
        this.windowSize = windowSize;
        this.lookaheadBufferSize = lookaheadBufferSize;
        this.searchBufferSize = windowSize - lookaheadBufferSize;
        this.source = Files.readAllBytes(inFile.toPath());
    }

    public void compress() throws IOException
    {
        /*
        *   1. create whole windowBuffer (named - `dictionary`)- that will by used by lookahead and by search Buffers.
        *   2. create compressed data - where the data that compressed will be send. 
        *   3. initialize dictionary - look a head buffer by giving it the size of `lookaheadBuffer`.
        *   4. start encode.
        *   5. make the encode.
        */
        
        System.out.println("compress");
        System.out.println("read the file.");
        System.out.println("check if source array work: ");
        for (int element: source) {
            System.out.print((char)element + "");
        }
        System.out.println("call to bufferInitialize function");
        StringBuilder dictionary = new StringBuilder();
        bufferInitialize(dictionary);
        System.out.println(dictionary.toString());
        StringBuilder compressed = new StringBuilder();     
        encode(dictionary,compressed);
    }
    public void bufferInitialize(StringBuilder dictionary)
    {
        System.out.println("bufferInitialize");
        for (int i = 0; i < lookaheadBufferSize; i++) {
            dictionary.append((char)source[nextByteIndex]);
            nextByteIndex++;
            currentLookaheadBufferSize++;
        }
        // initialize the buffer in the beginning with look a head buffer.
    }
    public void bufferUpdate()
    {
        
        // gets int length - and read those number of bytes - from `inPath` source file.
        
    }
    public void encode(StringBuilder dictionary,StringBuilder compressed)
    {
        //while(nextByteIndex < source.length)
        while(currentLookaheadBufferSize > 0)
        {
            Match match = findMatch(dictionary);
            System.out.print("<"+match.offset + ","+match.length+","+ dictionary.charAt(currentSearchBufferSize + match.length) + ">");
            appendToWindowBuffer = increaseBuffer(match.length);
            
            appendBuffer(dictionary);
        }
        /**
         * do while you reach to the end of the file
         *   check if there any possible match
         *      if do so
         *      find the maxMatch try always to add another character DONE
         *  call update function - 
         * the function will update the 
         * windowbuffer(dictionary), DONE
         * nextByteIndex and DONE
         * the position of the index that begins the lookAheadBuffer 
         * and size of the lookahead and 
         * search buffers, and 
         * reset the appendToWindowBuffer. DONE
         */     
    }
    public void convertStringToBits()
    {
        
    }
    public Match findMatch(StringBuilder dictionary)
    {
        /**
         * function get the window buffer - and index to start.
         * the function will be find the max match that starts from index 0 to index start (we cant start search after the `start index`) 
         * because this parts belong to the look a head buffer.
         * @param 
         * @return
         */
        Match match= new Match(0,0, "");
        String matchedString = null;
        int offset;
        int matchLookAheadIndex = currentSearchBufferSize;
        if(!haveAnyMatch(dictionary))
        {
            addMatch();
        }
        else {
            matchedString = "" + dictionary.charAt(matchLookAheadIndex);
            offset = findMatchIndex(dictionary,matchedString);
            while(offset != -1)
            {
                match.SetLength(match.length + 1);
                match.SetOffset(offset);
                match.SetValue(matchedString);
                matchLookAheadIndex++;
                matchedString +=dictionary.charAt(matchLookAheadIndex);
                offset = findMatchIndex(dictionary,matchedString);
            }
        }
        return match;
        
    }
    public int findMatchIndex(StringBuilder dictionary,String value)
    {
        int stringLength = value.length();
        String tmpMatch = null;
        int offsetMatch;
        for (int i = currentSearchBufferSize - 1; i >=0; i--) 
        {
            tmpMatch = dictionary.substring(i, i +stringLength );
            offsetMatch = currentSearchBufferSize - i;
            if(tmpMatch.equals(value))
            {
                System.out.println("data was match is searchWindow");
                System.out.println("the offset from LookAHead is: " + offsetMatch);
                return offsetMatch;
            }
        }
        return -1;
    }
    public boolean haveAnyMatch(StringBuilder dictionary)
    {
        if (currentSearchBufferSize == 0)
        {
            System.out.println("dont have match - search buffer is empty now");
            return false;
        }
        if(!isExistInSearchBuffer(dictionary,dictionary.charAt(currentSearchBufferSize)))   
        {
            System.out.println("dont have match - the first character in lookAheadBuffer wasn't found in searchBuffer");
            return false;
        }
        return true;
        /*
         * check: 
         * if search buffer is empty 
         * if the needed character isn't exist in the search buffer
         * if the current value is big enough - and match was not found.
         */
    }
    public boolean isExistInSearchBuffer(StringBuilder dictionary, char isCharAtDictionary)
    {
        for (int i = 0; i < currentSearchBufferSize; i++) {
            if(dictionary.charAt(i) == isCharAtDictionary)
            {
                return true;
            }
        }
        return false;
    }
    public void nextMatch(StringBuilder dictionary)
    {
        /**
         * @param: value, window buffer. 
         * @description: find the current match with the needed value in the search buffer boundaries.
         */
        
    }
    public int increaseBuffer(int matchLength)
    {
        return 1 + matchLength;
        /*
         * return int - that calulate by how many byte we need to increase the buffer
         */
    }
    public void addMatch()
    {
        
    }
    public void addBitSize() {
        
    }
    public void appendBuffer(StringBuilder dictionary)
    {
        for (int i = 0; i < appendToWindowBuffer; i++) {
            if(dictionary.length() == windowSize)
            {
                dictionary.deleteCharAt(0);
            }
            if(nextByteIndex<source.length  )
            {
                dictionary.append((char)source[nextByteIndex]);
                nextByteIndex++;
            }
            else
            {
                currentLookaheadBufferSize--;
            }
            if(currentSearchBufferSize < searchBufferSize)
            {
                currentSearchBufferSize++;
            }
            
        }
        appendToWindowBuffer = 0;
    }
}

Ответы

2 ShimonCohen Aug 15 2020 at 20:15

Кажется, это работает:

StringBuilder builder = new StringBuilder("abcdef");
builder.deleteCharAt(0);
System.out.println(builder.toString());

Печать: bcdef

Как ты это делаешь?

1 dustyeav Aug 22 2020 at 08:36

решение, которое работает для меня: мне нужно записать распакованный файл в выходной файл. Прописал в файл - в CHAR - это не так - нужно прописать вывод в BYTE

РАБОЧИЙ СПОСОБ, ЧТО Я ДЕЛАЮ:

    private void writeDecode (StringBuilder decompress) throws IOException
    {
        Writer write = new FileWriter(this.outFile);
        write.write(decompress.toString());
        write.close();
    }

ПРАВИЛЬНЫЙ ПУТЬ

    private void WriteToFile(StringBuilder decodedData) throws IOException
    {
        FileOutputStream outputFileStream = new FileOutputStream(this.outPath); 
        for(int i = 0; i < decodedData.length(); i++)
        {
            byte currentByte = (byte)decodedData.charAt(i);
            outputFileStream.write(currentByte);
        }
        outputFileStream.close();
    }

Мне нужно зарегистрироваться в файле в БАЙТЕ - это правильный путь.

LiveandLetLive Aug 15 2020 at 20:31

Если вы используете тот же код, который вы опубликовали, основной причиной вашей проблемы является следующая строка:

dictionary.append((char)source[nextByteIndex]);

Вы можете подтвердить это, выполнив свой код, закомментировав указанную выше строку.

Чтобы точно сказать вам, как это вызывает эту проблему, мне нужно знать все переменные в вашем коде, которые в настоящее время неизвестны.

Важное примечание:

В следующем цикле вы не проверяете границы sourceпри доступе к элементам sourceизнутри цикла.

for (int i = 0; i < appendToWindowBuffer; i++) 

Это может вызвать, ArrayIndexOutOfBoundsExceptionесли appendToWindowBuffer > source.length. Я настоятельно рекомендую вам также использовать границы sourceдля условия завершения, как показано ниже:

for (int i = 0; i < appendToWindowBuffer && i < source.length; i++) 

В качестве альтернативы,

for (int i = 0; i < Math.min(appendToWindowBuffer, source.length); i++) 

Обновление на основе кода, опубликованного вами позже:

Пройдя ваш код, я могу подтвердить, что вы получаете результат из-за dictionary.append((char)source[nextByteIndex]). Заявление dictionary.deleteCharAt(0)работает так, как ожидалось, и так оно и есть dictionary.append((char)source[nextByteIndex]). Он dictionary.append((char)source[nextByteIndex])добавляет последний символ, когда nextByteIndexстановится равным source.length - 1.