Любой java-разработчик знает, что создание чистого и эффективного решения при работе с операциями массива не всегда легко достичь. Тем не менее, они являются центральной частью экосистемы Java – и нам придется иметь дело с ними несколько раз.
По этой причине, это хорошо иметь “чит лист” – резюме наиболее распространенных процедур, которые помогут нам решать головоломки быстро. Этот учебник пригодится в таких ситуациях.
2. Классы массивов и помощников
Прежде чем приступить к работе, полезно понять, что такое массив в Java и как его использовать. Если вы впервые работаете с ним на Java, мы предлагаем взглянуть на этот предыдущий пост, где мы рассмотрели все основные понятия.
Обратите внимание, что основные операции, которые поддерживает массив, в определенном смысле ограничены. Это не редкость, чтобы увидеть сложные алгоритмы для выполнения относительно простых задач, когда дело доходит до массивов.
По этой причине, для большинства наших операций, мы будем использовать помощник классов и методов, чтобы помочь нам: Массивы класс, предоставляемый Java и Apache ArrayUtils Один.
Чтобы включить последнее в наш проект, мы должны добавить Апач Викисклад зависимость:
Мы можем проверить последнюю версию этого артефакта на Мавен Центральной .
3. Получить первый и последний элемент массива
Это одна из наиболее распространенных и простых задач благодаря индексу доступа к массивам.
Начнем с объявления и инициализации int массив, который будет использоваться во всех наших примерах (если мы не указать иное):
Зная, что первый элемент массива связан с значением индекса 0 и что он имеет длина атрибут, который мы можем использовать, то это просто, чтобы выяснить, как мы можем получить эти два элемента:
4. Получить случайное значение от массива
Используя java.util.Random объект, который мы можем легко получить любую ценность от нашего массива:
5. Приложение нового элемента к массиву
Как известно, массивы имеют фиксированный размер значений. Таким образом, мы не можем просто добавить элемент и превысить этот предел.
Для начала нужно будет объявить новый, больший массив и скопировать элементы базового массива на второй.
К счастью, Массивы класс предоставляет удобный метод репликации значений массива в новую структуру разного размера:
По желанию, если ArrayUtils класс доступен в нашем проекте, мы можем использовать его добавить метод (или его addAll альтернатива) для достижения нашей цели в одной строке заявление:
Как мы можем себе представить, этот метод не изменяет исходный массив объект; мы должны присвоить его выход новой переменной.
6. Вставьте значение между двумя значениями
Из-за своего индекса значения символа, вставка элемента в массиве между двумя другими не является тривиальной работой.
Apache счел это типичным сценарием и внедрил метод в своей ArrayUtils класс для упрощения решения:
Мы должны указать индекс, в который мы хотим вставить значение, и выход будет новый массив, содержащий большее количество элементов.
Последним аргументом является переменный аргумент (он же vararg ), таким образом, мы можем вставить любое количество элементов в массиве.
7. Сравните два массива
Несмотря на то, что массивы Объект s и, следовательно, обеспечить равняется метод, они используют реализацию по умолчанию его, опираясь только на равенство ссылок.
Мы можем так или иначе вызвать java.util.Arrays ‘ равняется метод проверки того, содержат ли два объекта массива одинаковые значения:
Примечание: этот метод не эффективен для зубчатые массивы . Соответствующим методом проверки равенства многомерных структур является Arrays.deepEquals Один.
8. Проверьте, пуст ли массив
Это несложное задание, имея в виду, что мы можем использовать длина атрибут массивов:
Кроме того, у нас также есть нулевой безопасный метод в ArrayUtils класс помощников, которые мы можем использовать:
Эта функция по-прежнему зависит от длины структуры данных, которая считает недействительными и пустыми под массивы как действительные значения тоже, так что нам придется следить за этими случаями края:
9. Как перемешать элементы массива
Для того, чтобы перетасовать элементы в массиве, мы можем использовать ArrayUtil ‘S особенность:
Это пустота метод и работает на фактических значениях массива.
10. Массивы коробки и распаковки
Мы часто сталкиваемся с методами, которые поддерживают только Объект на основе массивов.
Снова ArrayUtils класс помощников пригодится, чтобы получить коробочную версию нашего примитивного массива:
Возможна и обратная операция:
11. Удалите дубликаты из массива
Самый простой способ удаления дубликатов – это преобразование массива в набор реализация.
Как мы знаем, Коллекционая s использовать Generics и, следовательно, не поддерживают примитивные типы.
По этой причине, если мы не обуасвим массивы на основе объектов, как в нашем примере, нам сначала нужно будет обработать наши значения:
Примечание: мы можем использовать другие методы для преобразования между массивом и объектом Set.
Кроме того, если нам необходимо сохранить порядок наших элементов, мы должны использовать другую Установить реализации, например, LinkedHashSet .
12. Как распечатать массив
То же, что и с равняется метод, набор массива toString функция использует реализацию по умолчанию, предоставляемую Объект класс, который не очень полезен.
Оба Массивы и ArrayUtils классы отправки с их реализации для преобразования структур данных в читаемый Струнные .
Помимо несколько иного формата, который они используют, наиболее важным отличием является то, как они относятся к многомерным объектам.
Класс Java Util предоставляет два статических метода, которые мы можем использовать:
toString : не работает хорошо с зубчатыми массивами
deepToString : поддерживает любую Объект на основе массивов, но не компилирует с примитивными аргументами массива
С другой стороны, Реализация Apache предлагает единыйtoStringметод, который работает правильно в любом случае:
13. Карта массива к другому типу
Часто полезно применять операции на всех элементов массива, возможно, превращая их в другой тип объекта.
С этой целью, Мы постараемся создать гибкий метод помощников с использованием Generics:
Если мы не используем Java 8 в нашем проекте, мы можем отказаться от Функциональные аргумент, и создать метод для каждого отображения, что мы должны выполнить.
Теперь мы можем повторно использовать наш общий метод для различных операций. Давайте создадим два тестовых случая, чтобы проиллюстрировать это:
Для примитивных типов, мы должны боксировать наши значения в первую очередь.
В качестве альтернативы мы можем обратиться к Потоки Java 8 для выполнения отображения для нас.
Нам нужно превратить массив в ПотокОбъект s в первую очередь. Мы можем сделать это с Arrays.stream метод.
Например, если мы хотим составить карту наших int значения пользовательского Струнные представительство, мы будем осуществлять это:
14. Значения фильтра в массиве
Фильтрация значений из коллекции является общей задачей, которую нам, возможно, придется выполнять более чем в одном случае.
Это потому, что в то время как мы создаем массив, который будет получать значения, мы не можем быть уверены в его окончательный размер. Поэтому Мы будем полагаться наПотокs подход снова.
Представьте, что мы хотим удалить все нечетные числа из массива:
15. Другие операции общего массива
Есть, конечно, много других операций массива, которые мы, возможно, потребуется выполнить.
Помимо тех, которые показаны в этом учебнике, мы широко рассмотрели другие операции в посвященных должностей:
Проверьте, содержит ли Java Array значение
Как скопировать массив на Java
Удаление первого элемента массива
Поиск Мина и Макса в массиве с Java
Найти Sum и Average в Java Array
Как инвертировать массив в Java
Присоединиться и разделить массивы и коллекции на Java
Объединение различных типов коллекций на Java
Найти все пары чисел в массиве, который добавляет до данной суммы
Сортировка на Java
Эффективный калькулятор частоты слов в Java
Сортировка вставки в Java
16. Заключение
Arrays являются одной из основных функций Java, и поэтому очень важно понять, как они работают, и знать, что мы можем и не можем с ними сделать.
В этом учебнике мы узнали, как мы можем обрабатывать операции массива надлежащим образом в общих сценариях.
Как всегда, полный исходный код рабочих примеров доступен на наш Github репо .
Источник
Массивы в Java
Поддержка JavaScript отключена
SBP-Program
На главную -> Java
 
Массивы в Java
Автор: Субботин Б.П.
Что такое массив?
Массив в Java — это набор элементов одного типа, обратиться к которым можно по индексу. Элементы массивов в Java расположены друг за другом в памяти компьютера. Ниже разбирается пример массива в Java. Скачать пример можно здесь.
Объявление массива в Java
Объявим массив, для хранения элементов типа int:
Здесь объявлена переменная arr, которая является массивом. Чтоб использовать эту переменную нужно её определить.
Определение массива в Java
Для определения массива в Java следует указать его длину, т.е. количество элементов, которые могут в нём храниться:
В нашем массиве бедет храниться 5 элементов.
Массив — это набор элементов. К каждому элементу массива можно обратиться по его номеру. Номер принято называть индексом. Нумерация элементов массива в Java идёт с нуля.
Как загрузить элементы в массив?
Присвоим значение первому элементу массива, а первый элемент имеет индекс ноль:
Присвоим значение второму элементу массива, а второй элемент имеет индекс один:
и так далее. Обычно это делают в цикле:
Можно при объявлении массива сразу загрузить в него значения:
количество элементов здесь равно 5-ти, т.е. нет необходимости указать число элементов, оно будет определено автоматически.
Как получить элементы из массива?
К каждому элементу массива можно обратиться по его номеру. Чтоб получить элемент массива, надо указать имя массива и индекс элемента:
это первый элемент массива, ведь у первого элемета индекс ноль.
Присвоим значение третьего элемента массива переменной int a:
Выведем в цикле все элементы массива (переберем массив):
Упрощенный вариант цикла для вывода массива таков:
Как удалить массив в Java?
Удалить массив в Java можно так:
Как получить длину массива в Java?
Длину массива в Java получаем так:
Как получить первый элемент массива в Java?
Как получить полследний элемент массива в Java?
Как в Java задать массив переменной длины?
Как в Java задать массив переменной длины? Никак. Когда вы определяете массив, тогда и задаёте его длину, изменить её в дальнейшем нельзя. В таких случаях используют коллекции, например: Vector, ArrayList и др.
Итак, перемнной длина массива быть не может. Но можно использовать переменную при определении массива. Если так:
то получим ошибку, длина массива не может быть переменной.
Надо задать значение cd:
Теперь нормально. Если после определения массива изменить переменную cd, то это не повлияет на массив, т.е. его длина не изменится. Пример:
Максимальный индекс нашего массива равен 9-ти. Изменение значения переменной cd не влияет на массив, ведь он уже определен и его длина есть константа.
Переменные можно использовать для обращения к элементам массива:
Массив символов в Java
Пример массива символов в Java и его вывода:
Пример массива в Java
Многомерные массивы в Java
Для примера рассмотрим двумерный массив в Java.
Двумерные массивы Java— это прямоугольная или не прямоугольная таблица чисел. Двумерный массив Java состоит из рядов и столбцов. Первый индекс двумерного массива Java— это число рядов. Пример двумерного прямоугольного массива Java:
Здесь объявлен и определен двумерный массив, имеющий две строки и два столбца.
Загрузим массив элементами:
Вывод двумерного массива (перебираем массив):
мы проходим по рядам, а в цикле
Можно объявить и определить многомерный массив одновременно:
Длина многомерного массива в Java
Что считать длиной многомерного массива, ведь у него несколько измерений? Длиной многомерного массива является его первая размерность. Пример:
Здесь три ряда по два элемента каждый. Первая размерность — три, это и есть длина двумерного массива.
Трехмерный массив в Java
Пример трехмерного массива в Java:
Здесь объявлен и определен трехмерный массив. Его можно представит как куб, состоящий из двух слоёв (layer), каждый слой состоит из двух рядов и двух столбцов, т.е. каждый слой — это двумерный массив.
Как заполнить трехмерный массив? Можно в цикле, но мы для примера вручную заполним:
Как вывести трехмерный массив? Или как перебрать трехмерный массив? Так:
Java Array – это набор переменных одного типа. Например, массив int представляет собой набор переменных типа int, упорядоченных и имеющих свой индекс. Вот иллюстрация массивов Java:
Объявление массива
Переменная массива Java объявляется точно так же, как и переменная нужного типа, за исключением добавления [] после типа. Вот простой пример объявления:
Вы можете использовать массив в качестве поля, статического поля, локальной переменной или параметра, как и любую другую переменную. Ведь это просто вариация типа данных. Вместо того, чтобы быть единственной переменной этого типа, это набор переменных этого типа.
Вот еще несколько примеров объявления:
Первая строка объявляет массив ссылок String. Во второй строке объявляется массив ссылок на объекты класса MyClass, созданного пользователем.
У вас есть выбор места для квадратных скобок []. Первое вы уже видели, второе находится после имени переменной. Следующие объявления равнозначные:
Лучше указывать квадратные скобки [] после типа данных (например, String []), тогда код легче читать.
Создание
Когда вы объявляете переменную массива, вы объявляете только переменную (ссылку) на сам массив, но не создаете его. Процесс создания:
В этом примере создается массив типа int с пространством для 10 переменных int внутри.
Предыдущий пример создал массив int, который является примитивным типом данных. Возможно создать массив ссылок на объекты. Например:
Java позволяет создавать массив ссылок на любой тип объекта (на экземпляры любого класса).
Литералы
Язык программирования Java содержит ярлык для создания экземпляров массивов примитивных типов и строк. Если вы уже знаете, какие значения вставлять в массив, вы можете использовать литерал массива. Вот он как выглядит в коде Java:
Обратите внимание, как значения, которые будут вставлены в массив, перечислены внутри блока <…>. Длина этого списка также определяет длину созданного массива.
Не нужно писать новую часть int [] в последних версиях Java. Достаточно:
Стиль работает для массивов всех примитивных типов, а также массивов строк. Вот пример строкового массива:
Длина не может быть изменена
После создания массива его размер не может быть изменен. В некоторых языках программирования (например, JavaScript) это возможно. Если вам нужна структура данных, похожая на массив, которая может изменить свой размер, вы должны использовать List или создать массив с изменяемым размером. В некоторых случаях допустимо использовать Java RingBuffer, который, кстати, реализован с использованием массива внутри.
Доступ к элементам
Каждая переменная в массиве также называется «элементом». Таким образом, в примере, показанном ранее, был создан массив с пространством для 10 элементов, и каждый элемент является переменной типа int.
Вы можете получить доступ к каждому элементу в массиве через его индекс. Вот пример:
В этом примере сначала устанавливается значение элемента (int) с индексом 0, а во-вторых, он считывает значение элемента с индексом 0 в переменную int.
Вы можете использовать элементы в массиве так же, как если бы они были обычными переменными:
читать их значения;
присваивать им значения;
использовать в вычислениях;
передавать конкретные элементы в качестве параметров для вызовов методов.
Индексы элементов в массиве всегда начинаются с 0 и продолжаются до номера 1 ниже размера массива. Таким образом, в приведенном выше примере с массивом из 10 элементов индексы идут от 0 до 9.
Как получить длину?
Организация доступа к длине массива через его поле длины:
В этом примере переменная с именем arrayLength будет содержать значение 10 после выполнения второй строки кода.
Итерация
Как перебрать все элементы массива, используя цикл Java for:
Сначала создается массив ссылок String. Когда впервые создаете массив ссылок на объекты, каждая из ячеек в массиве указывает на ноль, а не на объект.
Первый из двух циклов for выполняет итерацию по массиву String, создает строку и делает ссылку на ячейку этой строкой.
Второй из двух циклов for перебирает массив String и печатает все строки, на которые ссылаются ячейки.
Если бы это был массив int (примитивные значения), он мог бы выглядеть так:
Переменная i инициализируется равной 0 и работает до длины массива минус 1. В этом случае i принимает значения от 0 до 9, каждый раз повторяя код внутри цикла for один раз, и для каждой итерации i имеет другое значение.
Как перебрать массив с помощью цикла «for-each» в Java. Вот как это выглядит:
Цикл for-each дает вам доступ к каждому элементу в массиве по одному, но не информацию об индексе каждого элемента. Есть доступ только к значению. Изменить значение элемента в этой позиции невозможно. Если это нужно, используйте обычный цикл for, как показано ранее.
Цикл for-each также работает с массивами объектов. Вот пример, как выполнить итерацию массива объектов String:
Многомерные массивы
Приведенные выше примеры – все созданные массивы с одним измерением, то есть элементы с индексами, начиная с 0 и выше. Однако возможно создать массивы, в которых каждый элемент имеет два или более индексов. Они идентифицируют (размещают) его в массиве.
Вы создаете многомерный массив в Java, добавляя один набор квадратных скобок ([]) к измерению, которое хотите добавить. Вот пример, который создает двумерный массив:
В этом примере создается двумерный массив элементов int. Он содержит 10 элементов в первом измерении и 20 во втором. Другими словами, массив массивов имеет пространство для 10 массивов int, а каждый массив int имеет пространство для 20 элементов int.
Для получения доступа к элементам в многомерном массиве с одним индексом на измерение нужно использовать два индекса. Вот пример:
Переменная с именем oneInt будет содержать значение 129 после выполнения последней строки кода Java.
Итерация многомерных
При итерации многомерного массива, нужно выполнять итерацию каждого измерения массива отдельно:
Вставка элементов
Как вставить новое значение в массив в Java:
Создается массив.
Он определяет индекс вставки и новое значение для вставки.
Все элементы от индекса вставки и до конца массива сдвигаются на один индекс вниз в массиве.
Обратите внимание, что это сместит последнее значение в массиве из массива(оно будет просто удалено).
Приведенный выше код вставки массива может быть встроен в метод:
Этот метод принимает массив int[] в качестве параметра, а также индекс для вставки нового значения и нового значения. Вставка элементов в массив, вызвав этот метод следующим образом:
Конечно, если метод insertIntoArray() находится в другом классе, нежели приведенный выше код, потребуется объект этого класса, чтобы вызывать метод. Если метод insertIntoArray() был статическим, нужно поместить имя класса и точку перед именем метода.
Удаление элементов
Код для удаления элемента из массива:
В этом примере сначала создается массив int. Затем он устанавливает значение элемента с индексом 10 равным 123. Потом пример удаляет элемент с индексом 10, перемещая все элементы ниже индекса 10 на одну позицию вверх в массиве. После удаления последний элемент в массиве будет существовать дважды. И в последнем, и во втором последнем элементе.
Приведенный выше код может быть встроен в метод. Вот как мог бы выглядеть такой Java-метод удаления массива:
Метод removeFromArray() принимает два параметра: массив для удаления элемента и индекс удаляемого элемента.
Конечно, если метод removeFromArray() находится в другом классе, нежели приведенный выше код, вам потребуется объект этого класса, чтобы вызывать метод. Или, если метод removeFromArray() был статическим, вам нужно поместить имя класса и точку перед именем метода.
Нахождение минимального и максимального значения в массивах
В Java нет встроенных функций для поиска минимального и максимального значения, поэтому нужно сделать это самостоятельно.
Как находить минимальное значение в массиве:
Вначале в примере для minVal устанавливается значение Integer.MAX_VALUE. Оно является максимально возможным значением, которое может принимать int. Это сделано для того, чтобы убедиться, что начальное значение не случайно меньше, чем наименьшее значение в массиве.
Во-вторых, пример перебирает массив и сравнивает каждое значение с minValue. Если элемент в массиве меньше minVal, тогда minVal устанавливается в значение элемента.
Наконец, минимальное значение, найденное в массиве, распечатывается. В приведенном выше примере минимальное значение равно 0.
Как найти максимальное значение:
В этом примере будет распечатано значение 10.
Основными отличиями в нахождении минимального значения являются инициализация maxVal и сравнение maxVal с элементами в массиве.
Класс
Java содержит специальный служебный класс, который облегчает выполнение многих часто используемых операций с массивами, таких как копирование и сортировка массивов, заполнение данных, поиск в массивах и т. д. Называется Arrays и находится в стандартном пакете Java.Util. Таким образом, полное имя класса:
Чтобы использовать java.util.Arrays в ваших классах, вы должны импортировать его:
Копирование
Возможно несколькими способами.
Копирование массива путем итерации массива
Первый способ – это перебрать массив и скопировать каждое значение исходного массива в целевой массив. Вот как выглядит копирование массива с использованием этого метода:
Первые два массива int созданы. Во-вторых, исходный массив инициализируется значениями от 0 до 9 (от 0 до длины массива минус 1). В-третьих, каждый элемент в исходном массиве копируется в целевой массив.
Копирование с помощью Arrays.copyOf()
Вот как выглядит копирование массива:
Метод Arrays.copyOf() принимает 2 параметра. Первый – это массив для копирования. Второй – это длина нового массива – можно использовать для указания количества копируемых элементов из исходного массива.
Копирование с использованием Arrays.copyOfRange()
Метод Arrays.copyOfRange() копирует диапазон массива, не обязательно полный массив. Процесс копирования с ним:
Метод Arrays.copyOfRange() принимает 3 параметра. Первый – это массив для копирования. Второй – это первый индекс в исходном массиве, который нужно включить в копию. Третий – это последний индекс в исходном массиве, который будет включен в копию (исключено – поэтому передача 10 будет копировать до и включая индекс 9).
Преобразование массивов в строки с помощью Arrays.toString()
Вы можете преобразовать массив примитивных типов в строку:
Первая строка создает массив int с 10 элементами. Цикл for инициализирует массив значениями от 10 до 1. В последней строке выводится значение, возвращаемое из Arrays.toString(). Возвращенная строка (которая печатается) выглядит так:
Сортировка
Вы можете отсортировать элементы массива с помощью метода Arrays.sort() в соответствии с порядком их сортировки:
Первая строка объявляет и создает экземпляр массива int длиной 10. Цикл for перебирает массив и вставляет значения в каждый элемент. Введенные значения будут идти от 10 до 1 в порядке убывания.
После цикла for массив преобразуется в строку с помощью Arrays.toString() и выводится на консоль (командная строка). Выход:
Затем массив сортируется с помощью Arrays.sort(). Элементы теперь будут упорядочены в порядке возрастания.
После сортировки массива он снова преобразуется в строку и выводится на консоль. Вывод:
Сортировка объектов
Показанный ранее пример Arrays.sort() работает только для массивов примитивных типов данных, которые имеют порядок:
естественный;
числовой;
символьный в таблице ASCII (двоичное число, представляющее символ).
У объектов может не быть естественного порядка сортировки, поэтому вам нужно предоставить другой объект, который может определять порядок ваших объектов. Такой объект называется компаратором – это интерфейс.
Вот первый класс для объектов, которые мы хотим отсортировать:
Класс Employee – это простая модель сотрудника, у которого есть имя и идентификатор. Вы можете отсортировать массив объектов Employee по имени или по идентификатору сотрудника.
Вот первый пример сортировки массива объектов Employee по их имени с помощью метода Arrays.sort():
Сначала объявляется массив.
Три объекта Employee создаются и вставляются в массив.
Метод Arrays.sort() вызывается для сортировки массива. В качестве параметра передаем массив employee и реализацию Comparator, которая может определять порядок объектов Employee. Это создает анонимную реализацию интерфейса Comparator.
В примере важно уловить реализацию метода compare() анонимной внутренней реализации интерфейса Comparator. Этот метод возвращает:
положительное число, если первый объект «больше»(позже в порядке сортировки), чем второй объект;
0 – они «равны»(в порядке сортировки);
отрицательное число, если первый объект «меньше» (ранее в порядке сортировки), чем второй объект.
В приведенном выше примере мы просто вызываем метод String.compare(), который выполняет для нас сравнение (сравнивает имена сотрудников).
После сортировки массива мы перебираем его и выводим имена сотрудников. Вывод:
Обратите внимание, как порядок был изменен по сравнению с порядком, в котором они были первоначально вставлены в массив.
Сортировка объектов Employee по их идентификатору сотрудника на основании предыдущего примера с измененной реализацией метода compare() анонимной реализации интерфейса Comparator:
Обратите внимание, как метод compare() возвращает разницу между идентификаторами сотрудников, вычитая одно из другого. Это самый простой способ определить естественный порядок числовых переменных.
Чтобы сравнить объекты Employee в массиве сначала по их имени, а если оно совпадает, то по их идентификатору сотрудника, реализация compare():
Заполнение Arrays.fill()
Класс Arrays имеет набор методов с именем fill(), которые могут заполнять массив заданным значением. Это проще, чем перебирать массив и вставлять значение самостоятельно. Вот пример использования Arrays.fill() для заполнения массива int:
В этом примере создается массив int и заполняется значение 123 во всех элементах массива. Последняя строка примера преобразует массив в строку и выводит его на консоль:
Существует версия метода Arrays.fill(), которая принимает значения from и to index, поэтому только элементы с индексами в этом интервале заполняются заданным значением:
Этот пример заполняет только те элементы, которые имеют индексы 3 и 4(от 3 до 5 без 5) значением 123. Вывод:
Поиск с помощью Arrays.binarySearch()
Класс Arrays содержит набор методов с именем binarySearch(). Этот метод поможет вам выполнить бинарный поиск в массиве. Сначала массив должен быть отсортирован. Вы можете сделать это самостоятельно или с помощью метода Arrays.sort(), описанного ранее в этом тексте. Вот пример:
Вторая строка этого примера ищет в массиве значение 6. Метод binarySearch() возвращает индекс в массиве, в котором был найден элемент. В приведенном выше примере метод binarySearch() вернет 3.
Если в массиве существует более одного элемента с искомым значением, нет гарантии, какой элемент будет найден.
Если элемент с данным значением не найден, будет возвращено отрицательное число. Отрицательным числом будет индекс, по которому будет вставлен искомый элемент, а затем минус один. Посмотрите на этот пример:
Число 7 не найдено в массиве. Номер 7 должен был быть вставлен в массив по индексу 4, если 7 должен был быть вставлен в массив (и порядок сортировки сохранен). Следовательно, binarySearch() возвращает -4 – 1 = -5.
Если все элементы в массиве меньше искомого значения, то двоичная Search() вернет – длина массива – 1. Посмотрите на этот пример:
В этом примере мы ищем 12 в массиве, но все элементы в массиве меньше 12. Поэтому binarySearch() вернет -length(-6) – 1 = -6 -1 = -7.
Метод Arrays.binarySearch() для поиска части массива. Вот как это выглядит:
В этом примере выполняется поиск в массиве значения 2, но только между индексами 0 и 4 (без 4).
Эта версия binarySearch() работает так же, как и другая версия, за исключением случаев:
Если не найдено ни одного элемента, совпадающего в пределах интервала индекса, то все равно вернется индекс того места, где должно было быть вставлено значение.
Если все значения в интервале меньше искомого значения, вернется -toIndex -1, а не -array length – 1.
Таким образом, этот пример:
вернет -5, а не -7, как в двоичном поиске (целых, 12).
Проверка, равны ли массивы Arrays.equals()
Класс java.util.Arrays содержит набор методов, называемых equals(), которые можно использовать для проверки, равны ли два массива. Два массива считаются равными, если имеют одинаковую длину, а элементы равны друг другу в порядке их нахождения в массиве. Пример:
В этом примере сравнивается массив ints1 с массивами ints2 и ints3. Первое сравнение приведет к значению true, поскольку ints1 и ints2 содержат одинаковые элементы в одинаковом порядке. Второе сравнение приведет к значению false. Массив ints1 содержит те же элементы, что и ints3, но не в том же порядке. Поэтому два массива не считаются равными.
