NodeList (javaparser-core 3.0.1 API)

java.lang.Object
- com.github.javaparser.ast.NodeList<N>

Type Parameters:

N - the type of nodes contained.

All Implemented Interfaces:

Observable, Visitable, HasParentNode<NodeList<N>>, Iterable<N>, Collection<N>, List<N>
```
public class NodeList<N extends Node>
extends Object
implements List<N>, Iterable<N>, HasParentNode<NodeList<N>>, Visitable, Observable
```
A list of nodes. It usually has a parent node. Unlike normal Nodes, this does not mean that it is a child of that parent. Instead, this list will make every node it contains a child of its parent. This way, a NodeList does not create an extra level inside the AST.

Constructor Summary

Constructors
Constructor and Description

NodeList()

NodeList(Node parent)

Constructors
Constructor and Description
`NodeList()`
`NodeList(Node parent)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<R,A> R`	`accept(GenericVisitor<R,A> v, A arg)` Accept method for visitor support.
`<A> void`	`accept(VoidVisitor<A> v, A arg)` Accept method for visitor support.
`void`	`add(int index, N node)`
`boolean`	`add(N node)`
`boolean`	`addAll(Collection<? extends N> c)`
`boolean`	`addAll(int index, Collection<? extends N> c)`
`void`	`addAll(NodeList<N> otherList)`
`void`	`clear()`
`boolean`	`contains(N node)`
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> c)`
`boolean`	`equals(Object o)`
`void`	`forEach(Consumer<? super N> action)`
`N`	`get(int i)`
`Optional<Node>`	`getParentNode()` Return the parent node or null, if no parent is set.
`Node`	`getParentNodeForChildren()` this for everything except NodeLists.
`int`	`hashCode()`
`int`	`indexOf(Object o)`
`boolean`	`isEmpty()`
`boolean`	`isRegistered(AstObserver observer)` Was this observer registered? Note that equals is used to determine if the given observer was registered.
`Iterator<N>`	`iterator()`
`int`	`lastIndexOf(Object o)`
`ListIterator<N>`	`listIterator()`
`ListIterator<N>`	`listIterator(int index)`
`static <X extends Node> NodeList<X>`	`nodeList(Collection<X> nodes)`
`static <X extends Node> NodeList<X>`	`nodeList(NodeList<X> nodes)`
`static <X extends Node> NodeList<X>`	`nodeList(X... nodes)`
`Stream<N>`	`parallelStream()`
`void`	`register(AstObserver observer)` Register an observer.
`N`	`remove(int index)`
`boolean`	`remove(Node node)`
`boolean`	`remove(Object o)`
`boolean`	`removeAll(Collection<?> c)`
`boolean`	`removeIf(Predicate<? super N> filter)`
`void`	`replaceAll(UnaryOperator<N> operator)`
`boolean`	`retainAll(Collection<?> c)`
`N`	`set(int index, N element)`
`NodeList<N>`	`setParentNode(Node parentNode)` Sets the parentNode
`int`	`size()`
`void`	`sort(Comparator<? super N> comparator)`
`Spliterator<N>`	`spliterator()`
`Stream<N>`	`stream()`
`List<N>`	`subList(int fromIndex, int toIndex)`
`Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`void`	`unregister(AstObserver observer)` Unregister an observer.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.github.javaparser.HasParentNode
getAncestorOfType, setAsParentNodeOf, setAsParentNodeOf

- Constructor Detail
  - NodeList
```
public NodeList()
```
  - NodeList
```
public NodeList(Node parent)
```
- Method Detail
  - add
```
public boolean add(N node)
```
    Specified by:
    
    add in interface Collection<N extends Node>
    
    Specified by:
    
    add in interface List<N extends Node>
  - remove
```
public boolean remove(Node node)
```
  - nodeList
```
@SafeVarargs
public static <X extends Node> NodeList<X> nodeList(X... nodes)
```
  - nodeList
```
public static <X extends Node> NodeList<X> nodeList(Collection<X> nodes)
```
  - nodeList
```
public static <X extends Node> NodeList<X> nodeList(NodeList<X> nodes)
```
  - contains
```
public boolean contains(N node)
```
  - stream
```
public Stream<N> stream()
```
    Specified by:
    
    stream in interface Collection<N extends Node>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Collection<N extends Node>
    
    Specified by:
    
    size in interface List<N extends Node>
  - get
```
public N get(int i)
```
    Specified by:
    
    get in interface List<N extends Node>
  - iterator
```
public Iterator<N> iterator()
```
    Specified by:
    
    iterator in interface Iterable<N extends Node>
    
    Specified by:
    
    iterator in interface Collection<N extends Node>
    
    Specified by:
    
    iterator in interface List<N extends Node>
  - set
```
public N set(int index,
             N element)
```
    Specified by:
    
    set in interface List<N extends Node>
  - remove
```
public N remove(int index)
```
    Specified by:
    
    remove in interface List<N extends Node>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Collection<N extends Node>
    
    Specified by:
    
    isEmpty in interface List<N extends Node>
  - sort
```
public void sort(Comparator<? super N> comparator)
```
    Specified by:
    
    sort in interface List<N extends Node>
  - addAll
```
public void addAll(NodeList<N> otherList)
```
  - add
```
public void add(int index,
                N node)
```
    Specified by:
    
    add in interface List<N extends Node>
  - getParentNode
```
public Optional<Node> getParentNode()
```
    Description copied from interface: HasParentNode
    
    Return the parent node or null, if no parent is set.
    
    Specified by:
    
    getParentNode in interface HasParentNode<NodeList<N extends Node>>
  - setParentNode
```
public NodeList<N> setParentNode(Node parentNode)
```
    Sets the parentNode
    
    Specified by:
    
    setParentNode in interface HasParentNode<NodeList<N extends Node>>
    
    Parameters:
    
    parentNode - the parentNode
    
    Returns:
    
    this, the NodeList
  - getParentNodeForChildren
```
public Node getParentNodeForChildren()
```
    Description copied from interface: HasParentNode
    
    this for everything except NodeLists. NodeLists use their parent as their children parent.
    
    Specified by:
    
    getParentNodeForChildren in interface HasParentNode<NodeList<N extends Node>>
  - accept
```
public <R,A> R accept(GenericVisitor<R,A> v,
                      A arg)
```
    Description copied from interface: Visitable
    
    Accept method for visitor support.
    
    Specified by:
    
    accept in interface Visitable
    
    Type Parameters:
    
    R - the type of the return value of the visitor
    
    A - the type the user argument passed to the visitor
    
    Parameters:
    
    v - the visitor implementation
    
    arg - the argument passed to the visitor (of type A)
    
    Returns:
    
    the result of the visit (of type R)
  - accept
```
public <A> void accept(VoidVisitor<A> v,
                       A arg)
```
    Description copied from interface: Visitable
    
    Accept method for visitor support.
    
    Specified by:
    
    accept in interface Visitable
    
    Type Parameters:
    
    A - the type the argument passed for the visitor
    
    Parameters:
    
    v - the visitor implementation
    
    arg - any value relevant for the visitor (of type A)
  - forEach
```
public void forEach(Consumer<? super N> action)
```
    Specified by:
    
    forEach in interface Iterable<N extends Node>
    
    See Also:
    
    Iterable.forEach(java.util.function.Consumer)
  - contains
```
public boolean contains(Object o)
```
    Specified by:
    
    contains in interface Collection<N extends Node>
    
    Specified by:
    
    contains in interface List<N extends Node>
    
    See Also:
    
    List.contains(java.lang.Object)
  - toArray
```
public Object[] toArray()
```
    Specified by:
    
    toArray in interface Collection<N extends Node>
    
    Specified by:
    
    toArray in interface List<N extends Node>
    
    See Also:
    
    List.toArray()
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Specified by:
    
    toArray in interface Collection<N extends Node>
    
    Specified by:
    
    toArray in interface List<N extends Node>
    
    See Also:
    
    List.toArray(java.lang.Object[])
  - remove
```
public boolean remove(Object o)
```
    Specified by:
    
    remove in interface Collection<N extends Node>
    
    Specified by:
    
    remove in interface List<N extends Node>
    
    See Also:
    
    List.remove(java.lang.Object)
  - containsAll
```
public boolean containsAll(Collection<?> c)
```
    Specified by:
    
    containsAll in interface Collection<N extends Node>
    
    Specified by:
    
    containsAll in interface List<N extends Node>
    
    See Also:
    
    List.containsAll(java.util.Collection)
  - addAll
```
public boolean addAll(Collection<? extends N> c)
```
    Specified by:
    
    addAll in interface Collection<N extends Node>
    
    Specified by:
    
    addAll in interface List<N extends Node>
    
    See Also:
    
    List.addAll(java.util.Collection)
  - addAll
```
public boolean addAll(int index,
                      Collection<? extends N> c)
```
    Specified by:
    
    addAll in interface List<N extends Node>
    
    See Also:
    
    List.addAll(int, java.util.Collection)
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    Specified by:
    
    removeAll in interface Collection<N extends Node>
    
    Specified by:
    
    removeAll in interface List<N extends Node>
    
    See Also:
    
    List.removeAll(java.util.Collection)
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    Specified by:
    
    retainAll in interface Collection<N extends Node>
    
    Specified by:
    
    retainAll in interface List<N extends Node>
    
    See Also:
    
    List.retainAll(java.util.Collection)
  - replaceAll
```
public void replaceAll(UnaryOperator<N> operator)
```
    Specified by:
    
    replaceAll in interface List<N extends Node>
    
    See Also:
    
    List.replaceAll(java.util.function.UnaryOperator)
  - removeIf
```
public boolean removeIf(Predicate<? super N> filter)
```
    Specified by:
    
    removeIf in interface Collection<N extends Node>
    
    See Also:
    
    Collection.removeIf(java.util.function.Predicate)
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Collection<N extends Node>
    
    Specified by:
    
    clear in interface List<N extends Node>
    
    See Also:
    
    List.clear()
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Collection<N extends Node>
    
    Specified by:
    
    equals in interface List<N extends Node>
    
    Overrides:
    
    equals in class Object
    
    See Also:
    
    List.equals(java.lang.Object)
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Collection<N extends Node>
    
    Specified by:
    
    hashCode in interface List<N extends Node>
    
    Overrides:
    
    hashCode in class Object
    
    See Also:
    
    List.hashCode()
  - indexOf
```
public int indexOf(Object o)
```
    Specified by:
    
    indexOf in interface List<N extends Node>
    
    See Also:
    
    List.indexOf(java.lang.Object)
  - lastIndexOf
```
public int lastIndexOf(Object o)
```
    Specified by:
    
    lastIndexOf in interface List<N extends Node>
    
    See Also:
    
    List.lastIndexOf(java.lang.Object)
  - listIterator
```
public ListIterator<N> listIterator()
```
    Specified by:
    
    listIterator in interface List<N extends Node>
    
    See Also:
    
    List.listIterator()
  - listIterator
```
public ListIterator<N> listIterator(int index)
```
    Specified by:
    
    listIterator in interface List<N extends Node>
    
    See Also:
    
    List.listIterator(int)
  - parallelStream
```
public Stream<N> parallelStream()
```
    Specified by:
    
    parallelStream in interface Collection<N extends Node>
    
    See Also:
    
    Collection.parallelStream()
  - subList
```
public List<N> subList(int fromIndex,
                       int toIndex)
```
    Specified by:
    
    subList in interface List<N extends Node>
    
    See Also:
    
    List.subList(int, int)
  - spliterator
```
public Spliterator<N> spliterator()
```
    Specified by:
    
    spliterator in interface Iterable<N extends Node>
    
    Specified by:
    
    spliterator in interface Collection<N extends Node>
    
    Specified by:
    
    spliterator in interface List<N extends Node>
    
    See Also:
    
    List.spliterator()
  - unregister
```
public void unregister(AstObserver observer)
```
    Description copied from interface: Observable
    
    Unregister an observer. If the given observer was not registered there are no effects.
    
    Specified by:
    
    unregister in interface Observable
  - register
```
public void register(AstObserver observer)
```
    Description copied from interface: Observable
    
    Register an observer.
    
    Specified by:
    
    register in interface Observable
  - isRegistered
```
public boolean isRegistered(AstObserver observer)
```
    Description copied from interface: Observable
    
    Was this observer registered? Note that equals is used to determine if the given observer was registered.
    
    Specified by:
    
    isRegistered in interface Observable

Class NodeList<N extends Node>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.github.javaparser.HasParentNode

Constructor Detail

NodeList

NodeList

Method Detail

add

remove

nodeList

nodeList

nodeList

contains

stream

size

get

iterator

set

remove

isEmpty

sort

addAll

add

getParentNode

setParentNode

getParentNodeForChildren

accept

accept

forEach

contains

toArray

toArray

remove

containsAll

addAll

addAll

removeAll

retainAll

replaceAll

removeIf

clear

equals

hashCode

indexOf

lastIndexOf

listIterator

listIterator

parallelStream

subList

spliterator

unregister

register

isRegistered