Java Programming Interviews Exposed

Table of contents

1. Cover
2. Part I: Navigating the Interview Process
   1. Chapter 1: Dissecting Interview Types
      1. Looking at the Phone Screening Process
      2. Reviewing Technical Tests
      3. Handling Face-to-Face Interviews
      4. Making the Decision
      5. Summary
   2. Chapter 2: Writing a Noticeable Resume
      1. How to Write a Resume and Cover Letter
      2. Writing a Cover Letter
      3. Summary
   3. Chapter 3: Technical Test and Interview Basics
      1. Technical Written Tests
      2. At-Computer Tests
      3. Face-to-Face Technical Interviews
      4. Summary
   4. Chapter 4: Writing Core Algorithms
      1. Looking at Big O Notation
      2. Sorting Lists
      3. Searching Lists
      4. Summary
   5. Chapter 5: Data Structures
      1. Lists
      2. Trees
      3. Maps
      4. Sets
      5. Summary
   6. Chapter 6: Design Patterns
      1. Investigating Example Patterns
      2. Commonly Used Patterns
      3. Summary
   7. Chapter 7: Implementing Popular Interview Algorithms
      1. Implementing FizzBuzz
      2. Demonstrating the Fibonacci Sequence
      3. Demonstrating Factorials
      4. Implementing Library Functionality
      5. Using Generics
      6. Summary
3. Part II: Core Java
   1. Chapter 8: Java Basics
      1. The Primitive Types
      2. Using Objects
      3. Java’s Arrays
      4. Working with Strings
      5. Understanding Generics
      6. Autoboxing and Unboxing
      7. Using Annotations
      8. Naming Conventions
      9. Handling Exceptions
      10. Using the Standard Java Library
      11. Looking Forward to Java 8
      12. Summary
   2. Chapter 9: Testing with JUnit
      1. The JUnit Test Life Cycle
      2. Best Practices for Using JUnit
      3. Eliminating Dependencies with Mocks
      4. Creating System Tests with Behavior-Driven Development
      5. Summary
   3. Chapter 10: Understanding the Java Virtual Machine
      1. Garbage Collection
      2. Memory Tuning
      3. Interoperability between the JVM and the Java Language
      4. Summary
   4. Chapter 11: Concurrency
      1. Using Threads
      2. Working with Concurrency
      3. Actors
      4. Summary
4. Part III: Components and Frameworks
   1. Chapter 12: Integrating Java Applications with Databases
      1. SQL: An Introduction
      2. JDBC: Combining Java and the Database
      3. Testing with In-Memory Databases
      4. Summary
   2. Chapter 13: Creating Web Applications
      1. Tomcat and the Servlet API
      2. Jetty
      3. Play Framework
      4. Summary
   3. Chapter 14: Using HTTP and REST
      1. The HTTP Methods
      2. HTTP Clients
      3. Creating HTTP Services Using REST
      4. Summary
   4. Chapter 15: Serialization
      1. Reading and Writing Java Objects
      2. Using XML
      3. JSON
      4. Summary
   5. Chapter 16: The Spring Framework
      1. Core Spring and the Application Context
      2. Spring JDBC
      3. Integration Testing
      4. Spring MVC
      5. Summary
   6. Chapter 17: Using Hibernate
      1. Using Hibernate
      2. Summary
   7. Chapter 18: Useful Libraries
      1. Removing Boilerplate Code with Apache Commons
      2. Developing with Guava Collections
      3. Using Joda Time
      4. Summary
   8. Chapter 19: Developing with Build Tools
      1. Building Applications with Maven
      2. Ant
      3. Summary
   9. Chapter 20: Android
      1. Basics
      2. User Interface
      3. Persistence
      4. Android Hardware
      5. Summary
5. Appendix: Introducing Scala
   1. Scala Basics
   2. Functions as Values
   3. Immutability
   4. Summary
6. Introduction
   1. Overview of the Book and Technology
   2. How This Book Is Organized
   3. Who Should Read This Book
   4. Tools You Will Need
   5. Downloading the Example Source Code
   6. Summary