Executor tasks for parallelizing a method
First of all, regarding your questions:


Yes. The 4 Futures will be mapped to 4 executor threads for all practical considerations. There might be edge-cases, where the first future is finished before the last is submitted and a thread gets reused, but this does not lead to any practical implications.
No, the i is a local variable. There is a different instance in each thread.
As you go index-based, you might as well use start- and end-indexes for your Future executions instead of sublists. On the other hand, if the list is an ArrayList this is exactly what happens under the hood of the sublist call.
Yes, I cannot see the question there.


However, your code has some other points worth addressing:


as AJNeufeld already mentioned, deleteObject() gets called twice per object
if a single object deletion fails, the following objects in that sublist will not even be attempted - is that the expected behaviour?
Callable is a functional interface, so instead of creating an anonymous subclass for each callable, simply use a lambda expression: () -&gt; parallelDeleteOperation(listDir1)
index-based list traversal only makes sense if you actually need the index variable. In this case, you should use for(int x : listDir)


Regarding the general principle: you try to do many things manually and via a design decision, which the system already can do for you. Especially the idea to use exactly 4 CPUs is odd: if the target machine only has 2 CPUs you will wast time through unnecessary thread-switches, on an 8-core half of the machine is idle.

Additionally, as I already mentioned above, you don't attempt to delete every object, but only up to the first failure.

To rectify this, I suggest that you simply use a parallelStream which will be split to a number of cores suited for the given machine automatically, and collect the total success value via a reducer:

boolean allDeletionsSuccessful
= listDir.parallelStream()             // split to number of cores
    .map(x -&gt; deleteObject(x))         // attempt each deletion, record success value
    .reduce(true, (x, y) -&gt; x &amp; y);    // merge with logical AND