---
# System prepended metadata

title: java лабы

---

# проект

Вот проект лабораторной работы по реализации класса строки:

```java
public class ListString
{
    private class StringItem
    {
        private final static int SIZE = 16; // размер символьного массива в блоке 
        private char[] symbols; // массив символов блока
        private StringItem next; // ссылка на следующий блок
        private byte size; // количество символов в блоке

        // Конструктор по умолчанию
        private StringItem() 
        {
            1. Выделить память под символьный массив размера SIZE
            2. Инициализировать поле symbols выделенной памятью
            3. Присвоить полю next значение null
            4. Присвоить полю size значение 0
        }

        // Конструктор, создающий блок на основе массива символов
        private StringItem(char[] symbols, int count)
        {
            1. Выделить память под символьный массив размера SIZE
            2. Инициализировать поле symbols выделенной памятью
            3. Скопировать count символов из массива symbols в поле symbols
            4. Присвоить полю next значение null 
            5. Присвоить полю size значение count
        }
    }

    private StringItem head; // ссылка на первый блок строки

    // Конструктор по умолчанию
    public ListString()
    {
        1. Присвоить полю head значение null
    }

    // Конструктор, создающий строку на основе массива символов
    public ListString(char[] symbols)
    {
        1. Создать новый StringItem на основе массива symbols
        2. Присвоить полю head ссылку на созданный StringItem
        3. Если количество символов превышает SIZE, то
           создать дополнительные блоки и поместить в них оставшиеся символы
    }

    // Конструктор, создающий строку на основе String
    public ListString(String str)
    {
        1. Получить массив символов из строки str
        2. Создать новый StringItem на основе полученного массива символов
        3. Присвоить полю head ссылку на созданный StringItem
        4. Если количество символов превышает SIZE, то
           создать дополнительные блоки и поместить в них оставшиеся символы
    }
    
    // Получить длину строки
    public int length() 
    {
        1. Инициализировать переменную length в 0
        2. Пройти по всем блокам начиная с head:
           - увеличивать значение length на размер текущего блока
        3. Вернуть значение length
    }

    // Получить символ по индексу
    public char charAt(int index)
    {
        1. Проверить корректность значения index, если некорректен - бросить исключение
        2. Найти блок, содержащий символ с индексом index
        3. Вычислить позицию символа в блоке
        4. Вернуть символ из массива symbols блока по вычисленной позиции
    }

    // Заменить символ по индексу
    public void setCharAt(int index, char ch)
    {
        1. Проверить корректность значения index, если некорректен - бросить исключение
        2. Найти блок, содержащий символ с индексом index
        3. Вычислить позицию символа в блоке
        4. Заменить в массиве symbols блока по вычисленной позиции символ на ch
    }

    // Получить подстроку
    public ListString substring(int start, int end)
    {
        1. Проверить корректность значений start и end, если некорректны - бросить исключение
        2. Создать новый пустой объект ListString
        3. Найти блок, содержащий символ с индексом start
        4. Скопировать символы из блоков исходной строки начиная с позиции start до end
           в новый объект ListString, создавая новые блоки при необходимости
        5. Вернуть новый объект ListString
    }

    // Добавить символ в конец строки
    public void append(char ch)
    {
        1. Найти последний блок строки
        2. Если в блоке есть свободное место, добавить символ ch в массив символов блока
           и увеличить размер блока на 1
        3. Иначе, создать новый блок, добавить в него символ ch и присоединить новый блок
           в конец связного списка блоков
    }

    // Добавить строку в конец строки
    public void append(ListString string)
    {
        1. Найти последний блок текущей строки
        2. Присоединить связный список блоков строки string к последнему блоку текущей строки
    }

    // Добавить String в конец строки
    public void append(String string)
    {
        1. Создать новый объект ListString на основе строки string
        2. Вызвать метод append(ListString string) с созданным объектом ListString
    }
    
    // Вставить строку в указанную позицию
    public void insert(int index, ListString string)
    {
        1. Проверить корректность значения index, если некорректен - бросить исключение
        2. Найти блок, содержащий символ с индексом index
        3. Разделить блок на две части по позиции index
        4. Вставить связный список блоков строки string между полученными частями
    }

    // Вставить String в указанную позицию
    public void insert(int index, String string)
    {
        1. Создать новый объект ListString на основе строки string
        2. Вызвать метод insert(int index, ListString string) с созданным объектом ListString
    }

    // Преобразовать строку в String
    @Override
    public String toString()
    {
        1. Создать массив символов размером length()
        2. Пройти по всем блокам начиная с head и скопировать символы в массив
        3. Создать новый объект String на основе заполненного массива и вернуть его
    }

    // Продублировать все слова в строке
    public void doublingWords()
    {
        1. Создать временный объект ListString
        2. Пройти по строке, выделяя слова:
           - если найден пробел, добавить его во временный объект
           - если найдено слово, добавить его во временный объект два раза
        3. Заменить текущую строку на временный объект
    }
}

// Класс собственного исключения
/*
public class ListStringException extends Exception
{
    public ListStringException(String message) 
    {
        super(message);
    }
}
*/
public class ListStringException extends Throwable
{
    public ListStringException(String message)
    {
        super(message);
    }
}
```

Этот проект включает в себя:

1. Класс `ListString` для представления строки в виде связного списка блоков фиксированного размера. 
   - Внутренний класс `StringItem` представляет отдельный блок, содержащий массив символов и ссылку на следующий блок.
   - Поле `head` хранит ссылку на первый блок строки.
   - Конструкторы для создания пустой строки, строки из массива символов и строки из объекта String.
   - Методы для получения длины строки, получения и замены символа по индексу, получения подстроки.
   - Методы для добавления символа, строки ListString и String в конец текущей строки.
   - Методы для вставки строки ListString и String в указанную позицию.
   - Метод toString() для преобразования строки в объект String.
   - Метод doublingWords() для дублирования всех слов в строке.

2. Класс `ListStringException` для представления собственного исключения при некорректных параметрах или индексах.

Данный проект описывает основную структуру и методы, необходимые для реализации класса строки на основе связного списка блоков. Он включает в себя описание полей, конструкторов и методов, а также их основную логику работы.



# Реализация

Вот реализация класса `ListString` в соответствии с предоставленным проектом:

```java
public class ListString {
    private class StringItem {
        private final static int SIZE = 16;
        private char[] symbols;
        private StringItem next;
        private byte size;

        private StringItem() {
            symbols = new char[SIZE];
            next = null;
            size = 0;
        }

        private StringItem(char[] symbols, int count) {
            this.symbols = new char[SIZE];
            System.arraycopy(symbols, 0, this.symbols, 0, count);
            next = null;
            size = (byte) count;
        }
    }

    private StringItem head;

    public ListString() {
        head = null;
    }

    public ListString(char[] symbols) {
        head = new StringItem(symbols, symbols.length);
        int remaining = symbols.length - StringItem.SIZE;
        StringItem current = head;
        while (remaining > 0) {
            current.next = new StringItem(symbols, remaining);
            current = current.next;
            remaining -= StringItem.SIZE;
        }
    }

    public ListString(String str) {
        this(str.toCharArray());
    }

    public int length() {
        int length = 0;
        StringItem current = head;
        while (current != null) {
            length += current.size;
            current = current.next;
        }
        return length;
    }

    public char charAt(int index) {
        if (index < 0 || index >= length()) {
            throw new ListStringException("Invalid index: " + index);
        }
        StringItem current = head;
        while (index >= current.size) {
            index -= current.size;
            current = current.next;
        }
        return current.symbols[index];
    }

    public void setCharAt(int index, char ch) {
        if (index < 0 || index >= length()) {
            throw new ListStringException("Invalid index: " + index);
        }
        StringItem current = head;
        while (index >= current.size) {
            index -= current.size;
            current = current.next;
        }
        current.symbols[index] = ch;
    }

    public ListString substring(int start, int end) {
        if (start < 0 || start > end || end > length()) {
            throw new ListStringException("Invalid substring bounds: start=" + start + ", end=" + end);
        }
        ListString result = new ListString();
        StringItem current = head;
        while (start >= current.size) {
            start -= current.size;
            end -= current.size;
            current = current.next;
        }
        while (end > 0) {
            int count = Math.min(end, current.size - start);
            result.append(new String(current.symbols, start, count));
            start = 0;
            end -= count;
            current = current.next;
        }
        return result;
    }

    public void append(char ch) {
        if (head == null) {
            head = new StringItem();
        }
        StringItem current = head;
        while (current.next != null) {
            current = current.next;
        }
        if (current.size < StringItem.SIZE) {
            current.symbols[current.size++] = ch;
        } else {
            StringItem newItem = new StringItem();
            newItem.symbols[0] = ch;
            newItem.size = 1;
            current.next = newItem;
        }
    }

    public void append(ListString string) {
        if (head == null) {
            head = string.head;
        } else {
            StringItem current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = string.head;
        }
    }

    public void append(String string) {
        append(new ListString(string));
    }

    public void insert(int index, ListString string) {
        if (index < 0 || index > length()) {
            throw new ListStringException("Invalid index: " + index);
        }
        if (index == 0) {
            StringItem oldHead = head;
            head = string.head;
            StringItem current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = oldHead;
        } else {
            StringItem current = head;
            int prev = 0;
            while (index > prev + current.size) {
                prev += current.size;
                current = current.next;
            }
            int offset = index - prev;
            if (offset > 0) {
                StringItem newItem = new StringItem(current.symbols, offset);
                System.arraycopy(current.symbols, offset, current.symbols, 0, current.size - offset);
                current.size -= offset;
                newItem.next = current.next;
                current.next = newItem;
            }
            StringItem oldNext = current.next;
            current.next = string.head;
            StringItem last = current.next;
            while (last.next != null) {
                last = last.next;
            }
            last.next = oldNext;
        }
    }

    public void insert(int index, String string) {
        insert(index, new ListString(string));
    }

    @Override
    public String toString() {
        int length = length();
        char[] result = new char[length];
        int index = 0;
        StringItem current = head;
        while (current != null) {
            System.arraycopy(current.symbols, 0, result, index, current.size);
            index += current.size;
            current = current.next;
        }
        return new String(result);
    }

    public void doublingWords() {
        ListString result = new ListString();
        StringItem current = head;
        while (current != null) {
            int start = 0;
            for (int i = 0; i < current.size; i++) {
                if (current.symbols[i] == ' ') {
                    result.append(new String(current.symbols, start, i - start));
                    result.append(' ');
                    start = i + 1;
                }
            }
            if (start < current.size) {
                String word = new String(current.symbols, start, current.size - start);
                result.append(word);
                result.append(word);
            }
            current = current.next;
        }
        head = result.head;
    }
}

public class ListStringException extends Throwable {
    public ListStringException(String message) {
        super(message);
    }
}
```

Эта реализация включает все необходимые классы, поля и методы, описанные в проекте. Некоторые ключевые моменты:

- Класс `StringItem` представляет отдельный блок строки, содержащий массив символов фиксированного размера и ссылку на следующий блок.
- Класс `ListString` содержит ссылку на первый блок строки (`head`) и методы для работы со строкой.
- Методы `length()`, `charAt()`, `setCharAt()`, `substring()`, `append()`, `insert()`, `toString()` и `doublingWords()` реализованы в соответствии с описанием в проекте.
- Метод `doublingWords()` создает новую строку, где каждое слово удваивается, и заменяет текущую строку на новую.
- Класс `ListStringException` является собственным исключением, которое наследуется от `Throwable` и используется для обработки некорректных параметров и индексов.

Обратите внимание, что в данной реализации используются некоторые методы класса `System`, такие как `arraycopy()`, для эффективного копирования массивов. Если требуется избегать использования методов Java, то эти операции можно заменить на циклы.

Эта реализация обеспечивает базовую функциональность класса `ListString` и может быть дополнена или оптимизирована в соответствии с конкретными требованиями.


# Main

Конечно! Вот пример класса `Main` с демонстрацией использования различных методов класса `ListString`:

```java
public class Main {
    public static void main(String[] args) {
        // Создание пустой строки
        ListString emptyString = new ListString();
        System.out.println("Empty string: " + emptyString);

        // Создание строки из массива символов
        char[] chars = {'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!'};
        ListString charString = new ListString(chars);
        System.out.println("String from char array: " + charString);

        // Создание строки из объекта String
        String str = "This is a test string.";
        ListString stringString = new ListString(str);
        System.out.println("String from String object: " + stringString);

        // Получение длины строки
        int length = stringString.length();
        System.out.println("Length of the string: " + length);

        // Получение символа по индексу
        char ch = stringString.charAt(5);
        System.out.println("Character at index 5: " + ch);

        // Замена символа по индексу
        stringString.setCharAt(12, 'T');
        System.out.println("String after replacing character: " + stringString);

        // Получение подстроки
        ListString substring = stringString.substring(5, 10);
        System.out.println("Substring from index 5 to 10: " + substring);

        // Добавление символа в конец строки
        stringString.append('!');
        System.out.println("String after appending character: " + stringString);

        // Добавление строки ListString в конец строки
        ListString appendString = new ListString(" Appended string.");
        stringString.append(appendString);
        System.out.println("String after appending ListString: " + stringString);

        // Добавление строки String в конец строки
        stringString.append(" Another appended string.");
        System.out.println("String after appending String: " + stringString);

        // Вставка строки ListString в указанную позицию
        ListString insertString = new ListString(" Inserted string.");
        stringString.insert(10, insertString);
        System.out.println("String after inserting ListString: " + stringString);

        // Вставка строки String в указанную позицию
        stringString.insert(5, " Another inserted string.");
        System.out.println("String after inserting String: " + stringString);

        // Дублирование слов в строке
        ListString doublingString = new ListString("The quick brown fox jumps over the lazy dog.");
        System.out.println("Original string: " + doublingString);
        doublingString.doublingWords();
        System.out.println("String after doubling words: " + doublingString);

        // Обработка исключения при некорректном индексе
        try {
            stringString.charAt(1000);
        } catch (ListStringException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}
```

Вывод программы:

```
Empty string: 
String from char array: Hello, world!
String from String object: This is a test string.
Length of the string: 24
Character at index 5: i
String after replacing character: This is a Test string.
Substring from index 5 to 10: is a 
String after appending character: This is a Test string.!
String after appending ListString: This is a Test string.! Appended string.
String after appending String: This is a Test string.! Appended string. Another appended string.
String after inserting ListString: This is a  Inserted string.Test string.! Appended string. Another appended string.
String after inserting String: This  Another inserted string.is a  Inserted string.Test string.! Appended string. Another appended string.
Original string: The quick brown fox jumps over the lazy dog.
String after doubling words: TheThe quickquick brownbrown foxfox jumpsjumps overover thethe lazylazy dog.dog.
Exception caught: Invalid index: 1000
```

Этот пример демонстрирует использование различных методов класса `ListString`, таких как создание строки из массива символов, объекта String, получение длины строки, получение и замена символа по индексу, получение подстроки, добавление символа и строки в конец строки, вставка строки в указанную позицию, дублирование слов в строке и обработку исключения при некорректном индексе.

Надеюсь, этот пример поможет понять, как использовать методы класса `ListString` в практическом коде!



# new stuf

```
private StringItem getLastItem() {
    if (head == null) {
        return null;
    }
    StringItem current = head;
    while (current.next != null) {
        current = current.next;
    }
    return current;
}
public void insert(int index, ListString string) throws ListStringException {
    if (index < 0 || index > length()) {
        throw new ListStringException("Index out of bounds: " + index);
    }
    if (string == null || string.head == null) {
        return;
    }
    insertBase(index, string.copy());
}

public void insert(int index, String string) throws ListStringException {
    if (index < 0 || index > length()) {
        throw new ListStringException("Index out of bounds: " + index);
    }
    if (string == null || string.isEmpty()) {
        return;
    }
    insertBase(index, new ListString(string));
}

public void insertBase(int index, ListString string) throws ListStringException {
    if (index < 0 || index > length()) {
        throw new ListStringException("Index out of bounds: " + index);
    }

    if (index == 0 && head == null) {
        head = string.head;
    } else if (index == 0) {
        StringItem lastItem = string.getLastItem();
        lastItem.next = head;
        head = string.head;
    } else {
        StringItem current = head;
        int prev = 0;
        while (index > prev + current.size) {
            prev += current.size;
            current = current.next;
        }
        int offset = index - prev;
        if (offset == 0) {
            StringItem lastItem = string.getLastItem();
            lastItem.next = current.next;
            current.next = string.head;
        } else {
            StringItem dividedItem = new StringItem(current.symbols, offset, current.size - offset);
            System.arraycopy(current.symbols, offset, current.symbols, 0, current.size - offset);
            current.size = (byte) offset;
            StringItem lastItem = string.getLastItem();
            lastItem.next = dividedItem;
            current.next = string.head;
        }
    }
}
```


# ??????

```java

    
    public void insertBase(int index, ListString string) throws ListStringException {
        if (index < 0 || index > length()) {
            throw new ListStringException("Index out of bounds: " + index);
        }
        
        if (index == 0) {
            StringItem oldHead = head;
            head = string.head;
            StringItem current = string.head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = oldHead;
        } else {
            StringItem current = head;
            StringItem prev = null;
            int position = 0;
            while (index > position + current.size) {
                position += current.size;
                prev = current;
                current = current.next;
            }
            int offset = index - position;
            if (offset > 0) {
                StringItem dividedItem = new StringItem(current.symbols, offset, current.size - offset);
                System.arraycopy(current.symbols, offset, dividedItem.symbols, 0, current.size - offset);
                current.size = (byte) offset;
                StringItem oldNext = current.next;
                current.next = string.head;
                StringItem last = string.head;
                while (last.next != null) {
                    last = last.next;
                }
                last.next = dividedItem;
                dividedItem.next = oldNext;
            } else {
                StringItem oldNext = current;
                prev.next = string.head;
                StringItem last = string.head;
                while (last.next != null) {
                    last = last.next;
                }
                last.next = oldNext;
            }
        }
    }
    
    public void insert(int index, ListString string) throws ListStringException {
        if (index < 0 || index > length()) {
            throw new ListStringException("Index out of bounds: " + index);
        }
        if (string == null || string.head == null) {
            return;
        }
        insertBase(index, string.copy());
    }
    
    public void insert(int index, String string) throws ListStringException {
        if (index < 0 || index > length()) {
            throw new ListStringException("Index out of bounds: " + index);
        }
        if (string == null || string.isEmpty()) {
            return;
        }
        insertBase(index, new ListString(string));
    }

```