Why a list size lower than COPY_THRESHOLD means it is a arraylist?

In package java.util.Collections, here is the source code about copy function:

    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        int srcSize = src.size();
        if (srcSize > dest.size())
            throw new IndexOutOfBoundsException("Source does not fit in dest");

        if (srcSize < COPY_THRESHOLD ||
            (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
        } else {
            ListIterator<? super T> di=dest.listIterator();
            ListIterator<? extends T> si=src.listIterator();
            for (int i=0; i<srcSize; i++) {
                di.next();
                di.set(si.next());
            }
        }
    }

And if the src list size lower than COPY_THRESHOLD srcSize < COPY_THRESHOLD,then it is a arraylist.I don't know why.

It's a trick question - it doesn't assume it's an array list. You would know if it did, because it would do a cast to ArrayList, probably.

Instead, the reason is likely efficiency. The two most common varieties of List are ArrayList and LinkedList; ArrayList is random-access, so getting to any individual element is equally fast, but LinkedList is not, so the further from the front any element is, the longer it takes.

If the list is random-access (which is to say, accessing any element is as efficient as accessing any other), then it makes sense that the fastest way to copy list A over to list B would be to simply get() and set() the relevant indices. This is what the condition (src instanceof RandomAccess && dest instanceof RandomAccess) checks.

If a list is not random-access, so is a linked list or some other type of list, then accessing elements in the middle via get() and set() is likely to be inefficient. So, Java uses iterators instead, copying elements one at a time. This is the else block of the conditional.

The problem with that, is that creating the list iterators, and iterating with them, requires overhead time that you wouldn't need to spend if you were using a primitive int. If your linked list is small enough - so, all the items you need to copy are close to the front - then it's probably still faster to use get() and set() than it is to use iterators. This is what the condition srcSize < COPY_THRESHOLD checks. Presumably, COPY_THRESHOLD is a constant that's been determined by the Java developers based on experimentation, so that the quickest approach is always chosen.