Трудный способ создания массивов

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

int[] integers = new int[5]; for (int aa = 0; aa < integers.length; aa++) { integers[aa] = aa; }

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

Загрузка массива

Чтобы загрузить массив, нужно перебрать целые числа от 1 до длины массива (которую можно определить, вызвав параметр.length этого массива – подробнее об этом ниже). В данном случае мы останавливаемся на 5.

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

Logger l = Logger.getLogger(" Test" ); for (int aa = 0; aa < integers.length; aa++) { l.info(" This little integer's value is: " + integers[aa]); }

Работает также следующий синтаксис (впервые появившийся в JDK 5):

Logger l = Logger.getLogger(" Test" ); for (int i: integers) { l.info(" This little integer's value is: " + i); }

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

Метод length

Это встроенный метод, поэтому его синтаксис не включает обычных скобок. Достаточно ввести слово length, и вы получите длину массива.

В языке Java массивы начинаются с нулевой позиции. Так что первый элемент некоторого массива с именем array всегда находится по адресу array [0], а последний – array[array.length – 1].

Индекс элемента

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

element = arrayName [elementIndex];

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

Массив объектов

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

Создание массива объектов java.lang.Integer не сильно отличается от создания массива простых типов. Опять же, это можно сделать двумя способами:

// создает пустой массив на 5 элементов: Integer[] integers = new Integer[5];

// создает массив из 5 элементов со значениями: Integer[] integers = new Integer[] { Integer.valueOf(1), Integer.valueOf(2) Integer.valueOf(3) Integer.valueOf(4) Integer.valueOf(5));

Списки (list)

Список представляет собой коллекцию, которая по определению упорядочена, то есть является последовательностью. Так как список упорядочен, можно полностью управлять тем, куда помещаются его элементы. Коллекция Java List может содержать только объекты и строго регламентирует их поведение.

List – это интерфейс, так что его экземпляр нельзя создать напрямую. Обычно работают с его реализацией ArrayList:

List< Object> listOfObjects = new ArrayList< Object> ();

Обратите внимание, что мы присвоили объект ArrayList переменной типа List. Язык Java позволяет присваивать переменную одного типа переменной другого типа, если это переменная суперкласса или интерфейс, реализованный присваиваемой переменной.

Формальный тип

А что такое < Object> в приведенном выше фрагменте кода? Это формальный тип, что указывает компилятору на то, что список List содержит коллекцию типа Object, то есть в List можно помещать что угодно.

Если нужно ужесточить ограничения на то, что можно или нельзя помещать в список List, это определение следует переписать так:

List< Person> listOfPersons = new ArrayList< Person> ();

Теперь список List может содержать только экземпляры Person.

Использование списков

Использовать списки очень легко, как и коллекции Java в целом. Вот некоторые из вещей, которые можно делать сосписками:

поместить что-либо в список;
спросить, насколько велик список в данный момент;
извлечь что-то из списка.

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

Чтобы поместить что-то в список List, нужно вызвать метод add():

List< Integer> listOfIntegers = new ArrayList< Integer> (); listOfIntegers.add(Integer.valueOf(238));

Метод add() добавляет элемент в конец списка.

Чтобы узнать длину списка, нужно вызвать метод size():

List< Integer> listOfIntegers = new ArrayList< Integer> (); listOfIntegers.add(Integer.valueOf(238)); Logger l = Logger.getLogger(" Test" ); l.info(" Current List size: " + listOfIntegers.size());

Чтобы извлечь элемент из списка, нужно вызвать метод get() и передадть ему индекс требуемого элемента:

List< Integer> listOfIntegers = new ArrayList< Integer> (); listOfIntegers.add(Integer.valueOf(238)); Logger l = Logger.getLogger(" Test" ); l.info(" Item at index 0 is: " listOfIntegers.get(0));

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

Перебираемая коллекция

Если коллекция реализует интерфейс java.lang.Iterable, она называется перебираемой (iterable) коллекцией. Это означает, что можно начать с одного конца и перебрать всю коллекцию, элемент за элементом.

Специальный синтаксис для итерации по коллекциям, которые реализуют интерфейс Iterable:

for (objectType varName: collectionReference) { // Начинаем сразу с использования ObjectType (через varName)... }

Перебор элементов списка

Предыдущий пример был абстрактным; а вот более реалистичный:

List< Integer> listOfIntegers = obtainSomehow(); Logger l = Logger.getLogger(" Test" ); for (Integer i: listOfIntegers) { l.info(" Integer value is: " + i); }

Этот короткий фрагмент кода делает то же самое, что и более длинный:

List< Integer> listOfIntegers = obtainSomehow(); Logger l = Logger.getLogger(" Test" ); for (int aa = 0; aa < listOfIntegers.size(); aa++) { Integer I = listOfIntegers.get(aa); l.info(" Integer value is: " + i); }

В первом фрагменте используется сокращенный синтаксис: в нем нет индексной переменной (в данном случае аа) для инициализации и нет вызова метода get() по отношению к списку.

Так как List – это продолжение коллекции java.util.Collection, которая реализует интерфейс Iterable, для перебора любого списока можно использовать сокращенный синтаксис.

Наборы (set)

Набор (Set) – это коллекция, которая, по определению, содержит уникальные элементы – без дубликатов. Если списокможет содержать одни и те же объекты сотни раз, то набор может содержать данный объект только один раз. Коллекция Java Set может содержать только объекты и строго регламентирует их поведение.

Так как Set является интерфейсом, нельзя создать его экземпляр непосредственно, и я покажу вам один из моих любимых способов его реализации: HashSet. HashSet прост в использовании и напоминает List.

Вот некоторые из вещей, которые можно делать с набором:

поместить что-то в набор;
спросить, насколько велик набор в данный момент;
извлечь что-то из набора.

Использование наборов

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

Set< Integer> setOfIntegers = new HashSet< Integer> (); setOfIntegers.add(Integer.valueOf(10)); setOfIntegers.add(Integer.valueOf(11)); setOfIntegers.add(Integer.valueOf(10)); for (Integer i: setOfIntegers) { l.info(" Integer value is: " + i); }

Можно было бы ожидать, что набор Set состоит из трех элементов, но на самом деле в нем только два элемента, потому что объект Integer со значением 10 будет добавлен только один раз.

Имейте это в виду при переборе наборов:

Set< Integer> setOfIntegers = new HashSet(); setOfIntegers.add(Integer.valueOf(10)); setOfIntegers.add(Integer.valueOf(20)); setOfIntegers.add(Integer.valueOf(30)); setOfIntegers.add(Integer.valueOf(40)); setOfIntegers.add(Integer.valueOf(50)); Logger l = Logger.getLogger(" Test" ); for (Integer i: setOfIntegers) { l.info(" Integer value is: " + i); }

Скорее всего, объекты будут выведены не в том порядке, в каком их добавляли, потому что Set гарантирует уникальность, но не порядок. Вы убедитесь в этом, если вставите приведенный выше код в метод main() своего классаPerson и выполните его.

Отображения (map)

Отображение (Map) – это удобная коллекция, которая позволяет связать один объект (ключ), с другим (значение). Естественно, ключ отображения должен быть уникальным, и он используется для последующего извлечения значений. Коллекция Java Map может содержать только объекты и строго регламентирует их поведение.

Так как Map является интерфейсом, нельзя создать его экземпляр непосредственно, и я покажу вам один из моих любимых способов его реализации: HashMap.

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

поместить что-то в отображение;
извлечь что-то из отображения;
получить набор ключей отображения – для его перебора.

Использование отображений

Чтобы поместить что-то в отображение, нужно иметь объект-ключ и объект-значение:

public Map< String, Integer> createMapOfIntegers() { Map< String, Integer> mapOfIntegers = new HashMap< String, Integer> (); mapOfIntegers.put(" 1", Integer.valueOf(1)); mapOfIntegers.put(" 2", Integer.valueOf(2)); mapOfIntegers.put(" 3", Integer.valueOf(3)); //... mapOfIntegers.put(" 168", Integer.valueOf(168)); }

В этом примере Map содержит объекты типа Integer с ключом типа String, который служит их строковымпредставлением. Чтобы получить определенное значение Integer, требуется его строковое представление:

mapOfIntegers = createMapOfIntegers(); Integer oneHundred68 = mapOfIntegers.get(" 168" );

⇐ Предыдущая 1 2 3 4 5 6 789 10 Следующая ⇒