- What This Cheat Sheet Covers (and What It Doesn't)
- Exam Mechanics at a Glance
- Voucher, Fee, and Retake Rules
- Scoring: 700 on a 1-1000 Scale
- Domain 1: Java Fundamentals
- Domain 2: Data Types, Variables, and Expressions
- Domain 3: Flow Control Implementation
- Domain 4: Object-Oriented Programming
- Domain 5: Code Compilation and Debugging
- Code-Tracing Traps to Memorize
- Scheduling the Domains Across Four Weeks
- Validity, Renewal, and Career Context
- Frequently Asked Questions
- The exam has 35-45 questions in 50 minutes and requires a scaled score of 700 on a 1-1000 scale.
- The US retail voucher with retake is USD 133; the retake code must be used within 60 days of failure.
- The current Pearson outline names ArrayList, Vector, Stack, LinkedList and HashSet, plus using generative AI to find code errors.
- Awards earned on or after June 18, 2025 expire after 5 years; renewal means passing the current exam.
What This Cheat Sheet Covers (and What It Doesn't)
This page condenses the must-know facts for the IT Specialist - Java exam, the credential issued through Certiport, a Pearson VUE business, under the Pearson IT Specialist program. Everything below applies to that exam only. It is not an Oracle Java certification, and it has nothing to do with JavaScript, a different language with a confusingly similar name.
If you are still orienting yourself, start with What Is ITS-J? and then return here. If you want the long-form learning path rather than a one-page review, the ITS-J Study Guide is the better companion. Use this cheat sheet in the final days before your appointment, or as a scaffold for deciding what to study first.
Exam Mechanics at a Glance
| Item | What to Know |
|---|---|
| Credential | IT Specialist - Java (Pearson; administered and issued by Certiport) |
| Question count | 35-45 questions per exam form (a published range, not a fixed total) |
| Exam time | 50 minutes standard, excluding administrative appointment activities |
| Format | Computer-based and proctored; the official tutorial illustrates multiple-choice questions with review and navigation before submission |
| Passing score | 700 on a 1-1000 scaled score |
| Prerequisites | No bachelor's degree requirement; the objectives are the preparation baseline |
| Delivery | Certiport Authorized Testing Centers (CATCs); Pearson VUE also offers test-center and OnVUE delivery |
| Identity and security | Identity verification, a proctor, and exam-security/NDA rules apply |
The intended candidate is a student or entry-level application developer with at least 150 hours of instruction or hands-on Java experience, including writing, debugging and documenting code. For a deeper look at eligibility, see ITS-J Requirements.
With roughly 50 minutes for 35-45 questions, expect to spend a bit over a minute per item on average. Code-tracing questions will take longer than definition questions, so bank time on the quick ones. The tutorial confirms you can review and change answers before submitting, so flag uncertain items and return to them.
Voucher, Fee, and Retake Rules
- US individual retail price: USD 133 for the IT Specialist Exam Voucher + Retake. This is not an exam-only price and not a universal-channel price.
- Proctoring: CATC proctoring may cost extra, so confirm with your testing center.
- Original voucher expiry: 1 year after purchase.
- Retake code: issued after a failed attempt and must be used within 60 days of failure.
- Channel matching: match your voucher to the delivery channel you plan to use (CATC, Pearson VUE test center, or OnVUE).
- Thrive online CATC: sold separately, ages 18+, requires an active voucher. Its conditions should not be generalized to school testing or to OnVUE.
For scheduling mechanics and timing, see ITS-J Exam Dates.
Scoring: 700 on a 1-1000 Scale
The passing mark is 700 on a 1-1000 scaled score. Two misreadings are common and both are wrong:
- 700 is not "70% correct." Scaled scores are derived from the exam form, so you cannot convert a raw percentage directly into a scaled mark.
- It is not a pass rate. The 700 figure tells you the cutoff, not how many candidates pass.
Because the exam length varies from 35 to 45 questions and the item split is not published, do not try to compute how many questions you can miss. Aim for comfortable mastery of every domain instead. More on this in ITS-J Passing Score, and for honest context on difficulty and pass-rate claims, read How Hard Is the ITS-J Exam? and ITS-J Pass Rate.
Domain 1: Java Fundamentals
Java Fundamentals
This domain covers the building blocks of a Java program: how source code is structured, how a program starts, and how the language and platform fit together.
- Know the shape of a class and the
public static void main(String[] args)entry point. - Understand packages, imports, and how classes are organized into files.
- Recognize the difference between the source file, compiled bytecode, and the runtime that executes it.
- Be able to read short programs and predict console output from
System.out.printlnversusprint. - Know comment styles and why documentation is part of the candidate profile.
Fundamentals questions tend to be the gentlest on the exam, which makes them the cheapest points to secure. Do not skip them just because they feel basic; a missed entry-point or import question costs as much as a missed inheritance question.
Domain 2: Data Types, Variables, and Expressions
Data Types, Variables, and Expressions
This is where the most detail lives. It includes primitives, strings, casting, operators, and the collection types named in the current Pearson outline.
- Primitives: know the integral, floating-point, boolean, and char types, default values for fields, and that locals must be initialized before use.
- Strings: immutability,
equalsversus==, and common methods such assubstring,indexOf,length, andcharAt. - Casting and conversion: implicit widening versus explicit narrowing, and integer division truncating.
- Operators: precedence, increment forms, compound assignment, and string concatenation with
+. - Collections: the outline explicitly includes ArrayList, Vector, Stack, LinkedList and HashSet.
The Collections Quick Reference
| Type | Remember This |
|---|---|
| ArrayList | Resizable, index-based, allows duplicates, preserves insertion order |
| Vector | Older list-style class with similar index-based behavior; know it as a legacy sibling of ArrayList |
| Stack | Last-in, first-out behavior: push, pop, peek |
| LinkedList | List with efficient add/remove at the ends; also usable in queue-style operations |
| HashSet | No duplicates; do not rely on iteration order |
The Collections and AI-debugging topics are newer additions that older public study material may not reflect, so check any resource's alignment against the current objectives PDF. Collections questions most often probe duplicate handling, ordering, and which method adds, removes, or inspects elements. For the full domain view, see ITS-J Exam Domains.
Domain 3: Flow Control Implementation
Flow Control Implementation
Expect questions that make you trace execution by hand. Precision with loop boundaries matters more than memorizing syntax.
- Decisions:
if/else if/else, the ternary operator, andswitchincluding fall-through whenbreakis missing. - Loops:
for, enhancedfor,while, anddo-while, with attention to when each condition is evaluated. - Jumps:
breakandcontinue, and their effect on nested loops. - Boolean logic: short-circuit
&&and||, negation, and compound conditions. - Exceptions as flow: try/catch/finally ordering and which block runs when.
The classic loop mistakes are off-by-one boundaries (< versus <=), forgetting that a do-while body runs at least once, and missing a break in a switch. Practice tracing each by writing out variable values line by line.
Domain 4: Object-Oriented Programming
Object-Oriented Programming
This domain tests whether you can model behavior with classes and predict how objects interact.
- Classes and objects: fields, methods, constructors, and the role of
this. - Encapsulation: access modifiers and getter/setter patterns.
- Inheritance:
extends,super, constructor chaining, and method overriding versus overloading. - Polymorphism: a superclass reference holding a subclass object, and which method version runs.
- Abstraction: abstract classes and interfaces, and what each can and cannot contain.
- Static versus instance: what belongs to the class and what belongs to each object.
Key Takeaway
When a question mixes a superclass reference with a subclass object, ask two separate questions: what does the compiler allow based on the reference type, and which overridden method runs based on the actual object type. Most OOP distractors exploit confusing those two.
Domain 5: Code Compilation and Debugging
Code Compilation and Debugging
This domain checks that you can find and fix errors, and the current outline includes using generative AI to find code errors.
- Compile-time versus runtime errors: syntax and type errors stop compilation; runtime exceptions occur during execution.
- Common compiler complaints: missing semicolons or braces, undeclared variables, incompatible types, missing return values, and uninitialized locals.
- Runtime exceptions: array index out of bounds, null references, arithmetic problems, and number-format failures.
- Debugging technique: read the message, locate the line, form a hypothesis, and verify with a small change.
- Generative AI for error-finding: understand it as a knowledge objective, including the idea that suggested fixes must be verified.
Code-Tracing Traps to Memorize
Short compilable snippets with a single trick are the dominant question style for this kind of exam. Rehearse these patterns until the answer is automatic.
- String comparison: two separately constructed strings with the same text can be equal by
equalsyet not by==. Strings never change in place, so callingtoUpperCase()without assigning the result leaves the original unchanged. - Integer division:
7 / 2is3, not3.5. Cast an operand to a floating type before dividing if you want a fraction. - Narrowing casts: casting a larger numeric type to a smaller one requires an explicit cast and can truncate or overflow.
- Concatenation order: in
1 + 2 + "x"the numbers add first, but in"x" + 1 + 2the result is"x12". - Loop boundaries: an array of length 5 has valid indexes 0 through 4; looping to
<= lengththrows an out-of-bounds exception. - Switch fall-through: without
break, execution continues into the next case. - Overriding versus overloading: overriding changes behavior at runtime based on the object; overloading is chosen at compile time by argument types.
- Exception ordering:
finallyruns whether or not an exception is thrown, and a more specific catch must come before a more general one.
For each trap, practice explaining why the wrong options are wrong, not just why the right one is right. That habit is what turns recognition into reliable scoring under time pressure.
Scheduling the Domains Across Four Weeks
Rather than a generic plan, sequence the domains by how much each builds on the last. Domain 2 and Domain 4 carry the most detail, so give them the most time.
Fundamentals and Data Types
- Write small programs covering program structure and primitives
- Drill strings, casting, and operator precedence
- Begin the collections reference table
Collections and Flow Control
- Use ArrayList, Vector, Stack, LinkedList and HashSet hands-on
- Hand-trace loops, switch fall-through, and nested breaks
Object-Oriented Programming
- Build a small inheritance hierarchy with overriding and constructors
- Practice reference-type versus object-type questions
Debugging and Timed Review
- Fix broken snippets and classify compile versus runtime errors
- Review the AI-debugging objective and run timed practice sets
Use the ITS-J Exam Prep practice tests in Weeks 3 and 4 to confirm that your hand-tracing holds up under the clock. Official CertPREP powered by GMetrix offers training and testing modes, but its practice-bank sizes and timers are not live-exam specifications, so do not treat them as predictions of your exam's length. Our ITS-J Training overview lists additional ways to build hands-on skill.
Validity, Renewal, and Career Context
- Validity: awards earned on or after June 18, 2025 expire after 5 years; earlier awards remain non-expiring.
- Renewal: buy a voucher and pass the current exam.
- Salary context: the BLS reported a May 2025 US median of USD 135,980 for software developers. This is occupation-wide data, not a certification-specific salary, an entry-level offer, or a demonstrated pay premium.
Treat the credential as evidence of foundational Java skills for students and entry-level application developers, not as a guarantee of any particular salary. Weigh it honestly with the ROI analysis, and explore realistic roles in ITS-J Jobs and earnings context in the ITS-J Salary Guide. When you are ready to test your recall against exam-style questions, head to the main practice test site.
Frequently Asked Questions
The published range is 35-45 questions in a standard 50-minute window, excluding administrative appointment activities. The exact total and the split between scored and unscored items are not published, so plan for the range rather than a fixed number.
No. The passing score is 700 on a 1-1000 scaled score. Scaled scores are not a raw percentage requirement, and the figure is not a candidate pass rate. Prepare for broad mastery instead of trying to calculate how many questions you can miss.
The US individual retail price is USD 133 for the exam voucher with retake. The original voucher expires 1 year after purchase, and the retake code issued after a failure must be used within 60 days. CATC proctoring may cost extra, and the voucher should match your chosen delivery channel.
No. This is the Pearson IT Specialist - Java exam issued through Certiport. The outline describes Java 6 SE or later as a language baseline, which is not an Oracle exam identity, and the exam does not cover JavaScript.
Yes. The retrieved Pearson outline explicitly names ArrayList, Vector, Stack, LinkedList and HashSet, and using generative AI to find code errors. These sit within the data types and debugging domains. Knowing them does not permit any outside AI help during the proctored exam.
Awards earned on or after June 18, 2025 expire after 5 years, while earlier awards remain non-expiring. To renew, you purchase a voucher and pass the current exam. Check the issuer's expiration policy for the latest wording before you plan your renewal.