Добавление элемента в позицию 2

[a, b, X, c, d, e, f, a, g]

[a, b, X, c, d, e, f, W, g]после замены элемента

[b, X, c, d, e, f, W, g]удален элемент a

Коллекция LinkedList<E> реализует связанный список. В отличие от массива, который хранит объекты в последовательных ячейках памяти, связанный список хранит объекты отдельно, но вместе со ссылками на следующее и предыдущее звенья последовательности.

В добавление ко всем имеющимся методам в LinkedList<E> реализованы методы void addFirst(E ob), void addLast(E ob), E getFirst(),
E getLast(), E removeFirst(), E removeLast() добавляющие, извлекающие, удаляющие и извлекающие первый и последний элементы списка соответственно.

Класс LinkedList<E> реализует интерфейс Queue<E>, что позволяет предположить, что такому списку легко придать свойства очереди. К тому же специализированные методы интерфейса Queue<E> по манипуляции первым и последним элементами такого списка E element(), boolean offer(E o), E peek(), E poll() , E remove() работают немного быстрее, чем соответствующие методы класса LinkedList<E>.

Методы element() и remove() отличаются от методов peek() и poll() тем, что генерируют исключение, если очередь пуста.

/* пример # 5: добавление и удаление элементов: DemoLinkedList.java */

package chapt10;

import java.util.*;

public class DemoLinkedList {

public static void main(String[] args){

LinkedList<Number> a = new LinkedList<Number>();

for (int i = 10; i <= 15; i++)

a.add(i);

for (int i = 16; i <= 20; i++)

a.add(new Float(i));

ListIterator<Number> list = a.listIterator(10);

System. out. println("\n"+ list.nextIndex()

+ "-й индекс");

list.next(); // важно!

System. out. println(list.nextIndex()

+ "-й индекс");

list.remove(); // удаление элемента с текущим индексом

while (list.hasPrevious())

System. out. print(list.previous()+" "); /*вывод

в обратном порядке*/

// демонстрация работы методов

a.removeFirst();

a.offer(71); // добавление элемента в конец списка

a.poll(); // удаление нулевого элемента из списка

a.remove(); // удаление нулевого элемента из списка

a.remove(1); // удаление первого элемента из списка

System. out. println("\n" + a);

Queue<Number> q = a; // список в очередь

for (Number i: q) // вывод элементов

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

System. out. println(":size= " + q.size());

// удаление пяти элементов

for (int i = 0; i < 5; i++) {

Number res = q.poll();

}

System. out. print("size= " + q.size());

}

}

В результате будет выведено:

Й индекс

Й индекс

19.0 18.0 17.0 16.0 15 14 13 12 11 10

[13, 15, 16.0, 17.0, 18.0, 19.0, 71]

13 15 16.0 17.0 18.0 19.0 71:size= 7

size= 2

При реализации интерфейса Comparator<T> существует возможность сортировки списка объектов конкретного типа по правилам, определенным для этого типа. Для этого необходимо реализовать метод int compare(T ob1,
T ob2), принимающий в качестве параметров два объекта для которых должно быть определено возвращаемое целое значение, знак которого и определяет правило сортировки. Этот метод автоматически вызывается методом public static <T> void sort(List<T> list, Comparator<? super T> c) класса Collections, в качестве первого параметра принимающий коллекцию, в качестве второго – объект-comparator, из которого извлекается правило сортировки.

/* пример # 6: авторская сортировка списка: UniqSortMark.java */

package chapt10;

import java.util.Comparator;

public class Student implements Comparator<Student> {

private int idStudent;

private float meanMark;

public Student(float m, int id) {

meanMark = m;

idStudent = id;

}

public Student() {

}

public float getMark() {

return meanMark;

}

public int getIdStudent() {

return idStudent;

}

// правило сортировки

public int compare(Student one, Student two) {

Return

(int)(Math.ceil(two.getMark() - one.getMark()));

}

}

package chapt10;

import java.util.*;

public class UniqSortMark {

public static void main(String[] args) {

ArrayList<Student> p = new ArrayList<Student>();

p.add(new Student(3.9f, 52201));

p.add(new Student(3.65f, 52214));

p.add(new Student(3.71f, 52251));

p.add(new Student(3.02f, 52277));

p.add(new Student(3.81f, 52292));

p.add(new Student(9.55f, 52271));

// сортировка списка объектов

try {

Collections.sort(p, Student. class. newInstance ());

} catch (InstantiationException e1) {

//невозможно создать объект класса

e1.printStackTrace();

} catch (IllegalAccessException e2) {

e2.printStackTrace();

}

for (Student ob: p)

System.out.printf("%.2f ", ob.getMark());

}

}

В результате будет выведено:

9,55 3,90 3,81 3,71 3,65 3,02

Метод boolean equals(Object obj) интерфейса Comparator<T>, который обязан выполнять свой контракт, возвращает true только в случае если соответствующий метод compare() возвращает 0.

Для создания возможности сортировки по другому полю id класса Student следует создать новый класс, реализующий Comparator по новым правилам.

/* пример # 7: другое правило сортировки: StudentId.java */

package chapt10;

public class StudentId implements Comparator<Student> {

public int compare(Student one, Student two) {

return two.getIdStudent() - one.getIdStudent();

}

}

При необходимости сортировки по полю id в качестве второго параметра следует объект класса StudentId:

Collections.sort(p, StudentId.class. newInstance ());

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

Deque

Интерфейс Deque определяет «двунаправленную» очередь и, соответственно, методы доступа к первому и последнему элементам двусторонней очереди. Методы обеспечивают удаление, вставку и обработку элементов. Каждый из этих методов существует в двух формах. Одни методы создают исключительную ситуацию в случае неудачного завершения, другие возвращают какое-либо из значений (null или false в зависимости от типа операции). Вторая форма добавления элементов в очередь сделана специально для реализаций Deque, имеющих ограничение по размеру. В большинстве реализаций операции добавления заканчиваются успешно.

В следующим примере реализована работа с интерфейсом Deque. Методы addFirst(), addLast() вставляют элементы в начало и в конец очереди соответственно. Метод add() унаследован от интерфейса Queue и абсолютно аналогичен методу addLast() интерфейса Deque.

/* пример # 8: демонстрация Deque: DequeRunner.java */

package chapt10;

import java.util.*;

public class DequeRunner {

public static void printDeque(Deque<?> d){

for (Object de: d)

System. out. println(de + "; ");

}

public static void main(String[] args) {

Deque<String> deque = new ArrayDeque<String>();

deque.add(new String("5"));

deque.addFirst("A");

//deque.addLast(new Integer(5));//ошибка компиляции

System. out. println(deque.peek());

System. out. println("Before:");

printDeque (deque);

deque.pollFirst();

System. out. println(deque.remove(5));

System. out. println("After:");

printDeque (deque);

}

}

В результате на консоль будет выведено:

A

Before:

A;

5;

False

After:

5;

Множества

Интерфейс Set<E> объявляет поведение коллекции, не допускающей дублирования элементов. Интерфейс SortedSet<E> наследует Set<E> и объявляет поведение набора, отсортированного в возрастающем порядке, заранее определенном для класса. Интерфейс NavigableSet существенно облегчает поиск элементов.

Рис. 10.2. Иерархия наследования множеств

Класс HashSet<E> наследуется от абстрактного суперкласса
AbstractSet<E> и реализует интерфейс Set<E>, используя хэш-таблицу для хранения коллекции. Ключ (хэш-код) используется вместо индекса для доступа к данным, что значительно ускоряет поиск определенного элемента. Скорость поиска существенна для коллекций с большим количеством элементов. Все элементы такого множества упорядочены посредством хэш-таблицы, в которой хранятся хэш-коды элементов.

Конструкторы класса:

HashSet()

HashSet(Collection <? extends E> c)

Не нашли, что искали? Воспользуйтесь поиском: