Can an object belong to both an array and arraylist simultaneously in Java?

Yes, this is possible. When we say an array (of a reference type) or array list "contains" some object, it really means that it holds a reference to that object. It is totally possible for two arrays or array lists to hold references to the same object.

The effect of this isn't apparent in the example you showed, because you cannot change String objects - they are immutable. When you do strArray[2] = "Monkey";, you are making the array hold a reference to a different String object.

That said, you can still show that the array and array list holds the same String objects by comparing them with ==. This compares whether they are the same objects (instead of comparing whether they have the same characters).

ArrayList<Object> arr = new ArrayList<Object>();

String[] strArray = new String[3];
strArray[0] = new String("one");
strArray[1] = "two";
strArray[2] = "three";

String[] str = strArray;

arr.add(str[0]);
arr.add(str[1]);
arr.add(str[2]);

for (int i = 0 ; i < 3 ; i++) {
    System.out.println(arr.get(i) == str[i]);
}
// this prints 3 "true"s.

As a more meaningful example, you can use a mutable class, like StringBuilder. A simple way to mutate a StringBuilder is to append some content to it.

ArrayList<Object> arr = new ArrayList<>();

StringBuilder[] strArray = new StringBuilder[3];
strArray[0] = new StringBuilder("one");
strArray[1] = new StringBuilder("two");
strArray[2] = new StringBuilder("three");

arr.add(strArray[0]);
arr.add(strArray[1]);
arr.add(strArray[2]);

strArray[2].append("Some additional content");

System.out.println(strArray[2]);
System.out.println(arr.get(2));
// prints two lines of "threeSome additional content"

Sure, you can hold the same reference in both the array and the list. I'm not giving an example of testing the objects references because it's well explained in Sweeper's answer.

For the second part of the question, you can use a data structure that is backed by another. The following example with Arrays.asList (javadoc) works as you expect whether modifying the array or the list:

public class ArraysExample {

    public static void main(String[] args) {

        String[] arrStrings = new String[]{"one", "two", "three"};
        List<String> arrAsList = Arrays.asList(arrStrings);

        displayArray(arrStrings);  // prints [one, two, three]
        displayList(arrAsList);    // prints [one, two, three]

        arrStrings[2] = "Monkey";  // Modify the array at position 2
        arrAsList.set(0, "Dog");   // Modify the list at position 0

        displayArray(arrStrings);  // prints [Dog, two, Monkey]
        displayList(arrAsList);    // prints [Dog, two, Monkey]
    }

    private static void displayList(List<String> arrAsList) {
        System.out.println(arrAsList);
    }

    private static void displayArray(String[] arrStrings) {
        System.out.println(Arrays.toString(arrStrings));
    }
}

From method Arrays.asList javadoc:

Returns a fixed-size list backed by the specified array. Changes made to the array will be visible in the returned list, and changes made to the list will be visible in the array. The returned list is Serializable and implements RandomAccess.

The returned list implements the optional Collection methods, except those that would change the size of the returned list. Those methods leave the list unchanged and throw UnsupportedOperationException.

The type of the list instance returned by Arrays.asList(arrStrings) is java.util.Arrays$ArrayList and this Stackoverflow answer explains more details about it.

As the other Answers explain, both an array and a Collection like ArrayList contain references as elements, not actually objects as elements.

In day-to-day work we often forget about this distinction. We usually think of List< Person > as containing Person objects. But, not really. The contents are actually references (pointers) to Person objects.

A diagram might help. Let's depict a JLabel object, used in Swing for labeling in a GUI.

JLabel label = new JLabel ( "Alice" ) ;  // Pass a `String` object as the initial content to be displayed to the user in a GUI.

We can store a reference to this label in both an array and in an ArrayList. One object, two references.

JLabel[] labelsArray = new JLabel[ 3 ] ; 
labelsArray[ 0 ] = label ;

List< JLabel > labelsList = new ArrayList<>( 3 ) ;
labelsList.add( label ) ;

A JLabel object is mutable; we can alter the text it contains by calling setText.

Since we have only one object in play, with a reference to that object in the array, and a reference to that object in the list, we can go through either the array or list to alter that one single object.

Via the array.

labelsArray[ 0 ].setText( "Bob" ) ;

Now call label.getText to see "Bob".

Via the list.

labelsList.get( 0 ).setText( "Carol" ) ;

Now call label.getText to see "Carol".