๐ŸŽ„

CertoMetrics - 15% OFF Special Discount Offer - Ends In:

0d 00h 00m 00s
Coupon code: SALE2026

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

Launch Free Demo
Best Value Bundle

Premium Bundle

Complete Success Suite

$83 $49

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

Verified by 15k+ Students
Secure Checkout
Popular

Standard Simulation

Practice Engine

$44

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

Chrome
Verified Secure Checkout

Basic Tier

PDF Study Guide

$39

Digital Access

  • โœ“ Exam Questions (PDF)
  • โœ“ Mobile Friendly
  • โœ“ 60 Days Updates
Download Free Sample PDF

Verified 11-Question Preview (1Z0-829)

Secure Checkout

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

Java Fundamentals and Object-Oriented Programming Principles
Working with Advanced Java Class Design and Core APIs
Implementing Functional Programming with Lambdas and Streams
Handling Exceptions, Assertions, and Concurrency
Developing Secure and Modular Applications

Career Path

Target Roles

Java Developer Software Engineer Backend Developer

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).

QUESTION 1

Given:

and the code fragment:

What is the result?

A
100.00CellPhone,ToyCar,Motor,Fan
B
100.00CellPhone,ToyCar
C
300.00CellPhone,ToyCar
D
300.00CellPhone,ToyCar,Motor,Fan

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
QUESTION 2

Given:

What is the result?

A
4
B
2
C
6
D
Compilation fails.
E
A runtime exception is thrown.
F
Nothing is printed because of an indefinite loop.
G
5
H
3

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
QUESTION 3

Given the code fragment:

What is the result?

A
Range1 -Range2 -Range3 -Range1 -Not a valid rank.
B
Range1 -Not a valid rank.
C
Range1 -Range2 -Range3
D
Range1

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
QUESTION 4

Given:

and the code fragment:

Which statement is true?

A
The program throws ClassCastException.
B
The program fails to compile.
C
The program throws StockException.
D
The program throws OutofStockException.

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
QUESTION 5

Given the code fragment:

Which action sorts the book list?

A
At Line n2, replace books.sort() with books.stream().sort().
B
At Line n1, convert books type to mutable ArrayList type.
C
At Line n2, replace compareTo() with compare().
D
At Line n1, convert books type to mutable array type.

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.

QUESTION 6

Given the course table:

Given the code fragment:

What is the result?

A
2
B
true
C
false
D
1

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()
QUESTION 7

Given the code fragment:

Which code fragment prints the elements of sList?

A
Option A
B
Option B
C
Option C
D
Option D

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
QUESTION 8

Given:

What is the result?

A
Sales - 102 is printed.Purchase - 102 is printed.
B
Sales - 101 is printed.Purchase - 102 is printed.
D
Sales - 102 is printed.Purchase - 103 is printed.
E
Sales - 101 is printed.Purchase - 101 is printed.

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
QUESTION 9

Given the code fragments:

record Product(String name, double price) {}

and,

What is the result?

A
false:true:false
B
true:false:false
C
true:false:true
D
false:true:true
E
true:true:true

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
QUESTION 10

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?

A
21D8M
B
P8M21D
C
08-MAY-2022
D
1Y0M7D

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)
QUESTION 11

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?

A
/home/data/data/home
B
/home/data../data
C
/home/../data/home
D
/home/../data../data/home
E
/home/data/data

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.

Customer Reviews

5 / 5
(15,000+ verified)
5
100%
4
0%
3
0%
2
0%
1
0%

Global Community Feedback

DM

David M.

Verified Student

"The practice engine is incredible. It feels exactly like the real testing environment and helped me build so much confidence."

SJ

Sarah J.

Premium Member

"The PDF is very well organized and the explanations for the answers are actually helpful, not just random text."

MC

Michael C.

Verified Buyer

"I was skeptical, but the content is high quality and definitely worth the price. I passed on my first try!"

Need Assistance?

> Our expert support team is available to assist you with any inquiries about our exam materials.

Contact Support
Average response: < 24 Hours

Get Exam Updates

> Subscribe to receive instant notifications on new questions and exclusive flash sales.

* Join 5,000+ students getting weekly updates

Support Chat โ— Active Now

๐Ÿ‘‹ Hi! How can we help you pass your exam?

Enter email to start chatting