ITSC 2214

Data Structures & Algorithms with Lalith

Hi everyone! 👋 This page is a Java knowledge map created to help support students in ITSC 2214 Data Structures & Algorithms at the Univeristy of North Carolina at Charlotte.

I’m Lalith Uriti, a teaching assistant for section 004 with Dr. Dale-Marie Wilson. I put this together based on both my own experience with the course and the common questions and challenges I see students run into throughout the semester. If you ever need to reach me, feel free to email me at luriti@charlotte.edu

One thing that comes up a lot in DSA is that struggles usually aren’t about the data structures themselves — they come from gaps in Java fundamentals. Concepts like references vs. primitives, object behavior, recursion, control flow, and how Java actually executes code tend to show up everywhere in this class. Having a solid baseline understanding of Java is crucial for doing well in 2214.

This knowledge map is meant to help with that.

It visually organizes the major Java and data-structure-related concepts you’re expected to be comfortable with, shows how they break down into subtopics, and highlights how everything connects. The goal is fast recall and conceptual navigation, not step-by-step teaching or replacing lectures.

Each entry represents a concept you should recognize and understand at a high level. You can click on many entries to jump to related explanations below, letting you focus on one idea at a time while still keeping the bigger picture in mind. Think of it as a way to organize your understanding, not something you need to memorize line by line.

You can use this map to:

• review Java fundamentals before in class quizzes and the final exam,

• identify weak spots to focus your studying,

• or quickly refresh concepts that show up in homework, labs, or projects.

This is a living resource! It reflects both topics I’ve already studied deeply and concepts I regularly revisit to keep my understanding sharp. Hopefully, it helps makes 2214 feel a little more manageable and connected.

---

Understanding Java
    ├─ Program lifecycle
    │  ├─ Source code (.java)
    │  │  └─ Human-readable Java source
    │  ├─ Compilation (javac)
    │  │  └─ Converts .java → .class (bytecode)
    │  ├─ Bytecode (.class)
    │  │  └─ Platform-independent instructions
    │  └─ JVM execution
    │     └─ Bytecode executed on target machine
    │
    ├─ Basics
    │  ├─ Program entry
    │  │  ├─ main(String[] args)
    │  │  │  └─ Entry point for all Java programs
    │  │  └─ Execution order
    │  │     └─ Top-to-bottom, statement by statement
    │  │
    │  ├─ Data types and variables
    │  │  ├─ Variables
    │  │  │  └─ Named storage locations with a fixed type
    │  │  │
    │  │  ├─ Primitive data types
    │  │  │  ├─ byte (8-bit)
    │  │  │  ├─ short (16-bit)
    │  │  │  ├─ int (32-bit)
    │  │  │  ├─ long (64-bit)
    │  │  │  ├─ float (32-bit, decimal)
    │  │  │  ├─ double (64-bit, decimal)
    │  │  │  ├─ char (Unicode character)
    │  │  │  └─ boolean (true / false)
    │  │  │     └─ Not numeric (0 ≠ false)
    │  │  │
    │  │  ├─ Reference types
    │  │  │  ├─ Store memory address
    │  │  │  ├─ Examples: String, arrays, objects
    │  │  │  └─ Created using new
    │  │  │
    │  │  ├─ Stack vs Heap
    │  │  │  ├─ Primitives → stack (values)
    │  │  │  └─ References → stack (address) → heap (object)
    │  │  │
    │  │  ├─ Type casting
    │  │  │  ├─ Implicit (widening)
    │  │  │  │  └─ int → long
    │  │  │  ├─ Explicit (narrowing)
    │  │  │  │  └─ long → int
    │  │  │  └─ boolean cannot be cast
    │  │  │
    │  │  └─ Variable scope
    │  │     ├─ Local
    │  │     ├─ Parameter
    │  │     └─ Field
    │  │
    │  ├─ Operations on primitive types
    │  │  ├─ Arithmetic (+ − * / %)
    │  │  ├─ Increment / decrement
    │  │  │  ├─ Postfix (a++, a--) → use then modify
    │  │  │  └─ Prefix (++a, --a) → modify then use
    │  │  │
    │  │  ├─ Relational operators
    │  │  │  ├─ ==, !=
    │  │  │  ├─ >, >=
    │  │  │  └─ <, <=
    │  │  │
    │  │  ├─ Boolean logic
    │  │  │  ├─ NOT (!) → invert
    │  │  │  ├─ AND (&&) → both true
    │  │  │  ├─ OR (||) → one true
    │  │  │  ├─ XOR (^) → different
    │  │  │  ├─ Precedence: ! → ^ → && → ||
    │  │  │  └─ Short-circuiting
    │  │  │     ├─ false && … → false
    │  │  │     └─ true || … → true
    │  │  │
    │  │  └─ Assignment operators
    │  │     └─ =, +=, -=, *=, /=, %=
    │  │
    │  ├─ Control flow statements
    │  │  ├─ Conditionals
    │  │  │  ├─ if / else
    │  │  │  ├─ switch
    │  │  │  └─ Ternary: cond ? a : b
    │  │  │
    │  │  ├─ Loops
    │  │  │  ├─ for
    │  │  │  ├─ while
    │  │  │  └─ do-while
    │  │  │
    │  │  └─ Branching
    │  │     ├─ break
    │  │     └─ continue
    │  │
    │  └─ Strings
    │     ├─ String (immutable)
    │     │  ├─ length()
    │     │  ├─ charAt(i)
    │     │  ├─ substring(i), substring(i, j)
    │     │  ├─ equals / equalsIgnoreCase
    │     │  ├─ compareTo / compareToIgnoreCase
    │     │  ├─ contains
    │     │  ├─ startsWith / endsWith
    │     │  ├─ indexOf / lastIndexOf
    │     │  ├─ toLowerCase / toUpperCase / trim
    │     │  ├─ split(regex)
    │     │  └─ toCharArray()
    │     │
    │     ├─ Character helpers
    │     │  ├─ isLetter / isDigit / isLetterOrDigit
    │     │  ├─ isUpperCase / isLowerCase
    │     │  └─ toUpperCase / toLowerCase
    │     │
    │     └─ StringBuilder (mutable)
    │        ├─ append(String / char / int)
    │        ├─ setCharAt
    │        ├─ insert
    │        ├─ delete
    │        └─ toString()
    │
    ├─ Code organization
    │  ├─ Methods
    │  │  ├─ Declaration
    │  │  │  └─ modifiers + return + name + params + body
    │  │  ├─ Signature
    │  │  │  └─ name + parameter list
    │  │  ├─ Static vs instance
    │  │  ├─ main method
    │  │  │  └─ public static void main(String[] args)
    │  │  ├─ Method calls
    │  │  │  ├─ Class.method()
    │  │  │  └─ object.method()
    │  │  └─ Built-in vs user-defined
    │  │
    │  ├─ Classes and objects
    │  │  ├─ Class → blueprint
    │  │  ├─ Object → instance
    │  │  ├─ Fields → state
    │  │  ├─ Constructors → initialization
    │  │  └─ this → current object
    │  │
    │  └─ Inheritance (IS-A)
    │     ├─ extends keyword
    │     ├─ Single inheritance
    │     └─ Polymorphism (override)
    │
    ├─ Working with data
    │  ├─ Arrays
    │  │  ├─ Declaration: int[] arr
    │  │  ├─ Instantiation: new int[n]
    │  │  ├─ Default values
    │  │  │  ├─ int → 0
    │  │  │  ├─ boolean → false
    │  │  │  └─ reference → null
    │  │  ├─ Length: arr.length (field)
    │  │  ├─ Iteration
    │  │  │  ├─ for (i < arr.length)
    │  │  │  └─ for-each
    │  │  ├─ Processing patterns
    │  │  │  ├─ Search
    │  │  │  ├─ Accumulate
    │  │  │  └─ Predicate check
    │  │  └─ 2D arrays
    │  │     └─ Nested loops
    │  │
    │  ├─ Collections framework
    │  │  ├─ Iterable
    │  │  ├─ List
    │  │  │  ├─ ArrayList (dynamic array)
    │  │  │  └─ LinkedList (node-based)
    │  │  ├─ Set
    │  │  │  └─ HashSet
    │  │  └─ Map
    │  │     └─ HashMap
    │  │
    │  ├─ Searching & ordering
    │  │  ├─ Linear search
    │  │  ├─ Comparable
    │  │  │  └─ object defines compareTo
    │  │  └─ Comparator
    │  │     └─ external comparison logic
    │  │
    │  ├─ Hashing
    │  │  ├─ char → Unicode int
    │  │  ├─ Accumulate values
    │  │  └─ Modulo tableSize
    │  │
    │  ├─ Stacks & queues
    │  │  ├─ Stack (LIFO)
    │  │  │  ├─ push / pop / peek
    │  │  │  └─ Reverse, palindrome, postfix
    │  │  └─ Queue (FIFO)
    │  │     ├─ enqueue / dequeue
    │  │     └─ Conditional cycling
    │  │
    │  ├─ Linked structures
    │  │  ├─ Node<E> (data, next)
    │  │  ├─ Build from array
    │  │  ├─ Insert / remove
    │  │  └─ Linear search
    │  │
    │  ├─ Recursion
    │  │  ├─ Base case
    │  │  ├─ Recursive case
    │  │  ├─ Math sequences
    │  │  ├─ String recursion
    │  │  ├─ Array recursion
    │  │  └─ Tree recursion
    │  │
    │  ├─ Trees
    │  │  ├─ Binary tree
    │  │  ├─ Traversals
    │  │  │  ├─ Preorder (NLR)
    │  │  │  ├─ Inorder (LNR)
    │  │  │  └─ Postorder (LRN)
    │  │  └─ Properties
    │  │     ├─ Height
    │  │     ├─ Node count
    │  │     └─ Full / complete
    │  │
    │  └─ Graphs
    │     ├─ Representations
    │     │  ├─ Adjacency matrix
    │     │  └─ Adjacency list
    │     ├─ Properties
    │     │  ├─ Self loops
    │     │  ├─ Degree
    │     │  ├─ Edge count
    │     │  ├─ Complete graph
    │     │  └─ Triangle detection
    │     └─ Graph algorithms
    │        ├─ hasEdge
    │        ├─ removeEdge
    │        ├─ getNodeDegree
    │        └─ Matrix ↔ list conversion
    │
    └─ Errorless code
            ├─ Exceptions
            │  ├─ Checked
            │  ├─ Unchecked
            │  └─ try / catch / finally
            │
            ├─ Common runtime errors
            │  ├─ NullPointerException
            │  ├─ ArithmeticException
            │  └─ IndexOutOfBoundsException
            │
            └─ Testing
                ├─ Unit tests
                ├─ Assertions
                └─ JUnit

Program lifecycle

Source code

Source code is the human-written form of a Java program and is where all logic is defined using Java’s syntax and rules. These files are readable and editable by programmers but cannot be executed directly by the computer.

In real projects (especially coursework), you may be given empty or partially completed .java files to implement while other functionality already exists as compiled .class files. This separation is intentional: it allows you to write code against an existing interface or API without seeing the full implementation, which mirrors how real-world libraries are used.

When you type in VS Code, the editor is constantly analyzing your source code in the background. It checks for syntax errors, missing imports, type mismatches, and unresolved methods before you ever run the program, which is why errors and warnings appear as you type.

Compilation

Compilation is the process where the Java compiler, javac, checks .java files for syntax and type errors. If the code is valid, javac translates the source code into .class files containing bytecode.

This step is where Java becomes strict: every variable must have a type, every method call must exist, and access rules must be respected. If compilation fails, no .class file is produced, and the program cannot proceed.

When you click Run or Test in VS Code, the IDE automatically invokes javac for you behind the scenes. The success or failure of compilation directly determines whether the JVM will ever start, which is why many errors never make it to “runtime.”

Bytecode

Bytecode is the compiled output of a Java program stored in .class files. It is platform-independent and designed to run on any system that has a Java Virtual Machine.

Although .class files may show readable strings when opened in an editor, they are not human-readable source code and are not meant to be edited. What you’re seeing are embedded names, constants, and metadata that help the JVM and tools like debuggers and test frameworks understand the structure of the program.

At this stage, your program exists as structured instructions, not text logic. This is the form that libraries, testing frameworks, and the JVM itself work with.

JVM execution

JVM execution begins when a Java program is run and the Java Virtual Machine starts with a specific entry point, such as a main method or a JUnit test. The JVM does not load every class at once; instead, it loads .class files on demand as they are needed.

Each class is first verified to ensure the bytecode is safe and valid, then linked so references between classes can be resolved. Only after this does execution begin, with the JVM translating bytecode into machine code that your operating system can run.

During execution, tools like VS Code, JUnit, and the Java runtime collect information about what code is being used. When you see percentages, green checkmarks, or coverage bars, those come from testing and coverage tools that track which lines and branches of bytecode were executed during a run.

In other words, VS Code isn’t just “running” your program. It is coordinating compilation, launching the JVM, running tests, observing execution, and reporting results back to you in a human-friendly way.

Java separates writing, checking, running, and observing code into clear stages, and your IDE simply automates the handoff between them.

Basics

Code organization

Working with data

Errorless code

Program entry

Every Java program begins execution at public static void main(String[] args), which serves as the JVM entry point. Statements execute top-to-bottom unless redirected by control flow constructs.

Data types and variables

Java is statically typed, meaning every variable must declare a fixed type such as int, double, or String before use. Variables represent named storage locations whose behavior depends on whether they are primitive values or object references.

Operations on primitive types

Primitive types support arithmetic, relational, and logical operations including +, ==, &&, and || with defined precedence rules. Increment and decrement operators behave differently in prefix versus postfix form.

Control flow statements

Control flow constructs such as if, switch, for, and while determine execution paths and repetition. Keywords like break and continue alter loop behavior at runtime.

Strings

String objects are immutable, meaning operations like substring() create new objects rather than modifying existing ones. StringBuilder enables efficient mutable string manipulation.

---

Code organization

Methods

Methods encapsulate reusable behavior and are identified by a signature consisting of a name and parameter list. Calls resolve at compile time based on static types.

Classes and objects

A class defines structure and behavior, while an object is a runtime instance created using new. Fields store state, and constructors initialize that state.

Inheritance

Inheritance establishes an IS-A relationship using extends, allowing subclasses to reuse and override behavior. Java supports single inheritance with runtime polymorphism.

---

Working with data

Arrays

Arrays store fixed-size sequences of same-type elements and expose their size via arr.length. Elements are automatically initialized to default values.

Collections framework

The Collections Framework provides dynamic data structures such as ArrayList, HashSet, and HashMap. Interfaces define behavior while implementations determine performance.

Searching & ordering

Linear search inspects elements sequentially, while ordering relies on Comparable or Comparator. Comparison logic determines sort order and equality semantics.

Hashing

Hashing converts data into integer indices using hashCode() and modulo arithmetic. Efficient hashing minimizes collisions and enables constant-time access.

Stacks & queues

Stacks follow LIFO behavior using push and pop, while queues follow FIFO ordering using enqueue and dequeue. These structures model controlled access patterns.

Linked structures

Linked structures store elements in Node<E> objects connected by references rather than contiguous memory. This enables efficient insertion and removal.

Recursion

Recursion solves problems by invoking a method within itself until a base case is reached. Each recursive call consumes stack space.

Trees

Trees represent hierarchical data using parent-child relationships. Traversals such as inorder and preorder define visit order.

Graphs

Graphs model arbitrary relationships using adjacency matrices or adjacency lists. Algorithms operate on edges, degrees, and connectivity.

---

Errorless code

Exceptions

Exceptions represent abnormal execution conditions handled using try, catch, and finally. Checked exceptions require explicit handling at compile time.

Common runtime errors

Errors such as NullPointerException and IndexOutOfBoundsException occur during execution due to invalid state or access.

Testing

Testing verifies correctness using unit tests, assertions, and frameworks like JUnit. Automated tests detect regressions early.