I think the part you're missing is: JavaScript, unlike the other languages, comes with built-in windowing, rendering, templating, and styling known as "the browser", "HTML", and "CSS". When you're first learning it, it can be daunting, because if you had picked Java or Python, you'd just be learning code, without all the excess.

However, you're going to reach a point with Java, where you need to build a user interface. You can do that using native graphics toolkits like GTK or Qt, or Java-oriented ones like JavaFX. You can also build websites in Java using Spring Boot.

But what you'll likely find out is, building a UI for a Java app is harder than building it in React (for example). And that building a fullstack application in Java, depending who you ask, is harder in Spring Boot (although it does offer some advantages) than building it in Next.js.

In addition to that, all of the "Hash maps, linked lists, merge sort, recursion etc" you mention, are also thing you'll do in JS (or TS).

So what I'm thinking is, you go introduced to fullstack meta web frameworks, which are intimidating, and seem like they're doing a bunch of stuff that "regular languages" like Java don't do. But that isn't the case. You'll be doing all the same data structures, and algorithms - for the most part - in JS Land, it's just that BECAUSE JS is easier, and also has built in windowing, rendering, templating, and styling... you're introduced to UI libraries and meta frameworks much earlier (like you were in TOP).

When you're tasked with building a full stack Java application using Spring Boot, chances are, you're going to be like "holy shit, this was so much easier in Next.js/React".

Additionally, Java is an OOP languages while JS is a procedural language. You can still write OOP code in JS/TS if you'd like, but I personally dislike OOP, I only work with it when I have to, and the differences can be drastic. Other's on here prefer OOP, and think it's better suited for certain tasks (which I often disagree with, but no use in beating a dead horse).

For example, here's a linked list in TypeScript:

class LinkedList<T> {
    head: Node<T> | null = null;

    add(value: T): void {
        const newNode = new Node(value);
        if (!this.head) {
            this.head = newNode;
        } else {
            let current = this.head;
            while (current.next) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    remove(value: T): void {
        if (!this.head) return;

        if (this.head.value === value) {
            this.head = this.head.next;
            return;
        }

        let current = this.head;
        while (current.next && current.next.value !== value) {
            current = current.next;
        }

        if (current.next) {
            current.next = current.next.next;
        }
    }

    print(): void {
        let current = this.head;
        const values: T[] = [];
        while (current) {
            values.push(current.value);
            current = current.next;
        }
        console.log(values.join(" -> "));
    }
}

And here's that same linked list in Java:

class Node<T> {
    T value;
    Node<T> next;

    public Node(T value) {
        this.value = value;
        this.next = null;
    }
}

class LinkedList<T> {
    private Node<T> head = null;

    public void add(T value) {
        Node<T> newNode = new Node<>(value);
        if (head == null) {
            head = newNode;
        } else {
            Node<T> current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    public void remove(T value) {
        if (head == null) return;

        if (head.value.equals(value)) {
            head = head.next;
            return;
        }

        Node<T> current = head;
        while (current.next != null && !current.next.value.equals(value)) {
            current = current.next;
        }

        if (current.next != null) {
            current.next = current.next.next;
        }
    }

    public void print() {
        Node<T> current = head;
        StringBuilder values = new StringBuilder();

        while (current != null) {
            values.append(current.value);
            if (current.next != null) {
                values.append(" -> ");
            }
            current = current.next;
        }

        System.out.println(values.toString());
    }
}

So it's not that you necessarily do different things in TS/JS than you are in JAVA, you're still going to do all the sorting, and algorithms, and DSA, for w/e it is you're trying to do. it's just that you were introduced to GUI libraries and metaframeworks in JS early, because it's a facet of the language itself (and as an "easier language", you're introduced to new things much quicker).