%{search_type} search results

• Preface xv
• Chapter 1. Strings, Languages, and Compilers 1 1.1 Introduction 1 1.2 Basic Language Concepts 1 1.3 Basic Compiler Concepts 3 1.4 Basic Set Theory 4 1.5 Null String 6 1.6 Concatenation 7 1.7 Exponent Notation 7 1.8 Star Operator 8 1.9 Concatenation of Sets of Strings 9 1.10 Plus Operator 11 1.11 Question Mark Operator 11 1.12 Shorthand Notation for a Set Containing a Single String 12 1.13 Operator Precedence 12 1.14 Regular Expressions 13 1.15 Limitations of Regular Expressions 15 Problems 16
• Chapter 2. Context-Free Grammars,
• Part 1 19 2.1 Introduction 19 2.2 What is a Context-Free Grammar? 20 2.3 Derivations Using a Context-Free Grammar 21 2.4 Language Defined by a Context-Free Grammar 23 2.5 Different Ways of Representing Context-Free Grammars 25 2.6 Some Simple Grammars 26 2.7 Techniques for Generating Languages with Context-Free Grammars 29 2.8 Regular and Right Linear Grammars 35 2.9 Counting with Regular Grammars 37 2.0 Grammars for Lists 39 2.10 An Important Language that is Not Context Free 44 Problems 45
• Chapter 3. Context-Free Grammars,
• Part 2 49 3.1 Introduction 49 3.2 Parse Trees 49 3.3 Leftmost and Rightmost Derivations 51 3.4 Substitution 52 3.5 Ambiguous Grammars 54 3.6 Determining Nullable Nonterminals 59 3.7 Eliminating Lambda Productions 60 3.8 Eliminating Unit Productions 64 3.9 Eliminating Useless Nonterminals 66 3.10 Recursion Conversions 71 3.11 Adding the Null String to a Language 76 Problems 77
• Chapter 4. Context-Free Grammars,
• Part 3 83 4.1 Introduction 83 4.2 Grammars for Arithmetic Expressions 83 4.3 Specifying Associativity and Precedence in Grammars 90 4.4 Backus-Naur Form 92 4.5 Syntax Diagrams 94 4.6 Abstract Syntax Trees and Three-Address Code 96 4.7 Noncontracting Grammars 97 4.8 Essentially Noncontracting Grammars 97 4.9 Converting a Context-Free Grammar to an Essentially Noncontracting Grammar 98 4.10 Pumping Property of Context-Free Languages 101 Problems 104
• Chapter 5. Chomsky's Hierarchy 107 5.1 Introduction 107 5.2 Context-Sensitive Productions 107 5.3 Context-Sensitive Grammars 110 5.4 Unrestricted Grammars 111 Problems 112
• Chapter 6. Top-Down Parsing 115 6.1 Introduction 115 6.2 Top-Down Construction of a Parse Tree 115 6.3 Parses that Fail 117 6.4 A Bad Grammar for Top-Down Parsing 118 6.5 Deterministic Parses 119 6.6 A Parser that Uses a Stack 120 6.7 Table Representation of a Stack Parser 124 6.8 Handling Productions with Nonleading Terminal 126 6.9 Writing a Stack Parser in Java 127 Problems 134
• Chapter 7. LL(1) Grammars 137 7.1 Introduction 137 7.2 FIRST Set of the Right Side of a Production 137 7.3 Determining Operation Sequences 140 7.4 Determining Selection Sets of Lambda Productions 142 7.5 Whatever-Follows-Left-Follows-Rightmost Rule 145 7.6 Selection Sets for Productions with Nullable Right Sides 147 7.7 Selection Sets Containing End-of-Input Symbol 149 7.8 A Stack Parser for a Grammar with Lambda Productions 152 7.9 Converting a Non-LL(1) Grammar to an LL(1) Grammar 153 7.10 Parsing with an Ambiguous Grammar 160 7.11 Computing FIRST and FOLLOW Sets 163 Problem 165
• Chapter 8. Table-Driven Stack Parser 171 8.1 Introduction 171 8.2 Unifying the Operations of a Stack Parser 172 8.3 Implementing a Table-Driven Stack Parser 175 8.4 Improving Our Table-Driven Stack Parser 180 8.5 Parsers that are Not Deterministic-A Digression on Theory 181 Problems 183
• Chapter 9. Recursive-Descent Parsing 185 9.1 Introduction 185 9.2 Simple Recursive-Descent Parser 185 9.3 Handling Lambda Productions 192 9.4 A Common Error 197 9.5 Java Code for Productions 198 9.6 Left Factoring in a Recursive-Descent Parser 199 9.7 Eliminating Tail Recursion 204 9.8 Translating the Star, Plus, and Question Mark Operators 108 9.9 Doing Things Backward 210 Problems 211
• Chapter 10. Recursive-Descent Translation 215 10.1 Introduction 215 10.2 A Simple Translation Grammar 215 10.3 Converting a Translation Grammar to Java Code 217 10.4 Specifications for a Translation Grammar 218 10.5 Passing Information During a Parse 231 10.6 L-Attributed Grammars 236 10.7 New Token Manager 238 10.8 Solving the Token Lookahead Problem 241 10.9 Code for the New Token Manager 241 10.10 Translation Grammar for Prefix-Expression Compiler 253 10.11 An Interesting Use of Recursion 257 Problems 261
• Chapter 11. Assembly Language 265 11.1 Introduction 265 11.2 Structure of the J1 Computer 265 11.3 Machine Language Instructions 266 11.4 Assembly Language Instructions 268 11.5 Pushing Characters 269 11.6 aout Instruction 270 11.7 Using Labels 270 11.8 Using the Assembler 272 11.9 stav Instruction 275 11.10 Compiling and Assignment Statement 277 11.11 Compiling print and println 280 11.12 Outputting Strings 281 11.13 Inputting Decimal Numbers 283 11.14 Entry Directive 284 11.15 More Assembly Language 285 Problems 285
• Chapter 12. S1-A Simple Compiler 289 12.1 Introduction 289 12.2 The Source Language 289 12.3 Grammar for Source Language 289 12.4 The Target Language 291 12.5 Symbol Table 292 12.6 Code Generator 293 12.7 Token Class 293 12.8 Writing the Translation Grammar 294 12.9 Implementing the S1 Compiler 299 12.10 Trying Out S1 315 12.11 Advice on Extending the S1 Compiler 318 12.12 Specifications for S2 320 Problems 324
• Chapter 13. JavaCC 331 13.1 Introduction 331 13.2 JavaCC Extended Regular Expressions 333 13.3 JavaCC Input File 337 13.4 Specifying Actions for Regular Expressions 344 13.5 JavaCC Input File for S1j 348 13.6 Files Produced by JavaCC 355 13.7 Using the Star and Plus Operators 359 13.8 Choice Points and the Lookahead Directive 362 13.9 JavaCC's Choice Algorithm 367 13.10 Syntactic and Semantic Lookahead 371 13.11 Using JavaCC to Create a Token Manager Only 372 13.12 Using the Token Chain 373 13.13 Suppressing Warning Messages 377 Problems 387
• Chapter 14. Building on S2 383 14.1 Introduction 383 14.2 Extending println and print 383 14.3 Cascaded Assignment Statement 388 14.4 Unary Plus and Minus 313 14.5 readint Statement 393 14.6 Controlling the Token Trace from the Command Line 395 14.7 Specifications for S3 396 Problems 396
• Chapter 15. Compiling Control Structures 399 15.1 Introduction 399 15.2 while Statement 399 15.3 if Statement 403 15.4 do-while Statement 407 15.5 Range Checking of Numerical Constants 408 15.6 Handling Backslash-Quote in a String 410 15.7 Handling Backslash-Quote with JavaCC 411 15.8 Universal Blocks in JavaCC 416 15.9 Handling Strings that Span Lines 418 15.10 Handling Strings that Span Lines Using JavaCC 419 15.11 Special-Token Block in JavaCC 422 15.12 Error Recovery 424 15.13 Error Recovery in JavaCC 429 15.14 Specifications for S4 430 Problems 431
• Chapter 16. Compiling Programs in Functional Form 435 16.1 Introduction 435 16.2 Separate Assembly and Linking 435 16.3 Calling and Returning from Functions 439 16.4 Source Language for S5 443 16.5 Symbol Table for S5 445 16.6 Code Generator for S5 446 16.7 Translation Grammar for S5 447 16.8 Linking with a Library 457 16.9 Specifications for S5 458 16.10 Extending S5 458 Problems 461
• Chapter 17. Finite Automata 465 17.1 Introduction 465 17.2 Deterministic Finite Automata 466 17.3 Converting a DFA to a Regular Expression 468 17.4 Java Code for a DFA 468 17.5 Nondeterministic Finite Automata 474 17.6 Using an NFA as an Algorithm 476 17.7 Converting an NFA to a DFA with the Subset Algorithm 478 17.8 Converting a DFA to a Regular Grammar 479 17.9 Converting a Regular Grammar to an NFA 482 17.10 Converting a Regular Expressions to an NFA 484 17.11 Finding the Minimal DFA 488 17.12 Pumping Property of Regular Languages 493 Problems 495
• Chapter 18. Capstone Project: Implementing Grep Using Compiler Technology 499 18.1 Introduction 499 18.2 Regular Expressions for Our GREP Program 501 18.3 Token Manager for Regular Expression 501 18.4 Grammar for Regular Expressions 503 18.5 Target Language for Our Regular Expression Compiler 503 18.6 Using an NFA for Pattern Matching 508 Problems 513
• Chapter 19. Compiling to a Register-Oriented Architecture 515 19.1 Introduction 515 19.2 Using the Register Instruction Set 516 19.3 Modifications to the Symbol Table for R1 517 19.4 Parser and Code Generator for R1 518 Problems 526
• Chapter 20. Optimization 529 20.1 Introduction 529 20.2 Using the 1dc Instruction 531 20.3 Reusing Temporary Variables 432 20.4 Constant Folding 535 20.5 Register Allocation 537 20.6 Peephole Optimization 540 Problems 543
• Chapter 21. Interpreters 547 21.1 Introduction 547 20.2 Converting S1 to 11 549 20.3 Interpreting Statements that Transfer Control 552 20.4 Implementing the Compiler-Interpreter C11 553 20.5 Advantages of Interpreters 558 Problems 559
• Chapter 22. Bottom-Up Parsing 561 22.1 Introduction 561 22.2 Principles of Bottom-Up Parsing 561 22.3 Parsing with Right- versus Left-Recursive Grammars 565 22.4 Bottom-up Parsing with an Ambiguous Grammar 566 22.5 Do-Not Reduce Rule 569 22.6 SLR(1) Parsing 570 22.7 Shift/Reduce Conflicts 577 22.8 Reduce/Reduce Conflicts 579 22.9 LR(1) Parsing 579 Problems 584
• Chapter 23. yacc 587 23.1 Introduction 587 23.2 yacc Input and Output Files 587 23.3 A Simple yacc-Generated Parser 588 23.4 Passing Values Using the Value Stack 596 23.5 Using yacc With an Ambiguous Grammar 602 23.6 Passing Values down the Parse Tree 604 23.7 Implementing Sly 606 23.8 jflex 612 Problems 618 Appendix A. Stack Instruction Set 621 Appendix B. Register Instruction Set 625 References 629 Index 631.
• (source: Nielsen Book Data)

Broad in scope, involving theory, the application of that theory, and programming technology, compiler construction is a moving target, with constant advances in compiler technology taking place. Today, a renewed focus on do-it-yourself programming makes a quality textbook on compilers, that both students and instructors will enjoy using, of even more vital importance. This book covers every topic essential to learning compilers from the ground up and is accompanied by a powerful and flexible software package for evaluating projects, as well as several tutorials, well-defined projects, and test cases.
(source: Nielsen Book Data)

• Ch. 1. Getting up and running with QuickTime for Java
• Ch. 2. Playing movies
• Ch. 3. Editing movies
• Ch. 4. Working with components
• Ch. 5. Working with QuickDraw
• Ch. 6. Capture
• Ch. 7. Audio media
• Ch. 8. Video media
• Ch. 9. Miscellaneous media.

QuickTime Java (QJT) is a terrific multimedia toolkit, but it's also terrifying to the uninitiated. Java developers who need to add audio, video, or interactive media creation and playback to their applications find that QTJ is powerful, but not easy to get into. In fact, when it comes to class-count, QuickTime Java is nearly as large as all of Java 1.1. Once you learn the entire scope of Apple's QuickTime software, you really appreciate the problem. At its simplest, QuickTime allows Mac and Windows users to play audio and video on their computers. But QuickTime is many things: a file format, an environment for media authoring, and a suite of applications that includes browser plug-ins for viewing media within a web page, a PictureViewer for working with still pictures, QuickTime Streaming Server for delivering streaming media files on the Internet in real time, and QuickTime Broadcaster for delivering live events on the Internet. Among others. As if that weren't daunting enough, the javadocs on QJT are wildly incomplete, and other books on the topic are long out of date and not well regarded, making progress with QTJ extremely difficult. So what can you do? Our new hands-on guide, QuickTime Java: The Developer's Notebook, not only catches up with this technology, but de-mystifies it. This practical "all lab, no lecture" book is an informal, code-intensive workbook that offers the first real look at this important software. Like other titles in our Developer's Notebook series, QuickTime Java: The Developer's Notebook is for impatient early adopters who want get up to speed on what they can use right now. It's deliberately light on theory, emphasizing example over explanation and practice over concept, so you can focus on learning by doing. QuickTime Java: The Developer's Notebook gives you just the functionality you need from QTJ. Even if you come to realize that 95 per cent of the API is irrelevant to you, this book will help you master the 5 per cent that really counts.
(source: Nielsen Book Data)

• 1. Programming Concepts
• 2. Setting Up the Environment
• 3. Writing Java Programs
• 4. Data Types
• 5. Operators
• 6. Statements
• 7. Classes and Objects
• 8. Methods
• 9. Constructors
• 10. Modules
• 11. Object and Objects Classes
• 12. Wrapper Classes
• 13. Execution Handling
• 14. Assertions
• 15. Strings
• 16. Dates and Times
• 17. Formatting Data
• 18. Regular Expressions
• 19. Arrays
• 20. Inheritance
• 21. Interfaces
• 22. Enum Types
• 23. Java Shell Appendix A: Character Encodings Appendix B: Documentation Comments.
• (source: Nielsen Book Data)

Learn the fundamentals of the Java 17 LTS or Java Standard Edition version 17 Long Term Support release, including basic programming concepts and the object-oriented fundamentals necessary at all levels of Java development. Authors Kishori Sharan and Adam L. Davis walk you through writing your first Java program step-by-step. Armed with that practical experience, you'll be ready to learn the core of the Java language. Beginning Java 17 Fundamentals provides over 90 diagrams and 240 complete programs to help you learn the topics faster. While this book teaches you the basics, it also has been revised to include the latest from Java 17 including the following: value types (records), immutable objects with an efficient memory layout; local variable type inference (var); pattern matching, a mechanism for testing and deconstructing values; sealed types, a mechanism for declaring all possible subclasses of a class; multiline text values; and switch expressions. The book continues with a series of foundation topics, including using data types, working with operators, and writing statements in Java. These basics lead onto the heart of the Java language: object-oriented programming. By learning topics such as classes, objects, interfaces, and inheritance you'll have a good understanding of Java's object-oriented model. The final collection of topics takes what you've learned and turns you into a real Java programmer. You'll see how to take the power of object-oriented programming and write programs that can handle errors and exceptions, process strings and dates, format data, and work with arrays to manipulate data. What You Will Learn Write your first Java programs with emphasis on learning object-oriented programming How to work with switch expressions, value types (records), local variable type inference, pattern matching switch and more from Java 17 Handle exceptions, assertions, strings and dates, and object formatting Learn about how to define and use modules Dive in depth into classes, interfaces, and inheritance in Java Use regular expressions Take advantage of the JShell REPL tool Who This Book Is For Those who are new to Java programming, who may have some or even no prior programming experience.
(source: Nielsen Book Data)

The #1 Java Guide for Serious Programmers: Fully Updated through Java 17 Core Java, Volume II: Fundamentals, Twelfth Edition, is the definitive guide to writing robust, maintainable code. Whatever version of Java you are usingup to and including Java 17this book will help you achieve a deep and practical understanding of the language and APIs. With with authoritative coverage of enterprise programming, networking, databases, security, modularization, internationalization, code processing, native methods, and more. Cay S. Horstmann explores sophisticated new features with depth and completeness, demonstrating how to use them to build professional-quality applications This book is written for readers with prior programming experience who are looking for in-depth coverage of the Java language and platform. You'll learn about all language features in detail, including the recent improvements in Java 17. The examples are carefully crafted for easy understanding and maximum practical value, so you can rely on them to jump-start your own code.. For 25 years, Core Java has prepared serious programmers for serious Java programming. Master advanced techniques, idioms, and best practices for writing superior Java code Make the most of enhanced Java I/O APIs, object serialization, and regular expressions Efficiently connect to network services, implement servers and the improved HTTP client, and harvest web data Process code via scripting and compiler APIs, and use annotations to generate code and files Deepen your understanding of the Java Platform Module System, including recent refinements Deepen your understanding of the Java Platform Module System, including recent refinements Preview powerful new APIs for accessing "foreign" functions and memory Core Java, Volume II: Advanced Features, Twelfth Edition is the reliable source for expert coverage of Java 17 enterprise features, the module system, annotations, networking, security, and advanced UI programming.

• Chapter 1: An Introduction to Java- When every version was released, how were they called and what were the particularities- What is Java, how it is executed, what type of language it is and what is it good for-
• Chapter 2: Preparing your development environment- Installing Java, choosing an editor, choosing a build tool-
• Chapter 3: Getting your feet wet- Writing a simple program, compile and execute- Adding a dependency of somebody else's code through dependencies of existing libraries- Mention best tools for java and most used frameworks like Spring
• Chapter 4: Java syntax- what is a package, module- class- enums- interface ( private methods & default methods)- class, constructor, methods... etc- removal of _
• Chapter 5: Data Types- primitive, object types (emphasis on String, Collections, Calendar API)- String - compact Strings- Collections: Immutable collections, factory methods for Collections(JEP 269)- mention Generics- optional - enhancements - threads, futures - CompletableFuture (JEP 266)
• Chapter 6: Operators- unary, binary, ternary, logic, and the diamond operator (used in conjunction with anonymous inner classes)
• Chapter 7: Controlling the flow - if, loops- try catch (try with resources with managed variables)- recursion
• Chapter 8: The Stream API - streams , optional to Stream, enhancements
• Chapter 9: Debugging , testing and documenting- what is a break point- loggers : unified JVM logging (JEP 264)- mocks and stubs- jmc, jps, jcmd - JDK utilities- The new Doclet API- the JShell Command Line Tool- accessing the process API- @Deprecated enhancements (JEP 277)
• Chapter 10: Making your application interactive- request data with System.in- Swing- Web applications (use the new HTTP client)- JavaFX UI (JEP 253)- Internationalization (JEP 267)
• Chapter 11: Writing files- storing data to files, reading it from them- serialization to Binary, XML, JSON, YML (JEP290)- playing with images - multi-resolution API
• Chapter 12: Publish-Subscribe Framework- reactive streams
• Chapter 13: Garbage Collection- JEP 214,248,271,291.
• (source: Nielsen Book Data)

Write your first code in Java 17 using simple, step-by-step examples that model real-word objects and events, making learning easy. With Java 17 for Absolute Beginners you'll be able to pick up the concepts without fuss. It teaches Java development in language anyone can understand, giving you the best possible start. You'll see clear code descriptions and layout so that you can get your code running as soon as possible. Author Iuliana Cosmina focuses on practical knowledge and getting you up to speed quickly-all the bits and pieces a novice needs to get started programming in Java. First, you'll discover what type of language Java is, what it is good for, and how it is executed. With the theory out of the way, you'll install Java, choose an editor such as IntelliJ IDEA, and write your first simple Java program. Along the way you'll compile and execute this program so it can run on any platform that supports Java. As part of this tutorial you'll see how to write high-quality code by following conventions and respecting well-known programming principles, making your projects more professional and efficient. Java 17 for Absolute Beginners gives you all you need to start your Java programming journey. No experience necessary. After reading this book, you'll come away with the basics to get started writing programs in Java. What You Will Learn Get started with Java 17 from scratch Use data types, operators, and the stream API Install and use the IntelliJ IDEA and the Gradle build tool Exchange data using the new JSON APIs Play with images using multi-resolution APIs Implement the publish-subscribe architecture Who This Book Is For Those who are new to programming and who want to start with Java.
(source: Nielsen Book Data)

Quickly find solutions to dozens of common programming problems encountered while building Java applications, with recipes presented in the popular problem-solution format. Look up the programming problem that you want to resolve. Read the solution. Apply the solution directly in your own code. Problem solved! Java 17 Recipes is updated to reflect changes in specification and implementation since the Java 9 edition of this book. Java 17 is the next long-term support release (LTS) of the core Java Standard Edition (SE) version 17 which also includes some of the features from previous short term support (STS) releases of Java 16 and previous versions. This new edition covers of some of the newest features, APIs, and more such as pattern matching for switch, Restore Always-Strict-Floating-Point-Semantics, enhanced pseudo-random number generators, the vector API, sealed classes, and enhancements in the use of String. Source code for all recipes is available in a dedicated GitHub repository. This must-have reference belongs in your library. What You Will Learn Look up solutions to everyday problems involving Java SE 17 LTS and other recent releases Develop Java SE applications using the latest in Java SE technology Incorporate Java major features introduced in versions 17, 16, and 15 into your code Who This Book Is For Programmers and developers with some prior Java experience.

A practical introduction to Java programming-fully revised for the latest version, Java SE 17 Thoroughly updated for Java Platform Standard Edition 17, this hands-on resource shows, step by step, how to get started programming in Java from the very first chapter. Written by Java guru Herbert Schildt, the book starts with the basics, such as how to create, compile, and run a Java program. From there, you will learn essential Java keywords, syntax, and commands. Java: A Beginner's Guide, Ninth Edition covers the basics and touches on advanced features, including multithreaded programming, generics, Lambda expressions, and Swing. Enumeration, modules, and interface methods are also clearly explained. This guide delivers the appropriate mix of theory and practical coding necessary to get you up and running developing Java applications in no time! Clearly explains all of the new Java SE 17 features Features self-tests, exercises, and downloadable code samples Written by bestselling author and leading Java authority Herbert Schildt.

• 1. Introduction
• Part I. Fundamentals
• 2. Mathematical problems
• 3. Recursion
• 4. Strings
• 5. Arrays
• 6. Date Processing
• 7. Basic Data Structures: Lists, Sets, and Maps
• Part II. More Advanced and Tricky Topics
• 8. Advanced Recursion
• 9. Binary Trees
• 10. Searching and Sorting
• 11. Conclusion
• Part III Appendices
• A. JShell Quick Start
• B. JUnit Introduction
• C. O-notation Quick Start. - Bibliography.

Expand your knowledge of Java with this entertaining learning guide, which features 100+ exercises and programming challenges. Java Challenges will prepare you for your next exam or job interview, and covers many practical topics, such as strings, arrays, data structures, recursion, and date and time. The APIs and other material included in this book are Java 17 compatible. Each topic is addressed in its own separate chapter, starting with an introduction to the basics and followed by multiple exercises of varying degrees of difficulty, helping you to improve your programming skills effectively. Detailed sample solutions, including the algorithms used for all tasks, are included to maximize your understanding of each area. Author Michael Inden also describes alternative solutions and analyzes possible pitfalls and typical errors. Three appendices round out the book: one covering JShell, which is often helpful for trying out the code snippets and examples in the book, followed by an introduction to JUnit 5 for unit testing and verifying solutions, while the final appendix explains O-notation for estimating performance. After reading this book, you'll be prepared to take the next step in your career or tackle your next personal project. All source code is freely available for download via the Apress website. What You Will Learn Improve your Java knowledge by solving enjoyable but challenging programming puzzles Solve mathematical problems, recursions, strings, arrays and more Manage data processing and data structures like lists, sets, maps Handle advanced recursion as well as binary trees, sorting and searching Gamify key fundamentals for fun and easier reinforcement Who This Book Is For Professional software developers, makers, as well as computer science teachers and students. At least some prior experience with Java programming is recommended. .
(source: Nielsen Book Data)

Reactive systems and event-driven architecture are becoming indispensable to application design, and companies are taking note. Reactive systems ensure that applications are responsive, resilient, and elastic no matter what failures or errors may be occurring, while event-driven architecture offers a flexible and composable option for distributed systems. This practical book helps Java developers bring these approaches together using Quarkus 2.x, the Kubernetes-native Java framework. Clement Escoffier and Ken Finnigan show you how to take advantage of event-driven and reactive principles to build robust distributed systems, reducing latency and increasing throughput, particularly in microservices and serverless applications. You'll also get a foundation in Quarkus to help you create true Kubernetes-native applications for the cloud. Understand the fundamentals of reactive systems and event-driven architecture Learn how to use Quarkus to build reactive applications Combine Quarkus with Apache Kafka or AMQP to build reactive systems Develop microservices that utilize messages with Quarkus for use in event-driven architectures Learn how to integrate external messaging systems, such as Apache Kafka, with Quarkus Build applications with Quarkus using reactive systems and reactive programming concepts.
(source: Nielsen Book Data)

• Introduction 1
• Part 1: Getting Started with Java Programming 5
• Chapter 1: The Big Picture 7
• Chapter 2: Setting Up Your Computer 21
• Chapter 3: Running Programs 47
• Part 2: Writing Your Own Java Programs 71
• Chapter 4: Exploring the Parts of a Program 73
• Chapter 5: Composing a Program 95
• Chapter 6: Using the Building Blocks: Variables, Values, and Types 127
• Chapter 7: Numbers and Types 149
• Chapter 8: Numbers? Who Needs Numbers? 173
• Part 3: Controlling the Flow 197
• Chapter 9: Forks in the Road 199
• Chapter 10: Which Way Did He Go? 219
• Chapter 11: Around and Around It Goes 251
• Chapter 12: Circling Back to Java Loops 275
• Part 4: The Inside ScOOP 293
• Chapter 13: Programming with Objects and Classes 295
• Chapter 14: Using Methods and Fields from a Java Class 315
• Chapter 15: Creating New Java Methods 347
• Part 5: Smart Java Techniques 375
• Chapter 16: Piles of Files: Dealing with Information Overload 377
• Chapter 17: How to Flick a Virtual Switch 401
• Chapter 18: Creating Loops within Loops 423
• Chapter 19: Out of Many, One 443
• Chapter 20: Oooey-GUI Was a Worm 477
• Part 6: The Part of Tens 503
• Chapter 21: Ten Useful Classes in the Java API 505
• Chapter 22: Ten Bits of Advice for New Software Developers 511 Index 517.
• (source: Nielsen Book Data)

Become a Java wizard with this popular programming guide Consider Beginning Programming with Java For Dummies your indispensable guide to learning how to program in one of the most popular programming languages-Java! Java is an invaluable language to master, as it's widely used for application development, including Android, desktop, and server-side applications. Beginning Programming with Java For Dummies is written specifically for newbies to programming. The book starts with an overview of computer programming and builds from there; it explains the software you need, walks you through writing your own programs, and introduces you to a few of the more-complex aspects of programming in Java. It also includes step-by-step examples you can try on your own (and email the author if you need help). As you work through the book, you'll get smart about these Java features: Object-oriented programming (OOP), a Java mainstay IntelliJ IDEA, an integrated development environment (IDE), that gives you one place to do all your programming, including debugging code Loops, branches, and collections Variables and operators Expressions, statements, and blocks Beginning Programming with Java For Dummies translates all this foreign programming and computer syntax into plain English, along with plenty of helpful examples and tips. Learning a new language-and coding is definitely its own language-should be a fun endeavor. With this book as your handy interpreter, you'll be on your way to fluency, speaking the language of coders everywhere!.
(source: Nielsen Book Data)

• 1. WELCOME TO COMPUTER SCIENCE2. SPRINT 01: INTRODUCTION3. SPRINT 02: SETTING UP THE JAVA JDK AND INTELLIJ4. SPRINT 03: SETTING UP GITHUBa. QUIZ 01b. QUIZ 025. SPRINT 04: PROGRAMMING LANGUAGES6. SPRINT 05: HISTORY AND USES OF JAVA7. SPRINT 06: HOW JAVA WORKSa. QUIZ 038. SPRINT 07: FLOWCHARTINGa. ASSIGNMENT 01: PBJ'Db. QUIZ 049. SPRINT 08: HELLO, WORLDa. QUIZ 0510. SPRINT 09: SIMPLE JAVA PROGRAM STRUCTURE11. SPRINT 10: TEXT LITERALS AND OUTPUTa. ASSIGNMENT 02: EE'D12. SPRINT 11: VALUE LITERALS13. SPRINT 12: OUTPUT FORMATTING14. SPRINT 13: COMMENTS AND WHITESPACE15. SPRINT 14: ABSTRACTION OF NUMBERS16. SPRINT 15: BINARYa. QUIZ 0617. SPRINT 16: UNICODE18. SPRINT 17: VARIABLES19. SPRINT 18: MATH. UGH.a. QUIZ 07b. ASSIGNMENT 03: SILO'D20. SPRINT 19: MATH FUNCTIONS21. SPRINT 20: MANAGING TYPEa. ASSIGNMENT 04: SPACE'Db. QUIZ 08c. QUIZ 09d. QUIZ 10e. QUIZ 1122. SPRINT 21: RANDOM NUMBERS23. SPRINT 22: CAPTURE INPUT24. SPRINT 23: CREATING TRACE TABLES25. SPRINT 24: FUNCTIONSa. ASSIGNMENT 05: ORC'D26. SPRINT 25: NESTED FUNCTIONS27. SPRINT 26: FUNCTIONS AND VALUESa. QUIZ 1228. SPRINT 27: FUNCTIONS AND SCOPEa. QUIZ 13b. QUIZ 14c. QUIZ 15d. ASSIGNMENT 06: ULTIMA'De. ASSIGNMENT 07: CYCLONE'D29. SPRINT 28: BOOLEAN VALUES AND EQUALITYa. QUIZ 16b. ASSIGNMENT 08: SPRINT'Dc. USER STORY: 52-PICKUP30. SPRINT 29: SIMPLE CONDITIONAL STATEMENTSa. USER STORY: YAHTZEEb. USER STORY: YAHTZEE TESTINGc. QUIZ 17d. QUIZ 18e. QUIZ 1931. SPRINT 30: MATCHING CONDITIONS WITH THE SWITCH STATEMENT32. SPRINT 31: THE TERNARY OPERATOR33. SPRINT 32: THE STACK AND THE HEAP34. SPRINT 33: TESTING EQUALITY WITH STRINGSa. ASSIGNMENT 09: ESCAPE'Db. USER STORY: ESCAPE'D WHITE BOX35. SPRINT 34: DEALING WITH ERRORS36. SPRINT 35: DOCUMENTING WITH JAVADOC37. SPRINT 36: FORMATTED STRINGS38. SPRINT 37: THE WHILE LOOPa. QUIZ 20b. QUIZ 21c. QUIZ 2239. SPRINT 38: AUTOMATIC PROGRAM LOOPS40. SPRINT 39: THE DO/WHILE LOOPa. ASSIGNMENT 10: SEQUENCE'Db. USER STORY: DICEYc. USER STORY SOLUTION: DICEYd. USER STORY: CONVERTERe. USER STORY SOLUTION: CONVERTER41. SPRINT 40: PROBABILITY42. SPRINT 41: SIMPLIFIED ASSIGNMENT OPERATORS43. SPRINT 42: THE FOR LOOPa. QUIZ 23b. ASSIGNMENT 11: ODDS'D44. SPRINT 43: NESTING LOOPSa. USER STORY: MAP BUILDER45. SPRINT 44: STRINGS AS COLLECTIONSa. ASSIGNMENT 12: PALINDROME'Db. QUIZ 2446. SPRINT 45: MAKE COLLECTIONS USING ARRAYSa. QUIZ 2547. SPRINT 46: CREATING ARRAYS FROM STRINGSa. ASSIGNMENT 13: ELECTION'Db. QUIZ 2648. SPRINT 47: MULTIDIMENSIONAL ARRAYS49. SPRINT 48: LOOPING THROUGH MULTIDIMENSIONAL ARRAYSa. QUIZ 27b. QUIZ 2850. SPRINT 49: BEYOND ARRAYS WITH ARRAYLISTS51. SPRINT 50: INTRODUCING GENERICS52. SPRINT 51: LOOPING WITH ARRAYLISTSa. ASSIGNMENT 14: LIST'D53. SPRINT 52: USING FOR...EACH LOOPSa. ASSIGNMENT 15: NUMBER'Db. QUIZ 29c. QUIZ 3054. SPRINT 53: THE ROLE-PLAYING GAME CHARACTERa. ASSIGNMENT 16: ROLL'D55. SPRINT 54: POLYMORPHISMa. ASSIGNMENT 17: EXTEN'D56. SPRINT 55: MAKE ALL THE THINGS...CLASSES57. SPRINT 56: CLASS, EXTEND THYSELF!a. QUIZ 3158. SPRINT 57: I DON'T COLLECT THOSE
• TOO ABSTRACT.59. SPRINT 58: ACCESS DENIED: PROTECTED AND PRIVATEa. QUIZ 32b. QUIZ 3360. SPRINT 59: INTERFACING WITH INTERFACESa. QUIZ 34b. QUIZ 35c. QUIZ 36d. QUIZ 37e. ASSIGNMENT 18: STARSHIP'D61. SPRINT 60: ALL I'M GETTING IS STATIC62. SPRINT 61: AN ALL-STAR CAST, FEATURING NULL63. ANSWER KEY.
• (source: Nielsen Book Data)

Gain the essential skills for computer science using one of today's most popular programming languages, Java. This book will prepare you for AP CompSci Complete, but you don't need to be sitting that class to benefit. Computer science has become a basic life skill that everyone is going to need to learn. Whether you are going into a career or side hustle in business, technology, creativity, architecture, or almost any other field, you will find coding and computer science play a role. So when we learn programming we are going to focus on three things: what is the process; what is the syntax; and what is the flow. The process is represented as a flowchart. We will learn how to make these to help you plan out what you are going to do before you write a line of code. At first, the flowcharts will be pretty simple, but then they will get more complex. The syntax is the code: this is what you write that translates the process you create in a flowchart to the instructions that the computer can understand. Finally, there is the flow. This is where you trace through the code and see how the data and information it stores along the way changes. You can see how the operation of the program cascades from line to line. You will be building charts that will capture the programming flow so you can better understand how the computer processes code to make your next program easier to conceive and code. Along the way to aid in the learning of the essential Java skills, there will be three kinds of project types throughout this book: business software projects for applications where you work for a company and need to complete an internal project for a team such as the sales, marketing, or data science teams; social good projects where you are working for non-profits or for agencies that are trying to research and provide solutions to economic, environmental, medical, or humanitarian projects; and game development projects for games based on player input, random chance, or other mechanics for the use of entertainment. What is unique about computer science is how it has become a skill, and not just a career. While there are jobs and titles of "computer scientist", the skill of computer science, and specifically programming, are almost everywhere. After reading and using this book, you'll have the essential skills to think like a computer scientist, even if you are not. As a result you'll be of greater value to your clients, your company, and yourself. What You Will Learn Discover the primary building blocks of programming using the Java programming language See terminology and best practices of software development Work with object-oriented programming concepts Use common-language definitions and examples to help drive understanding and comprehension of computer science fundamentals Who This Book Is For Those who want to learn programming and want to think like a computer scientist. Ideal for anyone taking AP CompSci Complete.
(source: Nielsen Book Data)

What will you learn from this book? Ready to learn Java? This book combines puzzles, strong visuals, mysteries, and soul-searching interviews with famous Java objects to engage you in many different ways. It's fast, it's fun, and it's effective. And despite its playful appearance, Head First Java is serious stuff: a complete introduction to object-oriented programming and Java. You'll learn everything from the fundamentals to advanced topics. The new third edition brings the book up-to-date for Java 8-17, including major recent updates to the Java language and development platform. Java has seen some deep code-level changes and more modern approaches, requiring even more careful study and implementation. So learning the Head First way is more important than ever. What's so special about this book? If you've read a Head First book, you know what to expect--a visually rich format designed for the way your brain works. If you haven't, you're in for a treat. With this book, you'll learn Java through a multi-sensory experience that engages your mind rather than a text-heavy approach that puts you to sleep.

• 1. HelloWorld 2. Compile and Run
• 3. Variables
• 4. Operators
• 5. String
• 6. Arrays
• 7. Conditionals
• 8. Loops
• 9. Methods
• 10. Class
• 11. Stack
• 12. Inheritance
• 13. Overriding
• 14. Packages
• 15. Access Levels
• 16. Constants
• 17. Interface
• 18. Abstract
• 19. Enum
• 20. Exception Handling
• 21. Boxing and Unboxing
• 22. Generics 23. Modules.
• (source: Nielsen Book Data)

Quickly gain the insight necessary to address a multitude of Java coding challenges using this succinct reference guide, Java 17 Quick Syntax Reference, Third Edition. Short, focused code examples will help you learn and master various existing and new Java source code elements. This edition includes the following additions to Java SE and OpenJDK, through Java 17: Pattern matching for switch and instanceof, Sealed classes and interfaces, Switch expressions, Text block multiline strings, Java module system, Private methods in interfaces, and Type inference for local variables. You won't find any technical jargon, bloated samples, drawn out history lessons or witty stories in this book. What you will find is a language reference that is concise, to the point and highly accessible. The book is packed with useful information and is a must-have for any Java programmer.What You Will Learn Run a Java file with a single command Learn what a switch expression is and how to use it Use pattern matching Code with Java modules Create text blocks to handle multiline strings Learn what sealed classes are and how to use these and more Who This Book Is For Those with prior experience with Java who want a quick and handy reference. .
(source: Nielsen Book Data)

The definitive guide to Java programming-thoroughly revised for Java SE 17 Fully updated for the current version of Java, Java SE 17, this practical guide from Oracle Press shows, step by step, how to design, write, troubleshoot, run, and maintain high-performance Java programs. Inside, bestselling author Herbert Schildt covers the entire Java language, including its syntax, keywords, and libraries. The book lays out cutting-edge programming techniques and best practices. Java: The Complete Reference, Twelfth Edition features clear explanations, detailed code samples, and real-world examples that demonstrate how Java can be put to work in the real world. JavaBeans, servlets, applets, Swing, lambda expressions, multithreading, and the default interface method are thoroughly discussed. You will get full details on all of the new features and functions available in Java SE 17. Designed for novice, intermediate, and professional programmers alike Source code for all examples and projects are available for download Written in the clear, uncompromising style for which Herb Schildt is famous.
(source: Nielsen Book Data)

While containers, microservices, and distributed systems dominate discussions in the tech world, the majority of applications in use today still run monolithic architectures that follow traditional development processes. This practical book helps developers examine long-established Java-based models and demonstrates how to bring these monolithic applications successfully into the future. Relying on their years of experience modernizing applications, authors Markus Eisele and Natale Vinto walk you through the steps necessary to update your organization's Java applications. You'll discover how to dismantle your monolithic application and move to an up-to-date software stack that works across cloud and on-premises installations. Learn cloud native application basics to understand what parts of your organization's Java-based applications and platforms need to migrate and modernize Understand how enterprise Java specifications can help you transition projects and teams Build a cloud native platform that supports effective development without falling into buzzword traps Find a starting point for your migration projects by identifying candidates and staging them through modernization steps Discover how to complement a traditional enterprise Java application with components on top of containers and Kubernetes.
(source: Nielsen Book Data)

• 1. Annotation
• s2. Inner Classe
• s3. Reflectio
• n4. Generic
• s5. Lambda Expression
• s6. Thread
• s7. Input Outpu
• t8. Working with Archive File
• s9. New Input Output NI
• O10. New Input Output 2
• .011. Garbage Collectio
• n12. Collection
• s13. Stream
• s14. Implementing Service
• s15. The Module AP
• I16. Breaking Module Encapsulatio
• n17. Reactive Stream
• s18. Stack Walkin
• g19. Network Programmin
• g20. JDBC AP
• I21. Java Remote Method Invocatio
• n22. Java Native Interfac
• e23. Process AP
• I24. Packaging Module
• s25. Custom Runtime Images.
• (source: Nielsen Book Data)

Work with the essential and advanced features of the Java 17 release. This book covers features such as annotations, reflection, and generics. These topics are then complemented by details of how to use lambda expressions, allowing you to build powerful and efficient Java programs. Furthermore, added to this edition you'll find topics on network programming, Java RMI, the process API, and custom runtime images. The authors provide a multitude of diagrams and complete programs to help you visualize and better understand the topics covered in this book. More Java 17, Third Edition starts with a series of chapters on the essential language features provided by Java before moving on to Java module development and packaging, and improved interop with other languages. After reading this book, you'll have the know-how of a professional Java programmer and be able to tackle most projects with confidence. This book's source code can be accessed at github.com/Apress/more-java-17. What You Will Learn Use essential and advanced features of the Java language Code Java annotations Work with reflection and generics Manage streams with the Stream API Who This Book Is For Those new to Java programming who are continuing the Java learning journey; it is recommended that you read an introductory Java programming book first, such as Java 17 for Absolute Beginners, from Apress.
(source: Nielsen Book Data)

• All you need is Java / Anders Noras
• Approval testing / Emily Bache
• Augment Javadoc with AscilDoc / James Elliott
• Be aware of your container surroundings / David Delabassee
• Behavior is "easy" ; state is hard / Edson Yanaga
• Benchmarking is hard- JMH helps / Michael Hunger
• The benefits of codifying and asserting architectural quality / Daniel Bryant
• Break problems and tasks into small chunks / Jeanne Boyarsky
• Build diverse teams / Ixchel Ruiz
• Builds don't have to be slow and unreliable / Jenn Strater
• "But it works on my machine!" / Benjamin Muschko
• The case against fat JARs / Daniel Bryant
• The code restorer / Abraham Marin-Perez
• Concurrency on the JVM / Mario Fusco
• CountDownLatch- friend or foe? / Alexey Soshin
• Declarative expression is the path to parallelism / Russel Winder
• Deliver better software, faster / Burk Hufnagel
• Do you know what time it is? / Christin Gorman
• Don't hide your tools / Gail Ollis
• Don't vary your variables / Steve Freeman
• Embrace SQL thinking / Dean Wampler
• Events between Java components / A. Mahdy AbdelAziz
• Feedback loops / Liz Keogh
• Firing on all engines / Michael Hunger
• Follow the boring standards / Adam Bien
• Frequent releases reduce risk / Chris O'Dell
• From puzzles to products / Jessica Kerr
• "Full-stack developer" is a mindset / Maciej Walkowiak
• Garbage collection is your friend / Holly Cummins
• Get better at naming things / Peter Hilton
• Hey Fred, Can you pass me the HashMap? / Kirk Pepperdine
• How to avoid null / Carlos Obregon
• How to crash your JVM / Thomas Ronzon

• Improving repeatability and auditability with continuous delivery / Billy Korando
• In the language wars, Java holds its own / Jennifer Reif
• Inline thinking / Patricia Aas
• Interop with Kotlin / Sebastiano Poggi
• It's done, but / Jeanne Boyarsky
• Java certifications: touchstone in technology / Mala Gupta
• Java is a '90s kid / Ben Evans
• Java programming from a JVM performance perspective / Monica Beckwith
• Java should feel fun / Holly Cummins
• Java's unspeakable types / Ben Evans
• The JVM is a multiparadigm platform: use this to improve your programming / Russel Winder
• Keep your finger on the pulse / Trisha Gee
• Kinds of comments / Nicolai Parlog
• Know thy flatMap / Daniel Hinojosa
• Know your collections / Nikhil Nanivadekar
• Kotlin is a thing / Mike Dunn
• Learn Java idioms and cache in your brain / Jeanne Boyarsky
• Learn to Kata and Kata to learn / Donald Raab
• Learn to love your legacy code / Uberto Barbini
• Learn to use new Java features / Gail C. Anderson
• Learn your IDE to reduce cognitive load / Trisha Gee
• Let's make a contract: the art of designing a Java API / Mario Fusco
• Make code simple and readable / Emily Jiang
• Make your Java groovier / Ken Kousen
• Minimal constructors / Steve Freeman
• Name the date / Kevlin Henney
• The necessity of industrial-strength technologies / Paul W. Homer
• Only build the parts that change and reuse the rest / Jenn Strater
• Open Source projects aren't magic / Jenn Strater
• Optional is a lawbreaking monad but a good type / Nicolai Parlog
• Package-by-feature with the default access modifier / Marco Beelen
• Production is the happiest place on Earth / Josh Long
• Program with GUTs / Kevlin Henney

• Read OpenJDK daily / Heinz M. Kabutz
• Really looking under the hood / Rafael Benevides
• The rebirth of Java / Sander Mak
• Rediscover the JVM through Clojure / James Elliott
• Refactor Boolean values to enumerations / Peter Hilton
• Refactoring toward speed-reading / Benjamin Muskalla
• Simple value objects / Steve Freeman
• Take care of your module declarations / Nicolai Parlog
• Take good care of your dependencies / Brian Vermeer
• Take 'separation of concerns" seriously / Dave Farley
• Technical interviewing is a skill worth developing / Trisha Gee
• Test-driven development / Dave Farley
• There are great tools in your bin/ directory / Rod Hilton
• Think outside the Java Sandbox / Ian F. Darwin
• Thinking in coroutines / Dawn Griffiths and David Griffiths
• Threads are infrastructure: treat them as such / Russel Winder
• The three traits of really good developers / Jannah Patchay
• Trade-offs in a microservices architecture / Kenny Bastani
• Uncheck your exceptions / Kevlin Henney
• Unlocking the hidden potential of integration testing using containers / Kevin Wittek
• The unreasonable effectiveness of fuzz testing / Nat Pryce
• Use coverage to improve your unit tests / Emily Bache
• Use custom identity annotations liberally / Mark Richards
• Use testing to develop better software faster / Marit van Dijk
• Using object-oriented principles in test code / Angie Jones
• Using the power of community to enhance your career / Sam Hepburn
• What is the JCP program and how to participate / Heather VanCura
• Why I don't hold any value in certifications / Colin Vipurs
• Write one-sentence documentation comments / Peter Hilton
• Write "readable code" / Dave Farley
• The young, the old, and the garbage / Maria Arias de Reyna.

If you want to push your Java skills to the next level, this book provides expert advice from Java leaders and practitioners. You'll be encouraged to look at problems in new ways, take broader responsibility for your work, stretch yourself by learning new techniques, and become as good at the entire craft of development as you possibly can. Edited by Kevlin Henney and Trisha Gee, 97 Things Every Java Programmer Should Know reflects lifetimes of experience writing Java software and living with the process of software development. Great programmers share their collected wisdom to help you rethink Java practices, whether working with legacy code or incorporating changes since Java 8.

• Intro
• 1 Einleitung
• 1.1 Aufbau der Kapitel
• 1.2 Grundgerüst des Eclipse-Projekts
• 1.3 Grundgerüst für die Unit Tests
• 1.4 Anmerkung zum Programmierstil
• 1.5 Ausprobieren der Beispiele und Lösungen
• I Grundlagen
• 2 Mathematische Aufgaben
• 2.1 Einführung
• 2.1.1 Römische Zahlen
• 2.1.2 Zahlenspielereien
• 2.2 Aufgaben
• 2.2.1 Aufgabe 1: Grundrechenarten (.....)
• 2.2.2 Aufgabe 2: Zahl als Text ( .....)
• 2.2.3 Aufgabe 3: Vollkommene Zahlen (.....)
• 2.2.4 Aufgabe 4: Primzahlen (.....)
• 2.2.5 Aufgabe 5: Primzahlpaare (.....)
• 2.2.6 Aufgabe 6: Prüfsumme (.....)
• 2.2.7 Aufgabe 7: Römische Zahlen (.....)
• 2.2.8 Aufgabe 8: Kombinatorik (.....)
• 2.2.9 Aufgabe 9: Armstrong-Zahlen (.....)
• 2.2.10 Aufgabe 10: Max Change Calculator (.....)
• 2.2.11 Aufgabe 11: Befreundete Zahlen (.....)
• 2.2.12 Aufgabe 12: Primfaktorzerlegung (.....)
• 2.3 Lösungen
• 2.3.1 Lösung 1: Grundrechenarten (.....)
• 2.3.2 Lösung 2: Zahl als Text (.....)
• 2.3.3 Lösung 3: Vollkommene Zahlen (.....)
• 2.3.4 Lösung 4: Primzahlen (.....)
• 2.3.5 Lösung 5: Primzahlpaare (.....)
• 2.3.6 Lösung 6: Prüfsumme (.....)
• 2.3.7 Lösung 7: Römische Zahlen (.....)
• 2.3.8 Lösung 8: Kombinatorik (.....)
• 2.3.9 Lösung 9: Armstrong-Zahlen (.....)
• 2.3.10 Lösung 10: Max Change Calculator (.....)
• 2.3.11 Lösung 11: Befreundete Zahlen (.....)
• 2.3.12 Lösung 12: Primfaktorzerlegung (.....)
• 3 Rekursion
• 3.1 Einführung
• 3.1.1 Mathematische Beispiele
• 3.1.2 Algorithmische Beispiele
• 3.1.3 Ablauf beim Multiplizieren der Ziffern einer Zahl
• 3.1.4 Typische Probleme
• 3.2 Aufgaben
• 3.2.1 Aufgabe 1: Fibonacci (.....)
• 3.2.2 Aufgabe 2: Ziffern verarbeiten (.....)
• 3.2.3 Aufgabe 3: ggT / GCD (.....)
• 3.2.4 Aufgabe 4: Reverse String (.....)
• 3.2.5 Aufgabe 5: Array Sum (.....)
• 3.2.6 Aufgabe 6: Array Min (.....).

• 3.2.7 Aufgabe 7: Konvertierungen (.....)
• 3.2.8 Aufgabe 8: Exponentialfunktion (.....)
• 3.2.9 Aufgabe 9: Pascal'sches Dreieck (.....)
• 3.2.10 Aufgabe 10: Zahlenpalindrome (.....)
• 3.2.11 Aufgabe 11: Permutationen (.....)
• 3.2.12 Aufgabe 12: Count Substrings (.....)
• 3.2.13 Aufgabe 13: Lineal (.....)
• 3.3 Lösungen
• 3.3.1 Lösung 1: Fibonacci (.....)
• 3.3.2 Lösung 2: Ziffern verarbeiten (.....)
• 3.3.3 Lösung 3: ggT / GCD (.....)
• 3.3.4 Lösung 4: Reverse String (.....)
• 3.3.5 Lösung 5: Array Sum (.....)
• 3.3.6 Lösung 6: Array Min (.....)
• 3.3.7 Lösung 7: Konvertierungen (.....)
• 3.3.8 Lösung 8: Exponentialfunktion (.....)
• 3.3.9 Lösung 9: Pascal'sches Dreieck (.....)
• 3.3.10 Lösung 10: Zahlenpalindrome (.....)
• 3.3.11 Lösung 11: Permutationen (.....)
• 3.3.12 Lösung 12: Count Substrings (.....)
• 3.3.13 Lösung 13: Lineal (.....)
• 4 Strings
• 4.1 Einführung
• 4.1.1 Die Klasse String
• 4.1.2 Die Klassen StringBuffer und StringBuilder
• 4.1.3 Die Klasse Character
• 4.1.4 Beispiele zu Character und String
• 4.2 Aufgaben
• 4.2.1 Aufgabe 1: Zahlenumwandlungen (.....)
• 4.2.2 Aufgabe 2: Joiner (.....)
• 4.2.3 Aufgabe 3: Reverse String (.....)
• 4.2.4 Aufgabe 4: Palindrom (.....)
• 4.2.5 Aufgabe 5: No Duplicate Chars (.....)
• 4.2.6 Aufgabe 6: Doppelte Buchstaben entfernen (.....)
• 4.2.7 Aufgabe 7: Capitalize (.....)
• 4.2.8 Aufgabe 8: Rotation (.....)
• 4.2.9 Aufgabe 9: Wohlgeformte Klammern (.....)
• 4.2.10 Aufgabe 10: Anagramm (.....)
• 4.2.11 Aufgabe 11: Morse Code (.....)
• 4.2.12 Aufgabe 12: Pattern Checker (.....)
• 4.2.13 Aufgabe 13: Tennis-Punktestand (.....)
• 4.2.14 Aufgabe 14: Versionsnummern (.....)
• 4.2.15 Aufgabe 15: Konvertierung strToLong (.....)
• 4.2.16 Aufgabe 16: Print Tower (.....)
• 4.3 Lösungen
• 4.3.1 Lösung 1: Zahlenumwandlungen (.....)
• 4.3.2 Lösung 2: Joiner (.....).

• 4.3.3 Lösung 3: Reverse String (.....)
• 4.3.4 Lösung 4: Palindrom (.....)
• 4.3.5 Lösung 5: No Duplicate Chars (.....)
• 4.3.6 Lösung 6: Doppelte Buchstaben entfernen (.....)
• 4.3.7 Lösung 7: Capitalize (.....)
• 4.3.8 Lösung 8: Rotation (.....)
• 4.3.9 Lösung 9: Wohlgeformte Klammern (.....)
• 4.3.10 Lösung 10: Anagramm (.....)
• 4.3.11 Lösung 11: Morse Code (.....)
• 4.3.12 Lösung 12: Pattern Checker (.....)
• 4.3.13 Lösung 13: Tennis-Punktestand (.....)
• 4.3.14 Lösung 14: Versionsnummern (.....)
• 4.3.15 Lösung 15: Konvertierung strToLong (.....)
• 4.3.16 Lösung 16: Print Tower (.....)
• 5 Arrays
• 5.1 Einführung
• 5.1.1 Eindimensionale Arrays
• 5.1.2 Mehrdimensionale Arrays
• 5.1.3 Typische Fehler
• 5.2 Aufgaben
• 5.2.1 Aufgabe 1: Gerade vor ungeraden Zahlen (.....)
• 5.2.2 Aufgabe 2: Flip (.....)
• 5.2.3 Aufgabe 3: Palindrom (.....)
• 5.2.4 Aufgabe 4: Inplace Rotate (.....)
• 5.2.5 Aufgabe 5: Jewels Board Init (.....)
• 5.2.6 Aufgabe 6: Jewels Board Erase Diamonds (.....)
• 5.2.7 Aufgabe 7: Spiral-Traversal (.....)
• 5.2.8 Aufgabe 8: Add One to Array As Number (.....)
• 5.2.9 Aufgabe 9: Sudoku-Checker (.....)
• 5.2.10 Aufgabe 10: Flood-Fill (.....)
• 5.2.11 Aufgabe 11: Array Merge (.....)
• 5.2.12 Aufgabe 12: Array Min und Max (.....)
• 5.2.13 Aufgabe 13: Array Split (.....)
• 5.2.14 Aufgabe 14: Minesweeper Board (.....)
• 5.3 Lösungen
• 5.3.1 Lösung 1: Gerade vor ungerade Zahlen (.....)
• 5.3.2 Lösung 2: Flip (.....)
• 5.3.3 Lösung 3: Palindrom (.....)
• 5.3.4 Lösung 4: Inplace Rotate (.....)
• 5.3.5 Lösung 5: Jewels Board Init (.....)
• 5.3.6 Lösung 6: Jewels Board Erase Diamonds (.....)
• 5.3.7 Lösung 7: Spiral-Traversal (.....)
• 5.3.8 Lösung 8: Add One to Array As Number (.....)
• 5.3.9 Lösung 9: Sudoku-Checker (.....)
• 5.3.10 Lösung 10: Flood-Fill (.....).

• 5.3.11 Lösung 11: Array Merge (.....)
• 5.3.12 Lösung 12: Array Min und Max (.....)
• 5.3.13 Lösung 13: Array Split (.....)
• 5.3.14 Lösung 14: Minesweeper Board (.....)
• 6 Datumsverarbeitung
• 6.1 Einführung
• 6.1.1 Die Aufzählungen DayOfWeek und Month
• 6.1.2 Die Klassen LocalDate, LocalTime und LocalDateTime
• 6.1.3 Die Klasse ZonedDateTime
• 6.1.4 Die Klasse ZoneId
• 6.1.5 Die Klasse Duration
• 6.1.6 Die Klasse Period
• 6.1.7 Datumsarithmetik
• 6.1.8 Formatierung und Parsing
• 6.2 Aufgaben
• 6.2.1 Aufgabe 1: Schaltjahre (.....)
• 6.2.2 Aufgabe 2: Basiswissen Date-API (.....)
• 6.2.3 Aufgabe 3: Monatslänge (.....)
• 6.2.4 Aufgabe 4: Zeitzonen (.....)
• 6.2.5 Aufgabe 5: Zeitzonenberechnung (.....)
• 6.2.6 Aufgabe 6: Berechnungen mit LocalDate (.....)
• 6.2.7 Aufgabe 7: Kalenderausgabe (.....)
• 6.2.8 Aufgabe 8: Wochentage (.....)
• 6.2.9 Aufgabe 9: Sonntage und Schaltjahre (.....)
• 6.2.10 Aufgabe 10: TemporalAdjuster (.....)
• 6.2.11 Aufgabe 11: NthWeekdayAdjuster (.....)
• 6.2.12 Aufgabe 12: Payday-TemporalAdjuster (.....)
• 6.2.13 Aufgabe 13: Formatting and Parsing (.....)
• 6.2.14 Aufgabe 14: Fault Tolerant Parsing (.....)
• 6.3 Lösungen
• 6.3.1 Lösung 1: Schaltjahre (.....)
• 6.3.2 Lösung 2: Basiswissen Date-API (.....)
• 6.3.3 Lösung 3: Monatslänge (.....)
• 6.3.4 Lösung 4: Zeitzonenberechnung (.....)
• 6.3.5 Lösung 5: Zeitzonen (.....)
• 6.3.6 Lösung 6: Berechnungen mit LocalDate (.....)
• 6.3.7 Lösung 7: Kalenderausgabe (.....)
• 6.3.8 Lösung 8: Wochentage (.....)
• 6.3.9 Lösung 9: Sonntage und Schaltjahre (.....)
• 6.3.10 Lösung 10: TemporalAdjuster (.....)
• 6.3.11 Lösung 11: NthWeekdayAdjuster (.....)
• 6.3.12 Lösung 12: Payday-TemporalAdjuster (.....)
• 6.3.13 Lösung 13: Formatting and Parsing (.....)
• 6.3.14 Lösung 14: Fault Tolerant Parsing (.....).

• 7 Basisdatenstrukturen: Listen, Sets und Maps
• 7.1 Einführung
• 7.1.1 Das Interface Collection
• 7.1.2 Listen und das Interface List&lt
• E&gt
• 7.1.3 Mengen und das Interface Set
• 7.1.4 Schlüssel-Wert-Abbildungen und das Interface Map
• 7.1.5 Der Stack als LIFO-Datenstruktur
• 7.1.6 Die Queue als FIFO-Datenstruktur
• 7.2 Aufgaben
• 7.2.1 Aufgabe 1: Mengenoperationen (.....)
• 7.2.2 Aufgabe 2: List Reverse (.....)
• 7.2.3 Aufgabe 3: Duplikate entfernen (.....)
• 7.2.4 Aufgabe 4: Maximaler Gewinn (.....)
• 7.2.5 Aufgabe 5: Längstes Teilstück (.....)
• 7.2.6 Aufgabe 6: Eigener Stack (.....)
• 7.2.7 Aufgabe 7: Wohlgeformte Klammern (.....)
• 7.2.8 Aufgabe 8: Check Magic Triangle (.....)
• 7.2.9 Aufgabe 9: Pascal'sches Dreieck (.....)
• 7.2.10 Aufgabe 10: Häufigste Elemente (.....)
• 7.2.11 Aufgabe 11: Addition von Ziffern (.....)
• 7.2.12 Aufgabe 12: Compound Key (.....)
• 7.2.13 Aufgabe 13: List Merge (.....)
• 7.2.14 Aufgabe 14: Excel Magic Select (.....)
• 7.3 Lösungen
• 7.3.1 Lösung 1: Mengenoperationen (.....)
• 7.3.2 Lösung 2: List Reverse (.....)
• 7.3.3 Lösung 3: Duplikate entfernen (.....)
• 7.3.4 Lösung 4: Maximaler Gewinn (.....)
• 7.3.5 Lösung 5: Längstes Teilstück (.....)
• 7.3.6 Lösung 6: Eigener Stack (.....)
• 7.3.7 Lösung 7: Wohlgeformte Klammern (.....)
• 7.3.8 Lösung 8: Check Magic Triangle (.....)
• 7.3.9 Lösung 9: Pascal'sches Dreieck (.....)
• 7.3.10 Lösung 10: Häufigste Elemente (.....)
• 7.3.11 Lösung 11: Addition von Ziffern (.....)
• 7.3.12 Lösung 12: Compound Key (.....)
• 7.3.13 Lösung 13: List Merge (.....)
• 7.3.14 Lösung 14: Excel Magic Select (.....)
• II Fortgeschrittenere und kniffligere Themen
• 8 Rekursion Advanced
• 8.1 Memoization
• 8.1.1 Memoization für Fibonacci-Zahlen
• 8.1.2 Memoization für Pascal'sches Dreieck
• 8.2 Backtracking
• 8.2.1 n-Damen-Problem.

Dieses Buch bietet ein breit gefächertes Spektrumvon über 100 Übungsaufgaben und Programmierpuzzlesinklusive Lösungen zum Knobeln und Erweitern derKenntnisse zu unterschiedlichen praxisrelevantenThemengebieten wie Arrays, Datenstrukturen, Rekursion, Date and Time API usw. Java-Training- für Prüfungen- für Job-Interviews- zur Fortbildung vom Java-Experten Michael Inden (»Der Weg zum Java-Profi»).