LinkedList and Index

1. They have a logical index, yes - effectively the number of times you need to iterate, starting from the head, before getting to that node.
2. it can't directly search using index of the object
3. Typically O(1) access by index is performed by using an array lookup, and in the case of a linked list there isn't an array - there's just a chain of nodes. To access a node with index N, you need to start at the head and walk along the chain N times... which is an O(N) operation.
4. import java.util.LinkedList; import java.util.List; import java.util.function.Supplier; import java.util.stream.Collectors; import java.util.stream.IntStream; public class LnkedListNthh { public static void main(String[] args) { LnkedListNthh app = new LnkedListNthh(); LinkedList list = app.createList(); app.nthElement(list, 2); app.SecondLastElement(list); } private void nthElement(LinkedList list, Integer n) { list.get(n); System.out.println(n + "th Element is " + list.get(n)); } private void SecondLastElement(LinkedList list) { System.out.println("SecondLastElement = " + list.get(list.size() - 1)); } private LinkedList createList() { LinkedList list = new LinkedList(); Supplier> supplier = () -> new LinkedList(); return (LinkedList) IntStream.range(2, 102).boxed().collect(Collectors.toCollection(supplier)); } }

Continue Reading

Java 8 New

1. Function Interface
1.  Java.util.function has special interface like bleow, it contains generic methods used as type for lambda expression with same type and signature.
2. An interface with exactly one abstract method is called Functional Interface.
3. @FunctionalInterface annotation is added so that we can mark an interface as functional interface.
4.  If  we try to have more than one abstract method, it throws compiler error.
5. The major benefit of java 8 functional interfaces is that we can use lambda expressions to instantiate them and avoid using bulky anonymous class implementation.
6. Java 8 has defined a lot of functional interfaces in java.util.function package. Some of the useful java 8 functional interfaces are Runnable, Consumer, Supplier, Function and Predicate
1. Custom
1. @FunctionalInterface public interface Square { public int calculate(int number); } // Custom Square sq = (i) -> (i * i); int result = sq.calculate(2); System.out.println(result);
2. Runnable
1. Thread t = new Thread(() -> { System.out.println("Thread Running"); }); t.start();
3. Predecate Interface
1. The Functional Interface PREDICATE is defined in the java.util.Function package.It improves manageability of code, helps in unit-testing them separately, and contain some methods like:
1. isEqual(Object targetRef) : Returns a predicate that tests if two arguments are equal according to Objects.equals(Object, Object).
2. and(Predicate other) : Returns a composed predicate that represents a short-circuiting logical AND of this predicate and another.
3. negate() : Returns a predicate that represents the logical negation of this predicate.
4. or(Predicate other) : Returns a composed predicate that represents a short-circuiting logical OR of this predicate and another.
5. test(T t) : Evaluates this predicate on the given argument.boolean test(T t)
2. // Simple Predicate Predicate lesserThan = (i) -> (i > 10); System.out.println(lesserThan.test(11)); // Predicate Chaining Predicate lessThan = (i) -> (i < 10); Predicate greaterThan = (i) -> (i > 5); boolean result = lesserThan.and(greaterThan).test(6); System.out.println(result); // negation boolean result2 = lesserThan.and(greaterThan).negate().test(6); System.out.println(result2); Predicate equals = (i) -> (i == 2); boolean result3 = equals.test(2); System.out.println(result3);
2. Static methods and Default methods
1. Default methods
1. Java 8 interface changes include static methods and default methods in interfaces. Prior to Java 8, we could have only method declarations in the interfaces. But from Java 8, we can have default methods and static methods in the interfaces.
2. For creating a default method in java interface, we need to use “default” keyword with the method signature. For example,
3. public interface Interface2 { void method2(); default void log(String str){ System.out.println("I2 logging::"+str); } }
2. Static methods 
1. Java interface static method is similar to default method except that we can’t override them in the implementation classes.
2. public interface MyData { default void print(String str) { if (!isNull(str)) System.out.println("MyData Print::" + str); } static boolean isNull(String str) { System.out.println("Interface Null Check"); return str == null ? true : "".equals(str) ? true : false; } }
3. Java interface static methods are good for providing utility methods, for example null check, collection sorting etc.
3. Abstract Class Needs
1. Abstract class can define constructor. They are more structured and can have a state associated with them. 
2. The constraint on the default method is that it can be implemented only in the terms of calls to other interface methods, with no reference to a particular implementation's state. So the main use case is higher-level and convenience methods.

Continue Reading

Angular 6 CRUD Application

1. Angular CLI Useful Commands
1. ng g component my-new-component
2. ng g directive my-new-directive
3. ng g pipe my-new-pipe
4. ng g service my-new-service
5. ng g class my-new-class
6. ng g guard my-new-guard
7. ng g interface my-new-interface
8. ng g enum my-new-enum
9. ng g module my-module
2. Create components. Template, component and js file will be generated with this and Module will be added to @ngModule decorations decalarion part of app.module.ts.
1. ng g component login ng g component add-user ng g component edit-user ng g component list-user
2. app.module.ts
3. import { NgModule } from '@angular/core'; import { Routes, RouterModule } from '@angular/router'; import { LoginComponent } from "./login/login.component"; import { AddUserComponent } from "./add-user/add-user.component"; import { EditUserComponent } from "./edit-user/edit-user.component"; import { ListUserComponent } from "./list-user/list-user.component"; const routes: Routes = [ { path: 'login', component: LoginComponent }, { path: 'add-user', component: AddUserComponent }, { path: 'edit-user', component: EditUserComponent }, { path: 'list-user', component: ListUserComponent }, { path: '', component: LoginComponent } ]; @NgModule({ imports: [RouterModule.forRoot(routes)], exports: [RouterModule] }) export class AppRoutingModule { }
4. Following is our routing configurtion.We have configured to use LoginComponent as a default component.Also, do not forget to include it in the main module - app.module.ts
5. app.routing.ts
6. import { NgModule } from '@angular/core'; import { Routes, RouterModule } from '@angular/router'; import { LoginComponent } from "./login/login.component"; import { AddUserComponent } from "./add-user/add-user.component"; import { EditUserComponent } from "./edit-user/edit-user.component"; import { ListUserComponent } from "./list-user/list-user.component"; const routes: Routes = [ { path: 'login', component: LoginComponent }, { path: 'add-user', component: AddUserComponent }, { path: 'edit-user', component: EditUserComponent }, { path: 'list-user', component: ListUserComponent }, { path: '', component: LoginComponent } ]; @NgModule({ imports: [RouterModule.forRoot(routes)], exports: [RouterModule] }) export class AppRoutingModule { }
3. Create model user.model.ts
1. ng g class model/User
2.  user.model.ts
3. export class User { id: number; firstName: string; lastName: string; email: string; }
4. Create Service service/user.service.ts
1. ng g service service/UserService
2. We can make web api call using HttpClent package in service class by the use of model User
3. user.service.ts 
4. import { Injectable } from '@angular/core'; import { HttpClient } from '@angular/common/http'; import { User } from '../model/user'; @Injectable({ providedIn: 'root' }) export class UserServiceService { constructor(private http: HttpClient) { } baseUrl: string = 'http://localhost:8080/user-portal/users'; getUsers() { return this.http.get(this.baseUrl); } getUserById(id: number) { return this.http.get(this.baseUrl + '/' + id); } createUser(user: User) { return this.http.post(this.baseUrl, user); } updateUser(user: User) { return this.http.put(this.baseUrl + '/' + user.id, user); } deleteUser(id: number) { return this.http.delete(this.baseUrl + '/' + id); } }
5. Edit Html and component class to make the application
1. add-user.component.html
6. 2.    add-user.component.ts
1. import { Component, OnInit } from '@angular/core'; import {FormBuilder, FormGroup, Validators} from "@angular/forms"; import {UserService} from "../service/user.service"; import {first} from "rxjs/operators"; import {Router} from "@angular/router"; @Component({ selector: 'app-add-user', templateUrl: './add-user.component.html', styleUrls: ['./add-user.component.css'] }) export class AddUserComponent implements OnInit { constructor(private formBuilder: FormBuilder,private router: Router, private userService: UserService) { } addForm: FormGroup; ngOnInit() { this.addForm = this.formBuilder.group({ id: [], email: ['', Validators.required], firstName: ['', Validators.required], lastName: ['', Validators.required] }); } onSubmit() { this.userService.createUser(this.addForm.value) .subscribe( data => { this.router.navigate(['list-user']); }); } }
7. Adding Materials
1. With the release of Angular 6, we can directly run ng add @angular/material command to add material design capabilities to an existing Angular application. By executing below command we will be installing Angular Material and the corresponding theming into the project.

Continue Reading

Angular6 Routing

• To generate new component employee. Go to app root in CLI and run below command
• ng g c employee/create-employee --spec=false --flat=true ng g c employee/list-employees --spec=false --flat=true
• component.ts, html and css files will be genarated in employee folder in app and it will add List Employee and Create Employee components in app.module.ts as below
• app.module.ts
• import { BrowserModule } from '@angular/platform-browser'; import { NgModule } from '@angular/core'; import { AppRoutingModule } from './app-routing.module'; import { AppComponent } from './app.component'; import { CreateEmployeeComponent } from './employee/create-employee.component'; import { ListEmployeesComponent } from './employee/list-employees.component'; @NgModule({ declarations: [ AppComponent, CreateEmployeeComponent, ListEmployeesComponent ], imports: [ BrowserModule, AppRoutingModule ], providers: [], bootstrap: [AppComponent] }) export class AppModule { }
• Generate routing module to app. It will create app-routing.module.ts file and add Routing  to app.module.ts
• ng g m app-routing --flat=true --module=app
• Inside app-routing.module.ts, add  RouterModule object and call forRoot Method as below.
• import { NgModule } from '@angular/core'; import { Routes, RouterModule } from '@angular/router'; import { ListEmployeesComponent } from './employee/list-employees.component'; import { CreateEmployeeComponent } from './employee/create-employee.component'; const routes: Routes = [ {path: 'list', component: ListEmployeesComponent}, {path: 'create', component: CreateEmployeeComponent} ]; @NgModule({ imports: [RouterModule.forRoot(routes)], exports: [RouterModule] }) export class AppRoutingModule { }
• Go to app.component.html and add new routes using routerLink tag

• 
  

Continue Reading

Angular Interview Questions

1. define AngularJS?
1. AngularJS is an open-source JavaScript framework designed for creating dynamic single web page applications with fewer lines of code. 
2. What is Angular 2?
1. Angular is a framework to build large scale and high performance web application while keeping them as easy-to-maintain.
2. Components − The earlier version of Angular had a focus of Controllers but now has changed the focus to having components over controllers. Components help to build the applications into many modules. This helps in better maintaining the application over a period of time.
3. TypeScript − The newer version of Angular is based on TypeScript. This is a superset of JavaScript and is maintained by Microsoft.
4. Services − Services are a set of code that can be shared by different components of an application. So for example if you had a data component that picked data from a database, you could have it as a shared service that could be used across multiple applications.
3. What are the key components of Angular 2?
1. Modules − This is used to break up the application into logical pieces of code. Each piece of code or module is designed to perform a single task.
2. Component − This can be used to bring the modules together.
3. Templates − This is used to define the views of an Angular JS application.
4. Metadata − This can be used to add more data to an Angular JS class.
5. Service − This is used to create components which can be shared across the entire application.
4. Explain Modules in Angular 2.
1. Modules are used in Angular JS to put logical boundaries in your application. Hence, instead of coding everything into one application, you can instead build everything into separate modules to separate the functionality of your application. A module is made up of the following parts −
1. Bootstrap array − This is used to tell Angular JS which components need to be loaded so that its functionality can be accessed in the application. Once you include the component in the bootstrap array, you need to declare them so that they can be used across other components in the Angular JS application.
2. Export array − This is used to export components, directives, and pipes which can then be used in other modules.
3. Import array − Just like the export array, the import array can be used to import the functionality from other Angular JS modules.
5. Explain Components in Angular 2.
1. Each application consists of Components. Each component is a logical boundary of functionality for the application. You need to have layered services, which are used to share the functionality across components.Following is the anatomy of a Component. A component consists of −
1. Class − This is like a C or Java class which consists of properties and methods.
2. Metadata − This is used to decorate the class and extend the functionality of the class.
3. Template − This is used to define the HTML view which is displayed in the application.
6. What are Angular 2 directives? Explain with examples?
1. A directive is a custom HTML element that is used to extend the power of HTML. Angular 2 has the following directives that get called as part of the BrowserModule module.
1. ngIf
1. The ngif element is used to add elements to the HTML code if it evaluates to true, else it will not add the elements to the HTML code.
2. *ngIf = 'expression'
2. ngFor
1. The ngFor element is used to elements based on the condition of the For loop.
2. *ngFor = 'let variable of variablelist'
7. How will you handle errors in Angular 2 applications?
1. Angular 2 applications have the option of error handling. This is done by including the ReactJS catch library and then using the catch function.
2. The catch function contains a link to the Error Handler function.
3. In the error handler function, we send the error to the console. We also throw the error back to the main program so that the execution can continue.
4. Now, whenever you get an error it will be redirected to the error console of the browser.
8. What is routing?
1. Routing helps in directing users to different pages based on the option they choose on the main page. Hence, based on the option they choose, the required Angular Component will be rendered to the user.
2. product.component.ts
3. import { Component } from '@angular/core'; @Component ({ selector: 'my-app', template: 'Products', }) export class Appproduct { }
4. app.module.ts
5. import { NgModule } from '@angular/core'; import { BrowserModule } from '@angular/platform-browser'; import { AppComponent } from './app.component'; import { Appproduct } from './product.component'; import { AppInventory } from './Inventory.component'; import { RouterModule, Routes } from '@angular/router'; const appRoutes: Routes = [ { path: 'Product', component: Appproduct }, { path: 'Inventory', component: AppInventory }, ]; @NgModule ({ imports: [ BrowserModule, RouterModule.forRoot(appRoutes)], declarations: [ AppComponent,Appproduct,AppInventory], bootstrap: [ AppComponent ] }) export class AppModule { }
6. app.component.ts
7. [routerLink] = "['/Product']
9. What is Dependency Injection? Explain with example?
1. Dependency injection is the ability to add the functionality of components at runtime. Lets take a look at an example and the steps used to implement dependency injection.
2. Create a separate class which has the injectable decorator. The injectable decorator allows the functionality of this class to be injected and used in any Angular JS module.
1. @Injectable() export class classname { }
3.  Next in your appComponent module or the module in which you want to use the service, you need to define it as a provider in the @Component decorator.
1. @Component ({ providers : [classname] })
10. Explain tsconfig.json file?
1. This file is used to give the options about TypeScript used for the Angular JS project.
2. { 'compilerOptions': { 'target': 'es5', 'module': 'commonjs', 'moduleResolution': 'node', 'sourceMap': true, 'emitDecoratorMetadata': true, 'experimentalDecorators': true, 'lib': [ 'es2015', 'dom' ], 'noImplicitAny': true, 'suppressImplicitAnyIndexErrors': true } }
2. The target for the compilation is es5 and that is because most browsers can only understand ES5 typescript.
3. The sourceMap option is used to generate Map files, which are useful when debugging. Hence, during development it is good to keep this option as true.
4. The "emitDecoratorMetadata": true and "experimentalDecorators": true is required for Angular JS decorators. If not in place, Angular JS application will not compile.
11.  package.json file?
1. This file contains information about Angular 2 project. Following are the typical settings in the file..
2. { "name": "angular-quickstart", "version": "1.0.0", "description": "QuickStart package.json from the documentation, supplemented with testing support", "scripts": { "build": "tsc -p src/", "build:watch": "tsc -p src/ -w", "build:e2e": "tsc -p e2e/", "serve": "lite-server -c=bs-config.json", "serve:e2e": "lite-server -c=bs-config.e2e.json", "prestart": "npm run build", "start": "concurrently \"npm run build:watch\" \"npm run serve\"", "pree2e": "npm run build:e2e", "e2e": "concurrently \"npm run serve:e2e\" \"npm run protractor\" --killothers --success first", "preprotractor": "webdriver-manager update", "protractor": "protractor protractor.config.js", "pretest": "npm run build", "test": "concurrently \"npm run build:watch\" \"karma start karma.conf.js\"", "pretest:once": "npm run build", "test:once": "karma start karma.conf.js --single-run", "lint": "tslint ./src/**/*.ts -t verbose" }, "keywords": [], "author": "", "license": "MIT", "dependencies": { "@angular/common": "<2 .4.0="" angular-in-memory-web-api="" angular="" canonical-path="" code="" compiler="" concurrently="" core-js="" core="" devdependencies="" forms="" http="" jasmine-core="" jasmine="" karma-chrome-launcher="" karma-cli="" karma-jasmine-html-reporter="" karma-jasmine="" karma="" lite-server="" lodash="" node="" platform-browser-dynamic="" platform-browser="" protractor="" repository="" rimraf="" router="" rxjs="" systemjs="" tslint="" types="" typescript="" zone.js="">
4. There are two types of dependencies, first is the dependencies and then there are dev dependencies. The dev ones are required during the development process and the others are needed to run the application.
5. The "build:watch": "tsc -p src/ -w" command is used to compile the typescript in the background by looking for changes in the typescript files.
12. Explain systemjs.config.json file.
1. This file contains the system files required for Angular JS application. This loads all the necessary script files without the need to add a script tag to the html pages. The typical files will have the following code.
1. ** * System configuration for Angular samples * Adjust as necessary for your application needs. */ (function (global) { System.config({ paths: { // paths serve as alias 'npm:': 'node_modules/' }, // map tells the System loader where to look for things map: { // our app is within the app folder app: 'app', // angular bundles '@angular/core': 'npm:@angular/core/bundles/core.umd.js', '@angular/common': 'npm:@angular/common/bundles/common.umd.js', '@angular/compiler': 'npm:@angular/compiler/bundles/compiler.umd.js', '@angular/platform-browser': 'npm:@angular/platformbrowser/bundles/platform-browser.umd.js', '@angular/platform-browser-dynamic': 'npm:@angular/platform-browserdynamic/bundles/platform-browser-dynamic.umd.js', '@angular/http': 'npm:@angular/http/bundles/http.umd.js', '@angular/router': 'npm:@angular/router/bundles/router.umd.js', '@angular/forms': 'npm:@angular/forms/bundles/forms.umd.js', // other libraries 'rxjs': 'npm:rxjs', 'angular-in-memory-web-api': 'npm:angular-in-memory-web-api/bundles/inmemory-web-api.umd.js' }, // packages tells the System loader how to load when no filename and/or no extension packages: { app: { defaultExtension: 'js' }, rxjs: { defaultExtension: 'js' } } }); })(this);
2. 'npm:': 'node_modules/' tells the location in our project where all the npm modules are located.
3. The mapping of app: 'app' tells the folder where all our applications files are loaded.
13. app.module.ts file.
1. mport { NgModule } from '@angular/core'; import { BrowserModule } from '@angular/platform-browser'; import { AppComponent } from './app.component'; @NgModule({ imports: [ BrowserModule ], declarations: [ AppComponent ], bootstrap: [ AppComponent ] }) export class AppModule { }
3. The import statement is used to import functionality from the existing modules. Thus, the first 3 statements are used to import the NgModule, BrowserModule and AppComponent modules into this module.
4. The NgModule decorator is used to later on define the imports, declarations, and bootstrapping options.
5. The BrowserModule is required by default for any web based angular application.
6. The bootstrap option tells Angular which Component to bootstrap in the application.
14. Angular Life Cycle
2. ngOnChanges − When the value of a data bound property changes, then this method is called.
3. ngOnInit − This is called whenever the initialization of the directive/component after Angular first displays the data-bound properties happens.
4. ngDoCheck − This is for the detection and to act on changes that Angular can't or won't detect on its own.
5. ngAfterContentInit − This is called in response after Angular projects external content into the component's view.
6. ngAfterContentChecked − This is called in response after Angular checks the content projected into the component.
7. ngAfterViewInit − This is called in response after Angular initializes the component's views and child views.
8. ngAfterViewChecked − This is called in response after Angular checks the component's views and child views.
9. ngOnDestroy − This is the cleanup phase just before Angular destroys the directive/component.

Continue Reading

Remove common number from two arrays

• Need to remove common number 4 from both arrays
• Input
• int[] arr1 = { 1, 4, 6, 7, 8 };
• int[] arr2 = { 2, 4, 5, 9, 0 };
• Output
• int[] arr1 = { 1, 6, 7, 8 };
• int[] arr2 = { 2, 5, 9, 0 };

• RemoveCommonElements.java
• public class RemoveCommonElements { public static void main(String[] args) { RemoveCommonElements app = new RemoveCommonElements(); app.commonRemove(); } private void commonRemove() { int[] arr1 = { 1, 4, 6, 7, 8 }; int[] arr2 = { 2, 4, 5, 9, 0 }; for (int e : arr1) { if (contains(arr2, e)) { remove(arr1, e); remove(arr2, e); } } System.out.print(arr1); System.out.print(arr2); } private boolean contains(int[] arr, int e) { for (int i : arr) { if (i == e) { return true; } } return false; } private int[] remove(int[] arr, int e) { for (int i = 0; i < arr.length; i++) { if (arr[i] == e) { for (int j = i; j < arr.length-1; j++) { arr[j] = arr[j + 1]; } } } return arr; } } ######### RESULT ########## 1, 6, 7, 8, 8 2, 5, 9, 0 ,0
• In below example CopyOnWriteArrayList will be concurrent in type and ConcurrentModificationException can be prevent
• /** * Get UNION list * Get INTERSECTION LIST by retainAll //common elements * Remove intersection from union */ private static void removeCommonElements() { List list1 = Arrays.asList(1, 2, 3, 4, 5, 6); List list2 = Arrays.asList(10, 2, 3, 40, 50, 60); List union = new ArrayList(list1); union.addAll(list2); List intersection = new ArrayList<>(list1); // only common elements intersection.retainAll(list2); union.removeAll(intersection); System.out.println(union); }

Continue Reading

Inheritance and Conditions

1. When Parent throws Generic Exception and Child throws specific exception
1. Compiles and run successfully
2. public class Animal { public void eat() throws Exception { System.out.println("Animal Eating..."); } } public class Cat extends Animal { @Override public void eat() throws FileNotFoundException { System.out.println("Cat Eating ....."); } } public class App { public static void main(String[] args) throws Exception { Animal cat = new Cat(); cat.eat(); } } ######### RESULT ########## Cat Eating .....
2. When Parent throws specific exception and child throws generic exception
1. Compile time error
3. When Parent modifier is protected and child modifier is public
1. Compiles and run successfully
4. When Parent modifier is private and child modifier is public
1. Compile time error
5. When Parent modifier is public and child modifier is private
1. Compile time error

Continue Reading

Java clone object – cloning in java

• Java Object class comes with native clone() method that returns the copy of the existing instance.
• To use java object clone method, we have to implement the marker interface java.lang.Cloneable so that it won’t throw CloneNotSupportedException at runtime.
• Also Object clone is a protected method, so we will have to override it to use with other classes
• Student.java
• public class Student implements Cloneable { private int id; private String name; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } }
• App.java
• public class App { public static void main(String[] args) throws CloneNotSupportedException { Student student1 = new Student(); student1.setId(1); student1.setName("Sonu"); Student student2 = (Student) student1.clone(); System.out.println(student2.getName()); if (student1.equals(student2)) { System.out.println("EQUAL"); } } }
• s1 == s2: false
• So s1 and s2 are two different object, not referring to same object. This is in agreement of the java clone object requirement.
• s1.name == s2.name: true
• So both s1 and s2 object variables refer to same object.
• Shallow copy
• Shallow copy is a bit-wise copy of an object. A new object is created that has an exact copy of the values in the original object. If any of the fields of the object are references to other objects, just the reference addresses are copied i.e., only the memory address is copied.
• Deep copy
• A deep copy copies all fields, and makes copies of dynamically allocated memory pointed to by the fields. A deep copy occurs when an object is copied along with the objects to which it refers.

Continue Reading

Structural design patterns

Structural design patterns are concerned with how classes and objects can be composed, to form larger structures.The structural design patterns simplifies the structure by identifying the relationships.These patterns focus on, how the classes inherit from each other and how they are composed from other classes.

• Adapter Pattern 
• An Adapter Pattern says that just "converts the interface of a class into another interface that a client wants".
• In other words, to provide the interface according to client requirement while using the services of a class with a different interface.
• The Adapter Pattern is also known as Wrapper.

Continue Reading