Edhesive 3.2 Code Practice Question 1: Exact Answer & Steps

Ever stared at a line of Java code and wondered why the test keeps failing, even though the logic looks solid?
That was me last week, wrestling with the first practice question from the edhesive 3.2 certification bundle. The thing that trips most people up isn’t the syntax—it’s the subtle contract between the interface and the implementation that the exam loves to hide Which is the point..

If you’ve ever felt that knot in your stomach when the IDE throws a “cannot find symbol” on a perfectly legal method, keep reading. I’m breaking down Question 1, why it matters, where most candidates slip, and exactly what you can do to nail it every time No workaround needed..

Not the most exciting part, but easily the most useful.

What Is the edhesive 3.2 Code Practice Question 1?

The edhesive series is a set of hands‑on labs that accompany the Java SE 8 Programmer I (1Z0‑808) exam prep. Version 3.2 is the latest refresh, and Question 1 is the entry‑level “write‑the‑method” challenge And that's really what it comes down to..

Implement a static method called calculateTotal that takes a List<Integer> of item prices and returns the sum after applying a 10 % discount to any price over $100.

That’s the gist, but the real test lies in the surrounding scaffolding:

• The method must be placed inside a class named PriceUtils.
• It must not modify the original list—immutability is part of the requirement.
• The return type is double, not int, because discounts can produce fractional cents.
• The signature must match exactly: public static double calculateTotal(List<Integer> prices).

Sounds simple, right? Turns out the devil is in the details that the exam writers sprinkle in The details matter here..

Why It Matters / Why People Care

You might wonder why a single practice question deserves a deep dive. Here’s the short version:

• Foundation for the real exam. The 3.2 bundle is designed to mimic the style of the actual certification. If you can’t solve Question 1 cleanly, you’re likely to stumble on the more complex “stream” and “lambda” items later.
• Real‑world relevance. The pattern of “process a collection without side‑effects” shows up in every enterprise codebase. Mastering it now saves you from rewriting buggy loops later.
• Score‑boosting. On the multiple‑choice section, the exam often throws a “which line would cause a compilation error?” question that directly references the method you just wrote. Knowing the contract inside‑out gives you a safety net.

In practice, the question tests three core competencies: **API familiarity (java.That's why util. On the flip side, list), proper use of primitives vs. But wrapper types, and functional thinking (no mutation). ** Miss any one and you’ll lose points Simple as that..

How It Works (or How to Do It)

Below is a step‑by‑step walk‑through of a clean, exam‑ready solution. I’ll include the code, then explain the reasoning behind each line.

1. Set Up the Class Skeleton

public class PriceUtils {

    public static double calculateTotal(List prices) {
        // implementation goes here
    }
}

Why this matters: The class name and method signature must be exactly as the prompt specifies. The exam’s automated grader does a string match before it even compiles Small thing, real impact..

2. Guard Against Null Input

if (prices == null) {
    throw new IllegalArgumentException("Price list cannot be null");
}

Most candidates skip this, assuming the test harness will never pass null. The official edhesive solution includes the check, and the exam sometimes throws a hidden test case to see if you’ve protected your method.

3. Iterate Without Mutating

We have two common routes: a classic for‑each loop or a Java 8 Stream. Both satisfy the “no mutation” rule, but the Stream version is a bit more concise and shows off modern Java knowledge Simple as that..

Classic Loop Approach

double total = 0.0;
for (Integer price : prices) {
    int p = price;                     // unbox
    if (p > 100) {
        total += p * 0.9;              // 10% discount
    } else {
        total += p;
    }
}
return total;

Stream Approach (Preferred)

return prices.stream()
             .mapToDouble(p -> p > 100 ? p * 0.9 : p)
             .sum();

Key points to note:

• mapToDouble converts the Integer stream into a primitive double stream, avoiding unnecessary boxing.
• The ternary operator implements the discount rule in a single line—clean and exam‑friendly.
• sum() returns a double, satisfying the required return type.

4. Keep the Original List Intact

Both implementations read from prices but never call add, remove, or set. If you were to write prices.That’s the immutability clause in action. set(i, discounted) you’d instantly fail the “does not modify the original list” test.

5. Full Working Example

Putting it all together:

import java.util.List;

public class PriceUtils {

    public static double calculateTotal(List prices) {
        if (prices == null) {
            throw new IllegalArgumentException("Price list cannot be null");
        }

        return prices.Also, stream()
                     . In real terms, p * 0. mapToDouble(p -> p > 100 ? 9 : p)
                     .

That’s the whole thing. Short, readable, and fully compliant with the edhesive spec.

---  

## Common Mistakes / What Most People Get Wrong

1. **Using `int` as the return type.**  
   The discount can produce a fractional value (e.g., 105 → 94.5). Returning `int` truncates the cents and the grader flags it as wrong.

2. **Mutating the input list.**  
   Some folks create a copy, apply the discount, then sum the copy. That works but adds unnecessary memory overhead, and the exam explicitly checks that the original list stays untouched.

3. **Hard‑coding the discount value.**  
   Writing `price * 0.9` is fine, but many candidates sprinkle `Math.round` or `DecimalFormat` to force two decimals. The spec doesn’t require rounding, so you just introduce rounding errors.

4. **Forgetting the null check.**  
   The hidden test case that passes `null` will make your method throw a `NullPointerException`. The official solution throws an `IllegalArgumentException`, which the grader expects.

5. **Using `List` instead of `List`.**  
   The prompt is crystal clear about the input type. Switching to `Double` compiles, but the method signature no longer matches, and you lose points instantly.

---  

## Practical Tips / What Actually Works

* **Memorize the exact signature.** Write it out on a sticky note until it becomes second nature.  
* **Prefer Streams for brevity.** The exam loves showing that you can use functional APIs; a one‑liner `mapToDouble(...).sum()` looks clean on the answer sheet.  
* **Guard against null early.** A single `if (prices == null)` line saves you from a cascade of hidden failures.  
* **Test locally with edge cases.**  
  * Empty list → should return `0.0`.  
  * All prices ≤ 100 → sum unchanged.  
  * All prices > 100 → each gets the 10 % discount.  
* **Don’t over‑engineer.** The question is intentionally simple; adding extra helper methods just adds noise.  

A quick local test harness:

```java
public static void main(String[] args) {
    List demo = Arrays.asList(50, 120, 200);
    System.out.println(calculateTotal(demo)); // Expected: 50 + 108 + 180 = 338.0
}

Run it, verify the output, and you’re good to go.

FAQ

Q1: Can I use BigDecimal for the calculation?
A1: Technically you could, but it’s overkill for this question. The exam expects a double result, and BigDecimal would require extra imports and conversion code that isn’t needed.

Q2: What if the list contains null elements?
A2: The official edhesive solution assumes a well‑formed list (no null entries). If you want to be ultra‑defensive, you could filter them out, but that isn’t required and may cost you points for extra complexity.

Q3: Is rounding to two decimal places required?
A3: No. The method returns a raw double. The test harness compares the numeric value, not its string representation And that's really what it comes down to..

Q4: How does this relate to the later “stream” questions?
A4: This question is a stepping stone. Master the pattern of stream().mapToDouble(...).sum() and you’ll breeze through the more advanced tasks that involve filter, reduce, or custom collectors.

Q5: What if I accidentally import java.awt.List?
A5: The code won’t compile because java.awt.List isn’t a generic collection. Always import java.util.List. It’s a common typo that trips beginners And it works..

That’s it. And the first edhesive 3. 2 practice question may look like a tiny puzzle, but it packs a lot of exam‑level concepts into a single method. Get the signature right, protect against null, keep the original list untouched, and use a Stream to apply the discount in one clean line.

Now go run that snippet, watch the numbers line up, and move on to Question 2 with confidence. Happy coding!