Can an empty array be useful?

The empty string $\epsilon \in \Sigma^*$ (the set of all strings with finite length) in automata theory and formal languages (theoretical CS). It is the neutral element of string concatenation.

Also if $L$ is a formal language, $L^0 = \{ \epsilon \}$ arises.

Addendum:

I was maybe exposed too much to C-like programming languages that I immediately associate arrays with strings. :-)

The proper mathematical equivalent of an array is probably the sequence over some finite index set $I$ into some set $A$:

$$ (a_k)_{k \in I} \in A^I = \left\{ a \, \left| \, \right. a : I \to A \right\} $$

That definition should include the more general associative arrays, where $I$ is not some subset of $\mathbb{N}$.

If the index set is the empty set $I = \emptyset$, we got the empty array, like the map $b : \emptyset \to \mathbb{C}$. I see no exiting use for that one. We can define the concatenation of arrays, and have it be the neutral element. But we had this with strings already.

To represent a string, a list data structure $L = [a, b, c ]$ is sufficient, where direct access to all stored data is not necessary, just access at the head $L = [H|T]$ is enough and order is preserved (it is not just a set), the functional languages and PROLOG like this model. However there recursion is used regulary, and the empty list $[]$ occurs naturally, for example in a clause that does not spawn anymore recursive call, at the leaves of a recursive call tree for a function that works on lists.

Mathematically, it is useful to have length be a nonnegative (not just positive) measurement. Then, we can do things like, given arrays $A,B$, define $C$ to be the largest array that agrees with both $A$ and $B$ for all its entries (agreement checked from the first entry onward). If $C$ cannot be empty, this definition can't be made.

If you're talking about applications in computer programming, suppose you initialize an array $A$ to the empty array, and then at some point in the program, which may be reached repeatedly, you do an operation that puts together the $n\times k$ array $A$ with the $n\times\ell$ array $B$, where the values of both of those change while the program is getting executed, to get the $n\times(k+\ell)$ array $[A, B]$.

I can imagine that being useful.

As for its utility in mathematics: I won't be surprised if in some situations it's useful, but I don't know what those are.

In programming it is useful for the Null Object Pattern. This simplifies the use of functions by mandating they always return a non-null value. Null values in programming an issue as they cannot be dereferenced without causing a runtime error as they point to literally nothing (apart from ruby)

e.g. With the function getValues() returning an empty array when there are no results

for (Integer value : getValues()) {
}

e.g. With the function getValues() returning NULL when there are no results forces us to make an extra check and complicates our code

Collection<Integer> values = getValues();
if (values != null) {
  for (Integer value : values) {
  }
}

In the category of Set, the empty set is the only initial object. I found that example, along with the fact that all one element sets are the terminal objects of Set, useful in understanding initial and terminal objects in general.

Also, it is possible to construct useful objects using nothing but the empty set and the basic operations of set theory: Set-theoretic definition of natural numbers

There are important differences between the concepts of arrays and of sets (sets have no order and contain no duplicates), but an empty set could still be thought of as analogous in some way to an empty array since they are both collections that contain no elements.

Imagine you have a function (either in programming or in mathematics) whose output is an array. It's easy to imagine that some inputs will naturally yield the empty array as an output -- but you may not know, at least at first, which inputs have this property.

It's very convenient not to have to keep checking whether or not you're removing the last element from an array.