openplanning

Hướng dẫn và ví dụ Java NavigableSet

Xem thêm các chuyên mục:

Hãy theo dõi chúng tôi trên Fanpage để nhận được thông báo mỗi khi có bài viết mới. Facebook

1- NavigableSet

NavigableSet là một interface con của SortedSet, vì vậy nó hoạt động giống như một SortedSet, ngoài ra nó được bổ xung các phương thức cho phép điều hướng và tìm kiếm các phần tử.
Chẳng hạn: NavigableSet cho phép truy cập và điều hướng theo thứ tự tăng dần hoặc giảm dần và cung cấp các phương thức như lower, floor, ceiling, higher,.. để tìm kiếm các phần tử.

public interface NavigableSet<E> extends SortedSet<E>
Các đặc điểm được thừa kết từ SortedSet:
Set<E> SortedSet<E> / NavigableSet<E>
Không cho phép phần tử trùng lặp.
Nếu bạn cố tình thêm 1 phần tử trùng lặp vào Set, hành động này sẽ bị bỏ qua.
Tương tự với Set.
Cho phép nhiều nhất một phần tử null. Cho phép nhiều nhất một phần tử null.
Thứ tự của các phần tử không được đảm bảo. Thứ tự của các phần tử được đảm bảo.
Tất cả các phần tử của SortedSet phải là kiểu Comparable (có thể so sánh) hoặc bạn phải cung cấp một Comparator (bộ so sánh) cho SortedSet để nó so sánh các phần tử với nhau.

2- NavigableSet Methods

Các phương thức của NavigableSet:

E lower(E e);

E floor(E e);

E ceiling(E e);

E higher(E e);

E pollFirst();

E pollLast();

NavigableSet<E> descendingSet();

Iterator<E> descendingIterator();

NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                       E toElement,   boolean toInclusive);

NavigableSet<E> headSet(E toElement, boolean inclusive);

NavigableSet<E> tailSet(E fromElement, boolean inclusive);

// --- Methods inherited from SortedSet ------------------------------

Comparator<? super E> comparator();

E first();

E last();

SortedSet<E> subSet(E fromElement, E toElement);

SortedSet<E> headSet(E toElement);

SortedSet<E> tailSet(E fromElement);  

default Spliterator<E> spliterator();  

// --- Other ethods inherited from Set, Collection. ------------------
Iterator<E> iterator();
...

3- Phần tử null

Đặc tả của interface SortedSetNavigableSet hoàn toàn không nói đến phần tử null, điều này có nghĩa là chúng có thể cho phép nhiều nhất một phần tử null (Thừa kế từ đặc tả của interface Set). Như vậy SortedSetNavigabletSet cho phép phần tử null hay không phụ thuộc vào lớp thi hành các interface này.
Trong Java Collection Framework. Lớp TreeSet thi hành interface NavigableSet, nó cho phép phần tử null nếu bạn cung cấp cho nó một Comparator để xử lý việc so sánh phần tử null với các phần tử khác của nó. Trong khi đó, ConcurrentSkipListSet cũng thi hành interface NavigableSet nhưng không cho phép phần tử null trong bất kỳ tình huống nào.
Bạn có thể tìm thấy ví dụ về NavigableSet và phần tử null trong bài viết sau:

4- Examples

Ví dụ: Một đối tượng NavigableSet<Integer> chứa các năm tổ chức World Cup. Sử dụng một vài phương thức của nó để điều hướng và tìm kiếm các phần tử theo yêu cầu.
NavigableSetEx1.java

package org.o7planning.navigableset.ex;

import java.util.Arrays;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSetEx1 {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930);

        // A sorted set in ascending order.
        NavigableSet<Integer> worldCupYears = new TreeSet<Integer>(list);

        System.out.println("World Cup Years: " + worldCupYears);

        // Get a reverse view of the navigable set
        NavigableSet<Integer> reverseYears = worldCupYears.descendingSet();

        System.out.println("Reverse of World Cup Years: " + reverseYears);

        // World Cup Years >= 1935
        NavigableSet<Integer> tailSet1 = worldCupYears.tailSet(1935, true);
        System.out.println("World Cup Years >= 1935: " + tailSet1);

        // World Cup Years <= 1958
        NavigableSet<Integer> headSet1 = worldCupYears.headSet(1938, true);
        System.out.println("World Cup Years <= 1938: " + headSet1);

        // The first year of the World Cup after 1938.
        int year1 = worldCupYears.higher(1938);
        System.out.println("The first year of the World Cup after 1938: " + year1);

        // The last year of the World Cup before 1950.
        int year2 = worldCupYears.lower(1950);
        System.out.println("The last year of the World Cup before 1950: " + year2);
    }
}
Output:

World Cup Years: [1930, 1934, 1938, 1950, 1954, 1958, 1962, 1966, 1970]
Reverse of World Cup Years: [1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930]
World Cup Years >= 1935: [1938, 1950, 1954, 1958, 1962, 1966, 1970]
World Cup Years <= 1938: [1930, 1934, 1938]
The first year of the World Cup after 1938: 1950
The last year of the World Cup before 1950: 1938
Ví dụ: Lớp Player mô phỏng một người chơi với các thông tin fullName, goldMedal, silverMedal, bronzeMedal (Họ tên, số huy chương vàng, bạc, đồng). Lớp Player thi hành interface Comparable<Player> nên có thể so sánh với nhau.
Nguyên tắc so sánh 2 đối tượng Player dựa trên nguyên tắc: Player nào có số lượng huy chương vàng nhiều hơn sẽ được coi là có thứ hạng cao hơn, sau đó sánh số lượng huy chương bạc, số lượng huy chương đồng, họ tên là tiêu chí so sánh cuối cùng. 
Player.java

package org.o7planning.beans;

public class Player implements Comparable<Player> {

    private String fullName;
    private int goldMedal;
    private int silverMedal;
    private int bronzeMedal;

    public Player(String fullName, int goldMedal, int silverMedal, int bronzeMedal) {
        this.fullName = fullName;
        this.goldMedal = goldMedal;
        this.silverMedal = silverMedal;
        this.bronzeMedal = bronzeMedal;
    }

    public String getFullName() {
        return fullName;
    }

    public int getGoldMedal() {
        return goldMedal;
    }

    public int getSilverMedal() {
        return silverMedal;
    }

    public int getBronzeMedal() {
        return bronzeMedal;
    }

    @Override
    public int compareTo(Player o) {
        int g = this.goldMedal - o.goldMedal;
        if (g != 0) {
            return g;
        }
        int s = this.silverMedal - o.silverMedal;
        if (s != 0) {
            return s;
        }
        int b = this.bronzeMedal - o.bronzeMedal;
        if (b != 0) {
            return b;
        }
        return this.fullName.compareTo(o.fullName);
    }
}
Ví dụ: Một NavigableSet chứa các đối tượng Player:
NavigableSetEx2.java

package org.o7planning.navigableset.ex;

import java.util.NavigableSet;
import java.util.TreeSet;

import org.o7planning.beans.Player;

public class NavigableSetEx2 {

    public static void main(String[] args) {
        Player tomA = new Player("Tom A", 3, 1, 4);
        Player tomB = new Player("Tom B", 2, 5, 1);
        Player jerryA = new Player("Jerry A", 1, 2, 4);
        Player jerryB = new Player("Jerry B", 3, 2, 3);
        Player donaldA = new Player("Donald A", 2, 2, 1);
        

        // A sorted set in ascending order.
        NavigableSet<Player> players = new TreeSet<Player>();

        players.add(tomA);
        players.add(tomB);
        players.add(jerryA);
        players.add(jerryB);
        players.add(donaldA);
        
        System.out.println("--- Players (in ascending order) ---");
        for(Player p: players)  {
            System.out.println(p.getGoldMedal()  + " : " + p.getSilverMedal() //
                 +" : " + p.getBronzeMedal() +" - " + p.getFullName());
        }
        
        System.out.println();
        System.out.println("--- Players in decending order ---");
        NavigableSet<Player> decendingPlayers = players.descendingSet();
        
        for(Player p: decendingPlayers)  {
            System.out.println(p.getGoldMedal()  + " : " + p.getSilverMedal() //
                 +" : " + p.getBronzeMedal() +" - " + p.getFullName());
        }
    }
}
Output:

--- Players (in ascending order) ---
1 : 2 : 4 - Jerry A
2 : 2 : 1 - Donald A
2 : 5 : 1 - Tom B
3 : 1 : 4 - Tom A
3 : 2 : 3 - Jerry B

--- Players in decending order ---
3 : 2 : 3 - Jerry B
3 : 1 : 4 - Tom A
2 : 5 : 1 - Tom B
2 : 2 : 1 - Donald A
1 : 2 : 4 - Jerry A
Xem thêm các ví dụ khác trong bài viết về SortedSet:

5- descendingSet()


public NavigableSet<E> descendingSet();
Ví dụ:
NavigableSet_descendingSet_ex1.java

package org.o7planning.navigableset.ex;

import java.util.Arrays;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSet_descendingSet_ex1 {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930);

        // A sorted set in ascending order.
        NavigableSet<Integer> worldCupYears = new TreeSet<Integer>(list); 
        System.out.println("worldCupYears: " + worldCupYears);

        // Get a reverse view of the navigable set
        NavigableSet<Integer> reverseYears = worldCupYears.descendingSet();
        
        System.out.println("reverseYears: " + reverseYears);
        System.out.println();

        System.out.println("Add year 1998");
        reverseYears.add(1998); // World Cup 1998 in France.
        
        System.out.println();
        System.out.println("worldCupYears: " + worldCupYears);
        System.out.println("reverseYears: " + reverseYears);
    }
}
Output:

worldCupYears: [1930, 1934, 1938, 1950, 1954, 1958, 1962, 1966, 1970]
reverseYears: [1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930]

Add year 1998

worldCupYears: [1930, 1934, 1938, 1950, 1954, 1958, 1962, 1966, 1970, 1998]
reverseYears: [1998, 1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930]

6- descendingIterator()


public Iterator<E> descendingIterator();
Trả về đối tượng Iterator để lặp trên các phần tử của NavigableSet theo thứ tự giảm dần. Tương đương với việc gọi descendingSet().iterator().
Ví dụ:
NavigableSet_descendingIterator_ex1.java

package org.o7planning.navigableset.ex;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSet_descendingIterator_ex1 {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("A1", "A2", "C1", "B1", "B2", "D1");
        // A sorted set in ascending order.
        NavigableSet<String> strings = new TreeSet<String>(list);
        System.out.println("NavigableSet: " + strings);
        System.out.println(); 
        Iterator<String> iter = strings.descendingIterator();
        
        while(iter.hasNext()) {
            System.out.println(iter.next());
        }
    }
}
Output:

NavigableSet: [A1, A2, B1, B2, C1, D1]

D1
C1
B2
B1
A2
A1

7- subSet(..)


public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,E toElement,  boolean toInclusive);
Trả về chế độ xem của một phần của NavigableSet này có các phần tử nằm trong khoảng từ fromElement đến toElement. Bao gồm cả fromElement nếu fromInclusivetrue, bao gồm cả toElement nếu toInclusivetrue.
NavigableSet trả về có liên hệ với NavigableSet hiện tại, các thay đổi trên NavigableSet này có ảnh hưởng tới NavigableSet kia và ngược lại.
Ví dụ:
NavigableSet_subSet_ex1.java

package org.o7planning.navigableset.ex;

import java.util.Arrays;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSet_subSet_ex1 {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1986, 1990, 1994,1998,2010, 2014, 2018); // Without: 2006,2002 (!)
        // A sorted set in ascending order.
        NavigableSet<Integer> worldCupYears = new TreeSet<Integer>(list);
        System.out.println("worldCupYears: " + worldCupYears);
        NavigableSet<Integer> subSet = worldCupYears.subSet(1994, true, 2010, true);
        System.out.println("subSet: " + subSet);
        System.out.println();

        System.out.println("Add years 2002,2006 to subSet");
        subSet.add(2002); // World Cup 2002 in South Korea, Japan.
        subSet.add(2006); // World Cup 2006 in Germany.
        
        System.out.println();
        System.out.println("worldCupYears: " + worldCupYears);
        System.out.println("subSet: " + subSet);
    }
}
Output:

worldCupYears: [1986, 1990, 1994, 1998, 2010, 2014, 2018]
subSet: [1994, 1998, 2010]

Add years 2002,2006 to subSet

worldCupYears: [1986, 1990, 1994, 1998, 2002, 2006, 2010, 2014, 2018]
subSet: [1994, 1998, 2002, 2006, 2010]

8- headSet(E toElement, boolean inclusive)


public NavigableSet<E> headSet(E toElement, boolean inclusive);
Trả về chế độ xem của một phần của NavigableSet này, bao gồm các phần tử nhỏ hơn (hoặc bằng, nếu inclusivetrue) toElement.
NavigableSet trả về có liên hệ với NavigableSet hiện tại, các thay đổi trên NavigableSet này có ảnh hưởng tới NavigableSet kia và ngược lại.

9- tailSet(E fromElement, boolean inclusive)


public NavigableSet<E> tailSet(E fromElement, boolean inclusive);
Trả về chế độ xem của một phần của NavigableSet này, bao gồm các phần tử lớn hơn (hoặc bằng, nếu inclusivetrue) fromElement.
NavigableSet trả về có liên hệ với NavigableSet hiện tại, các thay đổi trên NavigableSet này có ảnh hưởng tới NavigableSet kia và ngược lại.
Ví dụ:
NavigableSet_tailSet_ex1.java

package org.o7planning.navigableset.ex;

import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSet_tailSet_ex1 {

    public static void main(String[] args) {
        NavigableSet<String> mySet = new TreeSet<String>();
        mySet.add("A");
        mySet.add("B");
        mySet.add("C");
        mySet.add("D");
        mySet.add("D1");
        mySet.add("E"); 
        // A Head Set (elements >= "C")
        NavigableSet<String> tailSet = mySet.tailSet("C", true);
        System.out.println(" -- tailSet --");
        for (String s : tailSet) {
            System.out.println(s);
        }
        // Remove some elements from tailSet
        tailSet.remove("D");
        tailSet.remove("D1");
        System.out.println();
        System.out.println(" -- mySet (After remove some elements from tailSet --");
        for (String s : mySet) {
            System.out.println(s);
        }
    }
}
Output:

 -- tailSet --
C
D
D1
E

 -- mySet (After remove some elements from tailSet --
A
B
C
E

10- lower(E e)


public E lower(E e);
Trả về phần tử lớn nhất trong NavigableSet này nhỏ hơn phần tử đã cho, hoặc null nếu không có phần tử như vậy.

11- higher(E e)


public E higher(E e);
Trả về phần tử nhỏ nhất trong NavigableSet này lớn hơn phần tử đã cho, hoặc null nếu không có phần tử như vậy.

12- floor(E e)


public E floor(E e);
Trả về phần tử lớn nhất trong NavigableSet này nhỏ hơn hoặc bằng phần tử đã cho, hoặc null nếu không có phần tử như vậy.

13- ceiling(E e)


public E ceiling(E e);
Trả về phần tử nhỏ nhất trong NavigableSet này lớn hơn hoặc bằng phần tử đã cho, hoặc null nếu không có phần tử như vậy.

14- pollFirst()


public E pollFirst();
Lấy và loại bỏ phần tử đầu tiên (nhỏ nhất) hoặc trả về null nếu NavigableSet này rỗng.

15- pollLast()


public E pollLast();
Lấy và loại bỏ phần tử cuối cùng (lớn nhất) hoặc trả về null nếu NavigableSet này rỗng.

Xem thêm các chuyên mục: