Reverse subset of ArrayList using multidimensional ArrayList in Java

I am trying to reverse a sublist in a List using the indices provided in a multidimensional List. I don’t have much experience using multidimensional lists/arrays. I don’t understand why this doesn’t work.

/*
   Given a List<Integer> list and List<List<Integer>> operations
   reverse the sublist and print out the list after all the operations have been done.
   Ex: [5, 3, 2, 1, 3]
       [[0,1], [1, 3]]
*/

import java.util.*;
public class ReverseParameters {
   public static void main(String[] args) {
       List<Integer> list = Arrays.asList(5, 3, 2, 1, 3);
       List<List<Integer>> operations = new ArrayList<>(2);
       for(int i= 0; i < 3; i++){
           operations.add(new ArrayList<>());
       }
       operations.get(0).add(1);
       operations.get(1).add(3);

       subList(list, operations);
   }
   public static void subList (List<Integer> list, List<List<Integer>> operations) {
       System.out.println(list);
       int vertCount = operations.size();
       for (int i = 0; i < vertCount; i++) {
           int edgeCount = operations.get(i).size();
           for (int j = 0; j < edgeCount; j++) {
               int startInd = i;
               int endInd = operations.get(i).get(j);
               int shift = endInd - startInd;
               int right = Math.min(i + shift - 1, list.size() - 1);
               int temp = 0;
               while (startInd < right) {
                   temp = list.get(startInd);
                   list.set(startInd, list.get(right));
                   list.set(right, temp);
                   startInd+=1;
                   right-=1;
               }
               System.out.println();
               System.out.printf(" %d %d%n", startInd, endInd);
               System.out.println();
           }
       }
       System.out.println(list);
   }
}

The output of this code using [[0,1], [1, 3]] as the indecies is:

[5, 2, 3, 1, 3]

but it should be:

[3, 1, 2, 5, 3]

Can someone please help point me in the right direction?

Answer

This can be done as simple as this.

public class Main
{
    public static void main(String[] args)
    {
        //Given a List<Integer> list and List<List<Integer>> operations
        //reverse the sublist and print out the list after all the operations have been done.
        //Ex: [5, 3, 2, 1, 3] 
        //    [[0,1], [1, 3]]
        //Target: [3, 1, 2, 5, 3]
        
        //Steps:
        // 0  1  2  3  4 (Indices)
        //###############
        //[5, 3, 2, 1, 3]
        //[3, 5, 2, 1, 3] // Swap index of 0 and 1.
        //[3, 1, 2, 5, 3] // Swap index of 1 and 3.
        
        List<Integer> list = Arrays.asList(5, 3, 2, 1, 3);
        
        List<List<Integer>> listOfList = new ArrayList<List<Integer>>(2);
        listOfList.add(Arrays.asList(0, 1));
        listOfList.add(Arrays.asList(1, 3));
        
        for(int i=0; i < listOfList.size(); ++i) {
            final int indexA = listOfList.get(i).get(0); //[0 , [1
            final int indexB = listOfList.get(i).get(1); // 1],  3]
            
            //Swap the indices.
            final int tmpValue = list.get(indexA);
            list.set(indexA, list.get(indexB));
            list.set(indexB, tmpValue);
        }
        
        System.out.println(list);
        //[3, 1, 2, 5, 3]
    }
}