betacode

Руководство Java NavigableSet

Следуйте за нами на нашей фан-странице, чтобы получать уведомления каждый раз, когда появляются новые статьи. Facebook

1- NavigableSet

NavigableSet -это подинтерфейс  of SortedSet, поэтому он работает как SortedSet. Кроме того, он имеет дополнительные методы, которые позволяют перемещаться и находить элементы.
Например: NavigableSet позволяет осуществлять доступ и навигацию в порядке возрастания или убывания и предоставляет такие методы, как lower, floor, ceiling, higher, .. для поиска элементов.

public interface NavigableSet<E> extends SortedSet<E>
Характеристики наследуются от SortedSet:
Set<E>SortedSet<E> / NavigableSet<E>
Дубликаты элементов не допускаются. Если вы намеренно добавляете повторяющийся элемент
в Set, это действие будет проигнорировано.
Похоже на Set.
Допускает не более одного элемента null.Допускает не более одного элемента null.
Порядок элементов не гарантируется.
Порядок элементов гарантируется.
Все элементы  of  SortedSet должны иметь тип Comparable (сопоставимый), или вы должны предоставить Comparator  (компаратор) для SortedSet, чтобы он сравнивал элементы.

2- NavigableSet Methods

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- Элемент null

Спецификация интерфейса SortedSet и NavigableSet вообще не упоминает элементы null, это означает, что они могут допускать не более одного элемента null (наследуемого от спецификации интерфейса Set). Таким образом, разрешают ли SortedSet и NavigabletSet  элементы  null или нет, зависит от класса, реализующего эти интерфейсы.
В Java Collection Framework класс TreeSet реализует интерфейс NavigableSet, который позволяет обрабатывать элементы null, если вы даете ему Comparator для сравнения элемента null  другими его элементами. Между тем, ConcurrentSkipListSet также реализует интерфейс NavigableSet, но не допускает элемента null ни в одной ситуации.
Вы можете найти примеры о NavigableSet и элементе null  в следующей статье:

4- Examples

Например: Объект NavigableSet<Integer>, содержащий годы проведения World Cup. Используйте некоторые из его методов для навигации и поиска нужного элемента.
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
например: Класс Playerимитирует игрока с информацией FullName, goldMedal, silverMedal, bronzeMedal (полное имя, количество золотых, серебряных, бронзовых медалей). Класс Player реализует Comparable<Player>, поэтому он сопоставим.
Принцип сравнения двух объектов Player основан на этом принципе: Player с большим количеством золотых медалей будет считаться имеющим более высокий рейтинг, затем осуществляется сравнение  количества серебряных медалей, количество бронзовых медалей, полное имя является окончательным критерием сравнения.
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);
    }
}
Например: NavigableSet содержит объекты 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
Дополнительные примеры о SortedSet см. в статье:

5- descendingSet()


public NavigableSet<E> descendingSet();
Например:
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();
Возвращает объект Iterator для перебора элементов of NavigableSet  в порядке убывания. Это эквивалентно вызову descendingSet().iterator().
Например:
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);
Возвращает представление части этого NavigableSet, элементы которого варьируются от fromElement до toElement, включая fromElement, если значение fromInclusive равно true, и включая toElement, если значение toInclusive равно true.
Возвращенный NavigableSet связан с текущим NavigableSet. Изменения в одном NavigableSet  влияют на другой и наоборот.
Например:
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);
Возвращает представление части этого NavigableSet, включая элементы, которые меньше (или равны, если inclusive - true) toElement.
Возвращенный NavigableSet связан с текущим NavigableSet. Изменения в одном NavigableSet влияют на другой и наоборот.

9- tailSet(E fromElement, boolean inclusive)


public NavigableSet<E> tailSet(E fromElement, boolean inclusive);
Возвращает представление части этого NavigableSet, включая элементы, которые больше (или равны, если inclusive - true) fromElement.
Возвращенный NavigableSet связан с текущим NavigableSet. Изменения в одном NavigableSet влияют на другой и наоборот.
Например:
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);
Возвращает наибольший элемент в этом NavigableSet, который меньше, чем данный элемент, или null, если такого элемента нет.

11- higher(E e)


public E higher(E e);
Возвращает наименьший элемент в этом NavigableSet, который больше, чем данный элемент, или null, если такого элемента нет.

12- floor(E e)


public E floor(E e);
Возвращает наибольший элемент в этом NavigableSet, который меньше или равен данному элементу, или null, если такого элемента нет.

13- ceiling(E e)


public E ceiling(E e);
Возвращает наименьший элемент в этом NavigableSet, который больше или равнен данному элементу, или null, если такого элемента нет.

14- pollFirst()


public E pollFirst();
Извлекает и удаляет первый (наименьший) элемент или возвращает значение null, если этот NavigableSet пуст.

15- pollLast()


public E pollLast();
Извлекает и удаляет последний (самый большой) элемент или возвращает null, если этот NavigableSet пуст.
Maybe you are interested

Это онлайн курс вне вебсайта o7planning, который мы представляем, он включает бесплатные курсы или курсы со скидкой.