רשימה צובינד אין Java



ז'אבא Java רשימה רעשימע

רשימה צובינד אין Java

א Java רשימה אָדער רשימה צובינד אין Java איז אַ זאַמלונג אָדער סיקוואַנס פון עלעמענטן אין אַ אָרדערד שטייגער. זינט די רשימה מיינטיינז אַ באַזונדער סיקוואַנס, מיר קענען דורכפירן קיין אָפּעראַציע ווי לייגן, ויסמעקן, באַקומען, שטעלן אויף די רשימה מיט די פארלאנגט אינדעקס. דער אינדעקס שטענדיק סטאַרץ ביי 0. עס יקסטענדז די קאַלעקשאַן צובינד.

Java רשימה קלאַס אָדער צובינד?

די רשימה איז אַ צובינד און נישט אַ קלאַס. מיר מוזן שטענדיק זאָגן רשימה צובינד.

Java List Interface (ליסטע סינטאַקס)

מיר קענען מאַכן אַ רשימה צובינד אין די אונטן וועגן. מיר קענען נוצן ArrayList (), לינקעדליסט () אָדער סטאַק.

אָן כייפעץ טיפּ

מיר קענען קראָם קיין טיפּ פון ווערט אין ליסטע אויב מיר טאָן ניט ספּעציפיצירן די כייפעץ טיפּ.

רשימה רשימה נאָמען = נייַ אַררייַליסט ();

מיט כייפעץ טיפּ

מיר קענען קראָם בלויז ספּעציפיש ווערט טיפּ אין ליסטע אויב מיר ספּעציפיצירן די כייפעץ טיפּ.

רשימה ליסטנאַמע = נייַ אַררייַליסט ();

למשל: רשימה ליסטנאַמע = נייַ אַררייַליסט (); -> די רשימה קענען בלויז קראָם סטרינג וואַלועס

באַגרענעצן רשימה נומער ציילן

רשימה ליסטנאַמע = נייַ אַררייַליסט (נומער);

למשל: רשימה ליסטנאַמע = נייַ אַררייַליסט (2); -> די רשימה קענען בלויז קראָם 2 וואַלועס

פּעקל צו אַרייַנפיר

מיר דאַרפֿן צו אַרייַנפיר די אונטן דערמאנט פּעקל צו נוצן די Java רשימה צובינד.

אַרייַנפיר java.util.List;

Java ליפעטיאָנס

Java רשימה צובינד ווארפט ער אונטער אויסנעמען:

  • UnsupportedOperationException - ווען די אָפּעראַציע איז נישט געשטיצט
  • IndexOutofBoundsException - ווען פאַרקריפּלט אינדעקס איז ספּעציפיצירט (פֿון אינדעקס <0 אָדער פֿון אינדעקס> טאָינדעקס אָדער טאָינדעקס> גרייס)
  • ClassCastException - ווען דער סאָרט פון די ספּעסאַפייד עלעמענט פּריווענץ צו לייגן עס צו די רשימה
  • NullPointerException - ווען די ספּעסאַפייד עלעמענט איז נאַל און די רשימה קען נישט לייגן נול עלעמענטן
  • IllegalArgumentException - ווען עטלעכע פאַרמאָג פון די עלעמענט פּריווענץ צו לייגן צו די רשימה

Java רשימה מעטהאָדס

דזשאַוואַ ליסטע צובינד שטיצט אַלע די אונטן-דערמאנט מעטהאָדס און פעליקייַט מעטהאָדס פון די קאַלעקשאַן צובינד.

מעטאָדבאַשרייַבונגפּאַראַמעטער
באָאָלעאַן לייגן (כייפעץ e)מוסיף די ספּעסאַפייד עלעמענט צו די סוף פון דער רשימה.e - דער עלעמענט צו לייגן.
צוריקקער ווערט - אמת
פּאָסל לייגן (ינט אינדעקס, כייפעץ E)מוסיף דעם עלעמענט צו די ספּעסאַפייד אינדעקס. אויב דער אינדעקס שוין כּולל אַן עלעמענט, עס איז שיפטאַד צו די רעכטאינדעקס - דער אינדעקס אין וועלכן דער עלעמענט דאַרף זיין ינסערטאַד
e - דער עלעמענט וואָס דאַרף זיין ינסערטאַד
באָאָלעאַן אַדדאַלל (זאַמלונג C)לייגט אַ זאַמלונג פון ספּעסאַפייד עלעמענטן אין דער רשימה.c - זאַמלונג פון עלעמענטן צו זיין מוסיף
צוריקקער ווערט - אמת
באָאָלעאַן אַדדאַלל (ינט אינדעקס, זאַמלונג C)מוסיף אַ זאַמלונג פון עלעמענטן אין די ספּעסאַפייד אינדעקס. אויב דער אינדעקס שוין כּולל עלעמענט, עס איז דערנאָך שיפטאַד צו די רעכטאינדעקס - אינדעקס אין וואָס די עלעמענטן דאַרפֿן צו זיין מוסיף
c - זאַמלונג פון עלעמענטן צו זיין מוסיף
צוריקקער ווערט - אמת
פּאָסל קלאָר ()קלירז אַלע די עלעמענטן אין דער רשימה.
באָאָלעאַן כּולל (כייפעץ אָ)טשעקס אויב די רשימה כּולל די ספּעסאַפייד עלעמענטצוריקקער ווערט - אמת אויב די רשימה כּולל די עלעמענט
באָאָלעאַן כּולל אַלע (זאַמלונג C)טשעקס אויב די רשימה כּולל אַלע די עלעמענטן אין דער זאַמלונגצוריקקער ווערט - אמת אויב די רשימה כּולל אַלע די עלעמענטן
באָאָלעאַן יקוואַלז (כייפעץ אָ)קאָמפּאַרעס אויב די רשימה כּולל אַלע די ספּעסאַפייד עלעמענטן אין די פּינטלעך סדרצוריקקער ווערט - אמת אויב כייפעץ עלעמענטן גלייַכן מיט די רשימה
כייפעץ געטינדעקס (ינט אינדעקס)ריטריווז די עלעמענט אין די ספּעסאַפייד אינדעקסאינדעקס - דער אינדעקס אין וואָס דער עלעמענט וואָס דאַרף זיין ריטריווד
צוריקקער ווערט - דער עלעמענט אין דער ספּעסאַפייד אינדעקס
int indexOf (כייפעץ אָ)פעטשעס דער אינדעקס פון דער ערשטער פּאַסירונג פון די ספּעסאַפייד עלעמענטאָ - דער יסוד צו זיין יידענאַפייד
צוריקקער ווערט - אינדעקס ווערט
באָאָלעאַן isEmpty ()טשעקס אויב די רשימה איז ליידיק אָדער נישטצוריקקער ווערט - אמת אויב רשימה כּולל קיין וואַלועס
יטעראַטאָר יטעראַטאָר ()ריטריווז די יטעראַטאָר פון די רשימה אין סיקוואַנסצוריקקער ווערט - יטעראַטאָר
int lastIndexOf (כייפעץ אָ)ריטריווז די לעצטע פּאַסירונג פון די ספּעסאַפייד כייפעץאָ - עלעמענט צו זיין יידענאַפייד
צוריקקער ווערט - אינדעקס ווערט
כייפעץ אַראָפּנעמען (ינט אינדעקס)רימוווז די עלעמענט אין די ספּעסאַפייד אינדעקסאינדעקס - אינדעקס שטעלע אין וועלכן דער עלעמענט דאַרף ווערן אַוועקגענומען
צוריקקער ווערט - דער עלעמענט וואָס איז אַוועקגענומען
באָאָלעאַן אַראָפּנעמען (כייפעץ אָ)רימוווז דער ערשטער פּאַסירונג פון די ספּעסאַפייד כייפעץ פֿון דער רשימה אויב עס איז פאָרשטעלןאָ - דער עלעמענט וואָס דאַרף זיין אַוועקגענומען
ווייַזן ווערט - אמת אויב רשימה כּולל דעם עלעמענט
באָאָלעאַן אַראָפּנעמען אַלע (זאַמלונג C)רימוווז די ערשטע פּאַסירונג פון אַלע עלעמענטן אין דער זאַמלונג אויב עס איז פאָרשטעלןc - זאַמלונג פון עלעמענטן
צוריקקער ווערט - אמת אויב די רשימה כּולל די זאַמלונג
באָאָלעאַן ריטיין (קאַלעקשאַן C)ריטיין אַלע די עלעמענטן וואָס זענען ספּעסאַפייד אין דער זאַמלונג. אנדערע עלעמענטן וועלן ווערן אַוועקגענומעןc - זאַמלונג פון עלעמענטן וואָס מוזן זיין ריטיינד
צוריקקער ווערט - אמת אויב די רשימה איז געביטן רעכט צו דער גערופֿן אופֿן
כייפעץ שטעלן (ינט אינדעקס, כייפעץ אָ)ריפּלייסיז די עלעמענט אין די ספּעסאַפייד אינדעקס מיט דעם כייפעץ דורכגעגאנגעןאָ - דער עלעמענט צו זיין ריפּלייסט
אינדעקס - אינדעקס פון דער עלעמענט
צוריקקער ווערט - קערט דער עלעמענט וואָס איז געווען פריער אין די ספּעסאַפייד אינדעקס
ינט גרייס ()ברענגען די גרייס פון דער רשימהווייַזן ווערט - גרייס פון דער רשימה
רשימה סובליסט (רשימה פֿון אינדעקס, ינט צו אינדעקס)ריטריווז די טייל פון דער רשימה באזירט אויף אָנהייב און ענדינדעקסfromIndex - שטעלע פֿון וואָס די סובליסט דאַרף זיין ריטריווד (אַרייַנגערעכנט)
toIndex - דער אינדעקס ביז וואָס די סובליסט דאַרף זיין ריטריווד (יקסקלודיד)

Java List בייַשפּיל

פּראָגראַם צו אילוסטרירן רשימה () אַפּעריישאַנז

import java.util.ArrayList;
import java.util.List;

public class ListExample {

  public static void main(String[] args) {
    List<String> list1 = new ArrayList<String>();
    //Add elements to List1
    list1.add("Java");
    list1.add("Javascript");
    list1.add("C#");
    System.out.println("Elements of List1");
    System.out.println(list1);
    
    //Add element at index1
    list1.add(1, "C");
    System.out.println("Elements of List1 after adding new element at index 1:");
    System.out.println(list1);
    
    //Create new List with elements
    List<String> list2 = new ArrayList<String>();
    list2.add("PHP");
    list2.add("C++");
    System.out.println("Elements of List2");
    System.out.println(list2);
    
    //Adds all elements from List2 to List1
    list1.addAll(1, list2);
    System.out.println("Elements of List 1 after adding List2 elements");
    System.out.println(list1);
    
    //Fetch sublist from List1
    List<String> sub = new ArrayList<String>();
    sub = list1.subList(1, 3);
    System.out.println("Sublist of List 1 from index 1 to 3:" + sub);
    
    //Check if List1 contains an element
    Boolean b = list1.contains("C");
    System.out.println("To check if List1 contains C : " + b);
    
    //Check if List1 contains a collection
    b = list1.containsAll(list2);
    System.out.println("To check if List1 contains List2 elements : " + b);
    
    //Get an element of specific index
    String strvalue = list1.get(4);
    System.out.println("Element at index 4: " + strvalue);
    
    //Set an element at specific index
    list2.set(1, "VBScript");
    System.out.println("Elements in List2 after setting an element at index 1");
    System.out.println(list2);
    
    //Get list size
    System.out.println("Size of List2 is : " + list2.size());
    
    //Remove an element at specific index
    String strval = list1.remove(1);
    System.out.println("The element " + strval + " is removed from List1");
    System.out.println("Elements in List1 after remove method:");
    System.out.println(list1);
  }
}
Output:
Elements of List1
[Java, Javascript, C#]
Elements of List1 after adding new element at index 1:
[Java, C, Javascript, C#]
Elements of List2
[PHP, C++]
Elements of List 1 after adding List2 elements
[Java, PHP, C++, C, Javascript, C#]
Sublist of List 1 from index 1 to 3:[PHP, C++]
To check if List1 contains C : true
To check if List1 contains List2 elements : true
Element at index 4: Javascript
Elements in List2 after setting an element at index 1
[PHP, VBScript]
Size of List2 is : 2
The element PHP is removed from List1
Elements in List1 after remove method:
[Java, C++, C, Javascript, C#]

ליסטיטעראַטאָר

מיר נוצן ListIterator צו יבערקוקן אָדער דורכפאָר די רשימה. עס איז אַן פאַרלענגערונג פון די יטעראַטאָר צובינד און שטיצט די אונטן אַפּעריישאַנז.

מעטאָדבאַשרייַבונג
באָאָלעאַן hasNext ()קערט אמת אויב רשימה האט ווייַטער ווערט. עס איז געניצט צו קאָנטראָלירן אויב די רשימה האט מער וואַלועס צו פאָרן אין פאָרויס ריכטונג
שטריקל ווייַטער ()קערט דער ווייַטער עלעמענט
פּאָסל אַראָפּנעמען ()רימוווז די לעצטע עלעמענט וואָס איז אומגעקערט דורך next () אָדער previous (). עס קענען זיין גערופֿן נאָר אַמאָל פּער רופן
באָאָלעאַן האט פריער ()קערט אמת אויב די רשימה האט מער וואַלועס בשעת יטעראַטינג אין פאַרקערט ריכטונג
int nextIndex ()קערט דער אינדעקס פון דער עלעמענט אומגעקערט דורך ווייַטער
() מעטאָד
שטריקל פֿריִערדיקע ()רעטורנס די פריערדיקע עלעמענט אין דער רשימה
ינט פרייַערדיקינדעקס ()רעטורנס דער אינדעקס פון דעם עלעמענט אומגעקערט דורך פרייַערדיק () אופֿן
פּאָסל שטעלן (שטריקל e)ריפּלייסיז די עלעמענט אומגעקערט דורך ווייַטער () אָדער פרייַערדיק () מיט די ווערט דורכגעגאנגען

ליסטינג יטעראַטאָר אויסנעמען

ListIterator וואַרפן די אונטן אויסנעמען:

  • ConcurrentModificationException - ווען מיר פּרובירן צו מאָדיפיצירן די רשימה בשעת טראַווערסינג
  • NoSuchElementException - ווען עס יטעראַטאָר קען נישט צוריקקריגן אַזאַ עלעמענט.

בייַשפּיל: Java פּראָגראַם צו אילוסטרירן ListIterator

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class IteratorExample {

  public static void main(String[] args) {
    ListIterator<String> litr = null;
      List<String> months = new ArrayList<String>();
      months.add("Jan");
      months.add("Feb");
      months.add("March");
      months.add("April");
      months.add("May");
      
      //Obtaining list iterator
      litr=months.listIterator();
   
      System.out.println("Navigating the list in forward direction:");
      while(litr.hasNext()){
         System.out.println(litr.next());
      }
      
      //Setting element at the end of list
      litr.set("June");
      
      System.out.println("Navigating the list in backward direction:");
      while(litr.hasPrevious()){
         System.out.println(litr.previous());
      }
    
  }

}
Output:
Navigating the list in forward direction:
Jan
Feb
March
April
May
Navigating the list in backward direction:
June
April
March
Feb
Jan

סאָף

דעם טוטאָריאַל גיט דיטיילד אינפֿאָרמאַציע ווי צו נוצן Java ליפע (ליסטע צובינד אין Java) מעטהאָדס מיט אילוסטראציעס.

רעפערענץ:

https://en.wikipedia.org/wiki/Java_collections_framework#List_interface