Generics are a facility of generic programming that extend Java’s type system to allow a type or method to operate on objects of various types while providing compile-time type safety. In particular, the Java collections framework supports generics to specify the type of objects stored in a collection instance. Related Article: Visibility (controlling access to … Read more
Private Visibility private visibility allows a variable to only be accessed by its class. They are often used in conjunction with public getters and setters. class SomeClass { private int variable; public int getVariable() { return variable; } public void setVariable(int variable) { this.variable = variable; } } public class SomeOtherClass { public static void … Read more
An object is considered immutable if its state cannot change after it is constructed. Maximum reliance on immutable objects is widely accepted as a sound strategy for creating simple, reliable code Creating an immutable version of a type using defensive copying Some basic types and classes in Java are fundamentally mutable. For example, all array types are mutable, and so are … Read more
Immutable objects are instances whose state doesn’t change after it has been initialized. For example, String is an immutable class, and once instantiated its value never changes. Example without mutable refs public final class Color { final private int red; final private int green; final private int blue; private void check(int red, int green, int … Read more
This article is an intro to Java source-level annotation processor and provides examples of using this technique for generating additional source files during compilation. This example demonstrates how to do compile time checking of an annotated element. The annotation The @Setter annotation is a marker can be applied to methods. The annotation will be discarded during compilation … Read more
In Java, an annotation is a form of syntactic metadata that can be added to Java source code. It provides data about a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate. Classes, methods, variables, parameters and packages are allowed to be … Read more
The Java language provides three operator for performing bitwise shifting on 32 and 64 bit integer values. These are all binary operators with the first operand being the value to be shifted, and the second operand saying how far to shift. The << or left shift operator shifts the value given by the first operand … Read more
This documentation page is for showing details with example about java class constructors and about Object Class Methods which are automatically inherited from the superclass Object of any newly created class. hashCode() method When a Java class overrides the equals method, it should override the hashCode method as well. As defined in the method’s contract: … Read more
While not required, constructors in Java are methods recognized by the compiler to instantiate specific values for the class which may be essential to the role of the object. This topic demonstrates proper usage of Java class constructors. Default Constructor The “default” for constructors is that they do not have any arguments. In case you … Read more
Operators in Java programming language are special symbols that perform specific operations on one, two, or three operands, and then return a result. The Increment/Decrement Operators (++/–) Variables can be incremented or decremented by 1 using the ++ and — operators, respectively. When the ++ and — operators follow variables, they are called post-increment and … Read more
Maps provide methods which let you access the keys, values, or key-value pairs of the map as collections. Iterating through the contents of a Map. You can iterate through these collections. Given the following map for example: Map repMap = new HashMap<>();repMap.put(“Jon Skeet”, 927_654);repMap.put(“BalusC”, 708_826);repMap.put(“Darin Dimitrov”, 715_567); Iterating through map keys: for (String key : … Read more
The java.util.Map interface represents a mapping between keys and their values. A maps cannot contain duplicate keys; and each key can maps to at most one value. Since Maps is an interface, then you need to instantiate a concrete implementation of that interface in order to use it; there are several Maps implementations, and mostly … Read more
The list unmodifiable method is used to returns an unmodifiable view of the specified list. The Collections class provides a way to make a list unmodifiable: List ls = new ArrayList();List unmodifiableList = Collections.unmodifiableList(ls); If you want an unmodifiable list with one item you can use: List unmodifiableList = Collections.singletonList(“Only string in the list”); Moving objects around … Read more
A list is an ordered collection of values. In Java, lists are part of the Java Collections Framework. Lists implement the java.util.List interface, which extends java.util.Collection. Sorting a generic list The Collections class offers two standard static methods to sort a list: sort(List list) applicable to lists where T extends Comparable, and sort(List list, Comparator … Read more
Sometimes it is appropriate to use an immutable empty collection. There are several ways to create immutable empty List in Java. The Immutable Empty Collections class provides methods to get such collections in an efficient way: List anEmptyList = Collections.emptyList(); Map anEmptyMap = Collections.emptyMap(); Set anEmptySet = Collections.emptySet(); These methods are generic and will automatically … Read more
The collections framework in java.util provides a number of generic classes for sets of data with functionality that can’t be provided by regular arrays. Collections framework contains interfaces for Collection, with main sub-interfaces List and Set, and mapping collection Map. Collections are the root interface and are being implemented by many other collection frameworks. Removing … Read more
Java Arrays are used to store multiple values in a single variable, instead of declaring separate variables for each value. To declare an array, define the variable type with square brackets: String[] cars; We have now declared a variable that holds an java array of strings. Arrays are objects which provide space to store up to its size of … Read more
Object arrays are covariant, which means that just as Integer is a subclass of Number, Integer[] is a subclass of Number[]. This may seem intuitive, but can result in surprising behavior: Integer[] integerArray = {1, 2, 3}; Number[] numberArray = integerArray; // valid Number firstElement = numberArray[0]; // valid numberArray[0] = 4L; // throws ArrayStoreException … Read more
Creating a List from an Array The Arrays.asList() method can be used to return a fixed-size list containing the elements of the given array.. The resulting List will be of the same parameter type as the base type of the array. String[] stringArray = {“foo”, “bar”, “baz”};List stringList = Arrays.asList(stringArray); Note: This list is backed … Read more
In an enum it is possible to define a specific behavior for a particular constant of the enum which overrides the default behavior of the enum, this technique is known as constant specific body. Suppose three piano students – John, Ben and Luke – are defined in an enum named PianoClass, as follows: enum PianoClass … Read more