Yes; the Java Language Specification writes:

In the Java programming language, arrays are objects (§4.3.1), are dynamically created, and may be assigned to variables of type Object (§4.3.2). All methods of class Object may be invoked on an array.

Well, let's ask Java!

public class HelloWorld
{
  public static void main(String[] args)
  {
    System.out.println(args instanceof Object);
    int[] someIntegers = new int[] {42};
    System.out.println(someIntegers instanceof Object);
  }
}

Output:

true
true

Yes, it is an object in Java.

Also note that when you do array.length you're not invoking any methods but just accessing the array's length field. There are plenty of static methods in the Arrays class.

1. An array is not an instance of any class listed in the class tree, however each array is an object and inherits directly from java.util.Object

(new int[1]) instanceof Object   // -> evaluates to true

2. The class java.util.Arrays is a helper class, and arrays are not instances of this class.

(new int[1]) instanceof java.util.Arrays    // -> compile error

3. The class java.lang.reflect.Array is a helper class, and arrays are not instances of this class.

(new int[1]) instanceof java.lang.reflect.Array    // -> compile error

4. Arrays inherit all the members of java.lang.Object

5. Arrays override the method clone() inherited from Object.

6. Arrays implement the field length, which contains the number of components of the array. length may be positive or zero. It is public and final.

7. Arrays implement the interfaces Cloneable and java.io.Serializable.

8a. Arrays are supported by Class<T>. You can retrieve the Class<T> instance from an array instance

(new int[2]).getClass()

or from an array type

int[].class

8b. A unique reflection class instance (ie an instance of java.lang.Class<T>) is created for each different array type in your code. Examples

int[].class.getCanonicalName()    //  -> "int[]"
String[].class.getCanonicalName() //  -> "java.lang.String[]" /

9. To repeat: Arrays are objects but are not instances of any class in the class tree.

REFERENCES

From the Java specification Section 4.3.1 Objects

• An object is a class instance or an array.

• A class instance is explicitly created by a class instance creation expression.

• An array is explicitly created by an array creation expression.

From java.util.Arrays

• This class contains various methods for manipulating arrays (such as sorting and searching)

From java.lang.reflect.Array

• The Array class provides static methods to dynamically create and access Java arrays.

From Section 10.1 Objects

• The direct superclass of an array type is Object.

• Every array type implements the interfaces Cloneable and java.io.Serializable.

From Section 10.7 Array Members

The members of an array type are all of the following:

• The public final field length, which contains the number of components of the array. length may be positive or zero.

• The public method clone, which overrides the method of the same name in class Object and throws no checked exceptions. The return type of the clone method of an array type T[] is T[].

• A clone of a multidimensional array is shallow, which is to say that it creates only a single new array. Subarrays are shared.

• All the members inherited from class Object; the only method of Object that is not inherited is its clone method.

It would be important to note that arrays in Java have their own byte codes which they do not share with objects. They are certainly Objects, but are handled slightly differently at the low level.

I just want to add that arrays have a representation in the reflection API - java.lang.reflect.Array.

I would say the answer is yes, although I might add that, strictly speaking, an array is an object in C++ too. From §1.8 [intro.object] of the current standard (FDIS):

An object is a region of storage.

Every array in java is an object ex int[] a=new int [2]; So new is used to create an object and as it is an object we can check the class name just using a.getClass().getName();

Arrays of anything are objects. One can call methods such as equals, hashcode etc:

final int[] i = {};
i.equals(new int[] {1});  // false
i.hashcode();

One cannot call methods on a native type.

In java, arrays are objects, and are dynamically created. Arrays can be assigned to variables of type Object, and all methods of type Object can be invoked on arrays. An array can contain multiple variables or also contain 0 variables in which case it is said to be empty.

Observe below code snippet and output.

public class Tester {
int a[];
public static void main(String[] args) {
    System.out.println(new Tester().a);// null
    System.out.println(new Tester().a[0]);// Exception in thread "main" java.lang.NullPointerException \n at mainclass.Tester.main(Tester.java:10)
}

}

clearly array a is treated as object.

Yes, the docs say so:

An array is a container object that holds a fixed number of values of a single type.

Note that array types of primitive types (like int[] or char[]) themselves are also objects.

Every array directly extends java.lang.Object and implements the interfaces javs.lang.Cloneable and java.io.Serializable. The runtime type signature of an array is [L immediately followed class name of component type (e.g. [Ljava.lang.String). Arrays of primitive types have the following runtime signature:

• [B for byte[];
• [S for short[];
• [I for int[];
• [J for long[];
• [F for float[];
• [D for double[];
• [C for char[].

Some suggested checking the value returned by instance of. I think that manner is semantically wrong because once you are able to write and compile such code:

    int[] myArray = new int[3];
    if (myArray instanceof Object) {
    }

It already proved that myArray is an object. If it were not, the code won't compile. As is written in a oracle tutorial

The instanceof operator compares an object to a specified type. You can use it to test if an object is an instance of a class, an instance of a subclass, or an instance of a class that implements a particular interface