Java Data Types

Data Types

• Variables: reserved memory locations for storing values and creating variables reserves memory space.
• The two data types include: Primitive and Reference/Object

Primitive Data Types

• These data types are predefined by the language.
• Basic data types in Java, named by a keyword.

Reference/Object Data Types

• These data types are created using defined constructors of the classes and are used to access objects.
• Variables are declared of a specific type that cannot be changed.
• Example: Employee, Puppy etc.
• Default value of any reference variable is null.

Java Literals

• This is a source code representation of a fixed value.
• These are represented directly in the code without any computation.

Streams

• A stream is a sequence of objects that supports methods which can be pipelined to produce the desired result.

Conditional Statements

• Conditional statements support decisions based on a condition, where "true" executes a piece of code.

The If-Then Statement

• The most basic flow control statement in Java is if-then: if [something] is true, do [something].
• This make decisions simple.

Nested-if Statement

• Nested-if is an if statement that is the target of another if or else.
• Nested-if statements mean an if statement inside an if statement.

Switch-case Statement

• The switch statement is a multiway branch statement and provides an easy way to dispatch execution to different parts of code based on the value of the expression.

Loops in Java

• Looping facilitates the repeated execution of instructions/functions while a condition is true.
• While loop: A control flow statement that executes code repeatedly based on a Boolean condition, repeating a statement.
• For loop: A concise way of writing a loop structure that consumes initialization, condition, and increment/decrement in one line, providing a shorter, easy to debug structure.
• Do while loop: It is similar to a while loop, but checks the condition after executing the statements, making it an Exit Control Loop.

Arrays in Java

• An array is a group of like-typed variables referred to by a common name.

Enum Type

• This type enables the variable to be a set of predefined constants.
• The variable must equal to one of the predefined values.

BitSet

• The class is defined in the java.util package.
• It creates an array of bits represented by boolean values.
• The array's size is flexible and can grow as needed.

Vector

• This is a dynamic array that can grow or shrink in size.
• Any number of elements can be stored as there is no size limit.

Stacks

• Stacks are a Last In First Out (LIFO) data structure with push and pop operations.
• Push adds an element to the top, pop removes it.

Dictionary

• The Java dictionary is an abstract class that stores key-value pairs, allowing storage and retrieval by key, and is a list of key-value pairs.

Hash Tables

• Hash tables are a type of data structure in which address/index values of the data element are generated from a hash function.

Hash Properties

• Properties is a subclass of Hashtable.
• Used to maintain lists of values where the key and value are Strings.

Collections

• Java collections are a collection of individual objects that are represented as a single unit.
• Collections are objects that hold references to other objects.
• Collection interfaces declare the operations possible on each collection type.
• Classes and interfaces of collections frameworks are in the java.util package.

Java Collection Framework

• It offers the capability to Java Collection to represent a group of elements in classes and Interfaces
• An architecture for storing and manipulating groups of objects exists, including interfaces, classes, and algorithms.
• This includes interfaces, classes and algorithms.

Java Collection Framework Goals

• High-performance
• Interoperability between different collection types
• Easy extension and adaptation

Java Collection Framework Design

• It is designed around a set of standard interfaces.
• Standard implementations are provided such as LinkedList, HashSet, and TreeSet.

Linked List in Java Collection Framework

• A part of the Collection framework in the java.util package.
• This implements the LinkedList data structure.
• Linear data structure with non-contiguous elements.
• Elements are separate objects that have data and address parts.
• Elements linked using pointers and addresses (nodes).
• Dynamic and easy for insertions/deletions.
• Nodes cannot be accessed directly.

Types of Linked Lists

• Singly Linked List
• Doubly Linked List
• Circular Linked List

Singly Linked List

• It's a collection of nodes linked sequentially.
• Each node: data field and address field (reference to the next node).
• A node has a data part and a next part (link).

Doubly Linked List

• Each node: pointer to the previous node.
• Allows forward and backward traversal.
• Each node: data and two links (previous and next).
• The first node's previous link and the last node's next link are NULL.

Circular Linked List

• The last element is linked to the first element, forming a loop: variation of Linked List.
• Both Singly and Doubly Linked lists can be circular.

Hash Set

• Implements the Set interface, backed by a hash table (HashMap).
• There is no guarantee on the iteration order
• It permits the null element.
• It provides constant-time performance for basic operations
• Features include implementing the Set Interface, uses Hashtable as the underlying data structure, no duplicate values, objects not guaranteed to be inserted in the same order (based on hash code), and NULL elements allowed.
• It has the ability to store elements using hashing.
• Contains unique elements only and allows a single null value.
• It is non-synchronized.
• Doesn't maintain the insertion order.
• Best approach for search operations.
• The initial default capacity is 16, and the load factor is 0.75.

Tree Set

• Implementation of the SortedSet interface that uses a Tree for storage.
• Ordering maintained by natural ordering or an explicit comparator.
• This is a Non-linear data structure where data objects are organized hierarchically.
• Tree data structure is usefull when linear representation does not work.
• A Tree is a recursive data structure.
• Nodes maintain parent-child or sister relationships.
• A node can have any number of children nodes, but only one parent.

Collection Interface

• Collection Interface enables working with groups of objects and is the top of the collections hierarchy.

List Interface

• The List Interface extends a Collection and stores an ordered collection of elements.

Set Interface

• Set Interface extends Collection and handles sets (unique elements).

SortedSet Interface

• SortedSet Interface extends Set and handles sorted sets.

Map Interface

• The Map Interface maps unique keys to values.

Map.Entry Interface

• The Map.Entry Interface describes a key/value pair in a map, and is an inner class of Map.

SortedMap Interface

• The SortedMap Interface extends Map and maintains keys in ascending order.

Enumeration Interface

• Legacy interface for obtaining elements one at a time, superceded by Iterator.

Collection Interface Implementation

• Root interface of the Java collections framework, no direct implementation, implemented through subinterfaces (List, Set, Queue).
• ArrayList implements List.

Subinterfaces of Collection

• List: Ordered collection.
• Set: Stores elements in sets (no duplicates).
• Queue: FIFO access.

Collection Classes

• Standard collection classes implement Collection interfaces and exist in abstract and full implementation forms.

Adding Elements in Collection

• AddAll(): Adds specified elements to a collection.

Sorting a Collection

• Collections.sort(): Sorts elements in ascending order.
• Collections.reverseOrder(): Sorts in descending order.

Searching in a Collection

• Collections.binarySearch(): Returns the position of an object in a sorted list.

Copying Elements in Collection

• copy(): Copies elements from one list to another.

Disjoint Collection

• Collections.disjoint(): Checks if two collections have no common elements.

Collection Algorithm

• The collection algorithm includes algorithms applied to collections and maps.
• Defined as static methods in the Collections class.
• The algorithm can throw ClassCastException or UnsupportedOperationException.
• The algorithm defines EMPTY_SET, EMPTY_LIST and EMPTY_MAP (immutable).

JavaFX

• JavaFX is a set of packages for Java programmers to create rich graphics and media applications like GUI interfaces, 2D/3D games, animations, visual effects, touch-enabled applications, and multimedia applications.
• "Look and feel" is defined as the mechanism needed to interact with an app.

Java API

• The Java API has 3 APIs for the developer (Application Programming Interface): AWT (Abstract Windowing Toolkit), Swing, and JavaFX.

JavaFX Features

• Scene Builder integration is a major advantage of using JavaFX over other APIs.
• JavaFX Scene Builder is a tool for GUI development without coding, providing a blank area to drag and drop JavaFX components.

JavaFX Structure Application

• A JavaFX application is divided hierarchically into three main components known as Stage, Scene, and nodes.
• javafx.application.Application class must be imported in every JavaFX application as this provides the lifecycle methods.
• Stage in a JavaFX application is similar to the Frame in a Swing Application, acting as a container for all JavaFX objects, and the primary Stage is created internally by the platform.
• A node may be any object of the user's interface like text area, buttons, shapes, media, etc.
• Scene actually holds all the physical contents (nodes) of a JavaFX application.
• The Javafx.scene.Scene class provides all the methods to deal with a scene object, and creating scene is necessary in order to visualize the contents on the stage.

JavaFX Architecture

• The JavaFX is a set of Java libraries designed to enable developers to create and deploy rich client applications that behave consistently across platforms.

NetBeans

• an open-source, free IDE (Integrated Development Environment) using a modular architecture of modules (groups of classes and libraries) to implement specific features into an application.
• A very popular Java IDE.