Is adding list in List of Lists added by reference?

I'm trying to understand java object references. What I learned so far is

1. Objects' references are passed by value, so adding something in that object will be available in the object after the method returns.
2. Creating a new object foo inside a method that received the object foo as argument will not reflect changes made on locally created foo object, on passed foo object.

Based on this knowledge, I'm trying to understand why the following code snippet isn't removing objects from current list that've been added to result list.

The code below doesn't suffer from empty list at the end of recursion even though it's adding references of currentList to resultList & we're removing elements from currentList.

findCombations(condidates, 0, target, new ArrayList<Integer>(), result); 
public void findCombinations(int[] candidates, int index, Int target, List<Integer> currentList, List<List<Integer» result) { 
	if(target == 0) { 
		result.add(currentList); 
		return; 
	} 
	if(target < 0) { return; } 
	
	for(int i = index; i < candidates.length; i++) {
	 if(i == index && candidates[i] != candidates[i - 1]) { 
		 currentList.add(candidates[i]); 
		 findCombinations(candidates, i + 1, target - candidates[i], currentList, result); 
		 currentList.remove(currentList.size() - 1); //why removing numbers from this list not removing the numbers from the currentList that's been added to result list?
	 }
 }

Can someone please help me understand this behavior?

EDIT:

This is a leetcode question that requires unique combinations that lead to target:
We've to find all the unique number combinations whose sum lead to the given target. We can't have duplicate sets/combinations.
The provided code is doing DFS on the given array & finding the combinations based on subtracting an element that it comes across in the array. There are 2 base cases, when the target == 0, we just add the currentList in resultList. CurrentList contains the numbers whose sum == target & the other base case is if target < 0, in that case, we end recursion.

Input: candidates = [10,1,2,7,6,1,5], target = 8,
A solution set is:
[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

> Is adding list in List of Lists added by reference?

Yes, it is. The method call result.add(currentList) adds a reference to currentList to the result list. Any changes that you make to currentList after this point will be seen also through "result," because it holds a reference to the same object.

Simplified example: intuitively you might think this program should print [["hello"], []] but instead it prints [[], []] because result holds two references to the same instance of list.

List<List<String>> result = new ArrayList<>();
List<String> currentList = new ArrayList<>();

currentList.add("hello");
result.add(currentList);

currentList.remove(0);
result.add(currentList);

System.out.println(result);

If you want to stop this from happening, you can create a copy of currentList when you add it to result.

// add a copy instead of a reference to the same list
result.add(new ArrayList<>(currentList));