在Java中，為了應對高并發場景，我們可以采用以下策略來優化ListNode類和相關操作：

1. 使用線程安全的集合：在高并發環境下，使用線程安全的集合可以避免數據不一致的問題。例如，可以使用ConcurrentHashMap或CopyOnWriteArrayList等線程安全的數據結構。

import java.util.concurrent.CopyOnWriteArrayList;

public class ListNode {
    private int val;
    private CopyOnWriteArrayList<ListNode> next;

    public ListNode(int val) {
        this.val = val;
        this.next = new CopyOnWriteArrayList<>();
    }

    // 其他方法...
}

2. 使用鎖或同步塊：為了確保數據的一致性，可以使用鎖或同步塊來控制對共享資源的訪問。例如，可以使用ReentrantLock來實現同步。

import java.util.concurrent.locks.ReentrantLock;

public class ListNode {
    private int val;
    private ListNode next;
    private ReentrantLock lock = new ReentrantLock();

    public ListNode(int val) {
        this.val = val;
    }

    public void setNext(ListNode next) {
        lock.lock();
        try {
            this.next = next;
        } finally {
            lock.unlock();
        }
    }

    // 其他方法...
}

3. 使用原子操作：對于簡單的操作，可以使用原子操作來避免鎖的開銷。例如，可以使用AtomicInteger來存儲節點的值。

import java.util.concurrent.atomic.AtomicInteger;

public class ListNode {
    private AtomicInteger val = new AtomicInteger(0);
    private ListNode next;

    public ListNode(int val) {
        this.val.set(val);
    }

    public int getVal() {
        return val.get();
    }

    public void setVal(int val) {
        this.val.set(val);
    }

    // 其他方法...
}

4. 使用線程池：在高并發環境下，使用線程池可以有效地管理線程資源，避免頻繁創建和銷毀線程帶來的性能開銷。可以使用ExecutorService來創建和管理線程池。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ListNode {
    // ...

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        // 提交任務到線程池
        executorService.submit(() -> {
            // 處理ListNode相關操作
        });

        // 關閉線程池
        executorService.shutdown();
    }
}

5. 使用無鎖算法：在某些場景下，可以使用無鎖算法來提高性能。例如，可以使用AtomicReference來實現無鎖的鏈表操作。

import java.util.concurrent.atomic.AtomicReference;

public class ListNode {
    private AtomicReference<ListNode> val = new AtomicReference<>(null);
    private AtomicReference<ListNode> next = new AtomicReference<>(null);

    public ListNode(int val) {
        this.val.set(new ListNode(val));
    }

    public ListNode getNext() {
        return next.get();
    }

    public void setNext(ListNode next) {
        this.next.set(next);
    }

    // 其他方法...
}

通過以上策略，可以在Java中優化ListNode類，以應對高并發場景。