Module java.desktop
Package javax.swing.tree

# Class TreePath

java.lang.Object
javax.swing.tree.TreePath

All Implemented Interfaces:
  `Serializable`

public class TreePath extends Object implements Serializable
`TreePath` represents an array of objects that uniquely identify the path to a node in a tree. The elements of the array are ordered with the root as the first element of the array. For example, a file on the file system is uniquely identified based on the array of parent directories and the name of the file. The path `/tmp/foo/bar` could be represented by a `TreePath` as `new TreePath(new Object[] {"tmp", "foo", "bar"})`.

`TreePath` is used extensively by `JTree` and related classes. For example, `JTree` represents the selection as an array of `TreePath`s. When used with `JTree`, the elements of the path are the objects returned from the `TreeModel`. When `JTree` is paired with `DefaultTreeModel`, the elements of the path are `TreeNode`s. The following example illustrates extracting the user object from the selection of a `JTree`:

       DefaultMutableTreeNode root = ...;
       DefaultTreeModel model = new DefaultTreeModel(root);
       JTree tree = new JTree(model);
       ...
       TreePath selectedPath = tree.getSelectionPath();
       DefaultMutableTreeNode selectedNode =
           ((DefaultMutableTreeNode)selectedPath.getLastPathComponent());
       Object myObject= selectedNode.getUserObject();

Subclasses typically need override only `getLastPathComponent`, and `getParentPath`. As `JTree` internally creates `TreePath`s at various points, it's generally not useful to subclass `TreePath` and use with `JTree`.

While `TreePath` is serializable, a `NotSerializableException` is thrown if any elements of the path are not serializable.

For further information and examples of using tree paths, see How to Use Trees in The Java Tutorial.

Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. As of 1.4, support for long term storage of all JavaBeans has been added to the `java.beans` package. Please see `XMLEncoder`.

## Constructor Summary

Constructors
Modifier
Constructor
Description
`protected`
`TreePath()`
Creates an empty `TreePath`.
``
`TreePath(Object lastPathComponent)`
Creates a `TreePath` containing a single element.
``
`TreePath(Object[] path)`
Creates a `TreePath` from an array.
`protected`
`TreePath(Object[] path, int length)`
Creates a `TreePath` from an array.
`protected`
`TreePath(TreePath parent, Object lastPathComponent)`
Creates a `TreePath` with the specified parent and element.

## Method Summary

Modifier and Type
Method
Description
`boolean`
`equals(Object o)`
Compares this `TreePath` to the specified object.
`Object`
`getLastPathComponent()`
Returns the last element of this path.
`TreePath`
`getParentPath()`
Returns the `TreePath` of the parent.
`Object[]`
`getPath()`
Returns an ordered array of the elements of this `TreePath`.
`Object`
`getPathComponent(int index)`
Returns the path element at the specified index.
`int`
`getPathCount()`
Returns the number of elements in the path.
`int`
`hashCode()`
Returns the hash code of this `TreePath`.
`boolean`
`isDescendant(TreePath aTreePath)`
Returns true if `aTreePath` is a descendant of this `TreePath`.
`TreePath`
`pathByAddingChild(Object child)`
Returns a new path containing all the elements of this path plus `child`.
`String`
`toString()`
Returns a string that displays and identifies this object's properties.

### Methods declared in class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

## Constructor Details

### TreePath

@ConstructorProperties("path") public TreePath(Object[] path)
Creates a `TreePath` from an array. The array uniquely identifies the path to a node.

Parameters:
  `path` - an array of objects representing the path to a node
Throws:
  `IllegalArgumentException` - if `path` is `null`, empty, or contains a `null` value

### TreePath

public TreePath(Object lastPathComponent)
Creates a `TreePath` containing a single element. This is used to construct a `TreePath` identifying the root.

Parameters:
  `lastPathComponent` - the root
Throws:
  `IllegalArgumentException` - if `lastPathComponent` is `null`
See Also:
  - `TreePath(Object[])`

### TreePath

protected TreePath(TreePath parent, Object lastPathComponent)
Creates a `TreePath` with the specified parent and element.

Parameters:
  `parent` - the path to the parent, or `null` to indicate the root
  `lastPathComponent` - the last path element
Throws:
  `IllegalArgumentException` - if `lastPathComponent` is `null`

### TreePath

protected TreePath(Object[] path, int length)
Creates a `TreePath` from an array. The returned `TreePath` represents the elements of the array from `0` to `length - 1`.

This constructor is used internally, and generally not useful outside of subclasses.

Parameters:
  `path` - the array to create the `TreePath` from
  `length` - identifies the number of elements in `path` to create the `TreePath` from
Throws:
  `NullPointerException` - if `path` is `null`
  `ArrayIndexOutOfBoundsException` - if `length - 1` is outside the range of the array
  `IllegalArgumentException` - if any of the elements from `0` to `length - 1` are `null`

### TreePath

protected TreePath()
Creates an empty `TreePath`. This is provided for subclasses that represent paths in a different manner. Subclasses that use this constructor must override `getLastPathComponent`, and `getParentPath`.

## Method Details

### getPath

public Object[] getPath()
Returns an ordered array of the elements of this `TreePath`. The first element is the root.

Returns:
  an array of the elements in this `TreePath`

### getLastPathComponent

public Object getLastPathComponent()
Returns the last element of this path.

Returns:
  the last element in the path

### getPathCount

public int getPathCount()
Returns the number of elements in the path.

Returns:
  the number of elements in the path

### getPathComponent

public Object getPathComponent(int index)
Returns the path element at the specified index.

Parameters:
  `index` - the index of the element requested
Returns:
  the element at the specified index
Throws:
  `IllegalArgumentException` - if the index is outside the range of this path

### equals

public boolean equals(Object o)
Compares this `TreePath` to the specified object. This returns `true` if `o` is a `TreePath` with the exact same elements (as determined by using `equals` on each element of the path).

Overrides:
  `equals` in class `Object`
Parameters:
  `o` - the object to compare
Returns:
  `true` if this object is the same as the obj argument; `false` otherwise.
See Also:
  - `Object.hashCode()`
  - `HashMap`

### hashCode

public int hashCode()
Returns the hash code of this `TreePath`. The hash code of a `TreePath` is the hash code of the last element in the path.

Overrides:
  `hashCode` in class `Object`
Returns:
  the hashCode for the object
See Also:
  - `Object.equals(java.lang.Object)`
  - `System.identityHashCode(java.lang.Object)`

### isDescendant

public boolean isDescendant(TreePath aTreePath)
Returns true if `aTreePath` is a descendant of this `TreePath`. A `TreePath` `P1` is a descendant of a `TreePath` `P2` if `P1` contains all of the elements that make up `P2's` path. For example, if this object has the path `[a, b]`, and `aTreePath` has the path `[a, b, c]`, then `aTreePath` is a descendant of this object. However, if `aTreePath` has the path `[a]`, then it is not a descendant of this object. By this definition a `TreePath` is always considered a descendant of itself. That is, `aTreePath.isDescendant(aTreePath)` returns `true`.

Parameters:
  `aTreePath` - the `TreePath` to check
Returns:
  true if `aTreePath` is a descendant of this path

### pathByAddingChild

public TreePath pathByAddingChild(Object child)
Returns a new path containing all the elements of this path plus `child`. `child` is the last element of the newly created `TreePath`.

Parameters:
  `child` - the path element to add
Returns:
  a new path containing all the elements of this path plus `child`
Throws:
  `NullPointerException` - if `child` is `null`

### getParentPath

public TreePath getParentPath()
Returns the `TreePath` of the parent. A return value of `null` indicates this is the root node.

Returns:
  the parent path

### toString

public String toString()
Returns a string that displays and identifies this object's properties.

Overrides:
  `toString` in class `Object`
Returns:
  a String representation of this object