V computeIfPresent(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction) 

package corejava.map;

import java.util.HashMap;
import java.util.Map;

public class ComputeIfPresentExample {

	public static void main (String argv[]) {
		
		Map<String, Integer> map = new HashMap<String, Integer>();

		map.put("Sunglass", 105);
		map.put("Watch", 1501);
		
		
		newline("Original Map");
		map.forEach((a, b) -> {
			System.out.println(a + " -> " + b);
		});
		
		
		map.computeIfPresent("Watch", (k,v) -> {return v + v;});
		
		newline("After calling computeIfAbsent Map");
		map.forEach((a, b) -> {
			System.out.println(a + " -> " + b);
		});
	}
	
	static void newline(String s) {
		System.out.println("\n" + s);
	};
}

public V computeIfAbsent(K key, Function<? super K, ? extends V> remappingFunction)

package corejava.map;

import java.util.HashMap;
import java.util.Map;

public class ComputeIfAbsentExample {

	public static void main (String argv[]) {
		
		Map<Integer, String> map = new HashMap<Integer, String>();

		map.put(1, "one");
		map.put(2, "two");
		map.put(3, "three");
		map.put(4, "four");
		map.put(5, "five");
		
		newline("Original Map");
		map.forEach((a, b) -> {
			System.out.println(a + " -> " + b);
		});
		
		map.computeIfAbsent(6, k-> { return "six";});
		map.computeIfAbsent(7, k -> "seven");
		
		newline("After calling computeIfAbsent Map");
		map.forEach((a, b) -> {
			System.out.println(a + " -> " + b);
		});
	}
	
	static void newline(String s) {
		System.out.println("\n" + s);
	};
}

Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
map.put(4, "four");
map.put(5, "five");
map.put(6, "five");

newline("Original Map");
map.values().removeAll(Collections.singleton("five"));

newline("After removing values = five");
map.forEach( (a,b) -> {
	System.out.println(a + " -> " + b);
});

Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
map.put(4, "four");
map.put(5, "five");
map.put(6, "five");

newline("Original Map");

//remove entries where value = five
map.values().removeIf("five"::equals);

newline("After removing values = five");
map.forEach( (a,b) -> {
	System.out.println(a + " -> " + b);
});

static void clearALLItemsInMap() {
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "one");
		map.put(2, "two");
		map.put(3, "three");
		map.put(4, "four");
		map.put(5, "five");
		map.put(6, "five");
		
		newline("Original Map");
		map.forEach( (a,b) -> {
			System.out.println( a + " -> " + b);
		});
		
                 //clear the map
		map.clear();
		
		newline("After classing clear() Map");
		map.forEach( (a,b) -> {
			System.out.println(a + " -> " + b);
		});
	}

System.out.println(Integer.MAX_VALUE); //2147483647
System.out.println(Integer.MIN_VALUE);  //-2147483648

BigInteger a = BigInteger.valueOf(15);
BigInteger b = BigInteger.ONE;

BigInteger result = a.add(b);
System.out.println("Addition of a,b = " + result);

result = a.subtract(b);
System.out.println("Subtration of a,b = " + result);

result = a.divide(b);
System.out.println("Division of a,b = " + result);

result = a.multiply(b);
System.out.println("Multipllication of a,b = " + result);

private static int generateRandomInteger(int rangeStart, int rangeEnd) {
		// generate double between 0.0 and 1.0
		double r = Math.random();
		Integer result = (int) (rangeStart + r * (rangeEnd - rangeStart));
		return result;
	}

private static int generateRandomIntegerII(int rangeStart, int rangeEnd) {
		// generate double between 0.0 and 1.0
		Random random = new Random();
		double r = random.nextDouble();
		Integer result = (int) (rangeStart + r * (rangeEnd - rangeStart));
		return result;
}

import java.util.Random;
public class GenerateRandomNumber {

	public static void main(String[] args) {

		System.out.println(GenerateRandomNumber.generateRandomInteger(35, 40));
		System.out.println(GenerateRandomNumber.generateRandomIntegerII(35, 40));

	}

	private static int generateRandomInteger(int rangeStart, int rangeEnd) {
		// generate double between 0.0 and 1.0
		double r = Math.random();
		Integer result = (int) (rangeStart + r * (rangeEnd - rangeStart));
		return result;
	}

	private static int generateRandomIntegerII(int rangeStart, int rangeEnd) {
		// generate double between 0.0 and 1.0
		Random random = new Random();
		double r = random.nextDouble();
		Integer result = (int) (rangeStart + r * (rangeEnd - rangeStart));
		return result;
	}

}

/**
 * Tutorials and Samples form Java  Collection framework.
 */

package javaexp.corejava.collection;

@java.lang.Deprecated
package javaexp.corejava.oldcollection;

/**
 * Sample Calculator which can add two numbers
 * 
 */

public class OldCalculator {

	/**
	 * Add two number and return the value as Number
	 * 
	 * @param a : First number
	 * @param b : Second number
	 * @return result of addition as Number
	 * @see Number
	 */
	public Number add(Number a, Number b) {
		return a.doubleValue() + b.doubleValue();
	}

	@Deprecated(forRemoval = false, since = "1.1")
	public Number add(CalParameter a, CalParameter b) {
		return a.val.doubleValue() + b.val.doubleValue();
	}

}

@Deprecated
class CalParameter {
	Integer val;
}

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.project</groupId>
  <artifactId>java-module-project</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>java-module-project</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

private static boolean appleIsFruit() {
	System.out.println("calling apple ");
	return true;
}

private static boolean bananaIsFruit() {
	System.out.println("calling banana ");
	return true;
}

private static boolean cloudIsfruit() {
	System.out.println("calling cloud ");
	return false;
}

System.out.println("\n\napple | banana");
if (appleIsFruit() | bananaIsFruit()) {
	System.out.println("inside apple | banana");
}

System.out.println("\n\ncloud & apple");
if (cloudIsfruit() & appleIsFruit()) {
	System.out.println("inside cloud & apple");
}

System.out.println("apple || banana");
if (appleIsFruit() || bananaIsFruit()) {
	System.out.println("inside apple || banana");
}

System.out.println("\n\ncloud && apple");
if (cloudIsfruit() && appleIsFruit()) {
	System.out.println("inside cloud && apple");
}

Map<Integer, String> map = new HashMap<>();
map.put(1,"Argentina");
map.put(2,"France");
map.put(3,"Brazil");
map.put(4,"Germany");

//EntrySet Iterator
System.out.println("\nEntrySet foreach");
Iterator<Entry<Integer, String>> it = map.entrySet().iterator();
while(it.hasNext()) {
    Map.Entry<Integer, String> keyVal = it.next();
    System.out.println(keyVal.getKey() + " " + keyVal.getValue());
}

//EntrySet and foreach
System.out.println("\nEntrySet foreach");
Set<Entry<Integer, String>> entrySet = map.entrySet();
entrySet.forEach((e-> { System.out.println(e.getKey() + " " + e.getValue());}));

//Keyset Iterator
System.out.println("\nKeyset Iterator");
Iterator<Integer> kit = map.keySet().iterator();
while(kit.hasNext()) {
    Integer key = kit.next();
	System.out.println(key + " " + map.get(key));
}

//Keyset For loop
System.out.println("\nKeyset For loop");
for (Integer key : map.keySet()) {
	System.out.println(key + " " + map.get(key));
}

//map foreach (Java 8 Lambda)
System.out.println("\nUsing Map.foreach (Java 8 Lambda");
map.forEach((key,value)-> {System.out.println(key + " " + value);});

import java.util.LinkedHashMap;
import java.util.Map;

public class MapRemoveEntry {

	public static void main(String argv[]) {

		LinkedHashMap<Integer, String> map = new LinkedHashMap<Integer, String>() {
			private static final long serialVersionUID = 1L;

			protected boolean removeEldestEntry(Map.Entry<Integer,String> eldest) {
				return size() > 4;
			}
		};;
		

		map.put(0, "A");
		map.put(1, "B");
		map.put(2, "C");
		map.put(3, "D");
		map.put(4, "E");
		
		
		
		map.forEach((k,v) -> { System.out.println("key = " + k + " value = " + v);});
	}
}

package java17.sealed;

public abstract sealed class Tesla permits Model3, ModelS, TeslaSUV{
	public abstract Integer maxRange();
	public String basePrice() {
		return "25000 USD";
	}
}

//Subclass 1
public final class Model3 extends Tesla {
	@Override
	public Integer maxRange() {
		return 200;
	}
}

//Subclass 2
public final class ModelS extends Tesla {
	@Override
	public Integer maxRange() {
		return 400;
	}
}

//Subclass3 (non-sealed)
public non-sealed class TeslaSUV extends Tesla {
	@Override
	public Integer maxRange() {
		// TODO Auto-generated method stub
		return null;
	}
}

package java17.sealed;

public sealed class BMWCars {

	public final class BMW3 extends BMWCars implements ElectricVehicle{

	}
	
	public final class BMWI extends BMWCars implements Vehicle {

	}
	
	public non-sealed class BMWJV extends BMWCars implements Vehicle {

	}

}

package Java14;

public record AddressRecord(String street, String city, Integer zip, String state, String country) {

}

package Java14;

public class AddressRecordDemo {

	public static void main (String arg[]) {
		
		AddressRecord address1 = new AddressRecord("1044 Main Street", "Livermore", 94550, "CA", "USA");
		
		System.out.println(address1.street());
		System.out.println(address1.city());
		System.out.println(address1.state());
	}
}

final class MyCustomClass {
	
}

import java.lang.reflect.Modifier;

public class JavaReflectionModifiers {

	public static void main(String[] args) {
		
                 //prints 16
		System.out.println(MyCustomClass.class.getModifiers());
		
                 //returns true
		Modifier.isFinal(MyCustomClass.class.getModifiers());

	}

}


final class MyCustomClass {
	
}

package Java14;

import java.lang.reflect.Modifier;

public class JavaReflectionModifiers {

	public static void main(String[] args) {
		
		System.out.println(MyCustomClass.class.getModifiers());
		
		//prints true
		System.out.println(Modifier.isFinal(MyCustomClass.class.getModifiers()));
		
		//prints true
		System.out.println(Modifier.isFinal(String.class.getModifiers()));
		
		//prints false
		System.out.println(Modifier.isFinal(Number.class.getModifiers()));

	}

}


final class MyCustomClass {
	
}

record MobilePhone(String brand, String modelName, Number osVersion, boolean canFlip) {

}

package Java14;

import java.lang.reflect.Modifier;

public class RecordFinalTest {

	public static void main(String[] args) {
		
		MobilePhone phone1 = new MobilePhone("Samsung", "Galaxy1", 1, false);

		//false
		System.out.println(Modifier.isFinal(phone1.getClass().getModifiers()));
		
		//false
		System.out.println(Modifier.isFinal(MobilePhone.class.getModifiers()));

	}

}

class MyLinkedList<E> {

	/* first points to head of the list */
	public Node<E> first = null;

	/* last points to tail of the list */
	public Node<E> last = null;

	/**
	 * Add item to tail (end) of the List
	 * 
	 * @param item
	 * @return
	 */
	public boolean add(E item) {
		Node<E> newNode = new Node<E>(last, item, null);

		if (last == null) {
			// last points to the new node created
			first = newNode;
		} else {
			last.next = newNode;
		}
		// update last so that it points to the new node
		last = newNode;
		return true;
	}

	static class Node<E> {
		public E value;
		public Node<E> next;
		public Node<E> prev;

		Node(Node<E> prev, E element, Node<E> next) {
			this.value = element;
			this.next = next;
			this.prev = prev;
		}
	}

}

//create instance
MyLinkedList<Integer> list = new MyLinkedList<Integer>();

//add values 1,2,3,4,5
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);

//Get the first node (head node) and then print it by traversing all nodes
MyLinkedList.Node<Integer> node = list.first;
while (node != null) {
	System.out.println("Content of Node: " + node.value);
	node = node.next;
}

package java17.sealed;

public abstract sealed class Tesla permits Model3, ModelS, TeslaSUV{
	public abstract Integer maxRange();
	public String basePrice() {
		return "25000 USD";
	}
}

//Subclass 1
public final class Model3 extends Tesla {
	@Override
	public Integer maxRange() {
		return 200;
	}
}

//Subclass 2
public final class ModelS extends Tesla {
	@Override
	public Integer maxRange() {
		return 400;
	}
}

//Subclass3 (non-sealed)
public non-sealed class TeslaSUV extends Tesla {
	@Override
	public Integer maxRange() {
		// TODO Auto-generated method stub
		return null;
	}
}

package java17.sealed;

public sealed class BMWCars {

	public final class BMW3 extends BMWCars implements ElectricVehicle{

	}
	
	public final class BMWI extends BMWCars implements Vehicle {

	}
	
	public non-sealed class BMWJV extends BMWCars implements Vehicle {

	}

}