Какой длины ваша строка? — JavaTutor.net

Какой длины ваша текстовая строка? Вам понадобится ответ на этот вопрос, чтобы проверить допустимые ли данные ввел пользователь в поле данных ограниченной длины. Текстовое поле баз данных обычно ограничивают входные данные определенной длиной, так что вам надо сначала подтвердить длину текста, прежде чем отправить его. Какова бы ни была причина, нам всем иногда необходимо узнать длину текстового поля. Чтобы получить эту информацию, многие программисты используют метод length объекта String. И в большинстве случаев метод length обеспечивает правильный результат. Однако, это не единственный и не всегда верный способ узнать длину объекта String.

По крайней мере у вас есть три общих способа измерить длину текста, если вы используете платформу Java:

1. количество знаков char в коде
2. количество символов (characters) или кодовых единиц
3. число байтов

Подсчет знаков

char

В платформе Java используется Unicode Standard для определения символов. Unicode Standard определяет и фиксирует для каждого символа значение, состоящее из 16 битов, в пределе от U+0000 до U+FFFF. Префикс U+ означает допустимое значение в Юникоде как шестнадцатеричное число. В языке Java стандарт фиксированного размера символов удобно преобразуется в тип char. Таким образом значение char может быть представлено любым символом в 16-битном Юникоде.

Большинство программистов знакомы с методом length. Код, приведенный ниже, считает количество знаков char в примере строки. Обратите внимание, что пример объекта String содержит несколько простых символов и несколько символов, определенных в \u нотации языка Java. \u нотация определеяет шестнадцатеричное число и является аналогом нотации U+, используемой Unicode Standard.

private String testString = "abcd\u5B66\uD800\uDF30";
int charCount = testString.length();
System.out.printf("char count: %d\n", charCount);

Метод length считает количество знаков char в объекте String. Вот что выведет этот код:

Подсчет символов

Когда Unicode версии 4.0 определяет важные новые символы выше U+FFFF, 16-битный тип char не может более представлять все символы. Начиная с Java 2 Platform, Standard Edition 5.0 (J2SE 5.0), платформа Java поддерживает новые символы Юникода — пары 16-битных знаков char, которые называются
суррогатными парами (surrogate pair). Два знака char действуют как суррогатное представление символов Юникода в диапазоне от U+10000 до U+10FFFF. Символы в таком новом диапазоне называются дополнительные символы (supplementary characters).

Хотя единичный знак char все еще может представлять значение в Юникоде более U+FFFF, только суррогатная пара из двух char может представлять дополнительные символы. Главное или бóльшее значение в паре лежит в диапазоне от U+D800 до U+DBFF. Следующее или меньшее — от U+DC00 до U+DFFF. Unicode Standard
выделил два этих диапазона, чтобы специально использовать в суррогатных парах. Стандарт также определяет алгоритм для преобразования между суррогатными парами и символами, значения которых лежат выше U+FFFF. Используя суррогатные пары, программисты могут представить любой символ в Unicode Standard. Такое специальное использование 16-битных знаков называется UTF-16, и Java Platform пользуется UTF-16 для представления символов в Юникоде. Теперь тип char — это знак в коде UTF-16, необязательно целый символ Юникода (кодовая единица).

Метод length не может считать дополнительные символы, так как он считает только знаки char. К счастью в J2SE 5.0 API есть новый метод String:
codePointCount(int beginIndex, int endIndex). Этот метод показывает, сколько единиц Юникода (символов) между двумя индексами. Значения индексов ссылаются на код, обозначающий местоположение знака char. Значение выражения endIndex - beginIndex такое же как и значение, полученное с помощью метода length. Но это не всегда равно значению, возвращаемому методом codePointCount. Если ваш текст содержит суррогатные пары, вычисляемая длина сильно изменится. Суррогатная пара определяет код одного символа, который может состоять из одного или двух знаков char.

Чтобы узнать, сколько символов Юникода в строке, используйте метод codePointCount:

private String testString = "abcd\u5B66\uD800\uDF30";
int charCount = testString.length();
int characterCount = testString.codePointCount(0, charCount);
System.out.printf("character count: %d\n", characterCount);

Этот пример выведет следующее:

Переменная testString содержит два интересных символа: японский иероглиф, обозначающий «учение», и буква готского алфавита А (GOTHIC LETTER AHSA). Японский иероглиф в Юникоде имеет значение U+5B66 и такой же номер знака char в шестнадцатеричной системе \u5B66. Значение готской буквы — U+10330. В UTF-16 готская буква состоит из суррогатной пары \uD800\uDF30. Пара представляет один целый символ в Юникоде, таким образом число символов в строке равно 6, а не 7.

Подсчет байтов

Сколько байт в строке String? Ответ зависит от использованной кодировки. Одной из наиболее распространенных причин спрашивать «сколько байт?» является желание убедится, что вы удовлетворили ограничением на длину строки в базе данных. Метод getBytes преобразует символы Юникода в байтовую кодировку (в кодировку, работающую не с символами, а байтами) и возвращает количество байт: byte[]. Одной из байтовых кодировок является UTF-8. Это самая распространенная байтовая кодировка, потому что может точно представлять символы Юникода.

Далее представлен код, который преобразует текст в массив байтовых значений:

byte[] utf8 = null;
int byteCount = 0;
try {
  utf8 = str.getBytes("UTF-8");
  byteCount = utf8.length;
} catch (UnsupportedEncodingException ex) {
  ex.printStackTrace();
}
System.out.printf("UTF-8 Byte Count: %d\n", byteCount);

Наш набор символов определяет, сколько создано байтов. Кодировка UTF-8 преобразует один символ Юникода в один или несколько (до 4) 8-битовых единиц (байтов). Символы a, b, c и d требуют всего четыре байта. Японский иероглиф превращается в три байта. А готская буква занимает четыре байта. Вот каким будет результат:

Рисунок
1. Строки имеют различную длину, зависящую от того, что вы считаете.

В заключение

Даже используя дополнительные символы, вы никогда не увидите разницу между возвращаемыми значениями метода length и метода codePointCount. Однако, когда вы используете символы выше U+FFFF, вам пригодится умение определять длину различными способами. Если вы будете посылать свои продукты в Японию или Китай, то наверняка попадете в ситуацию, когда методы length и codePointCount вернут различные значения. Базы данных и некоторые форматы публикаций поощряют использование в качестве кодировки UTF-8. Но даже в этом случае измерение длины текста может дать различные результаты. В зависимости от того, как вы будете использовать длину, у вас есть различные способы ее измерить.

Дополнительная информация

Используйте эти ресурсы, чтобы найти информацию по теме данного технического совета:

http://java.sun.com/mailers/techtips/corejava/2006/tt0822.html#1

Java длина строки массива

Содержание

Описание

Метод length() — возвращает длину строки в Java. Длина равна числу 16-разрядных символов Юникода в строке.

Синтаксис

Синтаксис этого метода:

Параметры

Подробная информация о параметрах:

Возвращаемое значение

• В Java length() возвращает длину последовательности символов, представленного этим объектом.

Пример 1: определение в Java длины строки

Ниже представлен пример метода length(), который поможет определить длину строки.

Получим следующий результат:

Пример 2: сравнение длины строк

Также с помощью метода length() можно не только узнать длину строки, но и сравнить длину строк. Ниже представлен пример как это можно сделать.

Все, что мне нужно знать, – это найти длину строки внутри массива. Я также хотел бы знать, как найти строку, которая сначала начинается в алфавитном порядке в массиве.

Это позволит получить доступ к строке в местоположении 0, а затем получить ее длину.

Кроме того, для сортировки по алфавиту вы можете использовать

Вы можете просто использовать метод .length для любого элемента массива строк, чтобы получить его длину. И для сортировки этого массива в алфавитном порядке вы используете метод .sort –

Поэтому после сортировки strings[0] будет Example и string[0].length() будет равна 7

Не могли бы вы рассказать мне, как получить размер зарезервированного массива?

Я знаю, что это большой массив.

Я размещаю там данные и хочу получить размер данных третьего элемента.

arr_list[0][0].length – но он все равно возвращает 10 .

Но на [0][0] меня есть только 4 значения:

Как вернуть 4 , а не 10 ?

Массивы представляют собой контейнеры постоянного размера, они всегда имеют объявленную длину, поэтому вы всегда получите 10.

Вместо этого используйте List s (например, ArrayList ).

Вы инициализировали массив 5d. размер 1-го измерения – 2,2d – 10 3d – 10 4d – 2, а размер 5-й – 5.

поэтому общий размер будет 2 * 10 * 10 * 10 * 2 * 5 = 20 000, если вы оставите их пустыми. Они будут автоматически заполнены нулевыми символами. если вы хотите рассчитать размер. вы можете найти, где первый нулевой символ, и подсчитать элементы до него

Если вы инициализируете массив с new String[2][10][10][2][5] вы явно сказали системе, что хотите, чтобы arr_list [0] [0] имел 10 элементов. Я боюсь, что вам поверит, и создадим массив из 10 элементов.

Если вы хотите, чтобы размер изменялся в зависимости от количества фактического элемента, вам необходимо инициализировать его динамически.

public static String arr_list[][][][][]= new String[2][][][][]; создает arr_list с двумя нулевыми ссылками типа String[][][][] . Затем вы можете инициализировать каждый из них массивами, содержащими количество элементов, которые вам действительно нужны на следующем уровне, и так далее.

Подушка на стул OHIO, стул типа » Java» водоустойчива, ширина 39cм, длина 39cм, толщина 2,5cм, ткань 120, 100% полиэстер

УХОД: при загрязнении изделия использовать моющее средство и прополоскать проточной водой

Условия доставки покупок из магазина Alfashop.ee

Доставка товаров осуществляется курьером или в терминалы SmartPost.

Во время оформления заказа вы сможете выбрать доставку из следующих вариантов:

• Смартпост (если позволяют размеры товара) — цена от 3.5EUR до 6.90EUR
• Курьер — в зависимости от веса товара — цена от 3.5EUR до 14.90EUR
• Также можно выбрать доставку с заносом в квартиру и выносом старой техники (доступно только в Таллинне и ближайших пригородах.
• Самовывоз со склада — бесплатно.

В некоторых случаях при заказе будет доступна только курьерская доставка.

Время доставки:

В общем случае доставка осуществляется в течении 1-4 рабочих дней.

Однако, так как большая часть товаров находится на складах в Таллинне, эти товары доставляются в течении 1-3 рабочих дней.

Также во многих случаях, при желании, клиент может получить товар прямо со склада в тот же день.  

Некоторые товары имеют и более длительные сроки поставки, о чем указано на странице конкретного товара.

Более подробную информацию о доставке найдете 

здесь

Услуга заноса тяжелой техники и вывоз старой техники:

Мы также предлагаем за дополнительную плату услугу заноса тяжелой техники в квартиру (от 25EUR) и вынос (10EUR) старой техники (Занос и вынос возможен только в Таллинне и ближайших пригородах). Для заказа необходимо связаться по эмейлу — [email protected]

NB! Теперь у нас можно оплачивать покупки также и при получении прямо курьеру (только наличными).

Данный способ оплаты доступен при оформелнии заказа, но не на все товары. Больше информации о способах оплаты найдете здесь.

Почему java String.length дает другой результат, чем python len () для той же строки Ru Python

У меня есть строка, подобная следующей

("استنفار" OR "الأستنفار" OR "الاستنفار" OR "الإستنفار" OR "واستنفار" OR "باستنفار" OR "لستنفار" OR "فاستنفار" OR "والأستنفار" OR "بالأستنفار" OR "للأستنفار" OR "فالأستنفار" OR "والاستنفار" OR "بالاستنفار" OR "فالاستنفار" OR "والإستنفار" OR "بالإستنفار" OR "للإستنفار" OR "فالإستنفار" OR "إستنفار" OR "أستنفار" OR "إلأستنفار" OR "ألأستنفار" OR "إلاستنفار" OR "ألاستنفار" OR "إلإستنفار" OR "ألإستنفار") (("قوات سعودية" OR "قوات سعوديه" OR "القوات سعودية" OR "القوات سعوديه") OR ("القواتالسعودية" OR "القواتالسعوديه" OR "إلقواتالسعودية" OR "ألقواتالسعودية" OR "إلقواتالسعوديه" OR "ألقواتالسعوديه")("القوات السعودية" OR "إلقوات السعودية" OR "ألقوات السعودية" OR "والقوات السعودية" OR "بالقوات السعودية" OR "للقوات السعودية" OR "فالقوات السعودية" OR "وإلقوات السعودية" OR "بإلقوات السعودية" OR "لإلقوات السعودية" OR "فإلقوات السعودية" OR "وألقوات السعودية" OR "بألقوات السعودية" OR "لألقوات السعودية" OR "فألقوات السعودية") OR )

Если я использовал строковую переменную java и подсчитал количество символов, она дает мне 923, но если бы я использовал функцию len python, это дало мне 1514

В чем тут разница?

Похоже, в python (2. x) вы считаете длину байта, а не количество символов.

Преобразуйте байтовую строку в объект unicode с помощью str.decode , затем подсчитайте символы:

 len(byte_string_object.decode('utf-8')) 

Вам также может понадобиться снять пространственные пространства:

 len(byte_string_object.decode('utf-8').strip()) 

 >>> len('استنفار') # string (byte-string) literal 14 >>> len(u'استنفار') # unicode literal 7 >>> len('استنفار'.decode('utf-8')) # string -> unicode 7 

Это потому, что вы используете python (2.x). В python (2.x) строки по умолчанию байты, в то время как в python (3.x) они по умолчанию unicode и одинаковы с java. Например, если вы откроете интерпретатор python3 и введите

 len("استنفار") 

Вы получите 7, а если вы введете ту же строку в интерпретатор python2, вы получите 14

Если вы используете u «» перед строкой, что означает unicode в python2.x, то вы, возможно, получите тот же результат с Java

Найдите длину связанного списка в java

package org.arpit.java2blog;

класс Node {

общедоступные данные int;

публичный узел следующий;

public void displayNodeData () {

System.out.println («{» + data + «}»);

}

}

публичный класс SinglyLinkedList {

голова частного узла;

public boolean isEmpty () {

return (head == null);

}

// используется для вставки узла в начало связанного списка

public void insertFirst (int data) {

Node newNode = new Node ();

новый узел.data = данные;

newNode.next = голова;

head = newNode;

}

// Найдите длину связанного списка с помощью итеративного метода

public int lengthOfLinkedList ()

{

Node temp = head;

int count = 0;

while (temp! = Null)

{

temp = temp. next;

счет ++;

}

счетчик возврата;

}

// Найдите длину связанного списка с помощью рекурсии

public int lengthOfLinkedListRec (Node head)

{

Node temp = head;

if (temp == null)

{

return 0;

}

else

{

return 1+ lengthOfLinkedListRec (temp.следующий);

}

}

// используется для удаления узла из начала связанного списка

public Node deleteFirst () {

Node temp = head;

head = head.next;

температура возврата;

}

// используется для удаления узла из начала связанного списка

public Node deleteFirst (Node node) {

Node temp = head;

head = head.next;

температура возврата;

}

// Используется для удаления узла после определенного узла

public void deleteAfter (Узел после) {

Node temp = head;

в то время как (темп.следующий! = null && temp.data! = after.data) {

temp = temp.next;

}

if (temp.next! = Null)

temp.next = temp.next.next;

}

// используется для вставки узла в начало связанного списка

public void insertLast (int data) {

Node current = head;

в то время как (current.next! = Null) {

current = current.next; // мы будем зацикливаться, пока current.next не станет нулевым

}

Node newNode = new Node ();

новый узел.data = данные;

current.next = newNode;

}

// Для печати связанного списка

public void printLinkedList () {

System.out.println («Печать LinkedList (заголовок -> последний)»);

Ток узла = напор;

в то время как (текущий! = Ноль) {

current.displayNodeData ();

текущий = текущий.следующий;

}

System.out.println ();

}

}

Длина строки в Java: определение длины строки

Длина строки в Java — это общее количество символов Юникода в строке. В этом руководстве вы узнаете, как найти длину строки в Java, а также с примерами.

Какой метод используется для определения длины строки в Java?

Класс Java String предоставляет переопределенный метод length (), указанный в интерфейсе CharSequence. Длина строки в Java используется для вычисления длины указанной строки.

Синтаксис метода Java String Length ():

Ниже описан общий синтаксис использования метода Java string length ().

общедоступная длина int ()

Как видно из синтаксиса, длина строки в Java не принимает никаких параметров. Внутренняя реализация метода length ():

длина общедоступного интервала () {

возвращаемое значение.длина;

}

Возвращаемое значение длины строки Java

Метод length () возвращает целочисленное значение, определяющее длину строки в символах Юникода.

Курс для разработчиков Java Full Stack

The Gateway to Master Web DevelopmentExplore Course

Длина строки в примерах Java

Поскольку теперь вы знаете, что такое длина строки в Java, и метод, используемый для определения длины, взгляните на некоторые из этих примеров и посмотрите, как это работает.

Определение длины нулевой строки

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

Как видно из результата, длина нулевого значения всегда равна 0, как вы, возможно, уже догадались.

Определение длины отдельного слова

Давайте воспользуемся длиной строки в Java, чтобы узнать, какова длина «Simplilearn» и «Java».

Определение длины нескольких слов в строке

Теперь пора определить длину строки, состоящей из нескольких слов.

Как вы можете видеть в приведенном выше примере, длина строки в Java рассматривает «» и другие специальные символы как единицу и увеличивает длину на единицу для каждого экземпляра специального символа.

БЕСПЛАТНЫЙ тренинг по сертификации Java

Изучите Java от А до Я, как никогда раньше

Определение длины строки в Java с помощью операторов If и Else

В приведенном ниже примере вы должны объявить две строки. Одна строка имеет нулевое значение, а другая — «Simplilearn.«Вам нужно будет написать операторы if… else для отображения длины строки в Java.

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

Подводя итоги

Это руководство помогло вам понять длину строки в Java. Вы можете обратиться к руководству Simplilearn’s Java Tutorial for Beginners, чтобы узнать о других методах, доступных в классе Strings.Помимо класса Strings, он также поможет вам узнать о массивах, концепциях ООП и многом другом. Вы также можете выбрать наш онлайн-курс сертификации Java, чтобы понять все основные и расширенные концепции программирования Java и стать сертифицированным разработчиком.

У вас есть к нам вопросы? Оставьте их в комментариях к этой статье. Наши специалисты свяжутся с вами в ближайшее время.

Удачного обучения!

Калькулятор длины строки | Легко подсчитайте длину текста

Введите текст и нажмите «Рассчитать!»:

Ознакомьтесь с другими нашими инструментами!

Инструменты для работы с строкой просмотра

Рассчитайте длину строки текста или цифр, чтобы проверить число
символов, которые он содержит! Использование нашего онлайн-инструмента подсчета символов
быстро и просто! Этот инструмент отлично подходит для компьютерных программистов, веб-
разработчики, писатели и другие программисты.

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

Что такое персонаж в вычислениях?

Для компьютера персонаж — это единая единица информации. Для людей
иероглиф можно рассматривать как наименьшую форму компьютерного письма
система. Даже самые маленькие части предложения, строки текста или чисел
считается персонажем.Персонажи включают:

• Цифры (413 = 3 символа)
• Буквы (вода = 5 символов)
• Символы ($ @% * = 4 символа)
• Распространенные знаки препинания (. «; = 3 символа)
• Пробелы или пробелы (= 5 символов)
• Управляющие символы (кодовая точка или число, не представляющее
  письменный символ)

Например, в следующей строке текста 74 экземпляра
соответствуют приведенным выше классификациям персонажа, поэтому длина этого
строка текста будет состоять из 74 символов:

«Используйте калькулятор длины строки для удобства и экономии
время!»

Не стесняйтесь протестировать калькулятор длины строки с этой строкой текста!

Где можно использовать инструмент подсчета символов?

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

Например, многие люди знакомы с ограничениями персонажей, когда
взаимодействие с Интернетом, например, бывшие 140, а теперь 280 символов
ограничение, установленное Twitter для твитов, размещаемых на его платформе. Должное
к письмам, отправляемым и получаемым по технологии, символы больше
важно отслеживать, чем слова.

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

В компьютерном программировании символы собираются вместе в строки,
которые представляют собой типы данных, которые часто реализуются в байтах данных, которые могут
быть прочитанными компьютерами. С онлайн-активностью и использованием Интернета
платформы расширяются, инструменты подсчета символов могут использоваться все больше и больше для
эффективно управлять компьютерными программами и веб-приложениями,

Как найти длину строки с помощью инструмента подсчета символов

Наш счетчик символов — отличный инструмент для быстрого определения длины
ваша строка текста или чисел.Чтобы использовать инструмент, введите текст, который вы
хотите рассчитать длину символа, а затем нажмите «Рассчитать!»

Количество символов в строке текста или букв отобразится.
под кнопкой «Рассчитать».

У нас также есть другие инструменты для письма

для подсчета количества слов

а также

преобразование строки текста

в верхний, нижний или собственный регистр.Добавьте эти инструменты в закладки, чтобы
доступ и для увеличения вашей производительности!

Пример длины Java ArrayList — Примеры кода Java

Пример длины Java ArrayList показывает, как получить длину ArrayList. В примере также показано, как получить размер или длину ArrayList с помощью метода размера.

Как получить длину ArrayList в Java (размер ArrayList)?

Чтобы получить длину ArrayList, используйте метод size для ArrayList.

Этот метод возвращает количество элементов в ArrayList. Он возвращает 0, если ArrayList пуст.

Пример

Выход

9 Размер

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

Выход

Этот пример является частью ArrayList.

Пожалуйста, дайте нам знать ваше мнение в разделе комментариев ниже.

Длина строки — JavaScript | MDN

Свойство length объекта String содержит длину строки в единицах кода UTF-16. 53 — 1 элементов.Ранее максимальная длина не указывалась. В Firefox максимальная длина строк составляет 2 ** 30 - 2 (~ 1 ГБ). В версиях до Firefox 65 максимальная длина была 2 ** 28 - 1 (~ 256 МБ).

Для пустой строки длина равна 0.

Статическое свойство String.length не связано с длиной строк, это арность функции String (грубо говоря, количество формальных параметров, которые она имеет), которая равна 1.

Поскольку длина считает код единиц вместо символов, если вы хотите получить необходимое количество символов примерно так:

  function getCharacterLength (str) {
  
  
  возвращаться [...str] .length;
}

console.log (getCharacterLength ('A \ uD87E \ uDC04Z'));



Object.defineProperty (String.prototype, 'charLength', {
  получать () {
    return getCharacterLength (это);
  }
});

console.log ('A \ uD87E \ uDC04Z'.charLength);
  

Базовое использование

  let x = 'Mozilla';
let empty = '';

console.log (x + 'равно' + x.length + 'длина кодовых единиц');


console.log ('Пустая строка имеет длину' + empty.length);
  

Присвоение длине

  let myString = "bluebells";


myString.длина = 4;
console.log (myString);

console.log (myString.length);

  

Таблицы BCD загружаются только в браузере

Целые числа переменной длины

Кодирование целых чисел переменной длины — это алгоритм сжатия целых чисел фиксированной длины в целые числа переменной длины для экономии места, когда вы хотите хранить или передавать числа.

В этом сообщении блога мы рассматриваем реализацию varint для сжатия int , типа данных, который в Java имеет фиксированную длину 32 бита (4 байта).

Те же алгоритмы могут быть применены к типу данных long (64 бит); однако в этом сообщении в блоге я сосредоточен исключительно на типе данных int .

Если вы посмотрите на двоичное представление int 300, вы увидите, что первые два байта не содержат никакой информации, и только последние два байта необходимы для представления числа 300.

  00000000 00000000 00000001 00101100
  

Что еще хуже для числа 100, нам нужен только один байт, а остальные 3 байта не содержат никакой информации.

  00000000 00000000 00000000 01100100
  

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

Однако что, если вы заранее не знаете диапазон чисел, и это может быть число от -2 147 483 648 до 2 147 483 647 (максимальный диапазон int ).

С помощью varints мы можем хранить 300 в 2 байтах, 100 в одном байте и 1000000 в 3 байтах. Это может сэкономить много места, если вашему приложению в основном требуется обрабатывать небольшие числа и только время от времени очень большие числа.

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

В этом разделе мы сосредоточимся на положительном int и на том, как мы можем преобразовать их в целые числа переменной длины и обратно.

Кодировщик: фиксированная длина int -> переменная длина int

Идея этого кодирования переменной длины состоит в том, чтобы разбить число на группы по 7 бит. Затем возьмите каждую группу, в которой установлен хотя бы 1 бит и всегда наименее значимую (крайнюю правую) группу из 7 бит.

Добавьте один бит в каждую группу из 7 бит в качестве самого левого бита (старший значащий бит, MSB) для формирования байта.Установите этот бит в 1, за исключением младшего байта (крайний правый байт), установите его в 0. Этот дополнительный бит является индикатором для декодера, есть ли еще следующие байты.

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

Давайте посмотрим, как это работает для числа 300.

300 представлено следующими 4 байтами

  00000000 00000000 00000001 00101100
  

Первый шаг — разделить эти 32 бита на группы по 7.

  0000 0000000 0000000 0000010 0101100
  

Возьмите последнюю группу, 0101100 , и поместите ее первой в результат. Добавьте вторую группу (справа), потому что она содержит установленные биты. Игнорируйте остальные 3 группы, потому что ни один из битов не установлен.

В итоге получаем следующие 14 бит

  0101100 0000010
  

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

  10101100 00000010
  

Далее мы рассматриваем метод, реализующий эту кодировку в Java.

  общедоступный статический байт [] encodeUInt32 (int inputValue) {
    int value = inputValue;
    byte [] buffer = новый байт [5];
    int position = 0;
  

VariableLengthInt.java

Метод начинается с объявления некоторых переменных и резервирует буфер размером 5 байтов.Это также один из недостатков такого кодирования с переменной длиной. Поскольку мы собираемся разбить числа на группы по 7 бит и добавить один дополнительный бит, большое число будет закодировано в 5 байтов.

Затем метод запускает цикл.

  while (true) {
      
      if ((значение & 0b11111111111111111111111110000000) == 0) {
        буфер [позиция ++] = (байт) значение;
        перерыв;
      }
  

VariableLengthInt.java

Первая проверка — это побитовое И, при котором код проверяет, нет ли битов, установленных между позициями 8 и 32.Если это так, добавьте к результату последние 7 бит и прекратите кодирование. Поскольку это последняя группа, MSB должен быть 0, что здесь неявно происходит, потому что с проверкой if мы знаем, что бит в позиции 8 равен нулю (если бы он был 1, тогда проверка вернула бы false). Приведение (байта) берет младший байт из 4 байтов.

Здесь if проверяет, кодируем ли мы int 300.

  00000000 00000000 00000001 00101100 (int 300)
 И 11111111 11111111 11111111 10000000
 = 00000000 00000000 00000001 00000000 (целое 256)
  

Результат побитового И равен 256, а условие if оценивается как ложное.Теперь кодировщик знает, что это не последняя группа, поэтому он добавляет 7 младших битов к результату и устанавливает MSB равным 1

.

  буфер [позиция ++] = (байт) ((значение & 0b1111111) | 0b10000000);
  

VariableLengthInt.java

Поразрядное И с 1111111 сбрасывает все биты, которые установлены между позициями 8 и 32.

  00000000 00000000 00000001 00101100 (int 300)
 & 00000000 00000000 00000000 01111111
 = 00000000 00000000 00000000 00101100
  

Поразрядное ИЛИ с 10000000 затем устанавливает бит в позицию 8.

  00000000 00000000 00000000 00101100
 | 00000000 00000000 00000000 10000000
 = 00000000 00000000 00000000 10101100
  

Кроме того, приведение к байту извлекает младший байт

  10101100
  

Это первый байт нашего результата.

Затем алгоритм без знака вправо сдвигает переменную на 7 бит вправо. Это удаляет последние 7 бит из ввода, потому что мы их уже обработали.

  значение >>> = 7;
  

VariableLengthInt.Java

  00000000 00000000 00000001 00101100 (int 300)
 >>> 7 00000000 00000000 00000000 00000010
  

Метод продолжает цикл и снова выполняет проверку if. На этот раз значение равно 2 ( 00000000 00000000 00000000 00000010 ).

Поскольку ни один из битов не установлен между позициями 8 и 32, побитовое И возвращает число 0, и условие оценивается как истинное.

  00000000 00000000 00000000 00000010 (целое 2)
 И 11111111 11111111 11111111 10000000
 = 00000000 00000000 00000000 00000000 (целое 0)
  

Алгоритм извлекает младший байт (с преобразованием байт ) и добавляет его к результату.Это последняя группа результата с MSB, установленным на 0.

  10101100 00000010
  

Во временном буфере массив байтов длиной 5 релевантны только 2 байта, поэтому метод копирует эти два байта в новый массив байтов длиной 2 и возвращает его вызывающей стороне.

  байт [] dest = новый байт [позиция];
    System.arraycopy (буфер, 0, место назначения, 0, позиция);
    return dest;
  

VariableLengthInt.java

Декодер: переменная длина int -> фиксированная длина int

Задача декодера — перебрать байты, взять 7 младших битов каждого байта и добавить их к результату.Проверьте старший бит (MSB), если он установлен, продолжите цикл.

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

Реализация декодера на Java. Декодер получает массив байтов в качестве параметра и перебирает каждый байт.

  public static int decodeUInt32 (byte [] input) {
    int результат = 0;
    int shift = 0;
    for (int ix = 0; ix  

VariableLengthInt.java

Давайте посмотрим, как это работает с нашим закодированным числом 300: input = [10101100, 00000010] .

Первый байт - 10101100 , метод извлекает 7 младших битов с помощью побитового И с 1111111. Старший бит был добавлен кодером, поэтому декодер должен удалить его.

  10101100
 & 01111111
 = 00101100
  

Затем декодер сдвигает результат влево. В первой итерации shift равен 0, поэтому ничего не происходит. Результат этой операции И и сдвига добавляется к результату с помощью побитового ИЛИ.

Поскольку результат - это int , Java расширяет операторы до 4 байтов.

  00000000 00000000 00000000 00000000 (int 0, начальное значение результата)
 | 00000000 00000000 00000000 00101100
 = 00000000 00000000 00000000 00101100
  

Теперь алгоритм увеличивает сдвиг на 7 и проверяет с помощью побитового И, установлен ли MSB.

  10101100
 И 10000000
 = 10000000 (целое 128)
  

Сравнение с 0 оценивается как ложное, и декодер продолжает итерацию for со следующим байтом из входного массива .

Следующий байт - 00000010 . Опять же, декодер извлекает 7 младших битов и в этой итерации сдвигает результат на 7 бит влево.

  00000010
 & 01111111
 = 00000010
  

  00000010
 << 7 00000001 00000000
  

И применяет этот результат к переменной result с помощью побитового ИЛИ.

  00000000 00000000 00000000 00101100 (результат 1-й итерации)
 | 00000000 00000000 00000001 00000000 (И и сдвиг со 2-й итерации)
 = 00000000 00000000 00000001 00101100 (целое 300)
  

Затем декодер проверяет, установлен ли MSB

  00000010
 И 10000000
 = 00000000 (целое 0)
  

Поразрядное И возвращает 0, поэтому сравнение с 0 оценивается как истина, и декодер возвращает результат.

Нижняя сторона

Как упоминалось выше, для кодирования больших чисел, например 2 000 000 000, требуется 5 байтов. Поэтому, если вы заранее знаете, что большинство чисел int в вашем приложении будут больше 268 435 455, придерживайтесь кодирования фиксированной длины 4 байта. 268 435 455 - это последнее число, которое может быть представлено 4 байтами с этой кодировкой.

  2,000,000,000 --- кодирование переменной длины ---> 10000000 10101000 11010110 10111001 00000111
  

Отрицательные числа имеют ту же проблему.Отрицательный int , например -3, в Java, внутренне закодирован как

  11111111 11111111 11111111 11111101 = целое -3
  

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

  // кодирование переменной длины int -3
11111101 11111111 11111111 11111111 00001111
  

В следующем разделе мы увидим решение этой проблемы.

Простое решение, если все ваши числа отрицательны, состоит в том, чтобы преобразовать их в положительные числа, а затем пропустить их через кодировщик. В Java для этой цели можно использовать метод java.lang.Math.abs ()

  java.lang.Math.abs (-3) == 3
  

Затем ваше приложение должно знать, что эти числа, хотя и представлены как положительные числа, являются отрицательными, и вам необходимо преобразовать их в отрицательные, прежде чем отображать их пользователю или обрабатывать их в дальнейшем.

Но что, если входной набор данных содержит смесь отрицательных и положительных чисел. В этом случае мы можем использовать умное решение под названием ZigZag encoding. При такой кодировке каждое отрицательное число будет преобразовано в положительное.
Но это приведет к путанице, если алгоритм просто преобразует -3 в 3. Вы больше не сможете различать положительное 3 и отрицательное 3.

У кодирования

ZigZag есть умное решение для этого, и оно также кодирует положительные числа.Каждое положительное число становится четным, а каждое отрицательное число становится нечетным. Кодировщик удваивает каждое положительное число, а для каждого отрицательного числа он берет абсолютное значение, удваивает его и вычитает 1.

 -3 -> 5
-2 -> 3
-1 -> 1
 0 -> 0
 1 -> 2
 2 -> 4
 3 -> 6

 // положительный -> 2 * положительный
 // отрицательный -> 2 * абс (отрицательный) - 1

  

Затем декодер должен только проверить, является ли число четным, разделить его на 2, если нечетное, добавить 1, разделить его на 2 и вычесть из 0.(значение >> 31)


Давайте посмотрим на два примера: -3 и 3

значение = 3

  00000000 00000000 00000000 00000011 (целое 3)
<< 1 00000000 00000000 00000000 00000110 (число 6)
>> 31 00000000 00000000 00000000 00000000
  

Операция сдвига влево со знаком на 1 эквивалентна умножению на 2. Операция сдвига вправо со знаком на 31 всегда приводит к 0, если число положительное. Затем кодировщик поразрядно исключает их вместе.00000000 00000000 00000000 00000000 (результат >> 31)
= 00000000 00000000 00000000 00000110 (целое 6)

Итак, для числа 3 мы получаем закодированное число 6.

значение = -3

  11111111 11111111 11111111 11111101 (int -3)
<< 1 11111111 11111111 11111111 11111010 (int -6)
>> 31 11111111 11111111 11111111 11111111
  

Операция сдвига влево на 1 приводит к умножению на 2. Сдвиг вправо дает число, в котором установлены все 32 бита. — (результат & 1)

Снова смотрим на два числа -3 и 3.Декодер переменной длины возвращает 5 для числа -3 и 6 для числа 3.

закодировано 5, декодировано -3

Беззнаковый сдвиг вправо эквивалентен делению на 2 и вычитанию на 1, если это нечетное число.

  00000000 00000000 00000000 00000101 (число 5)
>>> 1 00000000 00000000 00000000 00000010 (целое 2)
  

В нечетном числе всегда устанавливается младший бит, а при сдвиге вправо на 1 бит удаляется.

Поразрядное И с 1 — это простая проверка четности или нечетности числа.11111111 11111111 11111111 11111111 (интервал -1)
= 11111111 11111111 11111111 11111101 (целое -3)

И мы приходим к декодированному значению -3

закодировано 6, декодировано 3

Правый битовый сдвиг без знака — это деление на 2

  00000000 00000000 00000000 00000110 (int 6)
>>> 1 00000000 00000000 00000000 00000011 (целое 3)
  

И с 1 дает 0, потому что 6 — четное число

  00000000 00000000 00000000 00000110 (int 6)
 $ 00000000 00000000 00000000 00000001 (целое 1)
 = 00000000 00000000 00000000 00000000 (целое 0)
  

Наконец, XOR двух значений вместе, и мы приходим к декодированному числу 3.00000000 00000000 00000000 00000000 (целое 0)
= 00000000 00000000 00000000 00000011 (целое 3)

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

Представьте, что у вас есть два int a и b, и приложение сохраняет только значения от 0 до 15 в этих двух переменных.

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

В этом примере вы можете пойти еще дальше. Поскольку значения от 0 до 15 могут быть представлены только 4 битами, приложение может объединить их в один байт.

  байт a = 8;
байт b = 3;
      

байтовое кодирование = (byte) (a << 4 | b);


byte decodedA = (byte) (закодировано >> 4 & 0b1111);
byte decodedB = (byte) (закодировано & 0b1111);
  

Дополнительные сведения о кодировании переменной длины см. В статье в Википедии по этой теме:
https: // en.wikipedia.org/wiki/Variable-length_quantity

См. Также реализацию этого алгоритма в Java в библиотеке буферов протокола:
CodedInputStream.java
CodedOutputStream.java

Исходный код этого сообщения в блоге размещен на GitHub:
https://github.com/ralscha/blog2019/blob/master/variable-length-int/VariableLengthInt.java

максимальная длина строки = 32 КБ? (Начало форума Java в Coderanch)

Maulin — ну, API для length () ничего не говорит о том, чтобы взять размер String и преобразовать его задолго до того, как вернуть число.Он говорит, что возвращает длину, период. Если он не может этого сделать, значит, он не может соответствовать собственному API.
Я знаю, что в Java есть ряд мест, где длинные числа преобразуются в целые числа, что может создавать отрицательные числа и различные раздражающие эффекты. Но каждый из этих случаев фактически где-то задокументирован — было бы крайне дурным тоном с их стороны бросать здесь этот тип преобразования, не предупредив никого.
Также рассмотрите метод toCharArray (). Любой массив ограничен числом элементов int — как еще вы могли бы получить доступ к более высоким индексам? Итак, строка длиннее, чем целое число.MAX_VALUE не может вернуть массив char [], который фактически содержит полное содержимое String — еще одно нарушение API. А как насчет многих других методов String, таких как lastIndexOf (char)? Опять же, он возвращает int, который может не содержать индекс правильного ответа.