Списък на Java

Java Collection Framework съдържа много полезни интерфейси и класове, които ги реализират за работа със структури от данни. Може да се каже, че това е една от най-важните JDK рамки. Интерфейсът List е много популярен. защото без всяHowви списъци в програмирането е незаменим. В тази статия ще разгледаме този интерфейс, методите и реализациите на Java List.

Java списък интерфейс

Най-важното нещо за списъка е, че той е подредена колекция. Можете също да го наречете последователност. В Java списъците са хомогенни, тоест елементите на списъка са от един и същи тип данни. Интерфейсът на Java List наследява от Collection, той наследява всички негови операции. Освен тях в List са възможни и следните операции:

• Позиционен достъп. Всеки елемент има индекс и може да бъде манипулиран въз основа на тяхната позиция. в списъка. Тоест можете да добавяте, изключвате и модифицирате елементи.
• Търсене. Можете да намерите елемент в списък по съдържанието му и да върнете индекса му.
• Повторение. Последователният характер на List позволява използването на итерационни методи (listIterator).
• Обхват-изглед. Методът подсписък изпълнява операции с произволен диапазон върху списъка.

Списъчни методи на Java

Горните операции са изложени в методите на интерфейса на Java List. Ето някои от тях:

Изпълнение на списък

Тъй като List е интерфейс, програмите трябва да създадат конкретна реализация на него. Можете да избирате между следните изпълнения на списък в API за колекции на Java:

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

Най-популярната реализация на интерфейса List се нарича ArrayList. Много по-рядко, но все още можете да видите използването на LinkedList в реални задачи, но Vector и Stack са морално остарели за дълго време, така че най-вероятно ще ги намерите само в проекти с древен наследен code.

Декларация за интерфейс на списък

Можете да декларирате списък в Java програма по един от следните начини:

List<String> myList = new ArrayList();
List myList1 = new ArrayList();
List myList3 = new ArrayList<String>();
ArrayList arrayList = new ArrayList();

Най-добре е да декларирате нов списък чрез интерфейс. По подобен начин можете да декларирате други реализации на List. Най-краткият път:

Vector myVector = new Vector;
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();

С такава декларация типът данни на елементите на такива списъци се определя по време на инициализацията на списъка, тоест когато елементите се добавят там.

List myList = new ArrayList<String>();
Vector myVector = new Vector();
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();
stack.add("Paul");
linkedList.add(1);
myVector.add(1.2f);
myList.add('a');

Сега към нашия стек могат да се добавят само низове, цели числа към linkedList , плаващи към myVector и myList е списък от знаци.

Как работи ArrayList

Ако вече сте запознати с обикновените масиви, донякъде сте запознати и с ArrayList. Всъщност ArrayList е динамичен масив, а вътре в него е обикновен масив. Този масив действа като хранorще на данни. ArrayList съхранява само референтни типове, всяHowви обекти, включително класове на трети страни, низове, изходни потоци и други колекции. Класовете Wrapper се използват за съхраняване на примитивни типове данни в ArrayList. Когато създаваме списък, можем веднага да зададем размера му, но в повечето случаи не го правим. По подразбиране размерът на ArrayList = 10. Как изглежда добавянето на нов елемент към ArrayList? Първо се започва проверка дали има достатъчно място във вътрешния масив и дали ще се побере още един елемент. Ако има място, новият елемент се добавя в края на списъка, тоест в клетката, която следва последния елемент. Неговият индекс ще бъде arraylist.size(). Ако току-що сме създали нашия списък и той е празен, това означава, че arrayList.size() = 0. Съответно към клетката ще бъде добавен нов елемент с индекс 0. Ако се окаже, че няма достатъчно място, нов вътре в ArrayList се създава масив с размер (размера на OldArray * 1.5) + 1. По същия принцип вмъкването се извършва в средата на списъка, но в същото време всички елементи, които следват вмъкнатия елемент, се изместен надясно. Така че, ако имаме 5 елемента в масива и трябва да вмъкнем елемент в клетка номер 2 (т.е. третата), тогава 0 и 1 елемент от масива остават на мястото си, нов елемент се появява в клетка 2 и неговият предшественик отива в третата клетка и т.н. ще бъде добавен нов елемент към клетката с индекс 0. Ако се окаже, че няма достатъчно място, в ArrayList се създава нов масив с размер (размера на OldArray * 1.5) + 1. По същия начин принцип, вмъкването се извършва в средата на списъка, но в същото време всички елементи, които следват вмъкнатия елемент, се изместват надясно. Така че, ако имаме 5 елемента в масива и трябва да вмъкнем елемент в клетка номер 2 (т.е. третата), тогава 0 и 1 елемент от масива остават на мястото си, нов елемент се появява в клетка 2 и неговият предшественик отива в третата клетка и т.н. ще бъде добавен нов елемент към клетката с индекс 0. Ако се окаже, че няма достатъчно място, в ArrayList се създава нов масив с размер (размера на OldArray * 1.5) + 1. По същия начин принцип, вмъкването се извършва в средата на списъка, но в същото време всички елементи, които следват вмъкнатия елемент, се изместват надясно. Така че, ако имаме 5 елемента в масива и трябва да вмъкнем елемент в клетка номер 2 (т.е. третата), тогава 0 и 1 елемент от масива остават на мястото си, нов елемент се появява в клетка 2 и неговият предшественик отива в третата клетка и т.н. възниква вмъкване в средата на списъка, но в същото време всички елементи, които следват вмъкнатия елемент, се изместват надясно. Така че, ако имаме 5 елемента в масива и трябва да вмъкнем елемент в клетка номер 2 (т.е. третата), тогава 0 и 1 елемент от масива остават на мястото си, нов елемент се появява в клетка 2 и неговият предшественик отива в третата клетка и т.н. възниква вмъкване в средата на списъка, но в същото време всички елементи, които следват вмъкнатия елемент, се изместват надясно. Така че, ако имаме 5 елемента в масива и трябва да вмъкнем елемент в клетка номер 2 (т.е. третата), тогава 0 и 1 елемент от масива остават на мястото си, нов елемент се появява в клетка 2 и неговият предшественик отива в третата клетка и т.н.

Пример за списък на Java (реализация на Arraylist)

import java.util.*;

public class ArrayListExample2 {
   public static void main(String[] args) {
       List<String> myFriendsList = new ArrayList();
       //we created list of some objects 
       System.out.println( "the size of myList before init = " + myFriendsList.size());
       myFriendsList.add("Alex");
       myFriendsList.add("Tanya");
       myFriendsList.add("Veloxy");
       myFriendsList.add("Alex");
       myFriendsList.add("Andrew");
       System.out.println(myFriendsList);
       System.out.println( "the size of myList after init = " + myFriendsList.size());

       myFriendsList.add("Ihor");
       System.out.println(myFriendsList);
       System.out.println("the size of my list = " +  myFriendsList.size());


       //here the program will print out the first appearance of "Alex" element
       System.out.println(myFriendsList.indexOf("Alex"));
       //program will print out the first appearance of "Alex" element starting from the element 0

       myFriendsList.remove(3);
       System.out.println(myFriendsList.get(3));
       System.out.println("after removing one of Alex's there is only one Alex: " + myFriendsList);
       System.out.println(myFriendsList.get(1));



       myFriendsList.clear();
       System.out.println("the size of the vector after clear method = " +  myFriendsList.size());

   }
}

Ето резултата от тази програма:

Как работи LinkedList

В LinkedList елементите всъщност са връзки в една и съща верига. Всеки елемент, освен данните, които съхранява, има връзка към предишния и следващия елемент. Тези връзки ви позволяват да навигирате от един елемент към друг. Итераторът поддържа преминаване в двете посоки. Внедрява методи за получаване, премахване и вмъкване в началото, средата и края на списък. Позволява ви да добавяте всяHowви елементи, включително null. LinkedList имплементира два интерфейса — не само List, но и Deque. Това осигурява възможност за създаване на двупосочна опашка от всяHowви елементи, дори нула. Всеки обект, поставен в свързания списък, е възел (възел). Всеки възел съдържа елемент, връзка към предишния и следващия възел. Всъщност свързаният списък се състои от поредица от възли, всеки от които е проектиран да съхранява обект от типа, дефиниран при създаването му.

Пример за code

import java.util.*;
public class LinkedListTest {

       public static void main(String args[]){

           List myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           myLinkedList.add(5);
           myLinkedList.remove(1);
           System.out.println(myLinkedList);
           myLinkedList.size(); //3
           
           //add new element at the specified position:
           myLinkedList.add(2,7);
           System.out.println(myLinkedList);
                }
       }

Резултатът е тук:

Пример за векторен code

Vector също е реализация на динамичен масив и е много подобен на ArrayList, но е синхронизиран и има някои наследени методи, които рамката за събиране не съдържа. Ето прост пример за използване на този клас.

import java.util.Vector;

public class VectorExample1 {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       vector.add("Alex");
       vector.add("Tanya");
       vector.add("Andrew");
       System.out.println(vector);
       vector.add("Alex");
       vector.add("Ihor");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Andrew"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Alex", 1));
       System.out.println(vector);
       vector.clear();
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

Резултатът е:

Пример за code на клас Java Stack

import java.util.Stack;

public class StackTest {
   public static void main(String[] args) {
       Stack stack = new Stack();
       System.out.println(stack.isEmpty());
       stack.add("Paul");
       stack.add("Johnny");
       stack.add("Alex");
       System.out.println(stack.isEmpty());
       stack.push("Andrew");
       System.out.println(stack);
       stack.pop();
       System.out.println(stack);
   }
}

Stack има не само add() и remove() методи, но и push и pop, те са класически за такава структура на данните. Стекът се подчинява на правилото „първи влязъл, последен излязъл“ — това е такава анти-опашка. Следователно операцията pop изважда елемента, който последно е бил поставен в стека. Ето резултата от нашия пример: