UnsupportedOperationException vs ConcurrentModificationExcetion

I have a code that adds data to a list. What I do not understand is why the UnsupportedOperationException is thrown in one case and ConcurrentModificationException in the other. I am adding data in list in both the case and then trying to remove list data while iterating over the list. What i have read so far is that whenever any modification is made to fail- fast collection,ConcurrentModificationException is thrown. So why this different behavior in both these cases?

  List<String> animalList = new ArrayList<>();
        animalList.add("cat");
        animalList.add("dog");
        animalList.add("bear");
        animalList.add("lion");

        Iterator<String> iter = animalList.iterator();

        while(iter.hasNext()){
            String animal = iter.next();
            System.out.println(animal);
            animalList.remove(3);
        }

This code throws ConcurrentModificationException

String[] strings = { "Java", "Honk", "Test" };

        List<String> list = Arrays.asList(strings);


        Iterator<String> iterator = list.iterator();

        while(iterator.hasNext()){
            String name = iterator.next();
            System.out.println(name);
            list.remove(3);
        }

while this one throws UnsupportedOperationException

Arrays.asList does not return an ArrayList. In fact, the list returned is not modifiable, thus when you try to modify it, it throws the UnsupportedOperationException.