Trouble with removing object in DoubleLinkedList in Java

I am struggling with this remove(Object obj) method. I have tried many different things, and this is the closest I can get. The item being deleted is the one before the object being passed in:

public boolean remove(Object obj)
{
	if (!this.contains(obj))
		return false;

	//if we get to here, we know that the list contains obj somewhere
	//change the links and return true at the end.
	else if (head.data.equals(obj))    //is it at the front?
	{
		this.removeFirst();
		return true;
	}

	else    //not at front, so traverse the list
	{
		DLLNode<E> doomed = head;
		while (!doomed.data.equals(obj))
			doomed = doomed.next;

		//now that it is found, find the node in front of it
		DLLNode<E> inFront = head;
		while (inFront.next != doomed)
			inFront = inFront.next;

                    //
                    // HERE IS THE PROBLEM & MY EXPLANATION BEHIND IT
                    //
		// locate the prev locator of the following node of the obj and set it equal to the beginning (prev) of the node in front of the obj removed
		inFront.next.prev = inFront.prev;
		// locate the next locator of the preceding node of the obj and set it equal to the end (next) of the node in front of the obj removed
		inFront.prev.next = inFront.next;

		//also...if the one that was deleted was the tail, we must reset the tail
		if (doomed == tail)
			tail = inFront;
	}

	return true;   //found it; links have been changed

}

The current output in my tests is removing the node before the node that matches the object being passed in.

Thank you.

EDIT: Just to make sure I am understanding this correctly, my inFront variable is to left of the doomed variable? At least that is how I have been thinking of it when I write the code. For example:

DDL: 1-->2-->3

I want to remove(2).

That means -

• doomed = 2
• inFront = 1

So, inFront.next would be the 'next' node for 1?

EDIT 2: I now understand that what I thought is true. With that I made an adjustment and was able to get the same output by changing the following from:

inFront.next.prev = inFront.prev;
inFront.prev.next = inFront.next;

to

inFront.next = doomed.next.next.prev;

Now, the correct node that matched the object is being deleted when the DLL is read left to right. However, when reading the DLL from right to left, the object reappears in the same position.

<h3>Edit: </h3>
Yes, the code to find the element is correct. But in the deletion part, you had thought inFront is the previous node, so it was deleting the wrong node.
Now for deletion. Before deleting you have something like this :

Now, you have to set inFront.next to doomed.next:

inFront.next=doomed.next;

Your list looks like this now:

The next step is to set doomed.next.prev to inFront:

doomed.next.prev=inFornt;

The final stat:

Since there is no reference to the doomed object, the Garbage collector will delete it from memory.

Solved! It was a stupid mistake. I was not considering a separate case. I understand that without all the information provided to this community, that I cannot expect anyone to be able to understand my problem fully and provide assistance. This one is on me. To publicly shame myself and persuade others in the future to provide necessary information, I will explain the problem and solution.

My initial problem was that the node being removed was the one in front of the requested object. Solved with this:

inFront.next = doomed.next;
doomed.next.prev = inFront;

Then, I was not considering the fact that an object removed at the end of the list would need a special case to avoid issues such as not removing, or destroying connections to other nodes. This was solved by creating an if statement:

if (doomed != tail) {
	inFront.next = doomed.next;
	doomed.next.prev = inFront;
} else {
	inFront.next = null;
}

Thank you! I'll be sure to better structure my questions in the future.