import
java.util.Collection;
import
java.util.Comparator;
import
java.util.Iterator;
import
java.util.NavigableSet;
import
java.util.SortedSet;
import
java.util.TreeSet;
class
TreeSetImplementation<E> {
private
TreeSet<E> set;
public
TreeSetImplementation()
{
set =
new
TreeSet<E>();
}
public
TreeSetImplementation(
Collection<?
extends
E> obj)
{
set =
new
TreeSet<E>(obj);
}
public
TreeSetImplementation(
Comparator<?
super
E> comparator)
{
set =
new
TreeSet<E>(comparator);
}
public
TreeSetImplementation(SortedSet<E> set1)
{
set =
new
TreeSet<E>(set1);
}
public
boolean
add(E ele) {
return
set.add(ele); }
public
boolean
addAll(Collection<?
extends
E> colle)
{
return
set.addAll(colle);
}
public
void
clear() { set.clear(); }
public
Object clone() {
return
set.clone(); }
public
Comparator<?
super
E> comparator()
{
return
set.comparator();
}
public
boolean
contains(Object obj)
{
return
set.contains(obj);
}
public
Iterator<E> descendingIterator()
{
return
set.descendingIterator();
}
public
NavigableSet<E> descendingSet()
{
return
set.descendingSet();
}
public
E first() {
return
set.first(); }
public
E floor(E ele) {
return
set.floor(ele); }
public
E ceiling(E ele) {
return
set.ceiling(ele); }
public
SortedSet<E> headSet(E ele)
{
return
set.headSet(ele);
}
public
NavigableSet<E> headSet(E ele,
boolean
inclusive)
{
return
set.headSet(ele, inclusive);
}
public
E higher(E ele) {
return
set.higher(ele); }
public
boolean
isEmpty() {
return
set.isEmpty(); }
public
Iterator<E> iterator() {
return
set.iterator(); }
public
E last() {
return
set.last(); }
public
E lower(E ele) {
return
set.lower(ele); }
public
E pollFirst() {
return
set.pollFirst(); }
public
E pollLast() {
return
set.pollLast(); }
public
boolean
remove(Object obj)
{
return
set.remove(obj);
}
public
int
size() {
return
set.size(); }
public
NavigableSet<E> subSet(E lele,
boolean
lInclusive,
E rele,
boolean
rInclusive)
{
return
set.subSet(lele, lInclusive, rele,
rInclusive);
}
public
SortedSet<E> subSet(E lele, E rele)
{
return
set.subSet(lele, rele);
}
public
SortedSet<E> tailSet(E ele)
{
return
set.tailSet(ele);
}
public
NavigableSet<E> tailSet(E ele,
boolean
inclusive)
{
return
set.tailSet(ele, inclusive);
}
}
public
class
GFG {
public
static
void
main(String[] arg)
{
TreeSetImplementation<Integer> set
=
new
TreeSetImplementation<Integer>();
set.add(
10
);
set.add(
30
);
set.add(
20
);
set.add(
40
);
set.add(
50
);
Iterator<Integer> it = set.iterator();
System.out.println(
"Elements of the TreeSet:"
);
while
(it.hasNext()) {
System.out.print(it.next() +
" "
);
}
System.out.println();
System.out.println();
System.out.println(
"Size of the set: "
+ set.size());
System.out.println();
System.out.println(
"Ceiling of 45: "
+ set.ceiling(
45
));
System.out.println();
Iterator<Integer> revit = set.descendingIterator();
System.out.println(
"The reverse order: "
);
while
(revit.hasNext()) {
System.out.print(revit.next() +
"\t"
);
}
System.out.println();
System.out.println();
System.out.println(
"The first element in the set: "
+ set.first());
System.out.println();
System.out.println(
"Floor value of 45: "
+ set.floor(
45
));
System.out.println();
System.out.println(
"The last element in the set: "
+ set.last());
System.out.println();
set.remove(
20
);
System.out.println(
"Size of the set: "
+ set.size());
System.out.println();
System.out.println(
"HeadSet of 35: "
);
NavigableSet<Integer> set1 = set.headSet(
35
,
true
);
Iterator<Integer> it1 = set1.iterator();
while
(it1.hasNext()) {
System.out.println(it1.next() +
" "
);
}
System.out.println();
System.out.println(
"Subset between 5 and 45: "
);
set1 = set.subSet(
5
,
true
,
30
,
true
);
it1 = set1.iterator();
while
(it1.hasNext()) {
System.out.println(it1.next() +
"\t"
);
}
System.out.println();
System.out.println(
"The tailSet of 35: "
);
set1 = set.tailSet(
35
,
true
);
it1 = set1.iterator();
while
(it1.hasNext()) {
System.out.println(it1.next() +
"\t"
);
}
System.out.println();
}
}