רשימת ג'אווה

ה-Java Collection Framework מכיל ממשקים ומחלקות שימושיים מאוד המיישמים אותם לעבודה עם מבני נתונים. ניתן לומר שזו אחת ממסגרות ה-JDK החשובות ביותר. ממשק הרשימה פופולרי מאוד. כי בלי כל מיני רשימות בתכנות זה הכרחי. במאמר זה, נסקור את הממשק הזה, שיטות Java List ויישומים.

ממשק רשימת ג'אווה

הדבר החשוב ביותר ברשימה הוא שמדובר באוסף מסודר . אתה יכול גם לקרוא לזה רצף. ב-Java, רשימות הן הומוגניות, כלומר, הרכיבים של הרשימה הם מאותו סוג נתונים. ממשק Java List יורש מאוסף, הוא יורש את כל הפעולות שלו. בנוסף אליהם, הפעולות הבאות אפשריות גם ב- List:

• גישה עמדה. לכל אלמנט יש אינדקס וניתן לתפעל אותו על סמך מיקומו. ברשימה. כלומר, אתה יכול להוסיף, לא לכלול ולשנות אלמנטים.
• לחפש. אתה יכול למצוא אלמנט ברשימה לפי התוכן שלו ולהחזיר את האינדקס שלו.
• איטרציה. האופי הרציף של List מאפשר שימוש בשיטות איטרציה (listIterator).
• תצוגת טווח. שיטת ה-sublist מבצעת פעולות טווח שרירותיות ברשימה.

שיטות רשימת Java

הפעולות לעיל נחשפות בשיטות של ממשק Java List. הנה כמה מהם:

יישום רשימה

מכיוון שרשימה היא ממשק, תוכניות צריכות ליצור יישום קונקרטי שלו. אתה יכול לבחור בין ההטמעות הבאות של רשימה ב-Java Collections API:

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

היישום הפופולרי ביותר של ממשק List בשם ArrayList. הרבה פחות לעתים קרובות, אבל אתה עדיין יכול לראות את השימוש ב-LinkedList במשימות אמיתיות, אבל Vector ו-Stack הפכו מיושנים מבחינה מוסרית במשך זמן רב, כך שסביר להניח שתמצא אותם רק בפרויקטים עם קוד מורשת עתיק.

הצהרת ממשק רשימה

אתה יכול להכריז על רשימה בתוכנית 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 הוא מערך דינמי, ובתוכו מערך רגיל. מערך זה פועל כמאגר נתונים. ArrayList מאחסן רק סוגי הפניות, אובייקטים כלשהם, כולל מחלקות של צד שלישי, מחרוזות, זרמי פלט ואוספים אחרים. מחלקות Wrapper משמשות לאחסון סוגי נתונים פרימיטיביים ב- ArrayList. בעת יצירת רשימה, אנו יכולים להגדיר מיד את גודלה, אך ברוב המקרים לא. כברירת מחדל, גודל ArrayList = 10. איך נראית הוספת אלמנט חדש ל-ArrayList? קודם כל, מתחילים לבדוק אם יש מספיק מקום במערך הפנימי והאם אלמנט אחד נוסף יתאים. אם יש מקום, האלמנט החדש מתווסף לסוף הרשימה, כלומר לתא שעוקב אחרי האלמנט האחרון. האינדקס שלו יהיה arraylist.size(). אם רק יצרנו את הרשימה שלנו והיא ריקה, זה אומר ש-arrayList.size() = 0. בהתאם, יתווסף לתא אלמנט חדש עם אינדקס 0. אם יתברר שאין מספיק מקום, מערך נוצר בתוך ArrayList עם הגודל (גודל ה-OldArray * 1.5) + 1. לפי אותו עיקרון, הוספה מתרחשת באמצע הרשימה, אך במקביל, כל האלמנטים הבאים אחרי האלמנט שהוכנס הם הוסט ימינה. לכן, אם יש לנו 5 אלמנטים במערך, ואנחנו צריכים להכניס אלמנט לתוך תא מספר 2 (כלומר, השלישי), אז רכיבי מערך 0 ו-1 נשארים במקומם, אלמנט חדש מופיע בתא 2, ו קודמו עובר לתא השלישי וכן הלאה.

דוגמה לרשימת Java (מימוש רשימת מערכים)

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, האלמנטים הם למעשה קישורים באותה שרשרת. לכל אלמנט, בנוסף לנתונים שהוא מאחסן, יש קישור לאלמנט הקודם והבא. קישורים אלו מאפשרים לנווט מאלמנט אחד למשנהו. האיטרטור תומך במעבר לשני הכיוונים. מיישמת שיטות לקבלה, הסרה והוספה בתחילת, באמצע וסוף רשימה. מאפשר לך להוסיף כל רכיב כולל null. LinkedList מיישמת שני ממשקים - לא רק List, אלא גם Deque. זה מספק את היכולת ליצור תור דו-כיווני מכל אלמנט, אפילו ריק. כל אובייקט המוצב ברשימה המקושרת הוא צומת (צומת). כל צומת מכיל אלמנט, קישור לצומת הקודם והבא. למעשה, הרשימה המקושרת מורכבת מרצף של צמתים, שכל אחד מהם נועד לאחסן אובייקט מהסוג שהוגדר בעת יצירתו.

דוגמה לקוד

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);
                }
       }

הפלט נמצא כאן:

דוגמה לקוד וקטור

וקטור הוא גם מימוש מערך דינמי והוא דומה מאוד ל-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());

   }
}

הפלט הוא:

קוד כיתה 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, הן קלאסיות עבור מבנה נתונים כזה. המחסנית מצייתת לכלל "ראשון נכנס, אחרון יוצא" - זה כזה אנטי-תור. לכן, פעולת הפופ מקפיצה את האלמנט שהונח לאחרונה על הערימה. הנה הפלט של הדוגמה שלנו: