Question: I've been reading the term *view* a few times when using [Guava](https://github.com/google/guava) collections and reading its documentation.

I've looked for an explanation of what a view is in this context and whether it's a term used outside of Guava. It's quite often used [here](https://github.com/google/guava/wiki/CollectionUtilitiesExplained). This [type](https://google.github.io/guava/releases/23.0/api/docs/com/google/common/collect/Sets.SetView.html) from Guava has *view* in its name.

My guess is that a view of a collection is another collection with the same data but structured differently; for instance when I add the entries from a `java.util.HashSet` to a `java.util.LinkedHashSet` the latter would be a view of the former. Is that correct?

Can somebody hook me up with a link to an accepted definition of *view*, if there is one?

Thanks.

Answer: 
A *view* of another object doesn't contain its own data at all. All of its operations are implemented in terms of operations on the other object.

For example, the `keySet()` view of a `Map` might have an implementation that looks something like this:

```
class KeySet implements Set<K> {
  private final Map<K, V> map;

  public boolean contains(Object o) {
    return map.containsKey(o);
  }

  ...
}

```

In particular, whenever you modify the *backing object* of your view -- here, the `Map` *backs* the `keySet()` -- the view reflects the same changes. For example, if you call `map.remove(key)`, then `keySet.contains(key)` will return `false` without you having to do anything else.

Alternately, `Arrays.asList(array)` provides a `List` view of that array.

```
String[] strings = {"a", "b", "c"};
List<String> list = Arrays.asList(strings);
System.out.println(list.get(0)); // "a"
strings[0] = "d";
System.out.println(list.get(0)); // "d"
list.set(0, "e");
System.out.println(strings[0]); // "e"

```

A view is just another way of looking at the data in the original backing object -- `Arrays.asList` lets you use the `List` API to access a normal array; `Map.keySet()` lets you access the keys of a `Map` as if it were a perfectly ordinary `Set` -- all *without* copying the data or creating another data structure.

Generally, the advantage of using a view instead of making a copy is the efficiency. For example, if you have an array and you need to get it to a method that takes a `List`, you're not creating a new `ArrayList` and a whole copy of the data -- the `Arrays.asList` view takes only constant extra memory, and just implements all the `List` methods by accessing the original array.
A *view* in this context is a collection backed by another collection (or array) that itself uses a constant amount memory (i.e. the memory does not depend on the size of the backing collection). Operations applied to the view are delegated to the backing collection (or array). Of course it's possible to expand this definition beyond just collections but your question seems to pertain specifically to them.

For example, [`Arrays.asList()`](http://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#asList%28T...%29) returns "a list view of the specified array". It does not copy the elements to a new list but rather creates a list that contains a reference to the array and operates based on that.

Another example is [`Collections.unmodifiableList()`](http://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#unmodifiableList%28java.util.List%29) which returns "an unmodifiable view of the specified list". In other words, it returns a list containing a reference to the specified list to which all operations are delegated. In this case, the list returned does not permit you to modify it in any way, and so instead of delegating methods responsible for mutating the list, it throws an exception when such methods are called instead.