Converts this list into a java.util.ArrayList.

@return The list that contains the elements.
977615
@Nonnull
    public final ArrayList<A> toArrayList() {
        ArrayList<A> list = new ArrayList<>(this.length);
        ImmutableList<A> l = this;
        for (int i = 0; i < length; i++) {
            list.add(((NonEmptyImmutableList<A>) l).head);
            l = ((NonEmptyImmutableList<A>) l).tail;
        }
        return list;
    }
429188
public List iterateObjectsToList() {
        List result = new ArrayList();
        Iterator iterator = iterateObjects();
        for (; iterator.hasNext(); ) {
            result.add(iterator.next());
        }
        return result;
    }
1065810
public java.util.ArrayList getExceptions() {
        if (exceptions != null)
            return (java.util.ArrayList) exceptions.clone();
        else
            return null;
    }
226856
public java.util.ArrayList toList() {
	int mySize = size();
	Object[] theElements = elements;
	java.util.ArrayList list = new java.util.ArrayList(mySize);
	for (int i=0; i < mySize; i++) list.add(theElements[i]);
	return list;
}
/**
* Returns a string representation of the receiver, containing
* the String representation of each element.
*/
public String toString() {
	return cern.colt.Arrays.toString(partFromTo(0, size()-1).elements());
}
/**
 * Trims the capacity of the receiver to be the receiver's current 
 * size. Releases any superfluos internal memory. An application can use this operation to minimize the 
 * storage of the receiver.
 */
public void trimToSize() {
	elements = cern.colt.Arrays.trimToCapacity(elements,size());
}
}
487017
public List<T> getElements() {
		ArrayList<T> list = new ArrayList<>(nodes.size());
		for (Node<T> node : nodes)
			list.add(node.element);
		return list;
	}
	
	/** Return the number of elements. */
	public int size() { return nodes.size(); }
	
}
955257
public CmsHtmlList getList() {

        if ((m_list != null) && (m_list.getMetadata() == null)) {
            m_list.setMetadata(getMetadata(getClass().getName(), m_list.getId()));
        }
        return m_list;
    }
849757
public static String[] toArray(List<String> list) {
        String[] ret = new String[list.size()];
        for (int i = 0; i < ret.length; i++)
            ret[i] = list.get(i);
        return ret;
    }
1347114
public static Object[] toArray(List<?> list) {
	Iterator<?> it = list.iterator();
	Class clazz = null;
	while (it.hasNext()) {
	    Object v = it.next();
	    if (v == null) continue;
	    if (clazz == null) clazz = v.getClass();
	    else if (clazz != v.getClass()) return list.toArray();
	}
	if (clazz == Object.class || clazz == null) return list.toArray();

	Object arr = java.lang.reflect.Array.newInstance(clazz, list.size());
	return list.toArray((Object[]) arr);
    }
916450
public List<T> toList() {
        try {
            return StreamSupport.stream(Spliterators.spliteratorUnknownSize(this, Spliterator.ORDERED), false)
                    .collect(Collectors.toList());
        } finally {
            close();
        }
    }
622614
public List<T> elementList() {

        if (m_cache != null) {
            return m_cache;
        }
        if (m_relativeOrdered) {
            List<T> objectList = new ArrayList<T>();
            Iterator<CmsIdObjectElement<T>> itObjs = m_orderedObjectList.iterator();
            while (itObjs.hasNext()) {
                CmsIdObjectElement<T> object = itObjs.next();
                objectList.add(object.getObject());
            }
            m_cache = Collections.unmodifiableList(objectList);
        } else {
            m_cache = Collections.unmodifiableList(m_objectList);
        }
        return m_cache;
    }
292257
public static <T> T[] toArray(List<T> list) {
    return toArray(getClass(list.get(0)), list);
  }
1097973
public ArrayList<E> toFlatArrayList() {
		ArrayList<E> ret = new ArrayList<>();
		this.columns.forEach(ret::addAll);
		return ret;
	}
319732
List<InputElement> getAllFields() {

        NodeList<Element> fields = getElement().getElementsByTagName(InputElement.TAG);
        List<InputElement> result = Lists.newArrayList();
        for (int i = 0; i < fields.getLength(); i++) {
            InputElement field = InputElement.as(fields.getItem(i));
            result.add(field);
        }
        return result;
    }
209536
@Nonnull
  public List<E> toList() {
    return new AbstractList<E>() {
      @Override
      public E get(final int index) {
        return Seq.this.get(index);
      }

      @Override
      public int size() {
        return length();
      }
    };
  }
489360
public List<T> toList() {
		final String sourceMethod = "toList"; //$NON-NLS-1$
		SignalUtil.lock(rwl.readLock(), sourceClass, sourceMethod);
		List<T> result = null;
		try {
			result = Arrays.asList(Arrays.copyOf(items, index.get()));
		} finally {
			rwl.readLock().unlock();
		}
		return result;
	}
997681
@Nonnull
    public ImmutableList<T> toList() {
        return this.foldAbelian((v, acc) -> acc.cons(v), ImmutableList.empty());
    }
1277611
public static <T> ArrayList<T> newArrayList(Iterator<? extends T> elements) {
        return Lists.newArrayList(elements);
    }