1. import java.util.Iterator;
2. import java.util.concurrent.atomic.AtomicReference;
3. import java.util.function.Consumer;
4.  
5. public class BST <E extends Comparable<E> > implements Iterable<E> {
6.     private Node root;
7.     private class Node {
8.         E elem;
9.         Node left, right;
10.         Node (E elem) {
11.             this.elem=elem;
12.         }
13.     }
14.     public void add (E elem) {
15.         root = add (root, elem);
16.     }
17.     private Node add (Node node, E elem) {
18.         if (node == null) return new Node(elem);
19.         int s = elem.compareTo(node.elem);
20.         if (s<0) {
21.             node.left = add(node.left, elem);
22.         } else if (s>0) {
23.             node.right = add(node.right, elem);
24.         }
25.         return node;
26.     }
27.  
28.     @Override
29.     public Iterator<E> iterator() {
30.         return new Iterator<E>() {
31.             class Stack {
32.                 Node node;
33.                 Stack parent;
34.                 Stack (Node node, Stack parent) {
35.                     this.node=node;
36.                     this.parent=parent;
37.                 }
38.             }
39.             Stack stack = null;
40.             {
41.                 put(root);
42.             }
43.             @Override
44.             public boolean hasNext() {
45.                 return stack != null;
46.             }
47.  
48.             @Override
49.             public E next() {
50.                 E res = stack.node.elem;
51.                 Node right = stack.node.right;
52.                 stack = stack.parent;
53.                 put(right);
54.                 return res;
55.             }
56.             void put (Node node) {
57.                 if (node != null) {
58.                     stack = new Stack(node, stack);
59.                     put(node.left);
60.                 }
61.             }
62.         };
63.     }
64.  
65.     @Override
66.     public void forEach (Consumer<? super E> consumer) {forEach(root, consumer);}
67.     private void forEach (Node node, Consumer<? super E> consumer) {
68.         if (node != null) {
69.             forEach(node.left, consumer);
70.             consumer.accept(node.elem);
71.             forEach(node.right, consumer);
72.         }
73.     }
74.  
75.  
76.  
77.     @Override
78.     public String toString() {
79.         AtomicReference<Boolean> firstTime= new AtomicReference<>(false);
80.         StringBuilder s = new StringBuilder();
81.         s.append('[');
82.         forEach(e -> {
83.             if (firstTime.get().booleanValue())
84.                 s.append(", ");
85.             firstTime.set(true);
86.             s.append(e);
87.         });
88.         s.append(']');
89.         return s.toString();
90.     }
91. }
92.  
93.  
94. public interface Comparable <T> {
95.     int compareTo (T o);
96. }
97.  
98.  
99.  
100.  
101. public class Int implements Comparable<Int> {
102.     int x;
103.     Int (int x) {
104.         this.x=x;
105.     }
106.     @Override
107.     public int compareTo(Int o) {
108.         return x - o.x;
109.     }
110.  
111.     @Override
112.     public String toString() {
113.         return Integer.toString(x);
114.     }
115. }
116.  
117.  
118.  
119. import java.util.Iterator;
120. import java.util.function.Consumer;
121.  
122. public interface Iterable <E> {
123.     Iterator<E> iterator();
124.     void forEach(Consumer<? super E> consumer);
125. }
126.  
127.  
128.  
129. public interface Iterator <T> {
130.     boolean hasNext ();
131.     T next ();
132. }
133.  
134.  
135. public class Main {
136.     public static void main (String[] argv) {
137.         BST<Int> bst = new BST<>();
138.         int[] a = {4, 7, 9, 3, 1};
139.         for (int e : a)
140.             bst.add(new Int(e));
141.         System.out.println(bst);
142.         /*for (int i : bst) {
143.  
144.         }*/
145.     }
146. }
147.