In order to understand the flatMap() method, you first need to understand the map() function of Java 8. The map() function is declared in the java.util.stream.Stream class and uses to transform one Stream into another, for example, it can convert a stream of integer numbers into another stream of ints where each element is the square of the corresponding element in the source stream. In the map() operation, a function is applied to each element of the source Stream and return values are inserted into a new Stream which is returned to the caller. The key point to note here is that the function used by the map() operation returns a single value.
How to get and set Value of a text field using jQuery? Example Tutorial
Hello guys, In the last jQuery tutorial, you learn how to dynamically add a text file into a form, and in this tutorial, I will show you how to get and set the value of the text field using jQuery. This is a common task and there is a good chance that you have already done something similar in your project. Our requirement is simple, the text field initially contains the value "username" and as soon as the user clicks on it to enter a username, it should become clear. After the user has entered the username of the user id, he can click on the submit button, and then your program should print the username and text field again becomes clear.
23 Design Patterns Java Developers Should know
Recently I come across a nice Java design pattern cheatsheet which
1. Abstract Factory Design Pattern
Abstract Factory is a creational Design Pattern, which is used to control the creation of Objects.
2. Adapter design pattern
The Adapter is a structural design pattern; it is used to maintain the structure of classes in object-oriented programs like Java applications.
1. Abstract Factory Design Pattern
Abstract Factory is a creational Design Pattern, which is used to control the creation of Objects.
2. Adapter design pattern
The Adapter is a structural design pattern; it is used to maintain the structure of classes in object-oriented programs like Java applications.
The adapter pattern converts interface of a class into expected interface, allowing classes with incompatible interfaces to work together.
Adapters are useful for integrating existing components.
Java implementation creates a wrapper class, that is explicitly used in the code:
public interface Log {
void warning(String message);
void error(String message);
}
public final class Logger {
void log(Level level, String message) { /* ... */ }
}
public class LoggerToLogAdapter implements Log {
private final Logger logger;
public LoggerToLogAdapter(Logger logger) { this.logger = logger; }
public void warning(String message) {
logger.log(WARNING, message);
}
public void error(String message) {
logger.log(ERROR, message);
}
}
Log log = new LoggerToLogAdapter(new Logger());
In Scala, we have a built-in concept of interface adapters, expressed as implicit classes:
3. Bridge Design Pattern
The bridge is also a structural design pattern
4. Builder Design Pattern
The Builder is another creational design pattern in Java.
5. Chain of Responsibility Pattern
Chain of Responsibility is a behavioral pattern from Gang of Four. It avoids coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. You actually have a chain of receiving objects, starting from lower level to higher level, request move along the chain until an object handles it.
6. Command Design Pattern
The Command Pattern is also a behavioral design pattern and uses to control the behavior of an object or set of objects in a program. The command object is used to encapsulate a request, thus allows you to parameterize clients with different requests, queue, or log requests, and also support undo sort of functionality. As the name suggests, it is used to execute commands e.g., buttons on the remote control.
7. Composite Design Pattern
Composite pattern is another structural design pattern
8. Decorator Design Pattern
Decorator is also a structural pattern
9. Facade Design Pattern
The Facade is another structure design pattern for Java developers.
10. Factory Method Design Pattern
Like Abstract Factory, this is also a creational design pattern, provides a better way to create an instance of objects in Java or any other object-oriented programming language.
The factory method pattern provides an interface for creating an object that encapsulates the actual class instantiation in a method, and lets subclasses decide which class to instantiate.
Factory method allows to:
merge complex object creation code,
select which class to instantiate,
cache objects,
coordinate access to shared resources.
We will consider the static factory method, which is slightly different from the classical version of the pattern “ static factory method avoids sub-classing, so there's no option to override the method.
In Java, we use a new operator to instantiate a class, by invoking its constructor. To implement the pattern, we rely on ordinary methods. Also, because we can’t define static methods in interface, we have to use a separate factory class:
public interface Animal {}
private class Dog implements Animal {}
private class Cat implements Animal {}
public class AnimalFactory {
public static Animal createAnimal(String kind) {
if ("cat".equals(kind)) return new Cat();
if ("dog".equals(kind)) return new Dog();
throw new IllegalArgumentException();
}
}
AnimalFactory.createAnimal("dog");
11. Flyweight Design Pattern
It's a structural pattern
12. Interpreter Design Pattern
13. Iterator Design Pattern
14. Mediator Design Pattern
15. Memento Design Pattern
16. Prototype Design Pattern
17. Proxy Design Pattern
18. Observer Design Pattern
19. Singleton Design Pattern
20. State Design Pattern
21. Strategy Design Pattern
The Strategy Pattern defines a group of polymorphic (interchangeable) and encapsulated Algorithms in a Context. If the algorithm changes then the client that uses it is not affected. Strategy Pattern can be thought as a very simple form of State Pattern where Algorithms does not access or alter the encapsulated Algorithm of the Context.
What Problem strategy pattern solves
When to use Strategy pattern
The strategy pattern is useful for situations where it is necessary to dynamically swap the algorithms used in an application. The strategy pattern is intended to provide a means to define a family of algorithms, encapsulate each one as an object, and make them interchangeable. The strategy pattern lets the algorithms vary independently from clients that use them.
It is also an alternative of passing behaviors to methods in Java in pre Java 8 world. Now you have a better option in terms of lambda expression for passing a function as parameter. Before that you can use Strategy pattern to pass behavior. It's the nearest substitue for a function of pointer in Java.
To add to the already magnificient answers: The strategy pattern has a strong similarity to passing a function (or functions) to another function. In the strategy this is done by wrapping said function in an object followed by passing the object. Some languages can pass functions directly, so they don't need the pattern at all. But other languages can't pass functions, but can pass objects; the pattern then applies.
When we have a set of similar algorithms and its need to switch between them in different parts of the application. With Strategy Pattern is possible to avoid ifs and ease maintenance;
When we want to add new methods to superclass that don’t necessarily make sense to every subclass. Instead of using an interface in a traditional way, adding the new method, we use an instance variable that is a subclass of the new Functionality interface. This is known as Composition : Instead of inheriting an ability through inheritance the class is composed with Objects with the right ability;
1. Encoding
2. Decoding
3. Compression
4. Splitting
Advantages
Drawbacks
Problem
Chess is a two-player strategy board game played on a chessboard, a checkered gameboard with 64 squares arranged in an eight-by-eight grid.
Each player begins the game with 16 pieces: one king, one queen, two rooks, two knights, two bishops, and eight pawns. Each of the six piece types moves differently.
Each chess piece has its own style of moving. In the diagrams
The king moves one square in any direction. The king has also a special move which is called castling and involves also moving a rook.
The rook can move any number of squares along any rank or file, but may not leap over other pieces. Along with the king, the rook is involved during the king's castling move.
The bishop can move any number of squares diagonally, but may not leap over other pieces.
The queen combines the power of the rook and bishop and can move any number of squares along rank, file, or diagonal, but it may not leap over other pieces.
The knight moves to any of the closest squares that are not on the same rank, file, or diagonal, thus the move forms an "L"-shape: two squares vertically and one square horizontally, or two squares horizontally and one square vertically. The knight is the only piece that can leap over other pieces.
Chess is played on a square board of eight rows (called ranks and denoted with numbers 1 to 8) and eight columns (called files and denoted with letters a to h) of squares
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* Problem with switch statement and solution using strategy pattern.
*
* @author
*/
public class Testing {
public static void main(String args[]) {
ChessPiece night = new ChessPiece("Night", ChessPiece.PieceType.NIGHT);
ChessPiece rook = new ChessPiece("Rook", ChessPiece.PieceType.ROOK);
ChessPiece bishop = new ChessPiece("Bishop", ChessPiece.PieceType.BISHOP);
ChessPiece pawn = new ChessPiece("Pawn", ChessPiece.PieceType.PAWN);
List<ChessPiece> pieces = new ArrayList<>();
pieces.add(night);
pieces.add(rook);
pieces.add(bishop);
pieces.add(pawn);
for (ChessPiece p : pieces) {
p.movePiece();
}
}
}
class ChessPiece {
private String name;
public enum PieceType {
PAWN, NIGHT, ROOK, BISHOP, QUEEN, KING;
}
private PieceType type;
public ChessPiece(String name, PieceType type) {
this.name = name;
this.type = type;
}
public void movePiece() {
System.out.print(name + ", ");
switch (type) {
case ROOK:
System.out.println("Moving horizontally");
break;
case BISHOP:
System.out.println("Moving diagonally");
break;
case NIGHT:
System.out.println("Moving two and half square");
break;
case PAWN:
System.out.println("Moving vertically");
break;
}
}
public String name() {
return name;
}
}
Output:
Night, Moving two and half square
Rook, Moving horizontally
Bishop, Moving diagonally
Pawn, Moving vertically
Example
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
*
*
* @author
*/
public class Testing {
public static void main(String args[]) {
ChessPiece night = new ChessPiece("Night", new NightMove());
ChessPiece rook = new ChessPiece("Rook", new RankMove());
ChessPiece bishop = new ChessPiece("Bishop", new DiagonalMove());
ChessPiece pawn = new ChessPiece("Pawn", new FileMove());
List<ChessPiece> pieces = new ArrayList<>();
pieces.add(night);
pieces.add(rook);
pieces.add(bishop);
pieces.add(pawn);
for (ChessPiece p : pieces) {
p.movePiece();
}
}
}
interface MoveStrategy {
public void move();
}
class DiagonalMove implements MoveStrategy {
@Override
public void move() {
System.out.println("Moving diagonally");
}
}
class FileMove implements MoveStrategy {
@Override
public void move() {
System.out.println("Moving horinzontally");
}
}
class RankMove implements MoveStrategy {
@Override
public void move() {
System.out.println("Moving vertically");
}
}
class NightMove implements MoveStrategy {
@Override
public void move() {
System.out.println("Moving two and half squares");
}
}
class ChessPiece {
private String name;
private MoveStrategy moveStrategy;
public ChessPiece(String name, MoveStrategy strategy) {
this.name = name;
this.moveStrategy = strategy;
}
public void movePiece() {
System.out.print(name + ", ");
moveStrategy.move();
}
public String name() {
return name;
}
}
Output :
Night, Moving two and half squares
Rook, Moving vertically
Bishop, Moving diagonally
Pawn, Moving horinzontally
Examples from JDK
Collections.sort() and Comparable method.
Important points
22. Template Method Design Pattern
23. Visitor Design Pattern
And here is the big diagram which shows the relationship among different object-oriented design patterns:
That's all on this list of object-oriented design Patterns, Java developers should know. In fact, this list of patterns is equally useful for any object-oriented programmer working on object-oriented languages like C++, Scala, or any other language.
These are also known as Gang Of Four (GOF) design pattern because it was first published in the GOF design pattern book. Just keep one thing in mind, design patterns are tried and tested solutions to some particular problem, but it doesn't mean you always need them.
In fact, if you are familiar with these patterns and know their intent and when to use them, you will automatically alert by your mind about places where you can use these patterns.
I always keep these patterns back of my mind, and while coding, I somehow know that, Ok, this is the place where I should use this pattern. I never use them pre-planned; in fact, they came at random while doing coding, testing, refactoring, and code review.
3 ways to sort a List in Java 8 and 11 - Example Tutorial
There are multiple ways to sort a list in Java 8, for example, you can get a stream from the List and then use the sorted() method of Stream class to sort a list like ArrayList, LinkedList, or Vector and then convert back it to List. Alternatively, you can use the Collections.sort() method to sort the list. There is also a sort() method added to the List class itself. The Collections.sort() method is an older one and it's available from JDK 1.0 itself but List.sort() is a new method added in Java 8. This method accepts a Comparator if you want to sort a List in a custom order, otherwise, you can pass null if you want to sort a List on the natural order of their elements.
How to use Spread operator and Rest parameter in JavaScript? Example Tutorial
Hello guys, if you are wondering what is Spread and Rest operator is in JavaScript are and how to use them in code then you have come to the right place. Earlier, I have shared some fundamental JavaScript concept tutorials like == vs === operator, hoisting, and destructuring, and in this JavaScirpt article, I am going to talk about Spread and Rest operators. JavaScript came out twenty-five years ago. Since then, it has changed a lot. First, it became the top programming language for client-side web development, and then with the emergence of Node.js, it also became the top player in server-side development.
What is Variable and Function Hoisting in JavaScript? Example Tutorial
Hoisting is a complex concept in JavaScript. Like other major programming languages, variables and functions are an important part of JavaScript. Being a dynamically typed programming language, the variable declaration does not require specifying variable types. JavaScript also supports functions. But there is a catch. When variables and functions are declared in JavaScript, a process called hoisting takes place, and if you don't know this important concept you may struggle reading and understanding code but don't worry. In this article, I will teach you what is hoisting in JavaScript and give you real-world examples of the function and variable hoisting to start with.
What is Destructuring in JavaScript? Example Tutorial
Arrays and objects play a very important role in programming. Every major programming language supports arrays and objects. Both arrays and objects are used to store data. The concept is simple but very powerful. JavaScript also supports arrays and objects. In fact, they are a very important part of modern JavaScript development. It does not matter if you are working on the frontend or backend, you are going to use arrays and objects. Over time, more and more features were added in JavaScript to make it easy to work with arrays and objects.
Difference between first level and second level cache in Hibernate
The main difference between the first level and second level cache in Hibernate is that the first level is maintained at the Session level and accessible only to the Session, while the second level cache is maintained at the SessionFactory level and available to all Sessions. This means, you can use the first-level cache to store local data, i.e. the data which is needed by the Session, and you can use the second-level cache to store global data, i.e. something which can be shared across sessions. This is also one of the frequently asked Hibernate Interview questions and accessible in both telephonic rounds as well as on the face-to-face interviews, in both fresher and experienced level interviews.
Difference between IN, OUT, and INOUT parameters in JDBC Stored Procedure? Answer
Hello guys, Java Database Connectivity, the JDBC API supports three types of parameters, I mean, IN, OUT, and INOUT. They are used to bind values into SQL statements. An IN parameter is the one whose value is unknown when the SQL statement is created and you bind values using various setXXX() method depending upon the type of column those IN parameter refers in SQL query. For example in SQL query, SELECT * from EMPLOYEE where EMP_ID=? if the EMP_ID is a VARCHAR column then you must call the setString() method to pass the value to the IN parameter.
How to create a custom tag in JSP? Steps and Example
You can create a custom tag in JSP either by implementing the SimpleTag interface or extending SimpleTagSupport class. Custom tags are introduced in JSP 2.0 in an effort to minimize Java code from JSP to keep them maintainable and allow page authors to work more in HTML or XML, like environment than writing Java codes. SimpleTag and SimpleTagSupport allow you to create a custom tag in JSP. It's easier to start with SimpleTagSupport class because it implements all methods of the SimpleTagSupport interface and if you are writing a basic tag then you just need to override the doTag() method of this class.
How to manager HTTP Session in JSP Servlet?
Since HTTP is a stateless protocol its not possible to identify that two separate HTTP request is coming from same client and HTTP session management handle that issue for us. By maintaining a session for each client at the Server side, we can serve the client better, for example, you can store authentication and authorization information in session to prevent authenticating client for each HTTP request like in an online banking system, a session is created when a user is successful authenticated and session is maintained at server untile clients logout or session times out. If you have to write such online banking system using Java and Java EE technologies like Servlet and JSP then main question arises is how to do session management in JSP?
There are mainly three ways to manage session in JSP applications 1) using hidden html fields 2) using Cookie and 3) using URL rewriting. In Cookie small piece of information is stored in client machine but User can turn off this option and may be there is case of browser not supporting cookies, on all those cases URL rewriting is the best option to manage session in JSP Servlet application. JSTL core tag library provides tag which can encode URL for managing session.
How to use lifecycle methods in functional components in React.js? useEffect() hook Example Tutorial
Hello guys, if you have been following my blogs then you know that I have launched a new series - React for Java developers and this is the 4th article on the series. Earlier, we have seen state management in React, Redux, and useState hooks example, and in this article, you will learn about how to use lifecycle methods in functional React components. Lifecycle methods are powerful features provided by React.js in the class-based components. Each of the lifecycle methods executes at a particular time during the lifecycle of a component.
What is Redux Thunk in React.js? Example tutorial
Hello folks, This is the 3 part of my React for Java developer series and in the past two articles we have been focusing on statement management in React and we have seen that how to use manage state using Redux and useState hooks. And, in this article, we will learn about Redux Thunk, another useful concept when it comes to statement in React.js. State management is one of the most important concepts in react. If you are a react developer, then you must have used state in your project. There is no react project without a state. The state is defined as an instance of a component. It is an object that controls the behavior of a component.
How to use JSTL tag libray in JSP pages?
JSTL stands for JavaServer pages Standard tag library, which was created to help JSP developer with common tasks e.g. iterating over Collection in JSP, printing values, encoding URLs etc. In order to use JSTL tags in JSP page you need to do things, first you need to add standard.jar and jstl.jar in your Web application's classpath. This you can do by putting these two jar files into WEB-INF/lib directory. Once you do this you need to import the JSTL tag library in your JSP page to use JSTL tags like out, foreach, or forTokens etc.
Can you Overload or Override main method in Java? Example
One of the common doubts among Java beginners while learning the overloading and overriding concept is, whether it's possible to overload the main in Java? Can you override the main method in Java? How will JVM find if you change the signature of the main method as part of the method overloading? etc. These are good questions and show the curiosity and application of knowledge of students, so if you are the tutor you must answer these questions. If you don't know the answer to this question, don't worry, just read this article till the end and you will find the answer yourself. I have tried to explain in simple words but if you still can't get it, feel free to comment and I will try to help you personally.
4 Examples of Stream.collect() method in Java 8
Hello guys, you may know that Java 8 brought Stream API which supports a lot of functional programming operations like filter, map, flatMap, reduce, and collect. In this article, you will learn about the collect() method. The collect() method of Stream class can be used to accumulate elements of any Stream into a Collection. In Java 8, you will often write code that converts a Collection like a List or Set to Stream and then applies some logic using functional programming methods like the filter, map, flatMap and then converts the result back to the Collection like a List, Set, Map, or ConcurrentMap in Java.
Difference between List and ArrayList Reference Variables in Java? Example Tutorial
Someone who is just starting with Java programming language often has doubts about how we are storing an ArrayList object in List variable, what is the difference between List and ArrayList? Or why not just save the ArrayList object in the ArrayList variable just like we do for String, int, and other data types. Well, the main difference between List and ArrayList is that List is an interface while ArrayList is a class. Most importantly, it implements the List interface, which also means that ArrayList is a subtype of the List interface. In Java or any object-oriented language, the supertype of a variable can store an object of subtype.
How to Increasing Heap Size of Java application in JVM? Example Tutorial
Hello guys, if you are wondering how to change the heap size of the heap space of your Java application then you have come to the right place. In this article, I am going to tell you how to increase Java heap space so that your JVM will not crash using OutOfmemoryError. We have already seen how to increase heap memory in Maven and ANT and now we will learn how to increase heap size in Java, Eclipse, Tomcat, and WebSphere Server in a series of articles. Since all these are Java applications, once you know how to change heap space in Java, you can do that in any Java application, provided you know the right place, which is what we will see in this article.
How to access JSTL variable in Scriptlet?
You can access the JSTL variable inside the scriptlet by calling the getAttribute() method on pageContext, request, response, or session objects, depending upon which scope your JSTL variable was created. For example, if your JSTL variable is created on request scope, you can call request.getAttribute("count") to get value of a variable named count. A JSTL variable is a variable that is created using a set tag and belongs to a particular scope, by default they are created in page scope.
The Ultimate Guide of Remote Debugging in Java using Eclipse IDE? Example Tutorial
The remote debugging of the Java program is an ultimate tool in the arsenal of a Java developer, which is often becoming the last and only tool to investigate a bug on a Java application running on the remote host like on a Linux server or Windows server. Almost all major Java IDE provides remote debugging like NetBeans, Eclipse, and IntelliJ IDEA, but I mostly use Eclipse for Java coding and so it's my preferred tool to remote debug a Java program. In order to set up remote debugging in Eclipse, you need to do a couple of tasks like you need to start your JVM with debugging parameters or arguments and then you need to create a "remote debug configuration" in Eclipse IDE itself.
Subscribe to:
Posts (Atom)