Javaツリーのデータ構造は？
Javaでツリーを表現するのに利用可能な（標準のJava）データ構造はありますか？
具体的には、次のように表現する必要があります。
- どのノードのツリーも任意の数の子を持つことができます
- 各ノード（ルートの後）は単なるString（その子もString）です。
- 与えられたノードを表す入力文字列を与えられたすべての子（ある種のリストまたは文字列の配列）を取得できるようにする必要があります。
これのために利用可能な構造はありますか、または私は私自身のものを作成する必要がありますか（そうであれば実装の提案は素晴らしいでしょう）。
ここに：
public class Tree<T> {
private Node<T> root;
public Tree(T rootData) {
root = new Node<T>();
root.data = rootData;
root.children = new ArrayList<Node<T>>();
}
public static class Node<T> {
private T data;
private Node<T> parent;
private List<Node<T>> children;
}
}
これはStringや他のオブジェクトに使える基本的な木構造です。あなたが必要とすることをするために単純な木を実装することはかなり簡単です。
追加する必要があるのは、追加、削除、トラバース、コンストラクタのためのメソッドだけです。 NodeはTreeの基本的な構成要素です。
さらに別の木構造：
public class TreeNode<T> implements Iterable<TreeNode<T>> {
T data;
TreeNode<T> parent;
List<TreeNode<T>> children;
public TreeNode(T data) {
this.data = data;
this.children = new LinkedList<TreeNode<T>>();
}
public TreeNode<T> addChild(T child) {
TreeNode<T> childNode = new TreeNode<T>(child);
childNode.parent = this;
this.children.add(childNode);
return childNode;
}
// other features ...
}
使用例
TreeNode<String> root = new TreeNode<String>("root");
{
TreeNode<String> node0 = root.addChild("node0");
TreeNode<String> node1 = root.addChild("node1");
TreeNode<String> node2 = root.addChild("node2");
{
TreeNode<String> node20 = node2.addChild(null);
TreeNode<String> node21 = node2.addChild("node21");
{
TreeNode<String> node210 = node20.addChild("node210");
}
}
}
_ボーナス_
本格的な木を見てください。
- イテレータ
- 検索する
- Java/C＃
実際にはJDKにはかなり良いツリー構造が実装されています。
javax.swing.tree 、 TreeModel 、および TreeNode を見てください。これらはJTreePanelと共に使用するように設計されていますが、実際にはかなり良いツリー実装であり、あなたがswingインターフェースなしでそれを使用するのを止めるものは何もありません。
Java 9では、これらのクラスは 'コンパクトプロファイル' には含まれないため、これらのクラスを使用しないことをお勧めします。
これはどうですか？
import Java.util.ArrayList;
import Java.util.Collection;
import Java.util.HashMap;
/**
* @author [email protected] (Yohann Coppel)
*
* @param <T>
* Object's type in the tree.
*/
public class Tree<T> {
private T head;
private ArrayList<Tree<T>> leafs = new ArrayList<Tree<T>>();
private Tree<T> parent = null;
private HashMap<T, Tree<T>> locate = new HashMap<T, Tree<T>>();
public Tree(T head) {
this.head = head;
locate.put(head, this);
}
public void addLeaf(T root, T leaf) {
if (locate.containsKey(root)) {
locate.get(root).addLeaf(leaf);
} else {
addLeaf(root).addLeaf(leaf);
}
}
public Tree<T> addLeaf(T leaf) {
Tree<T> t = new Tree<T>(leaf);
leafs.add(t);
t.parent = this;
t.locate = this.locate;
locate.put(leaf, t);
return t;
}
public Tree<T> setAsParent(T parentRoot) {
Tree<T> t = new Tree<T>(parentRoot);
t.leafs.add(this);
this.parent = t;
t.locate = this.locate;
t.locate.put(head, this);
t.locate.put(parentRoot, t);
return t;
}
public T getHead() {
return head;
}
public Tree<T> getTree(T element) {
return locate.get(element);
}
public Tree<T> getParent() {
return parent;
}
public Collection<T> getSuccessors(T root) {
Collection<T> successors = new ArrayList<T>();
Tree<T> tree = getTree(root);
if (null != tree) {
for (Tree<T> leaf : tree.leafs) {
successors.add(leaf.head);
}
}
return successors;
}
public Collection<Tree<T>> getSubTrees() {
return leafs;
}
public static <T> Collection<T> getSuccessors(T of, Collection<Tree<T>> in) {
for (Tree<T> tree : in) {
if (tree.locate.containsKey(of)) {
return tree.getSuccessors(of);
}
}
return new ArrayList<T>();
}
@Override
public String toString() {
return printTree(0);
}
private static final int indent = 2;
private String printTree(int increment) {
String s = "";
String inc = "";
for (int i = 0; i < increment; ++i) {
inc = inc + " ";
}
s = inc + head;
for (Tree<T> child : leafs) {
s += "\n" + child.printTree(increment + indent);
}
return s;
}
}
私は を書いた 一般的な木を扱う小さなライブラリ。それはスイングのものよりもはるかに軽量です。 mavenプロジェクトもあります そのために。
public class Tree {
private List<Tree> leaves = new LinkedList<Tree>();
private Tree parent = null;
private String data;
public Tree(String data, Tree parent) {
this.data = data;
this.parent = parent;
}
}
明らかにあなたは子を追加/削除するためにユーティリティメソッドを追加することができます。
ツリーが何であるか（ドメインに対して）を定義することから始める必要があります。これは最初に interface を定義することによって行われます。 add および remove ノードを使用できるようにすることで、すべてのツリー構造が変更可能になるわけではないため、追加のインターフェースを作成します。
値を保持するノードオブジェクトを作成する必要はありません 実際、私はこれをほとんどのツリー実装における主要な設計上の欠陥およびオーバーヘッドと見なしています。 Swingを見ると、TreeModelはノードクラスを必要としません（DefaultTreeModelのみがTreeNodeを使用します）。これらは実際には必要ではありません。
public interface Tree <N extends Serializable> extends Serializable {
List<N> getRoots ();
N getParent (N node);
List<N> getChildren (N node);
}
変更可能なツリー構造（ノードの追加と削除を可能にします）：
public interface MutableTree <N extends Serializable> extends Tree<N> {
boolean add (N parent, N node);
boolean remove (N node, boolean cascade);
}
これらのインタフェースが与えられれば、ツリーを使うコードはツリーがどのように実装されるかについてあまり気にする必要はありません。これにより、 一般的な実装 および 特定の 1を使用できます。ここでは、関数を別のAPIに委任することによってツリーを実現します。
例： ファイルツリー構造
public class FileTree implements Tree<File> {
@Override
public List<File> getRoots() {
return Arrays.stream(File.listRoots()).collect(Collectors.toList());
}
@Override
public File getParent(File node) {
return node.getParentFile();
}
@Override
public List<File> getChildren(File node) {
if (node.isDirectory()) {
File[] children = node.listFiles();
if (children != null) {
return Arrays.stream(children).collect(Collectors.toList());
}
}
return Collections.emptyList();
}
}
例： 一般的なツリー構造 （親子関係に基づく）：
public class MappedTreeStructure<N extends Serializable> implements MutableTree<N> {
public static void main(String[] args) {
MutableTree<String> tree = new MappedTreeStructure<>();
tree.add("A", "B");
tree.add("A", "C");
tree.add("C", "D");
tree.add("E", "A");
System.out.println(tree);
}
private final Map<N, N> nodeParent = new HashMap<>();
private final LinkedHashSet<N> nodeList = new LinkedHashSet<>();
private void checkNotNull(N node, String parameterName) {
if (node == null)
throw new IllegalArgumentException(parameterName + " must not be null");
}
@Override
public boolean add(N parent, N node) {
checkNotNull(parent, "parent");
checkNotNull(node, "node");
// check for cycles
N current = parent;
do {
if (node.equals(current)) {
throw new IllegalArgumentException(" node must not be the same or an ancestor of the parent");
}
} while ((current = getParent(current)) != null);
boolean added = nodeList.add(node);
nodeList.add(parent);
nodeParent.put(node, parent);
return added;
}
@Override
public boolean remove(N node, boolean cascade) {
checkNotNull(node, "node");
if (!nodeList.contains(node)) {
return false;
}
if (cascade) {
for (N child : getChildren(node)) {
remove(child, true);
}
} else {
for (N child : getChildren(node)) {
nodeParent.remove(child);
}
}
nodeList.remove(node);
return true;
}
@Override
public List<N> getRoots() {
return getChildren(null);
}
@Override
public N getParent(N node) {
checkNotNull(node, "node");
return nodeParent.get(node);
}
@Override
public List<N> getChildren(N node) {
List<N> children = new LinkedList<>();
for (N n : nodeList) {
N parent = nodeParent.get(n);
if (node == null && parent == null) {
children.add(n);
} else if (node != null && parent != null && parent.equals(node)) {
children.add(n);
}
}
return children;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
dumpNodeStructure(builder, null, "- ");
return builder.toString();
}
private void dumpNodeStructure(StringBuilder builder, N node, String prefix) {
if (node != null) {
builder.append(prefix);
builder.append(node.toString());
builder.append('\n');
prefix = " " + prefix;
}
for (N child : getChildren(node)) {
dumpNodeStructure(builder, child, prefix);
}
}
}
あまりにも単純化されているが実用的なコードについては答えがないので、ここでは次のようになります。
public class TreeNodeArray<T> {
public T value;
public final Java.util.List<TreeNodeArray<T>> kids = new Java.util.ArrayList<TreeNodeArray<T>>();
}
あなたは、文書やノードとしてJavaのXML APIを使うことができます。XMLは、文字列を持つ木構造です
Javaには、JDK SwingのDefaultMutableTreeNode、StanfordパーサーパッケージのTree、その他のおもちゃのコードなど、いくつかのツリーデータ構造があります。しかし、これらのどれもが十分ではなく、一般的な目的には十分に小さいものです。
Java-tree projectは、Javaで他の汎用ツリーデータ構造を提供しようとします。これと他の人の違いは
- 完全に無料です。あなたはそれをどこでも使うことができます（あなたの宿題を除いて：P）
- 小さいながらも十分一般的。すべてのデータ構造を1つのクラスファイルにまとめたので、コピー/貼り付けは簡単です。
- ただのおもちゃではありません。私はバイナリツリーや限られた操作しか扱えない数十のJavaツリーコードを知っています。このTreeNodeはそれ以上のものです。プレオーダ、ポストオーダ、幅優先、葉、ルートへのパスなど、ノードを訪問するさまざまな方法を提供します。さらに、イテレータも十分に提供されています。
- もっとutilsが追加されます。私はこのプロジェクトを包括的にするためにもっと多くの操作を加えたいと思います、特にあなたがgithubを通して要求を送るならば。
Garethの答えと同じように、 DefaultMutableTreeNode をチェックしてください。それは一般的ではありませんが、そうでなければ法案に合うようです。 javax.swingパッケージに含まれていても、AWTクラスやSwingクラスには依存しません。実際、ソースコードには実際にコメント// ISSUE: this class depends on nothing in AWT -- move to Java.util?があります。
ホワイトボードのコーディング、インタビュー、あるいは単に木を使うことを計画しているのであれば、これらの冗長性はすべて少しだけです。
さらに、ツリーがそこにない理由、例えばPair（これについても同じことが言えます）は、データをそれを使ってクラスにカプセル化する必要があるためです。{and最も簡単な実装は次のようになります。
/***
/* Within the class that's using a binary tree for any reason. You could
/* generalize with generics IFF the parent class needs different value types.
*/
private class Node {
public String value;
public Node[] nodes; // Or an Iterable<Node> nodes;
}
それは本当に任意の幅の木のためのそれです。
二分木が欲しい場合は、名前付きフィールドを使うほうが簡単です。
private class Node { // Using package visibility is an option
String value;
Node left;
Node right;
}
またはトライしたい場合は：
private class Node {
String value;
Map<char, Node> nodes;
}
今、あなたはあなたが欲しいと言った
与えられたノードを表す入力文字列を与えられたすべての子（ある種のリストまたは文字列の配列）を取得できるようにする
それはあなたの宿題のように聞こえます。
しかし、期限が過ぎていることは合理的に確信しているので…
import Java.util.Arrays;
import Java.util.ArrayList;
import Java.util.List;
public class kidsOfMatchTheseDays {
static private class Node {
String value;
Node[] nodes;
}
// Pre-order; you didn't specify.
static public List<String> list(Node node, String find) {
return list(node, find, new ArrayList<String>(), false);
}
static private ArrayList<String> list(
Node node,
String find,
ArrayList<String> list,
boolean add) {
if (node == null) {
return list;
}
if (node.value.equals(find)) {
add = true;
}
if (add) {
list.add(node.value);
}
if (node.nodes != null) {
for (Node child: node.nodes) {
list(child, find, list, add);
}
}
return list;
}
public static final void main(String... args) {
// Usually never have to do setup like this, so excuse the style
// And it could be cleaner by adding a constructor like:
// Node(String val, Node... children) {
// value = val;
// nodes = children;
// }
Node tree = new Node();
tree.value = "root";
Node[] n = {new Node(), new Node()};
tree.nodes = n;
tree.nodes[0].value = "leftish";
tree.nodes[1].value = "rightish-leafy";
Node[] nn = {new Node()};
tree.nodes[0].nodes = nn;
tree.nodes[0].nodes[0].value = "off-leftish-leaf";
// Enough setup
System.out.println(Arrays.toString(list(tree, args[0]).toArray()));
}
}
これはあなたがのように使うことができます：
$ Java kidsOfMatchTheseDays leftish
[leftish, off-leftish-leaf]
$ Java kidsOfMatchTheseDays root
[root, leftish, off-leftish-leaf, rightish-leafy]
$ Java kidsOfMatchTheseDays rightish-leafy
[rightish-leafy]
$ Java kidsOfMatchTheseDays a
[]
public abstract class Node {
List<Node> children;
public List<Node> getChidren() {
if (children == null) {
children = new ArrayList<>();
}
return chidren;
}
}
それが得るのと同じくらい簡単で、非常に使いやすいです。それを使うためには、それを拡張する：
public class MenuItem extends Node {
String label;
String href;
...
}
質問は利用可能なデータ構造を要求するので、ツリーはリストまたは配列から構築することができます。
Object[] tree = new Object[2];
tree[0] = "Hello";
{
Object[] subtree = new Object[2];
subtree[0] = "Goodbye";
subtree[1] = "";
tree[1] = subtree;
}
instanceofは、要素がサブツリーなのか終端ノードなのかを判断するために使用できます。
パスの追加をサポートする "HashMap"をベースにした小さな "TreeMap"クラスを書きました。
import Java.util.HashMap;
import Java.util.LinkedList;
public class TreeMap<T> extends LinkedHashMap<T, TreeMap<T>> {
public void put(T[] path) {
LinkedList<T> list = new LinkedList<>();
for (T key : path) {
list.add(key);
}
return put(list);
}
public void put(LinkedList<T> path) {
if (path.isEmpty()) {
return;
}
T key = path.removeFirst();
TreeMap<T> val = get(key);
if (val == null) {
val = new TreeMap<>();
put(key, val);
}
val.put(path);
}
}
それはタイプ "T"（総称）のもののツリーを格納するために使用することができますが、（まだ）追加のデータをそのノードに格納することをサポートしません。あなたがこのようなファイルがあるならば：
root, child 1
root, child 1, child 1a
root, child 1, child 1b
root, child 2
root, child 3, child 3a
それからあなたはそれを実行することによって木にすることができます：
TreeMap<String> root = new TreeMap<>();
Scanner scanner = new Scanner(new File("input.txt"));
while (scanner.hasNextLine()) {
root.put(scanner.nextLine().split(", "));
}
そして、あなたはいい木を手に入れるでしょう。あなたのニーズに適応するのは簡単なはずです。
例えば ：
import Java.util.ArrayList;
import Java.util.List;
/**
*
* @author X2
*
* @param <T>
*/
public class HisTree<T>
{
private Node<T> root;
public HisTree(T rootData)
{
root = new Node<T>();
root.setData(rootData);
root.setChildren(new ArrayList<Node<T>>());
}
}
class Node<T>
{
private T data;
private Node<T> parent;
private List<Node<T>> children;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public Node<T> getParent() {
return parent;
}
public void setParent(Node<T> parent) {
this.parent = parent;
}
public List<Node<T>> getChildren() {
return children;
}
public void setChildren(List<Node<T>> children) {
this.children = children;
}
}
これまでは、これにネストしたマップを使用しました。これは私が今日使用しているものです、それは非常に単純ですが、それは私のニーズに合っています。多分これは別のものを助けるでしょう。
import com.fasterxml.jackson.annotation.JsonValue;
import com.fasterxml.jackson.databind.ObjectMapper;
import Java.util.HashMap;
import Java.util.Map;
import Java.util.TreeMap;
/**
* Created by kic on 16.07.15.
*/
public class NestedMap<K, V> {
private final Map root = new HashMap<>();
public NestedMap<K, V> put(K key) {
Object nested = root.get(key);
if (nested == null || !(nested instanceof NestedMap)) root.put(key, nested = new NestedMap<>());
return (NestedMap<K, V>) nested;
}
public Map.Entry<K,V > put(K key, V value) {
root.put(key, value);
return (Map.Entry<K, V>) root.entrySet().stream().filter(e -> ((Map.Entry) e).getKey().equals(key)).findFirst().get();
}
public NestedMap<K, V> get(K key) {
return (NestedMap<K, V>) root.get(key);
}
public V getValue(K key) {
return (V) root.get(key);
}
@JsonValue
public Map getRoot() {
return root;
}
public static void main(String[] args) throws Exception {
NestedMap<String, Integer> test = new NestedMap<>();
test.put("a").put("b").put("c", 12);
Map.Entry<String, Integer> foo = test.put("a").put("b").put("d", 12);
test.put("b", 14);
ObjectMapper mapper = new ObjectMapper();
System.out.println(mapper.writeValueAsString(test));
foo.setValue(99);
System.out.println(mapper.writeValueAsString(test));
System.out.println(test.get("a").get("b").getValue("d"));
}
}
// TestTree.Java
// A simple test to see how we can build a tree and populate it
//
import Java.awt.*;
import Java.awt.event.*;
import javax.swing.*;
import javax.swing.tree.*;
public class TestTree extends JFrame {
JTree tree;
DefaultTreeModel treeModel;
public TestTree( ) {
super("Tree Test Example");
setSize(400, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public void init( ) {
// Build up a bunch of TreeNodes. We use DefaultMutableTreeNode because the
// DefaultTreeModel can use it to build a complete tree.
DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");
DefaultMutableTreeNode subroot = new DefaultMutableTreeNode("SubRoot");
DefaultMutableTreeNode leaf1 = new DefaultMutableTreeNode("Leaf 1");
DefaultMutableTreeNode leaf2 = new DefaultMutableTreeNode("Leaf 2");
// Build our tree model starting at the root node, and then make a JTree out
// of it.
treeModel = new DefaultTreeModel(root);
tree = new JTree(treeModel);
// Build the tree up from the nodes we created.
treeModel.insertNodeInto(subroot, root, 0);
// Or, more succinctly:
subroot.add(leaf1);
root.add(leaf2);
// Display it.
getContentPane( ).add(tree, BorderLayout.CENTER);
}
public static void main(String args[]) {
TestTree tt = new TestTree( );
tt.init( );
tt.setVisible(true);
}
}
Jakartaプロジェクトの一部であるApache JMeterに含まれている HashTree クラスを使用できます。
HashTreeクラスはorg.Apache.jorphan.collectionsパッケージに含まれています。このパッケージはJMeterプロジェクトの外ではリリースされていませんが、手軽に入手できます。
1） JMeterのソース をダウンロードしてください。
2）新しいパッケージを作成してください。
3）/ src/jorphan/org/Apache/jorphan/collections /にコピーします。 Data.Java以外のすべてのファイル
4）/src/jorphan/org/Apache/jorphan/util/JOrphanUtils.Javaもコピーします。
5）HashTreeを使用する準備が整いました。
Javaにはあなたの要求に合った特別なデータ構造はありません。あなたの要求は非常に具体的であり、あなたはあなた自身のデータ構造を設計する必要があります。あなたの要求を見れば、誰かがあなたがある特定の機能を持ったある種のn進ツリーが必要であると言うことができます。次のようにしてデータ構造を設計できます。
- ツリーのノードの構造は、ノード内のコンテンツおよび子のリストのようになります。子を一覧表示します。
- 与えられた文字列の子を取得する必要があるので、2つのメソッドを持つことができます。1：Node searchNode（String str）、与えられた入力と同じ値を持つノードを返します（検索にBFSを使用）2：List getChildren（String） str）：このメソッドは内部的にsearchNodeを呼び出して同じ文字列を持つノードを取得し、それから子のすべての文字列値のリストを作成して戻ります。
- また、ツリーに文字列を挿入する必要があります。 void insert（String parent、String value）と言う1つのメソッドを書く必要があります。これはparentと等しい値を持つノードを再び検索し、与えられた値でNodeを作成し、見つかった親の子のリストに追加できます。 。
Class Node {String value;}のように1つのクラスでノードの構造を書くことをお勧めします。子の一覧表示;}およびsearch、insert、getChildrenなどの他のすべてのメソッドを別のNodeUtilsクラスに含めることで、treeのルートを渡して次のような特定のツリーに対して操作を実行することもできます。 {// BFSを実行してノードを返す}
私はJava 8とうまく動作し、他の依存関係がないツリーライブラリを書きました。それはまた、関数型プログラミングからのいくつかのアイデアのゆるい解釈を提供し、そしてあなたが全体の木またはサブツリーを写像/フィルター処理/剪定/検索することを可能にする。
https://github.com/RutledgePaulV/Prune
インプリメンテーションは索引付けに関して特別なことは何もせず、私は再帰を避けなかったので、大きなツリーではパフォーマンスが低下し、スタックを破壊する可能性があります。しかし、あなたが必要としているのが、小さいから中程度の深さの単純な木だけであれば、それは十分うまくいくと思います。それは平等の正当な（値ベースの）定義を提供し、またツリーを視覚化することを可能にするtoString実装を持っています！
Collectionクラスを使用せずに、Treeデータ構造を使用した以下のコードを確認してください。コードにはバグ/改良があるかもしれませんが、参考のためにこれを使ってください
package com.datastructure.tree;
public class BinaryTreeWithoutRecursion <T> {
private TreeNode<T> root;
public BinaryTreeWithoutRecursion (){
root = null;
}
public void insert(T data){
root =insert(root, data);
}
public TreeNode<T> insert(TreeNode<T> node, T data ){
TreeNode<T> newNode = new TreeNode<>();
newNode.data = data;
newNode.right = newNode.left = null;
if(node==null){
node = newNode;
return node;
}
Queue<TreeNode<T>> queue = new Queue<TreeNode<T>>();
queue.enque(node);
while(!queue.isEmpty()){
TreeNode<T> temp= queue.deque();
if(temp.left!=null){
queue.enque(temp.left);
}else
{
temp.left = newNode;
queue =null;
return node;
}
if(temp.right!=null){
queue.enque(temp.right);
}else
{
temp.right = newNode;
queue =null;
return node;
}
}
queue=null;
return node;
}
public void inOrderPrint(TreeNode<T> root){
if(root!=null){
inOrderPrint(root.left);
System.out.println(root.data);
inOrderPrint(root.right);
}
}
public void postOrderPrint(TreeNode<T> root){
if(root!=null){
postOrderPrint(root.left);
postOrderPrint(root.right);
System.out.println(root.data);
}
}
public void preOrderPrint(){
preOrderPrint(root);
}
public void inOrderPrint(){
inOrderPrint(root);
}
public void postOrderPrint(){
inOrderPrint(root);
}
public void preOrderPrint(TreeNode<T> root){
if(root!=null){
System.out.println(root.data);
preOrderPrint(root.left);
preOrderPrint(root.right);
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
BinaryTreeWithoutRecursion <Integer> ls= new BinaryTreeWithoutRecursion <>();
ls.insert(1);
ls.insert(2);
ls.insert(3);
ls.insert(4);
ls.insert(5);
ls.insert(6);
ls.insert(7);
//ls.preOrderPrint();
ls.inOrderPrint();
//ls.postOrderPrint();
}
}
Java.util。*のTreeSetクラスを使用できます。バイナリサーチツリーのように機能しているので、すでにソートされています。 TreeSetクラスはIterable、Collection、およびSetの各インタフェースを実装しています。セットのようにイテレータを使ってツリーをたどることができます。
TreeSet<String> treeSet = new TreeSet<String>();
Iterator<String> it = treeSet.Iterator();
while(it.hasNext()){
...
}