{@link ArrayList} is an implementation of {@link List} interface. This resizable data structure based on an array and is simplified version of {@link

A reflection-based test class for {@link ArrayList}. <p> PLEASE NOTE: we use Reflection API only for learning purposes. It should NOT be used for prod

{@link Box} is a container class that can store a value of any given type. Using Object as a field type is flexible, because we can store anything we

This demo demonstrates why using Object is not safe. It's not safe because runtime casting can cause runtime exceptions. We should always fail as soon

{@link CollectionRepository} defines a contract of a runtime store for entities based on any {@link Collection}. It has methods that allow to save new

{@link CollectionUtil} is an util class that provides various generic helper methods.

{@link ComparableCollection} is a {@link Collection} that can be compared by size. It extends a {@link Collection} interface and {@link Comparable} in

{@link Converter} interface declares a typical contract of a converter. It works with two independent generic types. It defines a convert method which

{@link CrazyGenerics} is an exercise class. It consists of classes, interfaces and methods that should be updated using generics. <p> TODO: go step by

A reflection-based test class for {@link CrazyGenerics}. <p> PLEASE NOTE: we use Reflection API only for learning purposes. It should NOT be used for

An example of crazy lambda that is hard but still important to understand

{@link CrazyLambdas} is an exercise class. Each method returns a functional interface and it should be implemented using either lambda or a method ref

A test class for {@link CrazyLambdas}. @author Taras Boychuk

{@link CrazyOptionals} is an exercise class. Each method represents some operation with a {@link Account} and should be implemented using Optional API

A test class for {@link CrazyOptionals}. @author Taras Boychuk

{@link CrazyRegex} is an exercise class. Each method returns Pattern class which should be created using regex expression. Every method that is not im

A test class for {@link CrazyRegex}. @author Andriy Paliychuk

{@link CrazyStreams} is an exercise class. Each method represent some operation with a collection of accounts that should be implemented using Stream

A test class for {@link CrazyStreams}. <p> Please note that the helper methods of this test class do not use Stream API intentionally. You should try

Welcome! This is an introduction exercise that will show you a simple example of Bobocode exercises. <p> JavaDoc is a way of communication with other

This is a {@link ExerciseIntroductionTest} that is meant to verify if you properly implement {@link ExerciseIntroduction}. It is a simple example that

This is a custom exception that we throw in every method which should be implemented as a part of the exercise. If you see that it was thrown it means

{@link FileReaders} provides an API that allow to read whole file into a {@link String} by file name.

{@link FileStats} provides an API that allow to get character statistic based on text file. All whitespace characters are ignored.

{@link FlightDao} represents a Data Access Object (DAO) for flights. The implementation is simplified, so it just uses {@link HashSet} to store flight

{@link FlightService} provides an API that allows to manage flight numbers <p> todo: 1. Using {@link com.bobocode.oop.data.FlightDao} implement method

{@link FlightServiceFactory} is used to create an instance of {@link FlightService} <p> todo: 1. Implement method {@link FlightServiceFactory#creteFli

One of functional programming techniques if a function composition. Having two different functions f(x) and g(x) in math you would write f(g(x)) to co

{@link FunctionMap} is an API that allows you to store and retrieve functions by string name. {@link FunctionMap} is stored in a {@link HashMap}, wher

An util class that provides a factory method for creating an instance of a {@link FunctionMap} filled with a list of functions. <p> TODO: implement a

{@link HashTable} is a simple Hashtable-based implementation of {@link Map} interface with some additional methods. It is based on the array of {@link

A Reflection-based step by step test for a {@link HashTable} class. PLEASE NOTE that Reflection API should not be used for testing a production code.

{@link HelloAnnotationsExercise} is an exercise class that is marked with be corresponding @{@link Exercise} annotation. The annotation value specifie

{@link HeterogeneousMaxHolder} is a multi-type container that holds maximum values per each type. It's kind of a key/value map, where the key is a typ

Method reference is a shorthand for lambda expression that could be use in some cases for better readability.

Enum that lists all possible exercise complexity levels.

{@link Limited} is a container class that allows storing an actual value along with possible min and max values. It is special form of triple. All thr

{@link LinkedList} is a list implementation that is based on singly linked generic nodes. A node is implemented as inner static class {@link Node<T>}.

{@link LinkedList} is a list implementation that is based on singly linked generic nodes. A node is implemented as inner static class {@link Node<T>}.

A reflection-based test class for {@link LinkedList}. <p> PLEASE NOTE: we use Reflection API only for learning purposes. It should NOT be used for pro

{@link LinkedQueue} implements FIFO {@link Queue}, using singly linked nodes. Nodes are stores in instances of nested class Node. In order to perform

A reflection-based test class for {@link LinkedQueue}. <p> PLEASE NOTE: we use Reflection API only for learning purposes. It should NOT be used for pr

{@link LinkedStack} is a stack implementation that is based on singly linked generic nodes. A node is implemented as inner static class {@link Node<T>

A reflection-based test class for {@link LinkedStack}. <p> PLEASE NOTE: we use Reflection API only for learning purposes. It should NOT be used for pr

{@link ListRepository} extends {@link CollectionRepository} but specifies the underlying collection as {@link java.util.List}. @param <T> – a type of

A {@link Map} is a simplified interface of so-called dictionary. It maps keys to values and provides an API for data access and manipulation. Please n

{@link MaxHolder} is a container class that keeps track of the maximum value only. It works with comparable objects and allows you to put new values.

A list of different examples of method reference usage.

A list of method reference examples.

Class {@link Node} is a very simple data structure that consists of an element itself and the reference to the next node. An element can have any valu

A class that consists of static methods only and provides util methods for {@link Node}. <p><p> <strong>TODO: to get the most out of your learning, <a

This examples demonstrates how to calculate the sum of prime numbers using Object-Oriented approach. Please note that in order to perform this calcula