Do the methods used in if statement tests execute?

Disclaimer: I am a new programmer with only a few months of experience so I apologize if this question is trivial.

In Java, do the methods in the test of an if statement execute?
For example, in this snippet of code, I have a waitlist variable of type LinkedListQueue, which is a class that I wrote to model a queue data structure, with methods for enqueue() (add), dequeue() (remove), size, setCapacity, and isEmpty(). The dequeue() method returns the object removed from the queue. The waitlist variable is a LinkedQueue object of type int. I want to traverse through each element of the queue and check if it equals 3, and if it does, I will remove it. When the line of code for the if statement test executes, does it remove the object in the queue?

for (int i = 0; i < waitlist.size(); i++) {
    		if (waitlist.dequeue() == 3) {
    			waitlist.dequeue();
    		}
	}

The method calls inside the condition of an if-statement will execute unless the condition is short-circuited -> you have an OR and the first piece is already known to be true, the second piece isn't checked, or you have an AND and the first piece is known to be false, the second piece isn't checked.

if( true || test() ) // test isn't executed
if( false || test()) // test IS executed
if( true && test() ) // test IS executed
if( false && test() )// test isn't executed
if( test() ) // test IS executed
if( !test() )// test IS executed

The values can also be other method calls like so:

if( alwaysTrue() || test() ) // test will never execute
if( alwaysFalse() || test() ) // test will ALWAYS execute
if( alwaysTrue() && test() ) // test will ALWAYS execute
if( alwaysFalse() && test() )// test will never execute

Basically, the only way to prevent a method call in an if-statement from executing is to short-circuit or cause an exception to be thrown before the execution can happen.

If you absolutely need to call a method there, then consider a method that has no side-effects, such as just peeking at the value instead of removing it from the list.

The ArrayDeque implementation and the LinkedList implementation seem like they would fit your use case nicely.

What you are doing is de-queuing and checking if the result is 3, if so, de-queue again. You are essentially skipping the next one, if you wanted to use it.

Whatever came after 3, will be removed; plain and simple.

Be careful about using the size, at this can change as you are de-queuing items.

public class Waitlist {
    public static void main(String[] args) {
        basicExample();     // Hello, World,
        advancedExample();  // 2, 4, 6, 8,
        exceptionExample(); // Success!
    }

    // Stops short, because one item was removed, this is unreliable.
    private static void basicExample() {
        Queue<String> waitlist = new LinkedListQueue<>();
        waitlist.enequeue("Hello");
        waitlist.enequeue("World");
        System.out.printf("Before : %s%n", waitlist);
        System.out.print("During : ");
        for (int i = 0; i < waitlist.size(); i++) {
            System.out.printf("%s... ", waitlist.dequeue());
        }
        System.out.printf("%nAfter  : %s%n%n", waitlist);
    }

    // Runs through the entire queue and removes, all items, printing even numbers.
    private static void advancedExample() {
        Queue<Integer> waitlist = new LinkedListQueue<>();
        for (int i = 0; i < 10; i++) waitlist.enequeue(i);
        System.out.printf("Before : %s%n", waitlist);
        System.out.print("During : ");
        while (!waitlist.isEmpty()) {
            if (waitlist.dequeue() % 2 == 1 && !waitlist.isEmpty()) {
                System.out.printf("%s... ", waitlist.dequeue());
            }
        }
        System.out.printf("%nAfter  : %s%n%n", waitlist);
    }

    // Throws an exception
    private static void exceptionExample() {
        int max = 8;
        Queue<Integer> waitlist = new LinkedListQueue<>(max); // max of 8
        try {
            for (int i = 0; i <= max; i++) {
                waitlist.enequeue(i);
            }
        } catch (QueueFullException e) {
            System.out.println("Success!"); // We reached capacity!
        }

    }
}

Output

Before : Hello, World
During : Hello... 
After  : World

Before : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
During : 2... 4... 6... 8... 
After  : 

Success!

LinkedListQueue.java

Based on this, but I made it abstract.

import java.util.Iterator;

public class LinkedListQueue<T> implements Queue<T> {
    private static class Node<E> {
        private E data;
        private Node<E> next;

        public Node(E data) {
            this.data = data;
            next = null;
        }
    }

    private Node<T> head, tail;
    private int size, capacity;

    public LinkedListQueue() {
        this(Integer.MAX_VALUE);
    }

    public LinkedListQueue(int capacity) {
        this.size = 0;
        this.capacity = capacity;
    }

    @Override
    public void setCapacity(int capacity) {
        this.capacity = capacity;
    }

    @Override
    public void enequeue(T data) throws QueueFullException {
        if (this.size == this.capacity) {
            throw new QueueFullException("The queue has reached its maximum capacity.");
        }
        Node<T> node = new Node<>(data);
        if (head == null) {
            head = node;
        } else {
            tail.next = node;
        }
        tail = node;
        size++;
    }

    @Override
    public T dequeue() {
        if (isEmpty()) {
            throw new NullPointerException("There is nothing to dequeue from this queue.");
        }
        T temp = head.data;
        head = head.next;
        size--;
        return temp;
    }

    @Override
    public boolean isEmpty() {
        return head == null;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            Node<T> curr = head;
            @Override
            public boolean hasNext() {
                return curr != null;
            }
            @Override
            public T next() {
                T data = curr.data;
                curr = curr.next;
                return data;
            }
        };
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        Iterator<T> it = this.iterator();
        while (it.hasNext()) {
            builder.append(it.next() + ", ");
        }
        return builder.toString().replaceAll(", $", "");
    }
}

Queue.java

public interface Queue<T> extends Collection<T> {
    void enequeue(T data) throws QueueFullException;
    T dequeue();
    void setCapacity(int capacity);
}

Collection.java

public interface Collection<T> extends Iterable<T> {
    boolean isEmpty();
    int size();
}

QueueFullException.java

public class QueueFullException extends RuntimeException {
    public QueueFullException() {
        super();
    }
    public QueueFullException(String message) {
        super(message);
    }
}