Oracle Java SE 17 Developer (1Z0-829)
Get full access to the updated question bank and confidently prepare for your exam.
Vendor
Oracle
Certification
Java
Content
55 Qs
Status
Verified
Updated
2 days ago
Test the Practice Engine
Experience our interactive testing environment with free demo questions
Premium Bundle
Complete Success Suite
Save $34 Instantly
-
โFull PDF + Interactive Engine Everything you need to pass
-
โAll Advanced Question Types Drag & Drop, Hotspots, Case Studies
-
โPriority 24/7 Expert Support Direct line to certification leads
-
โ90 Days Free Priority Updates Stay current as exams change
Success Metric
98.4% Pass Rate
Standard Simulation
Practice Engine
One-Time Payment
-
Web-Based (Zero Install)
-
Real Testing Environment Virtual & Practice Modes
-
Interactive Engine Drag & Drop, Hotspots
-
60 Days Free Updates
Compatible with All Devices
Basic Tier
PDF Study Guide
Digital Access
- โ Exam Questions (PDF)
- โ Mobile Friendly
- โ 60 Days Updates
Verified 11-Question Preview (1Z0-829)
Verified Community
The CertoMetrics Standard.
Recommend the #1 platform for verified Oracle certification resources.
Success Network
Help a Colleague Succeed.
Invite a peer to get their own updated 1Z0-829 prep kit.
Exam Overview
The Oracle Java SE 17 Developer (1Z0-829) certification is a pivotal credential for any professional looking to validate their expertise in modern Java application development. Achieving this certification demonstrates a comprehensive understanding of Java SE 17's core features, including advanced object-oriented programming, functional programming constructs like Lambdas and Streams, concurrency utilities, and modularity. This certification is highly valued by employers, signaling a developer's capability to design, implement, and maintain robust, scalable, and efficient applications using the latest long-term support (LTS) Java release. It significantly enhances career opportunities, establishes credibility, and positions certified individuals as proficient Java professionals ready to tackle complex enterprise challenges in today's dynamic software landscape.
Questions
60
Passing Score
65%
Duration
90 Minutes
Difficulty
Intermediate
Level
Professional
Skills Measured
Career Path
Target Roles
Common Questions
Is the material up to date?
Yes. We update our question bank weekly to match the latest Oracle standards. You get free updates for 90 days.
What format do I get?
You get instant access to both the **PDF** (for reading) and our **Premium Test Engine** (for exam simulation).
Is there a guarantee?
Absolutely. If you fail the 1Z0-829 exam using our materials, we offer a full money-back guarantee.
When do I get the download?
Instantly. The download link is available in your dashboard immediately after payment is confirmed.
Free Study Guide Samples
Previewing updated 1Z0-829 bank (11 Questions).
Given:

and the code fragment:

What is the result?
Correct Option: D
โ
Option D (Correct) Reasoning: The first stream operation calculates the maximum price of all ElectricProduct instances (100, 90, 200, 300) using Collectors.summarizingDouble().getMax(), which is 300.00. The second stream operation maps all Product names to a string and joins them with commas using Collectors.mapping().joining(","), resulting in "CellPhone,ToyCar,Motor,Fan". The combined output is 300.00CellPhone,ToyCar,Motor,Fan.
โ Why the other choices are incorrect:
Option A is incorrect: The maximum price is 300.00, not 100.00.
Option B is incorrect: The maximum price is 300.00, and the name list is incomplete, missing "Motor" and "Fan".
Option C is incorrect: While the maximum price is correct (300.00), the joined names are incomplete, missing "Motor" and "Fan".
Reference: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/stream/Collectors.html
Given:

What is the result?
Correct Option: A
โ Option A (Correct) Reasoning: The variable 'x' is 2. 'y' is initialized to 2. The 'while' loop executes when 'y' is 2. Inside the 'switch', 'case 0+x' (which is 'case 2') matches. 'y' becomes 3. Due to fall-through (no break), 'case 1' executes, incrementing 'y' to 4. The 'while' loop condition (y < 3) is now false (4 < 3). The loop terminates, and 4 is printed.โ Why the other choices are incorrect:
Option B is incorrect: 'y' increments twice due to switch fall-through, not just once.
Option C is incorrect: The logic does not result in 6.
Option D is incorrect: The code is syntactically correct and compiles.
Option E is incorrect: No runtime errors occur.
Option F is incorrect: The loop condition eventually becomes false, so it terminates.
Option G is incorrect: The final value of 'y' is 4.
Option H is incorrect: The final value of 'y' is 4.
Reference: https://docs.oracle.com/javase/specs/jls/se17/html/jls-14.html#jls-14.11
Given the code fragment:

What is the result?
Correct Option: D
โ
Option D (Correct) Reasoning:The rank variable is initialized to 4. The switch statement evaluates rank. The case 1,4 -> the value 4. Consequently, System.out.println("Range1") is executed. The arrow (->) syntax for switch labels in Java 17 implies no fall-through, meaning the switch statement exits after the matched case's code block completes. Therefore, only "Range1" is printed.โ Why the other choices are incorrect:
Option A is incorrect: This option suggests multiple ranges and an invalid rank are printed, implying fall-through or multiple matches, which does not occur with the Java 17 arrow-syntax switch. Only one case matches and executes.
Option B is incorrect: This implies that after printing "Range1", the default case is also executed. The arrow-syntax switch does not fall through to other cases or the default case once a match is found and executed.
Option C is incorrect: This option suggests that all range prints execute. In a Java 17 switch expression/statement using arrow syntax, only the matching case's code block executes; there is no fall-through to subsequent cases.
Reference: https://docs.oracle.com/en/java/javase/17/language/switch-expressions.html
Given:

and the code fragment:

Which statement is true?
Correct Option: D
โ
Option D (Correct) Reasoning: The m() method first throws a StockException. This exception is caught by the catch (Exception e) block. Inside this block, a new OutofStockException() is thrown. Since both m() and main() declare throws OutofStockException, this exception propagates out of the main method, terminating the program with an OutofStockException.โ Why the other choices are incorrect:
Option A is incorrect: No invalid casting operations occur in the code that would lead to a ClassCastException.
Option B is incorrect: The code compiles successfully because all checked exceptions (StockException and OutofStockException) are either caught or declared in the method signatures.
Option C is incorrect: Although StockException is initially thrown, it is caught within the m() method's try-catch block. The exception that ultimately escapes m() and main() is OutofStockException.
Reference: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Exception.html
Given the code fragment:

Which action sorts the book list?
Correct Option: B
โ
Option B (Correct) Reasoning: The List.of() method at Line n1 creates an immutable list. The books.sort() method at Line n2 attempts to modify the list in place, which is not allowed for immutable lists, resulting in an UnsupportedOperationException. Changing the books type to a mutable ArrayList (e.g., using new ArrayList<>(List.of(...))) at Line n1 would resolve this, making the list modifiable and allowing books.sort() to succeed.โ Why the other choices are incorrect:
Option A is incorrect: books.stream().sort() is syntactically incorrect. java.util.stream.Stream has a sorted() method, which returns a new sorted stream, not modifies the original list. This would not fix the UnsupportedOperationException on the original books list.
Option C is incorrect: The lambda (Book a, Book b) -> a.title.compareTo(b.title) correctly implements the Comparator interface using the String.compareTo() method. Changing compareTo() to compare() within this context would be syntactically invalid and does not address the list's immutability issue.
Option D is incorrect: Converting to a mutable array type (e.g., Book[]) would require using Arrays.sort() instead of books.sort(), fundamentally changing the collection type and the sorting API used, which is not the simplest or most direct fix for the current List.sort() problem.
Given the course table:

Given the code fragment:

What is the result?
Correct Option: A
โ
Option A (Correct) Reasoning: The prStmt.executeUpdate() method returns an integer indicating the number of rows affected by the SQL DML statement. The SQL query UPDATE course SET course_fee = 1600.00 WHERE COURSE_LEVEL = 2 targets rows where COURSE_LEVEL is 2. From the table, both COURSE_ID 1022 and 1023 have COURSE_LEVEL = 2. Thus, two rows will be updated, and the method will return 2.โ Why the other choices are incorrect:
Option B is incorrect: The executeUpdate() method returns an integer representing the count of affected rows, not a boolean value like true.
Option C is incorrect: Similar to option B, executeUpdate() returns an integer, not a boolean false.
Option D is incorrect: The WHERE COURSE_LEVEL = 2 clause matches two rows in the provided course table (for COURSE_ID 1022 and 1023), not just one.
Reference: https://docs.oracle.com/en/java/javase/17/docs/api/java.sql/java/sql/PreparedStatement.html#executeUpdate()
Given the code fragment:

Which code fragment prints the elements of sList?
Correct Option: C
โ
Option C (Correct) Reasoning: The CopyOnWriteArrayList's iterators provide a snapshot of the list at the time of their creation, guaranteeing consistency without ConcurrentModificationException. Option C explicitly creates a new ArrayList (temp) from sList. This construction uses sList's snapshot iterator internally, effectively creating an explicit, consistent copy of sList's elements at that moment, which is then printed. This is a robust way to obtain a consistent view.
โ Why the other choices are incorrect:
Option A is incorrect: While using an enhanced for loop directly on a CopyOnWriteArrayList is valid and utilizes its snapshot iterator, Option C provides a more explicit and isolated snapshot by creating a new ArrayList, which can be advantageous in certain contexts for clarity and further processing.
Option B is incorrect: Similar to Option A, this code fragment creates a new reference to sList and then iterates over it using an enhanced for loop, implicitly leveraging the snapshot iterator. It is functionally identical to Option A.
Option D is incorrect: Using an indexed for loop (sList.get(i) and sList.size()) for iterating a CopyOnWriteArrayList does not guarantee a consistent snapshot across the entire iteration. Although thread-safe, if concurrent modifications are occurring, the size() could change, or get(i) might operate on different internal array versions, leading to an inconsistent view or potentially missing elements.
Reference: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CopyOnWriteArrayList.html
Given:

What is the result?
Correct Option: B
โ
Option B (Correct) Reasoning:The dId field is static, meaning it is shared by all instances of the Doc class. Its initial value is 100.1. When new Doc("Sales") is called, ++dId increments dId to 101. The printDoc() method then outputs "Sales - 101 is printed.".2. When new Doc("Purchase") is called, the shared dId (now 101) is incremented by ++dId to 102. The printDoc() method then outputs "Purchase - 102 is printed.".Thus, the final output matches option B.โ Why the other choices are incorrect:
Option A is incorrect: The first dId value printed should be 101, as it is incremented from 100 during the first object's creation. It is not 102.
Option D is incorrect: The first dId value should be 101. The second dId increments from 101 to 102, not 103, as ++dId applies only once per constructor call.
Option E is incorrect: Since dId is a static field, it retains its incremented value. It increments to 101 for the first object and then further increments to 102 for the second object, not remaining 101.
Reference: https://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html
Given the code fragments:
record Product(String name, double price) {}
and,

What is the result?
Correct Option: D
โ
Option D (Correct) Reasoning: The expression p1 == p2 is false because p1 and p2 are distinct objects. The expression p1 == p3 is true because p3 is assigned p1, making them reference the same object. The expression p3.equals(p2) is true because record classes automatically generate an equals method that compares all component fields for value equality. Both p3 (which is p1) and p2 have name="Pen" and price=9.0. Thus, the output is false:true:true.
โ Why the other choices are incorrect:
Option A is incorrect: The last comparison p3.equals(p2) should be true, not false, as records compare component values.
Option B is incorrect: The first comparison p1 == p2 should be false, as they are distinct object references.
Option C is incorrect: The first comparison p1 == p2 should be false, as they are distinct object references.
Option E is incorrect: The first comparison p1 == p2 should be false, as they are distinct object references.
Reference: https://docs.oracle.com/javase/specs/jls/se17/html/jls-8.html#jls-8.10.3
Given the code fragment:
LocalDate now = LocalDate.now();
LocalDate this_labourDay = LocalDate.of(2021, Month.MAY, 1); LocalDate next_labourDay = this_labourDay.plusYears(1);
LocalDate add_week = next_labourDay.plusDays(7);
Period p = now.until(add_week);
System.out.println(p);
Assume LocalDate.now() returns 17th Aug 2021.
What is the result?
Correct Option: B
โ
Option B (Correct) Reasoning: The code calculates the period between LocalDate.now() (2021-08-17) and add_week (2022-05-08) using Period.until(). This method determines the duration in years, months, and days. From August 17, 2021, to May 8, 2022, the elapsed time is 8 months and 21 days. The Period object's toString() method formats this as P8M21D.
โ Why the other choices are incorrect:
Option A is incorrect: The standard ISO 8601 representation for a period of 8 months and 21 days is P8M21D, not 21D8M.
Option C is incorrect: 08-MAY-2022 is the value of the add_week LocalDate itself, not the Period between the two dates.
Option D is incorrect: 1Y0M7D does not correctly represent the duration between 2021-08-17 and 2022-05-08. The correct calculation yields 8 months and 21 days.
Reference: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/Period.html#until(java.time.LocalDate)
Given:
Path p1 = Path.of("/home");
Path p2 = Path.of("../data");
System.out.println(p1.resolve(p2));
System.out.println(p2.resolve(p1));
What is the result?
Premium Solution Locked
Unlock all 55 answers & explanations
Full Question Bank Locked
You have reached the end of the free study guide preview. Upgrade now to unlock all 55 questions and the full simulation engine.
Certification Path
Related Certifications
Customer Reviews
Global Community Feedback
David M.
"The practice engine is incredible. It feels exactly like the real testing environment and helped me build so much confidence."
Sarah J.
"The PDF is very well organized and the explanations for the answers are actually helpful, not just random text."
Michael C.
"I was skeptical, but the content is high quality and definitely worth the price. I passed on my first try!"