Философия Java3

Map, по аналогии с массивами и Collection, легко расширяются до нескольких измерений; достаточно создать Map со значениями типа Map (причем значениями этих Map могут быть другие контейнеры, и даже другие Map). Контейнеры легко комбинируются друг с другом, что позволяет быстро создавать сложные структуры данных. Например, если нам потребуется сохранить информацию о владельцах сразу нескольких домашних животных, для этого будет достаточно создать контейнер Map

//. holding/MapOfList.java package holding; import typeinfo pets.*, import java.util.*.

import static net.mindview util Print *;

public class MapOfList {

public static Map

petPeople = new HashMap

static {

petPeople put(new PersonC'Dawn").

Arrays asList(new Cymric("Molly").new Mutt("Spot"))). petPeople put(new Person("Kate").

Arrays asList(new CatC'Shackleton"),

new Cat("Elsie May"), new DogCMargrett"))); petPeople put(new Person("Marilyn"). Arrays asList(

new Pug("Louie aka Louis Snorkel stein Dupree"). new Cat("Stanford aka Stinky el Negro"), new CatC'Pinkola"))). petPeople put(new Person("Luke").

Arrays asList(new Rat("Fuzzy"). new Rat("Fizzy"))). petPeople put(new Person("Isaac").

Arrays asList(new RatCFreckly"))).

}

public static void main(String[] args) {

print ("People- " + petPeople keySetO). printOPets: " + petPeople valuesO); for(Person person . petPeople.keySet()) { print(person + " has-"); for(Pet pet • petPeople get(person))

printC " + pet); продолжение & }

}

} /* Output

People [Person Luke, Person Marilyn. Person Isaac, Person Dawn. Person Kate] Pets [[Rat Fuzzy. Rat Fizzy], [Pug Louie aka Louis Snorkel stein Dupree. Cat Stanford aka Stinky el Negro, Cat Pinkola]. [Rat Freckly]. [Cymric Molly. Mutt Spot], [Cat Shackleton, Cat Elsie May, Dog Margrett]] Person Luke has Rat Fuzzy Rat Fizzy Person Marilyn has

Pug Louie aka Louis Snorkel stein Dupree Cat Stanford aka Stinky el Negro Cat Pinkola Person Isaac has Rat Freckly Person Dawn has. Cymric Molly Mutt Spot Person Kate has-Cat Shackleton Cat Elsie May Dog Margrett */// ~

Map может вернуть множество (Set) своих ключей, коллекцию (Collection) значений или множество (Set) всех пар «ключ-значение». Метод keySet() создает множество всех ключей, которое затем используется в синтаксисе foreach для перебора Map.

Очередь

Очередь обычно представляет собой контейнер, работающий по принципу «первым вошел, первым вышел» (FIFO). Иначе говоря, элементы заносятся в очередь с одного «конца» и извлекаются с другого в порядке их поступления. Очереди часто применяются для реализации надежной передачи объектов между разными областями программы.

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

//: hoiding/QueueDemo.java

// Восходящее преобразование LinkedList в Queue

import java.util.*;

public class QueueDemo {

public static void printQCQueue queue) { while(queue.peek() != null)

System out print(queue.remove() + " "), System out printin(),

}

public static void main(String[] args) {

Queue queue = new LinkedList();

Random rand = new Random(47); for(int i = 0; i < 10; i++)

queue.offer(rand.nextlnt(i + 10)); printQ(queue);

Queue qc = new LinkedList(); for(char с ; "Brontosaurus".toCharArrayO)

qc.offer(c); printQ(qc);

}

} /* Output;

8 1 1 1 5 14 3 1 0 1

Brontosaurus

*///;-

Метод offer(), один из методов Queue, вставляет элемент в конец очереди, а если вставка невозможна — возвращает false. Методы реек() и element() возвращают начальный элемент без его удаления из очереди, но реек() для пустой очереди возвращает null, a element() выдает исключение NoSuchElementException. Методы poll() и remove() удаляют и возвращают начальный элемент очереди, но poll() для пустой очереди возвращает null, a remove() выдает NoSuchElementException.

Автоматическая упаковка преобразует результат int вызова nextlnt() в объект Integer, необходимый для queue, a char с — в объект Character, необходимый для qc. Интерфейс Queue сужает доступ к методам LinkedList так, что доступными остаются только соответствующие методы и у пользователя остается меньше возможностей для вызова методов LinkedList (конечно, queue можно преобразовать обратно в LinkedList, но это создает дополнительные затруднения).

PriorityQueue

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

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

При помещении объекта в PriorityQueue вызовом offer() объект сортируется в очереди. По умолчанию используется естественный порядок помещения объектов в очередь, однако вы можете изменить его, предоставив собственную реализацию Comparator. PriorityQueue гарантирует, что при вызове peek(), poll() или removeQ вы получите элемент с наивысшим приоритетом.

Создание приоритетной очереди для встроенных типов — Integer, String, Character и т. д. — является делом тривиальным. В следующем примере используются те же значения, что и в предыдущем, но PriorityQueue выдает их в другом порядке:

//. hoiding/PriorityQueueDemo.java import java util *;

public class PriorityQueueDemo {

public static void main(String[] args) {

PriorityQueue priorityQueue = new PriorityQueue(); Random rand = new Random(47), for(int i = 0; i < 10; i++)

priorityQueue.offer(rand.nextInt(i + 10)); QueueDemo.pri ntQCpriori tyQueue);

List ints = Arrays.asList(25, 22, 20.

18. 14. 9. 3. 1. 1, 2. 3. 9. 14, 18. 21. 23. 25); priorityQueue = new PriorityQueue(ints); QueueDemo.pri ntQ(pri ori tyQueue); priorityQueue = new PriorityQueue(

ints.sizeO. Collections reverseOrderO); pri ori tyQueue.addAl1(i nts). QueueDemo.pri ntQCpriori tyQueue);

String fact = "EDUCATION SHOULD ESCHEW 0BFUSCATI0N"; List strings = Arrays.asList(fact.split("")); PriorityQueue stringPQ =

new Pri ori tyQueue(stri ngs); QueueDemo.printQ(stringPQ); stringPQ = new PriorityQueue(

strings.sizeO. Col lections. reverseOrderO); stringPQ.addAl1(strings); QueueDemo.printQ(stringPQ);

Set charSet = new HashSet(); for(char с • fact toCharArray())

charSet.add(c); // Автоматическая упаковка PriorityQueue characterPQ =

new PriorityQueue(charSet); QueueDemo printQ(characterPQ).

}

} /* Output:

0 1 1 1 1 1 3 5 8 14

1 1 2 3 3 9 9 14 14 18 18 20 21 22 23 25 25 25 25 23 22 21 20 18 18 14 14 9 9 3 3 2 1 1

AABCCCDDEEEFHHIILNN0000SSSTTUUUW WUUUTTSSS0000NNLIIHHFEEEDDCCCBAA

ABCDEFH I LN0STUW *///:-

Мы видим, что дубликаты разрешены, а меньшие значения обладают более высокими приоритетами. Чтобы показать, как изменить порядок элементов посредством передачи собственного объекта Comparator, при третьем вызове конструктора PriorityQueue и втором — PriorityQueue используется

Comparator с обратной сортировкой, полученный вызовом Collections.reverse-Order() (одно из новшеств Java SE5).

В последней части добавляется HashSet для уничтожения дубликатов Character — просто для того, чтобы пример был чуть более интересным.

Integer, String и Character изначально работают с PriorityQueue, потому что они обладают «встроенным» естественным упорядочением. Если вы хотите использовать собственный класс с PriorityQueue, включите дополнительную реализацию естественного упорядочения или предоставьте собственный объект Comparator.

Collection и Iterator

Collection — корневой интерфейс, описывающий общую функциональность всех последовательных контейнеров. Его можно рассматривать как «вторичный интерфейс», появившийся вследствие сходства между другими интерфейсами. Кроме того, класс java.util. AbstractCollection предоставляет реализацию Collection по умолчанию, поэтому вы можете создать новый подтип AbstractCollection без избыточного дублирования кода.

Один из доводов в пользу интерфейсов заключается в том, что они позволяют создавать более универсальный код. Код, написанный для интерфейса, а не для его реализации, может быть применен к более широкому кругу объектов. Таким образом, если я пишу метод, которому при вызове передается Collection, этот метод будет работать с любым типом, реализующим Collection, — следовательно, если новый класс реализует Collection, он будет совместим с моим методом. Однако интересно заметить, что стандартная библиотека С++ не имеет общего базового класса для своих контейнеров — вся общность контейнеров обеспечивается итераторами. Казалось бы, в Java будет логично последовать примеру С++ и выражать сходство между контейнерами при помощи итераторов, а не Collection. Тем не менее эти два подхода взаимосвязаны, потому что реализация Collection также означает поддержку метода iterator():

//: hoiding/InterfaceVsIterator.java import typeinfo pets *, import java.util.*,

public class InterfaceVsIterator {

public static void display(Iterator it) {. whileCit hasNextO) {

Pet p = it.nextO.

System out pri nt(p id() + " " + p + " ").

}

System.out.printi n();

}

public static void display(Collection pets) { for(Pet p • pets)

System out print(p id() + " " + p + " "), System out printlnO.

}

public static void main(String[] args) {

List petList = Pets arrayList(8).

Set petSet = new HashSet(petList). Map petMap =

new LinkedHashMap(). String[] names = ("Ralph. Eric, Robin. Lacey. " +

"Britney. Sam. Spot. Fluffy") splitC. "). for(int i = 0. i < names length. i++)

petMap.put(names[i]. petList get(i)). display(petList): display(petSet). display(petList iteratorO). displ ay (petSet iteratorO). System out println(petMap). System out. pri ntl n( petMap keySetO). displ ay (petMap valuesO). display(petMap.values О .iteratorO);

}

} /* Output-

0 Rat 1 Manx 2 Cymric 3.Mutt 4 Pug 5.Cymric 6 Pug 7 Manx 4:Pug 6 Pug 3 Mutt 1 Manx 5 Cymric 7 Manx 2:Cymric O-Rat O-Rat 1 Manx 2-Cymric 3-Mutt 4-Pug 5 Cymric 6 Pug 7 Manx 4-Pug 6 Pug 3 Mutt 1 Manx 5:Cymric 7.Manx 2 Cymric 0:Rat

{Ralph=Rat. Eric=Manx, Robin=Cymric. Lacey=Mutt. Britney=Pug. Sam=Cymric. Spot=Pug. Fluffy=Manx}

[Ralph. Eric. Robin. Lacey. Britney. Sam. Spot. Fluffy] 0:Rat l.Manx 2-Cymric 3-Mutt 4:Pug 5-Cymric 6:Pug 7 Manx 0:Rat 1 Manx 2-Cymric 3-Mutt 4.Pug 5:Cymric 6:Pug 7 Manx */// ~

Обе версии display() работают как с объектами Map, так и с подтипами Collection; при этом как Collection, так и Iterator изолируют методы display() от знания конкретной реализации используемого контейнера.

В данном случае два решения примерно равноценны. Использование Iterator становится предпочтительным при реализации постороннего класса, для которого реализация интерфейса Collection затруднена или нежелательна. Например, если мы создаем реализацию Collection наследованием от класса, содержащего объекты Pet, нам придется реализовать все методы Collection, даже если они не будут использоваться в методе display(). Хотя проблема легко решается наследованием от AbstractCollection, вам все равно придется реализовать iterator() вместе с size(), чтобы предоставить методы, не реализованные AbstractCollection, но используемые другими методами AbstractCollection:

// • hoidi ng/Col1ecti onSequence.java import typeinfo pets.*; import java.util.*;

public class CollectionSequence extends AbstractCollection {

private Pet[] pets = Pets.createArray(8); public int sizeO { return pets.length; } public Iterator iteratorO {

return new Iterator() {

private int index = 0; public boolean hasNextO. {

return index < pets.length;

public Pet nextО { return pets[index++]; } public void removeО { // He реализован

throw new UnsupportedOperationExceptionO;

}

}:

}

public static void main(String[] args) {

CollectionSequence с = new Col 1ectionSequence(); InterfaceVsIterator.di splay(с); InterfaceVsIterator.di splay(c.i terator());

}

} /* Output:

0:Rat l:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat l:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx *///:-

Метод remove() является необязательной операцией. В нашем примере реа-лизовывать его не нужно, и в случае вызова он выдает исключение.

Из приведенного примера видно, что при реализации Collection вы также реализуете iterator(), а простая отдельная реализация iterator() требует чуть меньших усилий, чем наследование от AbstractCollection. Но, если класс уже наследует от другого класса, наследование еще и от AbstractCollection невозможно. В этом случае для реализации Collection придется реализовать все методы интерфейса, и тогда гораздо проще ограничиться наследованием и добавить возможность создания итератора:

//: hoidi ng/NonCol1ecti onSequence.java import typeinfo.pets.*; import java.util.*;

class PetSequence {

protected Pet[] pets = Pets.createArray(8);

}

public class NonCollectionSequence extends PetSequence { public Iterator iteratorO {

return new Iterator() {

private int index = 0; public boolean hasNextO {

return index < pets length;

}

public Pet nextO { return pets[index++]; } public void removeO { // He реализован

throw new UnsupportedOperationExceptionO;

}

}:

}

public static void main(String[] args) {

NonCollectionSequence nc = new NonCollectionSequence(); InterfaceVsIterator.display(nc.iteratorO);

}

} /* Output:

0:Rat l:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx *///:-

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

Синтаксис foreach и итераторы

До настоящего момента «синтаксис foreach» использовался в основном с массивами, но он также будет работать с любым объектом Collection. Некоторые примеры уже встречались нам при работе с ArrayList, но можно привести и более общее подтверждение:

//: holding/ForEachCollections java

// Синтаксис foreach работает с любыми коллекциями

import java.util.*,

public class ForEachCollections {

public static void main(String[] args) {

Collection cs = new LinkedList(); Col lections.addAl1(cs,

"Take the long way home".splitC' ")); for(String s : cs)

System, out. pri nt(..... + s + .....),

}

} /* Output-

'Take' 'the' 'long' 'way' 'home' *///:-

Поскольку cs является Collection, этот пример показывает, что поддержка foreach является характеристикой всех объектов Collection.

Работа этой конструкции объясняется тем, что в Java SE5 появился новый интерфейс Iterable, который содержит метод iterator() для создания Iterator, и именно интерфейс Iterable используется при переборе последовательности в синтаксисе foreach. Следовательно, создав любой класс, реализующий Iterable, вы сможете использовать его в синтаксисе foreach:

//: hoidi ng/IterableClass.java // Anything Iterable works with foreach. import java.util.*;

public class IterableClass implements Iterable { protected StringE] words = ("And that is how " +

"we know the Earth to be banana-shaped.").splitC "); public Iterator iteratorO {

return new Iterator() { private int index = 0; public boolean hasNextO {

return index < words length;

}

public String nextO { return words[index++]; } public void remove0 { // Not implemented

throw new UnsupportedOperationExceptionO,

};

public static void main(Stnng[] args) {

for(String s • new IterableClassO) System out print(s + " ");

}

} /* Output.

And that is how we know the Earth to be banana-shaped. *///:-

Метод iterator() возвращает экземпляр анонимной внутренней реализации Iterator, последовательно доставляющей каждое слово в массиве. В main() мы видим, что IterableClass действительно работает в синтаксисе foreach.

В Java SE5 многие классы реализуют Iterable, прежде всего все классы Collection (но не Map). Например, следующий код выводит все переменные окружения (environment) операционной системы:

//: holding/Envi ronmentVariables.java import java util *;

public class EnvironmentVariables {

public static void main(String[] args) {

for (Map Entry entry System getenvO .entrySetO) { System.out.println(entry.getKey() + ": " + entry. getValueO);

}

}

} /* (Выполните, чтобы увидеть результат) *///:-

System.getenv() возвращает Map, entrySet() создает Set с элементами Map.Entry, a Set поддерживает Iterable и поэтому может использоваться в цикле foreach.

Синтаксис foreach работает с массивами и всем, что поддерживает Iterable, но это не означает, что массив автоматически поддерживает Iterable:

// ■ hoiding/ArraylsNotIterable.java import java.util.*;

public class ArraylsNotlterable {

static void test(Iterable ib) { for(T t • ib)

System.out.print(t + " ");

}

public static void main(String[] args) { test(Arrays.asList(l. 2, 3)); StringC] strings = { "А", "В". "С" }: // Массив работает в foreach, но не является Iterable: //! test(strings);

// его необходимо явно преобразовать к Iterable: testCArrays.asLi st(stri ngs));

}

} /* Output: 1 2 3 А В С *///•-

Попытка передачи массива в аргументе Iterable завершается неудачей. Автоматическое преобразование в Iterable не производится; его необходимо выполнять вручную.

Идиома «метод-адаптер»

Что делать, если у вас имеется существующий класс, реализующий Iterable, и вы хотите добавить новые способы использования этого класса в синтаксисе foreach? Допустим, вы хотите иметь возможность выбора между перебором списка слов в прямом или обратном направлении. Если просто воспользоваться наследованием от класса и переопределить метод iterator, то существующий метод будет заменен и никакого выбора не будет.

Одно из решений этой проблемы основано на использовании идиомы, которую я называю «методом-адаптером». Термин «адаптер» происходит от одноименного паттерна: вы должны предоставить интерфейс, необходимый для работы синтаксиса foreach. Если у вас имеется один интерфейс, а нужен другой, проблема решается написанием адаптера. В данном случае требуется добавить к стандартному «прямому» итератору обратный, так что переопределение исключено. Вместо этого мы добавим метод, создающий объект Iterable, который может использоваться в синтаксисе foreach. Как будет показано далее, это позволит нам предоставить несколько вариантов использования foreach:

//: hoiding/AdapterMethodldiom.java

// Идиома "метод-адаптер" позволяет использовать foreach

// с дополнительными разновидностями Iterable.

import java.util.*;

class ReversibleArrayList extends ArrayList {

public ReversibleArrayList(Collection c) { super(c); }. public Iterable reversedO {

return new Iterable() {

public Iterator iteratorO {

return new Iterator() {

int current = sizeO - 1,

public boolean hasNextO { return current > -1;

}

public T nextO { return get (current--); } public void removeO { // He реализован throw new

UnsupportedOperationExceptionO;

}

} •

}

}:

}

}

public class AdapterMethodldiom {

public static void main(String[] args) { ReversibleArrayList ral =

new ReversibleArrayList(

Arrays.asList(To be or not to be".splitC' "))): // Получаем обычный итератор, полученный при помощи iteratorO: forCString s : ral)

System.out.print(s + " "); System.out printlnO;

// Передаем выбранный нами Iterable forCString s • ral .reversedO)

System.out.print(s + " "),

}

} /* Output To be or not to be be to not or be To */// ~

Если просто поместить объект ral в синтаксис foreach, мы получим (стандартный) «прямой» итератор. Но если вызвать для объекта reversed(), поведение изменится.

Использовав этот прием, можно добавить в пример IterableClass.java два метода-адаптера:

// hoidi ng/MultiIterableClass.java // Adding several Adapter Methods, import java util *;

public class MultilterableClass extends IterableClass { public Iterable reversedO {

return new Iterable() {

public Iterator iteratorO {

return new Iterator() {

int current = words length - 1,

public boolean hasNextO { return current > -1;

}

public String nextO { return words[current--];

}

public void removeО { // He реализован throw new

UnsupportedOperationException(),

}

}:

}

}.

}

public Iterable randomizedO { return new Iterable() {

public Iterator iteratorO { List shuffled =

new ArrayList(Arrays.asList(words)); Collections.shuffleCshuffled, new Random(47)); return shuffled.iterator();

}

}:

}

public static void main(String[] args) {

MultilterableClass mic = new MultiIterableClassO; for (String s : mic. reversedO)

System out print(s + " "): System, out. pri ntlnO. for(String s : mic.randomizedO)

System out.print(s + " "); System.out.prmtlnO: продолжение & for(String s : mic)

System.out.print(s + " ");

}

} /* Output:

banana-shaped, be to Earth the know we how is that And is banana-shaped. Earth that how the be And we know to And that is how we know the Earth to be banana-shaped *///:-

Из выходных данных видно, что метод Collections.shuffle не изменяет исходный массив, а только переставляет ссылки в shuffled. Так происходит только потому, что метод randomized() создает для результата Arrays.asList() «обертку» в виде ArrayList. Если бы операция выполнялась непосредственно с объектом List, полученным от Arrays.asList(), то это привело бы к изменению нижележащего массива:

//- hoiding/ModifyingArraysAsList.java import java util.*;

public class ModifyingArraysAsList {

public static void main(String[] args) {

Random rand = new Random(47);

Integer[] ia = { 1, 2, 3. 4, 5, 6. 7, 8. 9, 10 },

List listl =

new ArrayList(Arrays.asList(ia));

System.out.printIn("До перестановки. " + listl);

Col 1ecti ons.shuff1e(1i st1, rand);

System.out.println("После перестановки: " + listl);

System.out.printlnf'Массив: " + Arrays.toString(ia)),

List list2 = Arrays.asList(ia);

System.out.println("До перестановки: " + list2);

Col 1 ecti ons. shuffled i st2. rand);

System.out.println("После перестановки: " + list2);

System.out.println("Массив: " + Arrays.toString(ia));

}

} /* Output:

До перестановки: [1, 2, 3. 4, 5. 6. 7, 8, 9, 10] После перестановки: [4. 6, 3, 1. 8, 7, 2, 5. 10. 9] Массив: [1, 2, 3. 4. 5. 6. 7, 8. 9. 10] До перестановки: [1, 2. 3, 4, 5, 6. 7. 8, 9, 10] После перестановки: [9, 1. 6. 3. 7, 2. 5, 10, 4, 8] Массив- [9. 1. 6. 3. 7, 2, 5. 10. 4. 8] *///:-

В первом случае вывод Arrays.asList() передается конструктору ArrayList(), а последний создает объект ArrayList, ссылающийся на элементы ia. Перестановка этих ссылок не изменяет массива. Но, если мы используем результат Arrays.asList(ia) напрямую, перестановка изменит порядок ia. Важно учитывать, что Arrays.asList() создает объект List, который использует нижележащий массив в качестве своей физической реализации. Если с этим объектом List выполняются какие-либо изменяющие операции, но вы не хотите изменения исходного массива, создайте копию в другом контейнере.

Резюме

В Java существует несколько способов хранения объектов:

• В массивах объектам назначаются числовые индексы. Массив содержит объекты заранее известного типа, поэтому преобразование типа при выборке объекта не требуется. Массив может быть многомерным и может использоваться для хранения примитивных типов. Тем не менее изменить размер созданного массива невозможно.

• В Collection хранятся отдельные элементы, а в Map — пары ассоциированных элементов. Механизм параметризации позволяет задать тип объектов, хранимых в контейнере, поэтому поместить в контейнер объект неверного типа невозможно, и элементы не нуждаются в преобразовании типа при выборке. И Collection, и Map автоматически изменяются в размерах при добавлении новых элементов. В контейнерах не могут храниться примитивы, но механизм автоматической упаковки автоматически создает объектные «обертки», сохраняемые в контейнере.

• В контейнере List, как и в массиве, объектам назначаются числовые индексы — таким образом, массивы и List являются упорядоченными контейнерами.

• Используйте ArrayList при частом использовании произвольного доступа к элементам или LinkedList при частом выполнении операций вставки и удаления в середине списка.

• Поведение очередей и стеков обеспечивается контейнером LinkedList.

• Контейнер Map связывает с объектом не целочисленный индекс, а другой объект. Контейнеры HashMap оптимизированы для быстрого доступа, а контейнер TreeMap хранит ключи в отсортированном порядке, но уступает по скорости HashMap. В контейнере LinkedHashMap элементы хранятся в порядке вставки, но хеширование обеспечивает быстрый доступ.

• В контейнере Set каждый объект может храниться только в одном экземпляре. Контейнер HashSet обеспечивает максимальную скорость поиска, а в TreeSet элементы хранятся в отсортированном порядке. В контейнере LinkedHashSet элементы хранятся в порядке вставки.

• Использовать старые классы Vector, Hashtable и Stack в новом коде не нужно.

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

Обработка ошибок и исключения

Один из основополагающих принципов философии Java состоит в том, что «плохо написанная программа не должна запускаться

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

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