Advanced Java Programming (Java SE 7)

Explore how Java packages organize classes to manage complexity, enable reuse, and prevent name conflicts. Learn importing and fully qualified names, with examples from Demo, Acme, and the Java API.

Explore how to organize Java source and class files in Eclipse, create packages and directories, and configure the build path, output folders, and runtime classpath for projects.

Explore how the Java doc utility generates HTML documentation from Javadoc comments; write basic Javadoc tags like author, version, deprecated, and attach descriptions to classes, fields, constructors, and methods.

Learn best practices for documenting Java 7 classes and interfaces with JavaDoc-style double-star comments, including purpose, usage, and references, along with author, version, and date metadata.

Document fields in Java using Java doc tags to describe variables, including static fields and serializable classes; learn how to keep documentation up to date as programs evolve.

Explore how to document constructors and methods in Java using Javadoc, including implicit and explicit default constructors, parameter and return descriptions, and deprecation notes with @deprecated and @link annotations.

Explore how the enhanced for loop iterates arrays without a counter, why it cannot modify elements, and how to modify objects via string buffers to reverse characters.

Learn how Java automatically boxes primitive ints into Integer objects and unboxes them for methods and assignments, using the compiler to convert primitives to wrappers and intValue to retrieve primitives.

explains static imports in java, showing how static members can be referenced without qualification, with benefits and cautions, and demonstrates using static imports for constants like pi and max value.

Explore var args in Java, enabling a method to accept a number of parameters and to pass unlimited values; see int and string examples for sum, string appends, and average.

Explore typesafe enumerations in Java, seeing how an enum defines a full class with constants, fields, and methods, and how to iterate, access data, and use enum sets.

Explore formatted strings in Java by examining String.format and printf, understand format specifiers like %s and %d, and learn how flags, width, precision, and type ensure correct output.

Master Java's string format method to format integers, floats, strings, and dates in Java, using flags, width, and precision through practical examples.

Explore assertion syntax in Java to validate program logic with boolean expressions, preconditions, postconditions, and invariants. Learn how assertions throw errors when false, document assumptions, and avoid production performance costs.

Learn to compile with assertions in Java, test preconditions, post-conditions, and invariants with boolean expressions, and use the two forms of assert, enabled in Eclipse for debugging.

Enable and disable assertions in Java to test condition validity and observe assertion errors, which are unchecked, with Eclipse run configurations and VM arguments used to activate assertions.

Explore assertion usage in Java, including control flow invariants, preconditions, post-conditions, and class and internal invariants, to detect bugs and verify code in development and production.

Explore regular expressions in Java and learn to manipulate data with the java.util.regex package, covering pattern matching, metacharacters, character classes, quantifiers, capturing groups, and boundary matches.

Explore string literals in Java, use a pattern object and a matcher to search text, find matches with start and end indices, and handle case-insensitive matching using special characters.

Explore character classes in Java regular expressions, using square brackets to define sets, negation, ranges, unions, and intersections to match precise text patterns.

Explore quantifiers in Java regex with an interactive app that reads a regex and a string. See braces for exact counts and how quantifiers apply to a capturing group.

Capturing groups and back references in Java regular expressions, using parentheses for grouping and repetition operators. Reuse captured content with back references to find duplicate words and emails.

Explore boundary matchers in Java regex to locate matches at string beginnings, ends, or word boundaries, using anchors like ^ and $, with examples showing \b and \B boundaries.

Learn to use java.util.regex Pattern and Matcher to implement regular expressions, handle PatternSyntaxException, and compile with flags like case-insensitive for flexible matching using matches for quick checks.

Explore the Java collections framework, including arrays for sorting and searching, comparable and comparator interfaces, list interface, iterators, maps, and the Collections class for efficient operations.

Explore the Java arrays class to manipulate arrays across all data types, using methods for sorting, searching, and conversion to lists with Arrays.asList, plus copyOfRange and fill utilities.

Explore searching and sorting arrays of primitives in Java using the Arrays class, including full and selective sorts, binary search, and performance comparisons with linear search and hashing.

Explore the comparable and comparator interfaces in Java, defining natural ordering, implementing compareTo for ID-based sorting, and using a separate comparator to sort by name.

Explore lists and sets in Java, focusing on the List and Set interfaces, ArrayList, Vector, and LinkedList, and how sets remove duplicates using a hash set.

Explore how Java iterators traverse lists and sets, accessing elements without exposing collection implementations. Obtain iterators from common collections and practice hasNext/next with while or for loops.

Explore maps in Java, including hash map, weak hash map, tree map, and hash table, and learn how equals and hashCode govern key handling and duplicates.

Explore the Java collections class and its static methods, including sort, reverse, shuffle, copy, and fill, with examples converting an array to a list and using min, max, and addAll.

Develop rules of thumb for the Java collections framework by choosing set, list, or map implementations based on duplicates, key-value mappings, and synchronized versus non synchronized options.

Generics let the compiler enforce type constraints with parameters, preventing runtime cast errors. A list shows an integer cast to string; generics catch it at compile time, showing their power.

Explore simple generics in Java, including generic types and methods, type parameters, and compile-time type safety, with examples using lists and maps and the enhanced for loop.

Explore generics and subtyping in Java, including the substitution principle, type hierarchies, and parameterized types, with examples of lists of numbers and wildcards.

Explore wildcards in Java generics, where the question mark represents an unknown type and enables methods to accept lists. See how a print list handles integers and strings.

Explore bounded wildcards in Java generics, using extends for upper bounds and super for lower bounds, with lists of integers and doubles and a method illustrating usage and compiler effects.

Explore generic methods in Java and how a single declaration handles multiple types with compile time type safety. See type parameters, actual type arguments, and overloaded methods in action.

Master advanced I/O in Java by examining streams, file I/O, buffered I/O, arrays viewed as lists, console access, and object serialization, plus techniques for compression, property files, and user preferences.

Explore basic file I/O in Java using the classic and new I/O APIs, creating, writing, reading, and obtaining file properties with File, FileWriter, BufferedWriter, FileReader, and BufferedReader.

This lecture explains buffered io in Java by comparing default read/write with buffered streams and custom buffers, highlighting improved throughput for file input and output.

Explore the Java io console class, including readLine and readPassword, and formatted output with a writer, plus a wrapper demo that reads input and echoes it back.

Learn how to serialize a Java object to disk using the Serializable interface and object streams. Mark non-serializable fields as transient to exclude sensitive data like passwords.

Learn how to compress files into a zip file using zip entries and decompress them in Java using java.util.zip, with zip output streams and file input streams.

Write your own io classes in Java by creating a checked output stream that updates an Adler 32 checksum as data is written, and verify the computed checksum.

Explore Java properties files using the Properties object to set, store, and load key-value pairs via streams, keeping database configurations out of code.

Explore the Java preferences API for storing user and system settings, with keys for strings, numbers, booleans, and byte arrays, plus retrieval, defaults, and package-level subgroups to avoid conflicts.

Explore the enhanced I/O in Java SE 7, including channels for reading and writing files or connections, and typed buffers (byte to double) and direct buffers with off-heap memory.

Explore Java channels, contrast stream oriented IO with block oriented IO, and learn asynchronous read and write using buffers, paths, position, and truncate.

Explore buffers typed in the Java IO package, including byte buffers and typed views like int buffers, and learn how limit, position, and capacity govern data storage and access.

Learn how direct buffers allocate memory outside the Java heap and boost io performance in Java. See an example creating a byte buffer and converting it to an int buffer.

Explore the Java logging API to centralize messages, report errors, and provide program information while configuring logger levels, creating loggers, and directing logs with handlers.

Explore the Java logging API to centralize text, report errors, and provide debugging information using getLogger for a named subsystem and logger.info that outputs class name and method name.

Learn how to use the Java logging API to log messages at various levels—from severe to finest—directed to a central log with configurable formats, including exception logging via overloaded methods.

Explore logger handlers and formatters in java se 7, configuring console and file handlers, setting levels, and applying simple or SML formatters, including creating custom formatters.

Learn how the global log manager creates and configures loggers in Java, including setting a default console handler and root logger level, reading logging properties, and applying updates.