В английском словаре Mutator означает иметь новую форму. Итак, Mutator, хотя и не найден в английском словаре, означает нечто, вызывающее изменение в новую форму. Частная переменная — это поле или свойство класса в Java. В Java нет предопределенного метода, называемого Mutator. Вместо этого Mutator — это метод в классе, и этот метод предназначен для изменения значения частной переменной класса. По соглашению программист должен начинать имя метода с «set». Таким образом, метод может быть чем-то вроде setAge(), setPrice(), setName() и т. д.

Разница между частной и общедоступной переменной

Закрытая переменная видна только членам (свойствам и методам) внутри определения класса. Его нельзя увидеть кодом вне определения класса. С другой стороны, общедоступная переменная может быть видна кодом вне определения класса. Код вне класса может просто изменить общедоступную переменную класса, присвоив новое значение, используя имя класса, если метод является статическим, или используя имя объекта, если метод не является статическим. С общедоступной переменной смысла мутации на самом деле нет. Но когда класс изменяет свое собственное значение, которое не может быть изменено извне, это называется трансформацией, в которой лучше понимается мутация.

Иллюстрация Mutator

Не каждому классу нужен Mutator. Однако, когда Mutator необходим для частной переменной (свойства), метод Mutatorа, который является членом класса, должен начинаться с «set». Затем программист определяет метод Mutatorа.

Любой объект в магазине может быть определен классом. Например, хорошая чашка в магазине может быть определена классом. Как минимум, класс будет иметь свойство, которое является ценой чашки, метод Mutatorа и метод доступа. Метод доступа — это метод чтения значения свойства. По соглашению метод доступа должен начинаться с «get». В данном случае это будет getPrice(). Пусть свойство с названием price будет частным. Если цена является общедоступной, то нет необходимости в Mutatorе и аксессоре, так как значение может быть установлено или получено (прочитано) публично.

Следующее определение класса предназначено для чашки (добавлено дополнительное свойство (поле) для валюты):

    class Cup {

        private double price = 2.0;

        private Character currency = '$';

        public void setPrice(Double dbl) {

            price = dbl;

        }

        public double getPrice() {

            return price;

        }

    }

Mutator setPrice() является общедоступным, поэтому к нему можно получить доступ из кода вне класса. Сделать Mutator общедоступным не означает сделать общедоступным соответствующее свойство. Соответствующее свойство должно быть частным. У Mutatorа здесь есть аргумент dbl, который является новой ценой. При изменении рыночных условий меняется и цена в магазине. Если бы цена была общедоступной, не было бы необходимости в Mutatorе setPrice(), поскольку код вне класса мог бы изменить цену. Поскольку setPrice является членом класса, он может видеть значение цены частного свойства. Однако код вне класса не может видеть это свойство. Это по дизайну.

Аксессор getPrice() является общедоступным, поэтому к нему можно получить доступ из кода вне класса. У него нет аргументов. Если бы цена была общедоступной, не было бы необходимости в методе доступа getPrice(), поскольку код вне класса мог бы прочитать цену. Поскольку getPrice является членом класса, он может видеть значение цены частной собственности. Однако код вне класса не может видеть это свойство. Это по дизайну.

Mutator setCurrency() и метод доступа getCurrency() могут быть аналогичным образом написаны для закрытой переменной currency.

Следующий основной класс и основной метод получают доступ к частной переменной price, изменяют переменную, а затем снова обращаются к переменной; все это после создания экземпляра класса:

    public class TheClass {

        public static void main(String[] args) {

            Cup cup1 = new Cup();

            double firstPrice = cup1.getPrice();

            System.out.print(firstPrice); System.out.print(", ");



            cup1.setPrice(3.0);



            double secondPrice = cup1.getPrice();

            System.out.print(secondPrice);

            System.out.println();

        }

    }

Результат:

   2.0, 3.0

Первый сегмент кода в основном методе создает экземпляр объекта Cup (cup1) и получает доступ к цене частного свойства через методы доступа getPrice() и cup1. Затем он распечатывает эту первую цену с запятой и пробелом.

Второй сегмент кода представляет собой сегмент кода из одной строки. Он изменяет цену частной собственности с помощью Mutatorа setPrice() и cup1. Третий сегмент кода считывает и печатает новую цену.

Проверка

Пользователь программы должен установить новую цену как двойную. Но что, если он введет какой-то другой тип данных? Новая цена должна быть подтверждена, если она действительно двойная. Код строки для этого случая должен выглядеть следующим образом:

            boolean bl = dbl instanceof Double;

Оператор instance of возвращает true, если его левый операнд является экземпляром правого операнда; ложно в противном случае.

При проверке определение метода Mutatorа должно быть:

        public void setPrice(Double dbl) {

            if (dbl instanceof Double)

                price = dbl;

            else

                System.out.println("New Price could not be set!");

        }

То есть, если входной dbl имеет тип Double, то цена меняется. Если это не так, выдается сообщение об ошибке, и программа продолжает работу. Обратите внимание, что «d» для double в этом сегменте кода — это «D», а не «d».

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

        public void setCurrency(Character ch) {

            if (ch instanceof Character)

                currency = '€';

            else

                System.out.println("New currency is not a character!");

        }

То есть, если ввод ch имеет тип Character, то валюта изменяется с $ на ‘€’. Если это не так, выдается сообщение об ошибке, и программа продолжает работу. Обратите внимание, что «c» для символа в этом сегменте кода — это «C», а не «c».

Заключение

В Java нет предопределенного метода в качестве Mutatorа. Mutator кодируется программистом. Mutator — это просто закодированный (общедоступный) метод, который изменяет приватное значение поля (свойства) класса. С другой стороны, метод доступа — это просто закодированный (общедоступный) метод, который считывает частное значение поля (свойства) класса.

Спасибо, что прочитали нашу статью. Оставьте комментарий о своих мыслях и прочитайте другие статьи, которые лучше всего соответствуют идеям, которые вы ищете.

Предположим, что вы предлагаете услуги трем разным людям, стоящим перед вами. Третий человек оказывается вашим другом. Услуга должна быть обслужена в порядке очереди. При использовании принципа «первым пришел — первым обслужен» первый человек имеет наибольший приоритет; второй человек имеет больший приоритет; третье лицо, меньший приоритет и так далее. Вас не накажут, если вы не соблюдаете принцип «первым пришел — первым обслужен». Вы решили сначала обслужить своего друга, затем первого человека, а затем второго человека. Это означает, что вы отдали своему другу наивысший приоритет. Если смотреть на сценарий с точки зрения робота, то третья позиция имела наибольший приоритет.

На следующий день пришли те же трое. На этот раз ваш друг находится посередине. Вы решили служить ему первым, впереди того, кто пришел первым, затем третьего лица и, наконец, первого лица. Итак, на этот раз, по мнению робота, позиция 2 имеет наибольший приоритет, за ней следует позиция 3.

На третий день ваш друг становится первым, и вы действуете по принципу «первым пришел — первым обслужен». Вывод любого и робота состоит в том, что приоритет зависит от того, кого это касается, и от позиции каждого человека. Примечание: в реальной жизни приоритет не всегда зависит от принципа «первым пришел — первым обслужен».

В программировании очередь с двоичным приоритетом — это очередь, в которой первый элемент имеет наибольший приоритет. Третий элемент может иметь больший приоритет, а второй элемент — третий приоритет. Очереди приоритетов имеют бинарную природу. Примечание: первый элемент всегда имеет наивысший приоритет в очереди приоритетов. Также может случиться так, что второй элемент имеет больший приоритет, а третий элемент имеет третий приоритет. В определении очереди приоритетов приоритеты второго и третьего элементов могут быть не в порядке убывания. Эта разница продолжается вниз по очереди до последнего элемента, который не может быть элементом с наименьшим приоритетом. Однако он будет одним из наименее приоритетных. Эта частичная сортировка также известна как частичная сортировка. Итак, очередь с приоритетом — это очередь с частичным порядком, где приоритет не «первым пришел — первым обслужен»,

При работе с массивом «первым пришел — первым обслужен» является «первым поступил — первым обслужен», записывается как FIFO. В вычислениях очередь — это FIFO, а очередь с приоритетом — частичная FIFO, потому что по мере убывания очереди некоторые элементы имеют более высокие приоритеты, чем их ближайшие предшественники. По мере дальнейшего опускания очереди приоритетов расстояние между такими ближайшими предшественниками и более высокими приоритетами увеличивается.

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

Структура данных кучи

Есть максимальная куча и есть минимальная куча. С max-heap первый элемент является самым большим значением. По мере спуска очереди значения продолжают уменьшаться, увеличиваться и вообще уменьшаться. В min-heap первый элемент является наименьшим значением. По мере опускания очереди значения продолжают увеличиваться, уменьшаться и в целом увеличиваться. Значения кучи можно хранить в массиве.

Двоичная куча — это место, где узел (элемент) имеет двух дочерних элементов. Первый ребенок — левый ребенок, а второй ребенок — правый ребенок. Значение любого узла называется ключом.

Max-Heap

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

89, 85, 87, 84, 82, 79, 73, 80, 81, , , 65, 69

89 — первое значение с индексом 0. Это корневой узел (корневой родитель). Это самая большая ценность среди всех ценностей. Его первый потомок (85) имеет индекс 1, индекс которого равен 2(0) + 1, где 0 — индекс родителя. Его второй потомок (87) имеет индекс 2, что равно 2(0) + 2, где 0 — индекс родителя.

85 находится в индексе 1. Это родитель. Его первый потомок (84) имеет индекс 3, что равно 2(1) + 1, где 1 — индекс родителя. Его второй потомок (82) имеет индекс 4, что равно 2(1) + 2, где 1 — индекс родителя.

87 находится в индексе 2. Это родитель. Его первый потомок (79) имеет индекс 5, что равно 2(2) + 1, где 2 — индекс родителя. Его второй потомок (73) имеет индекс 6, что равно 2(2) + 2, где 2 — индекс родителя.

В общем, поскольку подсчет индексов начинается с 0, пусть i представляет индекс родителя массива; и, таким образом, левый (первый) потомок родителя с индексом i имеет индекс 2i + 1; а его правый (второй) дочерний элемент имеет индекс 2i + 2. Некоторые ячейки ближе к концу массива могут быть пустыми; они не должны иметь значений.

Предыдущий список — хороший пример содержимого приоритетной очереди после завершения включения всех элементов. Если первый элемент удаляется, остальные перестраиваются для установки значений, образуя новую очередь приоритетов. Таким образом, удаление всех элементов сверху будет выглядеть так, как будто все элементы отсортированы правильно. Элементы по-прежнему можно получить как есть, в частичном порядке, без удаления какого-либо элемента.

Min-Heap

Min-heap — это обратная сторона max-heap.

Приоритетная очередь в Java

В Java есть класс PriorityQueue для Priority-Queue. Он имеет множество конструкторов и методов. Ниже описаны только три конструктора и более подходящие методы:

Создание очереди приоритетов в Java

Public PriorityQueue()

Это создает приоритетную очередь без какого-либо элемента. Класс PriorityQueue находится в пакете java.util.*, который необходимо импортировать. Следующий сегмент кода создает пустую PriorityQueue, а затем добавляет в очередь несортированные (даже частично не отсортированные) значения:

PriorityQueue<Integer> pq = new PriorityQueue<Integer>();



pq.add(69); pq.add(65); pq.add(87); pq.add(79);



pq.add(73); pq.add(84); pq.add(89); pq.add(80);



pq.add(81); pq.add(82); pq.add(85);

Все эти числа целые. Они взяты из частично отсортированного списка, приведенного выше, но в настоящее время они полностью не отсортированы по мере ввода. Элементы в pq теперь частично отсортированы в соответствии с определением приоритетной очереди в Java.

Public PriorityQueue(PriorityQueue<? extends E> c)

Это создает приоритетную очередь из другой приоритетной очереди. Следующий сегмент кода иллюстрирует это:

PriorityQueue<Integer> pq = new PriorityQueue<Integer>();



pq.add(69); pq.add(65); pq.add(87); pq.add(79);



pq.add(73); pq.add(84); pq.add(89); pq.add(80);



pq.add(81); pq.add(82); pq.add(85);



PriorityQueue<Integer> pq1 = new PriorityQueue<Integer>(pq);

pq1 был создан из pq. В настоящее время он имеет тот же частичный порядок и pq.

Третий метод конструктора показан ниже.

Java-методы приоритетной очереди

Public Int Size()

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

PriorityQueue<Integer> pq = new PriorityQueue<Integer>();



pq.add(69); pq.add(65); pq.add(87); pq.add(79);



pq.add(73); pq.add(84); pq.add(89); pq.add(80);



pq.add(81); pq.add(82); pq.add(85);



int sz = pq.size();



System.out.println(sz);

Вывод 11.

Public Void forEach(Consumer<? super E> action)

Этот метод нужно использовать особым образом, чтобы скопировать все значения в приоритетной очереди в частично отсортированном виде. Следующая программа иллюстрирует это:

PriorityQueue<Integer> pq = new PriorityQueue<Integer>();



pq.add(69); pq.add(65); pq.add(87); pq.add(79);



pq.add(73); pq.add(84); pq.add(89); pq.add(80);



pq.add(81); pq.add(82); pq.add(85);



pq.forEach (item -> System.out.print(item + " "));



System.out.println();

Обратите внимание на то, как сделан код в скобках метода forEach. Элемент — это фиктивная переменная, которая представляет каждый элемент в очереди. Обратите внимание на использование оператора стрелки. Результат:

65 69 84 79 73 87 89 80 81 82 85

Вывод правильный, в частичном порядке, но в порядке возрастания. Это не обязательно обратный порядок, указанный выше, из-за способа включения значений в список. То есть метод forEach возвращает список в виде минимальной кучи. Чтобы вернуть список в порядке убывания, используйте следующий конструктор:

Public PriorityQueue(Comparator<? super E> comparator)

Это конструктор. Следующий код показывает, как его использовать:

PriorityQueue<Integer> pq = new PriorityQueue<Integer>((x, y) -> Integer.compare(y, x));



pq.add(69); pq.add(65); pq.add(87); pq.add(79);



pq.add(73); pq.add(84); pq.add(89); pq.add(80);



pq.add(81); pq.add(82); pq.add(85);



pq.forEach (item -> System.out.print(item + " "));

X, y — фиктивные переменные, представляющие меньшее и меньшее значения. Обратите внимание, что в первых скобках для x и y x стоит перед y. Во вторых скобках y стоит перед x. Результат:

89 85 87 80 82 69 84 65 79 73 81

PriorityQueue<Integer> pq = new PriorityQueue<Integer>((x, y) -> Integer.compare(y, x));



pq.add(69); pq.add(65); pq.add(87); pq.add(79);



pq.add(73); pq.add(84); pq.add(89); pq.add(80);



pq.add(81); pq.add(82); pq.add(85); pq.add(70);



pq.forEach (item -> System.out.print(item + " "));

89 85 87 80 82 70 84 65 79 73 81 69

PriorityQueue<Integer> pq = new PriorityQueue<Integer>((x, y) -> Integer.compare(y, x));



pq.add(69); pq.add(65); pq.add(87); pq.add(79);



pq.add(73); pq.add(84); pq.add(89); pq.add(80);



pq.add(81); pq.add(82); pq.add(85); pq.add(70);



pq.forEach (item -> System.out.print(pq.poll() + " "));

89 87 85 84 82 81 80 79 73 70 69 65 Exception in thread "main" java.util.ConcurrentModificationException



at java.base/java.util.PriorityQueue.forEach(PriorityQueue.java:984)



at TheClass.main(TheClass.java:11)

Локальный файл находится на жестком диске или флешке, подключенной к порту USB. Файлы можно разделить на две категории: текстовые файлы и байтовые файлы. Типичные текстовые файлы — это файлы, созданные текстовым редактором. Файл изображения является примером байтового файла, состоящего в основном из необработанных байтов.

В этой статье дается базовое объяснение того, как читать локальные текстовые и байтовые файлы в Java. Чтобы прочитать текстовый файл, используйте класс FileReader. Чтобы прочитать байтовый файл, используйте класс FileInputStream. Оба класса находятся в пакете java.io.*, который необходимо импортировать. Первая половина этой статьи посвящена чтению текстовых файлов, а вторая половина — чтению байтовых файлов.

Чтение текстовых файлов

Создание объекта FileReader

Прежде чем научиться создавать объект FileReader, создайте следующий текстовый файл с помощью текстового редактора и нажмите клавишу Enter в конце первых двух строк:

A text 1 A text 1 A text 1 A text 1 A text 1



B text 2 B text 2 B text 2 B text 2 B text 2



C text 3 C text 3 C text 3 C text 3 C text 3

Если клавиша Enter не нажата в конце последней строки, текстовый редактор может добавить новую строку при сохранении файла. После создания предыдущего текста сохраните содержимое с именем temp.txt, используя меню текстового редактора, user@host :~/dir1$, в каталог. Это означает, что должен быть создан каталог dir1.

Создание программы чтения файлов

Класс FileReader имеет пять конструкторов. В этой статье проиллюстрирован только один (чтобы статья была короткой). Синтаксис конструктора следующий:

public FileReader(String fileName) throws FileNotFoundException

При этом создается в памяти поток (копия) файла, путь и имя которого представляет собой строку fileName. Выдает исключение FileNotFoundException, если файл не найден в указанном каталоге. После копирования содержимого файла открытый файловый объект необходимо закрыть, чтобы освободить любые системные ресурсы, связанные с открытым файлом.

Важные методы FileReader

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

public void close() throws IOException

После того, как файл только что был открыт, эффективное чтение файла еще не произошло. Чтобы читать по одному символу за раз (один, затем следующий), используйте синтаксис метода FileReader:

public int read() throws IOException

Это возвращает прочитанный символ (в виде целого числа) или -1, если достигнут конец потока (потока копирования файла в памяти).

Чтобы прочитать следующую последовательность символов файла в массив, используйте синтаксис метода FileReader:

public int read(char[] cbuf, int off, int len) throws IOException

Он возвращает количество прочитанных символов или -1, если был достигнут конец потока. Off в синтаксисе означает смещение. Это индекс в файле, с которого должно начаться чтение следующей последовательности символов. Len — количество символов для чтения. Это должна быть длина массива, а cbuf — это массив, в который считывается последовательность символов.

Помните, что объект FileReader должен быть закрыт с помощью его метода close после эффективного чтения.

Синтаксис метода, чтобы узнать, не вернет ли следующее чтение -1, таков:

public boolean ready() throws IOException

Он возвращает true, если есть что-то для чтения, и false в противном случае.

Чтение в строку

Следующий код считывает предыдущий файл посимвольно в строку StringBuilder:

            StringBuilder sb = new StringBuilder();

try{

FileReaderfr = new FileReader("dir1/temp.txt");



                while (fr.ready()) {          

                    char ch = (char)fr.read();

sb.append(ch);

                }

            }

catch(Exception e) {

e.getMessage();

            }

System.out.println(sb);

Код начинается с создания экземпляра объекта StringBuilder, sb. Далее идет конструкция try-catch. Блок try начинается с создания экземпляра FileReader, фр. И есть цикл while, который повторяется до тех пор, пока ready() не вернет false. Первый оператор цикла while считывает и возвращает следующий символ в виде целого числа. Его нужно перевести в char. Следующий оператор в цикле while добавляет к строке следующий символ, sb. Результат:

A text 1 A text 1 A text 1 A text 1 A text 1



B text 2 B text 2 B text 2 B text 2 B text 2



C text 3 C text 3 C text 3 C text 3 C text 3

Это в точности содержимое файла, но добавлена ​​лишняя строка на компьютере автора.

Чтение в массив

При чтении в массив содержимое массива должно быть освобождено для чтения следующей последовательности символов. Следующий код иллюстрирует это:

            StringBuilder sb = new StringBuilder();

try{

FileReaderfr = new FileReader("dir1/temp.txt");



                while (fr.ready()) {    

char[] arr = new char[5];

                    int offset = 0;

fr.read(arr, offset, 5);

                    offset = offset + 5;

System.out.print(arr);

                }

            }

catch(Exception e) {

e.getMessage();

            }

System.out.println();

Значение смещения должно увеличиваться для каждой итерации на длину массива. Результат:

A text 1 A text 1 A text 1 A text 1 A text 1



B text 2 B text 2 B text 2 B text 2 B text 2



C text 3 C text 3 C text 3 C text 3 C text 3

Это точно так же, как содержимое файла, но с добавлением дополнительной строки на компьютере автора.

Чтение байтовых файлов

Создание объекта FileInputStream

Следующий файл изображения называется bars.png. Он находится в каталоге user@host :~/dir1$, который совпадает с каталогом temp.txt. Он состоит всего из трех цветных полос:

Создание FileInputStream

Конструктор для объекта FileInputStream:

public FileInputStream(String name) throws FileNotFoundException

Поскольку он выдает исключение, он должен быть в конструкции try-catch. Помните, что этот класс предназначен для чтения байтов.

Важные методы FileInputStream

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

public void close() throws IOException

После того, как файл только что был открыт, эффективное чтение файла еще не произошло. Чтобы читать по одному байту за раз (один, затем другой), используйте синтаксис метода FileInputStream:

public int read() throws IOException

Это возвращает прочитанный байт (как целое число) или -1, если достигнут конец потока (потока копирования файла в памяти).

Помните, что после этого эффективного чтения объект FileInputStream должен быть закрыт с помощью его метода close.

Чтобы получить оценку количества байтов, оставшихся для чтения, используйте синтаксис метода:

public int available() throws IOException

Поскольку этот метод возвращает оценку, при использовании в сочетании с read() нельзя быть уверенным, что все байты файла были прочитаны. И следует отдать предпочтение следующему методу, который считывает все байты:

public byte[] readAllBytes() throws IOException

Этот метод возвращает все оставшиеся байты, но все равно будет читать весь файл.

Чтение в ArrayList

ArrayList должен быть импортирован из пакета java.util.*. Следующий код считывает оценку всех байтов в объект ArrayList:

ArrayList al = new ArrayList();

try{

FileInputStream fir = new FileInputStream("dir1/bars.png");



                while (fir.available() > 0) {          

                    byte bt = (byte)fir.read();

al.add(bt);

                }

            }

catch(Exception e) {

e.getMessage();

            }

System.out.println(al);

Код начинается с создания экземпляра объекта ArrayList, например. Далее идет конструкция try-catch. Блок try начинается с создания экземпляра FileInputStream, fir. И есть цикл while, который повторяется, пока не будет доступен(), и предполагает, что не осталось ни одного байта для чтения. Первый оператор цикла while считывает и возвращает следующий байт в виде целого числа. Его нужно преобразовать в байт. Следующий оператор в цикле while добавляет (добавляет) следующий символ в список, т.е. Результат:

[-119, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0, -7, 0, 0, 0, -10, 8, 6, 0, 0, 0, 20, 25, 33, 69, 0, 0, 0, 6, 98, 75, 71, 68, 0, -1, 0, -1, 0, -1, -96, -67, -89, -109, 0, 0, 3, 48, 73, 68, 65, 84, 120, -100, -19, -42, 49, 74, 67, 81, 0, 68, -47, -81, -68, 52, 105, 83, -120, 85, 42, 65, -112, -12, 41, 44, 92, 64, -74, -26, 34, 92, -110, -115, -107, 32, -23, -19, 44, 4, 9, -60, 85, 60, 62, 92, -50, 89, -63, 52, 23, -26, -26, -70, 44, -41, 5, 104, 58, -99 - - - and continues - - - ]

Байты — это целые числа. Будем надеяться, что изображение трех предыдущих баров состоит из всех этих байтов. Идея состоит в том, чтобы программист изменил некоторые байты, изменил изображение, а затем сохранил результат; затем повторно отобразите его с помощью средства просмотра изображений, представляя измененное изображение. Однако это дополнительное расписание не рассматривается в этой статье.

Чтение в массив

Метод readAllBytes() возвращает массив байтов. Итак, просто получите возвращаемые значения с массивом байтов, как показано в следующем коде:

byte[] arr = new byte[1000];

try{

FileInputStream fir = new FileInputStream("dir1/bars.png");



arr = fir.readAllBytes();

            }

catch(Exception e) {

e.getMessage();

            }



            for (int i=0; i<arr.length; i++)

System.out.print(arr[i] + ", ");

System.out.println();

Код начинается с объявления массива, который получит байты. Размер (длина) здесь должен быть выше предполагаемого размера. Предполагаемый размер можно получить с помощью метода available(). Основной код находится в блоке try. Результат:

-119, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0, -7, 0, 0, 0, -10, 8, 6, 0, 0, 0, 20, 25, 33, 69, 0, 0, 0, 6, 98, 75, 71, 68, 0, -1, 0, -1, 0, -1, -96, -67, -89, -109, 0, 0, 3, 48, 73, 68, 65, 84, 120, -100, -19, -42, 49, 74, 67, 81, 0, 68, -47, -81, -68, 52, 105, 83, -120, 85, 42, 65, -112, -12, 41, 44, 92, 64, -74, -26, 34, 92, -110, -115, -107, 32, -23, -19, 44, 4, 9, -60, 85, 60, 62, 92, -50, 89, -63, 52, 23, -26, -26, -70, 44, -41, 5, 104, 58, -99, - - - and continues - - -

Этот вывод и предыдущий совпадают на компьютере автора.

Вывод

Локальные текстовые и байтовые файлы могут быть прочитаны. Чтобы прочитать текстовый файл, используйте класс потока FileReader. Чтобы прочитать байтовый файл, используйте класс потока FileInputStream. Оба класса находятся в пакете java.io.*, который необходимо импортировать. Эти два класса имеют конструкторы и методы, обеспечивающие чтение. Мы надеемся, что эта статья была вам полезна. Дополнительные советы и руководства см. в других статьях Linux Hint.

Значение узла в дереве называется ключом. Бинарное дерево — это дерево, в котором каждый узел имеет не более двух дочерних элементов. Двоичное дерево поиска (BST) — это дерево, в котором для каждого узла правый дочерний элемент больше или равен левому дочернему элементу. Это приводит к тому, что правая половина дерева имеет значения, обычно превышающие значения левой половины на каждом уровне. Это означает, что бинарное дерево поиска частично отсортировано (тип неполной сортировки). BST можно хранить в структуре, подобной массиву, где корневой узел является первым значением.

Бинарное дерево может быть преобразовано в различные самобалансирующиеся деревья с различными наборами дополнительных условий, такие как дерево AVL и красно-черное дерево.

TreeMap в Java — это красно-черное дерево. Однако каждый узел состоит из ключа и соответствующего значения (пары ключ/значение), а не только из ключа. Каждая пара ключ/значение будет одним элементом в структуре, подобной массиву. В этой статье объясняется, как использовать TreeMap в Java, начиная с двоичного дерева поиска, за которым следует красно-черное дерево, а затем Java TreeMap.

Бинарное дерево поиска

Ниже приведен пример бинарного дерева поиска:

У каждого узла есть ключ. Ключ (значение) для корневого узла равен 8. Левый дочерний узел равен 3, а правый дочерний узел равен 10 (10 >= 3). Можно видеть, что для любого узла, имеющего двух дочерних элементов, правый дочерний элемент больше или равен левому дочернему элементу. Кроме того, правая половина дерева имеет значения, превышающие значения левой половины дерева для каждого уровня.

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

8, 3, 10, 1, 6, , , , 14, 4, 7, , , , , , , 13, ,

Обратите внимание, что массив (дерево) начинается с 8; опускается до 3, затем поднимается выше 8 в 10; снижается до 1, повышается до 6, затем имеет NIL до 14; снижается до 4; повышается до 7; снова NIL; затем 13 и последний NIL.

8 — это первое значение с индексом 0. Это корневой узел (корневой родитель). Это не обязательно самое большое значение среди всех значений. Его первый потомок (3) имеет индекс 1, индекс которого равен 2(0) + 1, где 0 — индекс родителя. Его второй потомок (10) имеет индекс 2, что равно 2(0) + 2, где 0 — индекс родителя.

3 находится в индексе 1. Это родитель. Его первый потомок (1) имеет индекс 3, что равно 2(1) + 1, где 1 — индекс родителя. Его второй потомок (6) имеет индекс 4, что равно 2(1) + 2, где 1 — индекс родителя.

6 находится в индексе 4. Это родитель. Его первый потомок (4) имеет индекс 9, что равно 2(4) + 1, где 4 — индекс родителя. Его второй потомок (7) имеет индекс 10, что равно 2(4) + 2, где 4 — индекс родителя.

10 находится в индексе 3. Это родитель. У него нет первого (левого) потомка, который должен был быть с индексом 7, что равно 2(3) + 1, где 3 — индекс родителя. Его второй потомок (14) имеет индекс 8, что равно 2(3) + 2, где 3 — индекс родителя.

14 находится в индексе 8. Это родитель. Его первый потомок (13) имеет индекс 17, что равно 2(8) + 1, где 8 — индекс родителя. У него нет правого (второго) потомка, который должен был быть с индексом 18, что равно 2(8) + 2, где 8 — индекс родителя.

В общем, поскольку подсчет индексов начинается с 0. Пусть я представляю индекс родителя массива; и поэтому левый (первый) потомок родителя с индексом i имеет индекс 2i + 1; а его правый (второй) дочерний элемент имеет индекс 2i + 2. Некоторые ячейки в массиве могут быть пустыми; они не должны иметь значений.

Красно-черное дерево

Красно-черное дерево — это сбалансированное бинарное дерево поиска. Ниже приведено уже сбалансированное красно-черное дерево:

Сбалансированное дерево – это дерево небольшой высоты. Позиции узлов изменены и отмечены красным и синим цветами, чтобы иметь наименьшую возможную высоту дерева в его развитии.

Используя формулы 2i + 1 и 2i + 2, значения можно поместить в структуру, подобную массиву, следующим образом:

13, 8, 17, 1, 11, 15, 25, , 6, , , , , 22, 27

Обратите внимание, что массив начинается с 13, опускается до 8 и затем повышается до 17. Затем он опускается за пределы 8 до 1, а затем повышается до 11, затем до 15, затем до 25; от которого идет NIL, а затем опускается до 6. Перед 22 и 27 следуют NIL.

Массив сбалансированного дерева, такой как красно-черное дерево выше, имеет меньше NIL, чем его соответствующее несбалансированное двоичное дерево поиска. Длина массива сбалансированного дерева короче, чем у соответствующего несбалансированного дерева.

Красно-черное дерево — это частично упорядоченное дерево.

Пары ключ/значение для Java TreeMap

Предыдущее красно-черное дерево имеет только ключи в качестве значений узлов. Каждому целочисленному ключу может быть присвоено соответствующее строковое значение. В следующем списке есть те же ключи с соответствующими значениями:

13/thirteen, 8/eight, 17/seventeen, 1/one, 11/eleven, 15/fifteen, 25/twenty-five, 6/six, 22/twenty-two, 27/twenty-seven

Это пары ключ/значение, подходящие для Java TreeMap. Каждому ключу будет сопоставлено соответствующее значение. Пара ключ/значение называется записью карты в Java. Для Java TreeMap расположение узлов осуществляется по ключам (а не по значениям пар ключ/значение). Каждый ключ сопоставляется со своим значением.

Создание карты Java TreeMap

В Java TreeMap — это класс в пакете java.util.*, который следует импортировать. Этот класс имеет четыре конструктора, и в этой статье проиллюстрированы два конструктора.

Публичная древовидная карта ()

Это создает пустой TreeMap. Следующий сегмент кода иллюстрирует это:

TreeMap<Integer,String> tm = new TreeMap<Integer,String>();



tm.put(13, "thirteen"); tm.put(8, "eight"); tm.put(17, "seventeen"); tm.put(1, "one");



tm.put(11, "eleven"); tm.put(15, "fifteen"); tm.put(25, "twenty-five"); tm.put(6, "six");



tm.put(22, "twenty-two"); tm.put(27, "twenty-seven");

Метод put() включает пары ключ/значение в TreeMap. После всего этого TreeMap становится сбалансированным внутри.

Public TreeMap (Map<? extends K,? extends V> m)

Этот метод конструктора создает карту из другой уже созданной карты, как в следующем фрагменте кода:

TreeMap<Integer,String> tm = new TreeMap<Integer,String>();



tm.put(13, "thirteen"); tm.put(8, "eight"); tm.put(17, "seventeen"); tm.put(1, "one");



tm.put(11, "eleven"); tm.put(15, "fifteen"); tm.put(25, "twenty-five"); tm.put(6, "six");



tm.put(22, "twenty-two"); tm.put(27, "twenty-seven");



TreeMap<Integer,String> tm1 = new TreeMap<Integer,String>(tm);

tm1 создается из tm. После всего этого оба TreeMaps внутренне сбалансированы; с первым сбалансированным первым. Балансировка происходит, поскольку ключи включают пары.

Методы карты дерева Java

Публичный V put (ключ K, значение V)

Строго говоря, метод put() не добавляет пару ключ/значение. Он связывает определенное значение с определенным ключом. Если ключ уже существовал в TreeMap с другим значением, значение заменяется новым. Этот метод возвращает старое значение или ноль, если старого значения не было. Применение этого метода было продемонстрировано выше.

Публичный размер()

Этот метод возвращает количество сопоставлений ключ/значение (пар) в TreeMap. Следующий фрагмент кода показывает, как его использовать:

int it = tm.size();



System.out.println(it);

Результат равен 10, что указывает на то, что в этом объекте TreeMap имеется 10 пар ключ/значение.

Public V get (ключ объекта)

Этот метод возвращает значение, соответствующее аргументу, который является ключом. Возвращает null, если ключ не существует. Следующий код иллюстрирует это для пары ключ/значение: 11/»eleven» и для ключа 40, которого не существует:

String val = tm.get(11); String str = tm.get(40);



System.out.print(val + ", "); System.out.print(str + " ");



System.out.println();

Результат:

eleven, null

Set<Integer> st = tm.keySet();



Iterator<Integer> iter = st.iterator();



while (iter.hasNext()) {



System.out.print(iter.next() + ", ");



}



System.out.println();





Результат:

1, 6, 8, 11, 13, 15, 17, 22, 25, 27,

Collection<String> col = tm.values();



Iterator<String> iter = col.iterator();



while (iter.hasNext()) {



System.out.print(iter.next() + ", ");



}



System.out.println();





Результат:

one, six, eight, eleven, thirteen, fifteen, seventeen, twenty-two, twenty-five, twenty-seven,

Set<Map.Entry<Integer,String>> pairs = tm.entrySet();



Iterator<Map.Entry<Integer,String>> iter = pairs.iterator();



while (iter.hasNext()) {



Map.Entry<Integer,String> etry = iter.next();



int in = etry.getKey(); String str = etry.getValue();



System.out.println(in + " => " + str);



}

1 => one



6 => six



8 => eight



11 => eleven



13 => thirteen



15 => fifteen



17 => seventeen



22 => twenty-two



25 => twenty-five



27 => twenty-seven

Рекурсия в Java — это вызов метода методом внутри метода. Это действие повторяется до тех пор, пока не будет выполнено условие. Метод должен быть методом в классе, отличном от метода в основном классе. Основной класс — это класс, который имеет метод main(). Имя файла Java совпадает с именем основного класса. Статический метод в основном классе все еще можно сделать рекурсивным, но в этой статье это не рассматривается. В этой статье объясняется рекурсия в Java с тремя хорошими примерами.

Подсчет целых чисел от нуля

Рассмотрим файл Java с двумя классами: закрытый класс следующим образом:

class AClass {

        void mthd (int no) {

System.out.print(no); System.out.print(' ');

            no = no + 1;

            if (no < 5)

mthd(no);

        }

    }

Метод, который будет вызывать сам себя, mthd(). Он имеет параметр «int no». Метод находится в классе AClass. Этот метод считает от 0 до 4. Первая строка метода содержит два утверждения. Первый печатает параметр no. Второй печатает пробел справа от напечатанного параметра. В следующей строке к номеру добавляется 1. Следующая строка представляет собой составной оператор if. Есть условие, которое должно быть выполнено. Условие, которое должно быть выполнено, это когда no достигает 5. Если 5 не достигнуто, «mthd(no);» называет себя без добавления 1 к нему.

Основным классом для этого метода может быть,

public class TheClass {

        public static void main(String[] args) {

            int num = 0;

AClass obj = new AClass();

obj.mthd(num);

System.out.println();

        }

    }

Первый оператор в методе main() объявляет целое число, num присваивая ему ноль. Для вызова метода объект должен быть создан из своего класса. Следующий оператор в методе main() создает экземпляр объекта obj из AClass. Оператор after использует этот объект для вызова метода mthd(), передавая ему аргумент num, равный 0. Это начало отсчета. Последний оператор в методе main() печатает новую строку после того, как весь результат был напечатан. Результат:

0 1 2 3 4

Рекурсивный метод mthd() вызывается в первый раз из метода main(). После этого он продолжает вызывать себя, пока не будет выполнено условие.

Такой подсчет можно сделать для любого диапазона. Чтобы достичь этого для любого диапазона, начальный номер диапазона должен быть присвоен num. Вместо 5 для условия if в методе следует ввести число сразу после диапазона.

Добавление диапазона непрерывных заданных чисел

Рассмотрим цифры:

10, 20, 30, 40, 50, 60

Сумма первых 4-х чисел равна 100. То есть: 10+20=30; 30 + 30 = 60; и 60 + 40 = 100. Рекурсивный метод может состоять в добавлении этих чисел к возрастающей сумме до тех пор, пока сумма не станет меньше или равной 100. Чтобы сложить первые пять чисел, рекурсивный метод может состоять в добавлении чисел к возрастающей сумме. sum до тех пор, пока сумма не станет меньше или равна 150.

Стратегия состоит в том, чтобы иметь все эти числа в массиве в методе main(). Затем передайте массив в качестве аргумента рекурсивному методу. Если требуется сложение первых четырех чисел, то при достижении суммы 100 рекурсивный метод должен перестать вызывать себя. Если требуется сложение первых пяти чисел, то при достижении суммы 150 рекурсивный метод должен перестать вызывать себя. Если требуется сложение первых шести чисел, то при достижении суммы 210 рекурсивный метод должен перестать вызывать себя.

Класс для этого рекурсивного метода может быть:

    class AClass {

        int sum = 0, i = 0;

        void mthd (int[] arry) {

            sum = sum + arry[i];

i = i + 1;

            if (sum < 100)

mthd(arry);

        }

    }

Это для сложения первых четырех чисел. В классе есть два поля: sum и i. i предназначен для перебора массива, начиная с индекса 0. Первый оператор рекурсивного метода, mthd(), добавляет следующее число к сумме, которая изначально равна нулю. Следующий оператор увеличивает i на 1 для следующего индекса массива следующего вызова. Оператор после является составным оператором if. Условие здесь — сумма не должна быть выше 100. Итак, при каждом вызове того, что сумма не до 100 (или выше), метод вызывается снова, передавая тот же массив. В этой ситуации условие находится в конце реализации метода.

Класс main() для этого может быть:

public class TheClass {

        public static void main(String[] args) {

int[] arr = new int[]{10, 20, 30, 40, 50, 60};

AClass obj = new AClass();

obj.mthd(arr);

System.out.println(obj.sum);

        }

    }

Первый оператор в методе main() создает экземпляр массива с его элементами. Второй оператор создает экземпляр объекта для AClass. Оператор после вызывает рекурсивный метод, передавая массив в качестве аргумента. Это первый вызов рекурсивного метода. После этого метод будет вызывать сам себя до тех пор, пока не будет достигнута необходимая сумма. Последний оператор печатает окончательную сумму. Выход для этого случая равен 100.

Факториал

Факториал 0, записанный как 0!, равен 1. Факториалы 5, 4, 3, 2, 1 следующие:

Factorial of 5 = 5 X 4 X 3 X 2 X 1 X 0! = 120



Factorial of 4 = 4 X 3 X 2 X 1 X 0! = 24



Factorial of 3 = 3 X 2 X 1 X 0! = 6



Factorial of 2 = 2 X 1 X 0! = 2



Factorial of 1 = 1 X 0! = 1

Программу можно написать так, что когда число передается рекурсивному методу, рекурсивный метод, в конце концов, возвращает результирующий факториал. Обратите внимание, что факториал можно вычислить до 1 вместо 0, и результат останется тем же.

Класс для рекурсивного метода может быть:

    class AClass {

        int mthd (int no) {

          if (no == 1)      

            return 1;

          else      

return(no * mthd(no-1));    

        }

    }

Все тело метода представляет собой составное условие if. Если число, факториал которого необходим, равно 1, то будет возвращено 1, так как факториал 1 равен 1. Если число больше 1, то все умножения должны быть выполнены, начиная с самого числа, уменьшившись на 1 единицу.

Результат получается, когда все умножение сделано. Возвращаемое выражение здесь является вызовом метода. Его аргумент является произведением числа и рекурсивного метода.

Предположим, что число, факториал которого нужен, равно 5, тогда аргумент первого обратного вызова будет:

5 X mthd(4)

Это выражение будет зарезервировано в памяти, и следующий вызов будет

5 X 4 X mthd(3)

Это выражение будет зарезервировано в памяти, и следующий вызов будет

5 X 4 X 3 X mthd(2)

Это выражение будет зарезервировано в памяти, и следующий вызов будет

5 X 4 X 3 X 2 X mthd(1)

Теперь mthd(1) возвращает 1 из-за оператора if-part «if (no == 1) return 1;», в результате чего

5 х 4 х 3 х 2 х 1 = 120

для окончательного возвращаемого значения.

Основным классом для этого может быть:

public class TheClass {

        public static void main(String[] args) {

AClass obj = new AClass();

            int ret = obj.mthd(5);

System.out.println(ret);

        }

    }

С аргументом 5 для первого вызова в методе main() окончательное возвращаемое значение равно 120.

Вывод

Рекурсия в Java — это вызов метода методом внутри метода. Это действие повторяется до тех пор, пока не будет выполнено условие.

Обрезка — это процесс манипулирования строкой, который используется для того, чтобы сделать вашу строку более четкой и лаконичной за счет удаления из нее ненужных частей. Метод обрезки в Java позволяет нам обрезать лишние пробелы в начале и в конце строки. В этой статье мы предоставим вам подробное руководство о том, как можно обрезать строку с помощью языка программирования Java.

Как обрезать лишние пробелы из строки с помощью Java

Мы инициализируем публичный класс, в котором будет написан весь код, как показано ниже:

Для этого примера в основной функции мы определили некоторый текст в java с некоторыми дополнительными пробелами, которые мы собираемся обрезать в более позднем коде.

String str1 ="        Эта строка содержит дополнительные пробелы.       ";

Если вы хотите найти общую длину строки, вы можете сделать это, набрав:

int n=str1.length();

Теперь мы собираемся отобразить строку вместе с ее длиной, как показано ниже.

System.out.println("Строка: "+ str1);

System.out.println("Длина: "+ n);

В Java есть встроенная функция trim(), которую можно использовать для обрезки ненужного пробела в строке, и для нашего кода мы можем использовать ее, набрав:

В приведенном выше коде строка хранится в переменной «str1», поэтому мы собираемся обрезать ее, набрав str1.trim(), а затем сохранив результат в новой переменной «str2» . Теперь, после обрезки, мы также собираемся найти новую длину строки, и для этого мы использовали функцию str2.length() и сохраняем результат внутри переменной «n» . После этого мы также собираемся отобразить новый результат на экране с помощью функции System.out.println() :

System.out.println("После обрезки, строка: "+ str2 );

System.out.println("Длина обрезанной строки: "+ n);

Полный код:

public class StringTrim {

    public static void main(String[] args) {

        System.out.println("Пример обрезки строки n");

        //Объявить строку

        String str1 ="        Эта строка содержит дополнительные пробелы.       ";

        int n=str1.length();    //Эта строка возвращает длину строки в переменную n

        System.out.println("Строка: "+ str1);

        System.out.println("Длина: "+ n);

        String str2=str1.trim();

        n=str2.length();

        System.out.println("После обрезки, строка: "+ str2 );

        System.out.println("Длина обрезанной строки: "+ n);

        //Все пробелы, такие как пробел, символ новой строки (n), tab (t)

        //которые присутствуют в начале или в конце строки, удаляются.

    }  

}

Терминал в операционной системе Linux обеспечивает простейший способ реализации и выполнения кода с использованием языка программирования Java. Во-первых, вам нужно создать java-файл с помощью терминала, набрав:

$ nano StringTrim.java

Следующим шагом является написание и сохранение кода в файле Java.

Примечание. Вам необходимо установить приложение комплекта разработки Java (JDK) для выполнения программ на основе Java, набрав:

$ sudo apt install default-jdk

После сохранения файла вам нужно сначала скомпилировать его, а затем вы можете выполнить его, набрав:

$ javac StringTrim.java

$ java StringTrim