What is Class Loading?
Loading is the process of finding the binary representation of a class or interface type with a particular name and creating a class or interface from that binary representation.

When Class is Loaded?

  1. Class loading done by Class Loaders may eagerly load a class or does lazy load
  2. Eager loading happens as soon as another class references it and lazy load happens when a need of class initialization occurs.
  3. If a Class is loaded before it’s actually being used, it can sit inside before being initialized which may vary from JVM to JVM.
  4. However, it’s guaranteed by JLS that a class will be loaded when there is a need of static initialization.

Whenever the JVM determines it needs a class (to use its static variables, to create a new object, to use its static methods etc) it will load the class and static initialization blocks will run, static variables are initialized etc. This is (at least under normal circumstances) done only once

SomeClass.someStaticMethod(); //SomeClass is loaded (if its not already)
SomeClass.someStaticVariable; //SomeClass is loaded (if its not already)
SomeClass var=new SomeClass(); //SomeClass is BOTH loaded (if its not already) AND instantiated

Class loader actually loads byte code into JVM , runs static initializers when you want to use static fields within class without creating an instance of it, class must be loaded by class loader first.Default classloader in java is java.lang.ClassLoader

Class Loading is mostly unpredictable

When Class is Initialized?
Class Initialization happens after class loading. A class is initialized in Java when

  1. An Instance of class is created using either new() keyword or using reflection using class.forName(), which may throw ClassNotFoundException in Java.
  2. an static method of Class is invoked.
  3. an static field of Class is assigned.
  4. an static field of class is used which is not a constant variable.
  5. if Class is a top level class and an assert statement lexically nested within class is

Which classes are Eagerly Loaded and Lazily Loaded

Eagerly Loaded Classes
are those the JVM must be able to load JVM class files. The JVM class loader loads referenced JVM classes that have not already been linked to the runtime system. Classes are loaded implicitly because: The initial class file – the class file containing the public static void main(String args[]) method – must be loaded at startup. Depending on the class policy adopted by the JVM, classes referenced by this initial class can be loaded in either a lazy or eager manner.

An eager class loader loads all the classes comprising the application code at startup. Lazy class loaders wait until the first active use of a class before loading and linking its class file.

The first active use of a class occurs when one of the following occurs: • An instance of that class is created • An instance of one of its subclasses is initialized • One of its static fields is initialized. Certain classes, such as ClassNotFoundException, are loaded implicitly by the JVM to support execution. You may also load classes explicitly using the java.lang.Class.forName() method in the Java API, or through the creation of a user class loader.

Based on the above rules, lazy class loading can be forced on the system.

Use java -XX:+TraceClassLoading to trace the loading of classes.

Use java -XX:+PrintCompilation to trace when methods are JITed.

Thread – direction or path that is taken while a program is executed

  1. Below code would explain how dirty read happens when multiple thread(2 threads) tries to access Instance variable at once from two different class objects
  2. Below we have 3 classes, One for Printing Report and Other for removing the report printed. Third for tracking the report status
  3. The Output of the code would be Consistently 0 every time which is expected when the number of reports to be printed is in range of less than 100. However the output changes with more the no of reports to be printed. I.E. totalReportsToBePrinted = 10000000
  4. This happens because for lower value of reports to be printed the thread executes fast with out context switching however for higher values other thread(RemovePrintedReports thread takes control before PrintExcelReports get completed) takes control which leads to inconsistency
  5. The Same code would return 0 every time if one thread(PrintExcelReports) completes before other(RemovePrintedReports) as below when we use join and didn’t start both the threads at once.
    .
    .
            t1.start();
            t1.join();
            
            t2.start();
            t2.join();
    
    .
    .
    

PrintExcelReports.java

public class PrintExcelReports implements Runnable {
    TotalReportCount totalReportCount;

    public PrintExcelReports(TotalReportCount totalReportCount) {
        this.totalReportCount = totalReportCount;
    }

    int totalReportsToBePrinted = 1000000;

    @Override
    public void run() {
        for(int i=0;i<totalReportsToBePrinted;i++){
            totalReportCount.totalReportsCntVal -= i;
        }
    }
}

RemovePrintedReports.java

public class RemovePrintedReports implements Runnable {
    TotalReportCount totalReportCount;

    public RemovePrintedReports(TotalReportCount totalReportCount) {
        this.totalReportCount = totalReportCount;
    }

    int totalReportsToBePrinted = 1000000;

    @Override
    public void run() {
        for(int i=0;i<totalReportsToBePrinted;i++){
            totalReportCount.totalReportsCntVal -= i;
        }
    }
}

ReportCurrentStatus.java

public class ReportCurrentStatus {
    public static void main(String[] args) throws InterruptedException {
        TotalReportCount objTotalReportCount = new TotalReportCount();
        objTotalReportCount.totalReportsCntVal = 0;

        PrintExcelReports objPrinter1 = new PrintExcelReports(objTotalReportCount);
        RemovePrintedReports objPrinter2 = new RemovePrintedReports(objTotalReportCount);

        Thread t1 = new Thread(objPrinter1);
        Thread t2 = new Thread(objPrinter2);

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(objTotalReportCount.totalReportsCntVal);
    }
}

Output when totalReportsToBePrinted is greater than 1000

RANDOM NUMBER

Output when totalReportsToBePrinted is less than 100

0

Why we need Custom Exception
Exceptions are technical causes which should be wrapped in a presentable way with a specific business logic and workflow. adding a higher abstraction layer for the exception handling, which results in more meaningful and readable API

How to write Custom Exception
All you need to do is create a new class and have it extend Exception. If you want an Exception that is unchecked, you need to extend RuntimeException.
Note: A checked Exception is one that requires you to either surround the Exception in a try/catch block or have a ‘throws’ clause on the method declaration. (like IOException) Unchecked Exceptions may be thrown just like checked Exceptions, but you aren’t required to explicitly handle them in any way (IndexOutOfBoundsException).

Exception, if you want your exception to be checked (i.e: required in a throws clause).RuntimeException, if you want your exception to be unchecked.

Creating Custom Checked Exception
Note:constructor takes a Throwable’s subclass which is the origin (cause) of the current exception

public class StudentStoreException extends Exception {
     public StudentStoreException(String message, Throwable cause) {
        super(message, cause);
    }
}

Creating Custom Unchecked Exception

public class IncorrectFileExtensionException 
  extends RuntimeException {
    public IncorrectFileExtensionException(String errorMessage, Throwable err) {
        super(errorMessage, err);
    }
}

Methods in Custom Exception

public class MyOwnException extends Exception {
    public MyOwnException() {

    }

    public MyOwnException(String message) {
        super(message);
    }

    public MyOwnException(Throwable cause) {
        super(cause);
    }

    public MyOwnException(String message, Throwable cause) {
        super(message, cause);
    }
}

Minimal Requirment

  1. Java 17 or higher
  2. Jakarta EE 10
  3. Spring Framework 6
  4. Works on Maven 3.5+
  5. Tomcat 10.0
  6. Improved observability with Micrometer and Micrometer Tracing

Improvements
Performance enhancements and optimizations to boost application responsiveness and efficiency.These improvements focus on reducing startup times, minimizing memory footprint, and optimizing resource utilization.

Changes in Code

  1. When we wanted to configure the Security settings, we had to extend the WebSecurityConfigurerAdapter class.This class has been deprecated and removed in Spring Security 6.
    Instead, we should now take a more component-based approach and create a bean of type SecurityFilterChain.

    @Configuration
    @EnableWebSecurity
    public class WebSecurityConfig {
     @Bean
      public SecurityFilterChain configure(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(requests -> requests
                .requestMatchers(new AntPathRequestMatcher("/openapi/openapi.yml")).permitAll()
                .anyRequest().authenticated())
            .httpBasic();
        return http.build();
      }
    }
    
  2. Instead of using authorizeRequests, which has been deprecated, we should now use authorizeHttpRequests.This method is part of the HttpSecurity configuration and allows you to configure fine-grained request matching for access control.
  3. Spring Security 6, AntMatcher, MvcMatcher, and RegexMatcher have been depreciated and replaced by requestMatchers or securityMatchers for path-based access control. This allows us to match requests based on patterns or other criteria without relying on specific matchers.
  1. New methods to the String class: isBlank, lines, strip, stripLeading, stripTrailing, and repeat.
  2. readString and writeString static methods from the Files class
    Path filePath = Files.writeString(Files.createTempFile(tempDir, "demo", ".txt"), "Sample text");
    String fileContent = Files.readString(filePath);
    assertThat(fileContent).isEqualTo("Sample text");
    
  3. java.util.Collection interface contains a new default toArray method
    List sampleList = Arrays.asList("Java", "Kotlin");
    String[] sampleArray = sampleList.toArray(String[]::new);
    assertThat(sampleArray).containsExactly("Java", "Kotlin");
    
  4. A static not method has been added to the Predicate interface. Predicate.not(String::isBlank)
  5. The new HTTP client from the java.net.http package was introduced in Java 9. It has now become a standard feature in Java 11.The new HTTP API improves overall performance and provides support for both HTTP/1.1 and HTTP/2:
    HttpClient httpClient = HttpClient.newBuilder()
        .version(HttpClient.Version.HTTP_2)
        .connectTimeout(Duration.ofSeconds(20))
        .build();
    HttpRequest httpRequest = HttpRequest.newBuilder()
        .GET()
        .uri(URI.create("http://localhost:" + port))
        .build();
    HttpResponse httpResponse = httpClient.send(httpRequest, HttpResponse.BodyHandlers.ofString());
    assertThat(httpResponse.body()).isEqualTo("Hello from the server!");
    
  6. A major change in this version is that we don’t need to compile the Java source files with javac explicitly anymore:
    Before Java 11Version

    $ javac HelloWorld.java
    $ java HelloWorld 
    Hello Java 8!
    

    New Version

    $ java HelloWorld.java
    Hello Java 11!
    
  1. forEach method in java.lang.Iterable interface

    Java 8 has introduced forEach method in java.lang.Iterable interface so that while writing code we focus on business logic. The forEach method takes java.util.function.Consumer object as an argument, so it helps in having our business logic at a separate location that we can reuse.

  2. myList.forEach(new Consumer < Integer > () {
        public void accept(Integer t) {
            System.out.println("forEach anonymous class Value::" + t);
        }
    
    });
    
    //traversing with Consumer interface implementation
    MyConsumer action = new MyConsumer();
    myList.forEach(action);
    

    Consumer implementation that can be reused

    class MyConsumer implements Consumer<Integer>{
    
    	public void accept(Integer t) {
    		System.out.println("Consumer impl Value::"+t);
    	}
    }
    
  3. Interfaces with default and static methods

    From Java 8, interfaces are enhanced to have a method with implementation. We can use default and static keyword to create interfaces with method implementation

  4. We know that Java doesn’t provide multiple inheritance in Classes because it leads to Diamond Problem. So how it will be handled with interfaces now since interfaces are now similar to abstract classes. Compiler will throw an exception in this scenario and we will have to provide implementation logic in the class implementing the interfaces.

    @FunctionalInterface
    public interface Interface1 {
    
        void method1(String str);
    
        default void log(String str) {
            System.out.println("I1 logging::" + str);
        }
    
        static void print(String str) {
            System.out.println("Printing " + str);
        }
    }    
    

    interfaces are not allowed to have Object default methods.

  5. @FunctionalInterface annotation. Functional interfaces are a new concept introduced in Java 8. An interface with exactly one abstract method becomes a Functional Interface. We don’t need to use @FunctionalInterface annotation to mark an interface as a Functional Interface.

    @FunctionalInterface annotation is a facility to avoid the accidental addition of abstract methods in the functional interfaces. You can think of it like @Override annotation and it’s best practice to use it. java.lang.Runnable with a single abstract method run() is a great example of a functional interface.

    Anonymous Class Implementation

    Runnable r = new Runnable() {
        @Override
        public void run() {
            System.out.println("My Runnable");
        }
    };
    

    Lambda Expression Implementation

    Runnable r1 = () - > {
        System.out.println("My Runnable");
    };
    

    If you have single statement in method implementation anonymous class can be instantiated using lambda expression as below
    lambda expressions Implementation

    Interface1 i1 = (s) -> System.out.println(s);		
    i1.method1("abc");
    
  6. New java.util.stream has been added in Java 8 to perform filter/map/reduce like operations with the collection. Stream API will allow sequential as well as parallel execution.
    public static void main(String[] args) {
    
        List < Integer > myList = new ArrayList < > ();
        for (int i = 0; i < 100; i++) myList.add(i);
    
        //sequential stream
        Stream < Integer > sequentialStream = myList.stream();
    
        //parallel stream
        Stream < Integer > parallelStream = myList.parallelStream();
    
        //using lambda with Stream API, filter example
        Stream < Integer > highNums = parallelStream.filter(p - > p > 90);
        //using lambda in forEach
        highNums.forEach(p - > System.out.println("High Nums parallel=" + p));
    
        Stream < Integer > highNumsSeq = sequentialStream.filter(p - > p > 90);
        highNumsSeq.forEach(p - > System.out.println("High Nums sequential=" + p));
    
    }
    

    parallel processing values are not in order, so parallel processing will be very helpful while working with huge collections.

  7. IO improvements known to me are:

    Files.list(Path dir) that returns a lazily populated Stream, the elements of which are the entries in the directory.
    Files.lines(Path path) that reads all lines from a file as a Stream.
    Files.find() that returns a Stream that is lazily populated with Path by searching for files in a file tree rooted at a given starting file.
    BufferedReader.lines() that return a Stream, the elements of which are lines read from this BufferedReader.

  8. Java Time API packages, I can sense that they will be very easy to use. It has some sub-packages java.time.format that provides classes to print and parse dates and times and java.time.zone provides support for time zones and their rules.

For Loop Syntax

for(Initialization; Condition; Updation)
{
  Loop Work
}

Print Odd numbers in For loop

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        int count = 1;
        
        for(int i=1;i<number;i=i+2){
          System.out.print(i + " ");                          
        }
        
    }
}

Input

10

Output

1 3 5 7 9

Factors
An Integer X is a factor of N if X divides N with no reminder

  1. 2 is factor of 4
  2. 4 is factor of 24

Factors of 10 are 1,2,5,10 leaving reminder 0
Factors of 24 are 1,2,3,4,6,8,12,24 leaving reminder 0

Minimum factor is the least factor which would be always 1
Maximum factor would be always N

All Factors lie between [1 to N]

Print Factors of a number

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        int count = 1;
        
        for(int i=1;i<=number;i++){
          if(number%i == 0){
             System.out.println(i);   
          }
        }
        
    }
}

Input

24

Output

1 2 3 4 6 8 12 24 

Check the number is prime number

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        int factors = 0;
        
        for(int i=1;i<=number;i++){
          if(number%i == 0){
             factors++;   
          }
        }

     if(factors == 2){
       System.out.println("Prime No");
     }
        
    }
}

Input

13

Output

Prime No

Now in the above code I am checking the factors is equals to 2 and deciding whether the input is
prime no or not

Imagine you are giving 12 as input for above code

Input :- 12


         i               factor
	 1                  1
	 2                  2
	 3                  3-----> You can break here as we already know factor is greater than 2
	 4                  4
	 5                  4
	 6                  5
	 7                  5
	 8                  5
	 9                  5
	 10                 5
	 11                 5
	 12                 6

Refactoring the above for loop by adding break conditon

.
.
 for(int i=1;i<=number;i++){
     if(number%i == 0){
         factors++;   
      }
  }

  if(factors > 2){ //Break Factor 
     break;
  }
.
.

Using break factor in for loop

public class CheckPrimen {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        int factors = 0;

        for (int i = 1; i <= number; i++) {
            if (number % i == 0) {
                factors++;
            }

            if(factors > 2){ //Break Factor 
                break;
            }
        }

        if(factors == 2){
            System.out.println("Prime No");
        }else{
            System.out.println("Not a Prime No");
        }
    }
}

Input


Output


Print Odd numbers in For loop


Input


Output


	

While Statement

  1. Initialization
  2. Condition
  3. Task
  4. Updation
.
.
int cnt = 1; //Initialization

while(cnt < 5) //Condition
{
 SOP("Hello"); //Task
 cnt++; //Updation
}

.
.

While loop becomes infinite loop if the updating has no effect on while loop condition

Print the numbers divisible by 4 till N
Approach 1

import java.util.Scanner;

public class displayWhile {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int count = scn.nextInt();
        int cnt = 4;

        while(cnt < count){
            if(cnt % 4 ==0)
             System.out.println(cnt);

            cnt++;
        }
    }
}

Approach 2

import java.util.Scanner;

public class displayWhile {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int count = scn.nextInt();
        int cnt = 4;

        while(cnt < count){
            System.out.println(cnt + " ");
            cnt+=4;
        }
    }
}

Input

40

Output

4 8 12 16 20 24 28 32 36 

Approach2 is faster and efficient since count in while jumps in multiples of 4

Printing perfect Square

import java.util.Scanner;

public class PerfectSquare {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int n = scn.nextInt();
        int cnt = 1;

        while(cnt*cnt < n){
            System.out.println(cnt*cnt + " ");
            cnt++;
        }
    }
}

Input

30

Output

1 4 9 16 25

Printing last character in string

import java.util.Scanner;

public class PrintIntval {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        Character[] arrChar = new Character[]{};

        String strCount = String.valueOf(number);
        int index = strCount.length()-1;

        while(index >= 0 ) {
            System.out.println(strCount.charAt(index));
            index--;
        }
    }
}

Input

1365

Output

5
6
3
1

Approach 2

import java.util.Scanner;

public class PrintIntval {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();

        while(number> 0 ) {
            System.out.println(number%10);
            number = number/10;
        }
    }
}

Input

1365

Output

5
6
3
1
-----------------------------------------------------
 n           n>0           n%10         n=n/10   
----------------------------------------------------
1365          Y             5            136
136           Y             6            13
13            Y             3            1
1             Y             1            0
0             N - Loop Stops 

Now how will you address if input is 0 por negative and you should get output?

To address above.. .

public class PrintIntval {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();

        if(number < 0)
            number *= -1;

        if(number == 0){
            System.out.println(number);
        }else {
            while (number > 0) {
                System.out.println(number % 10);
                number = number / 10;
            }
        }
    }
}

Input

-1365

Output

5
6
3
1

இதைப் படிக்க ஆரம்பிக்கும் முன் இது எல்லா “ஃபாஸ்ட்ஃபுட்” கோயில்களுக்கும் பொருந்தாது என்பதை கவனத்தில்கொள்ள வேண்டும். எல்லா லட்சணங்களையும் கொண்டிருக்கும் கோயில்களுக்கு மட்டும் தான் இது. பழங்காலத்துக் கோயில்களில் எல்லாம் இது 100% சதவிகிதம் உள்ளது.

எப்படி எனறு கேட்பவர்களுக்கு கொஞ்சம் விளக்கமாகச் சொல்கிறேன்.:

பூமியின் காந்த அலைகள் அதிகம் வீசப்படும் இடங்கள்தான் இந்தக் கோயில்களின் சரியான அமைவு. இது பொதுவாக ஊருக்கு ஒதுக்குப்புறமான இடங்கள், மலைகள் மற்றும் ஆழ்ந்த இடங்கள் தான் உகந்த இடங்கள்.

கோயில்களில் ஒரு அபரிதமான காந்த சக்தியும், பாஸிட்டிவ் எனர்ஜியும் அதிகம் கொண்டிருக்கும். இது நார்த் போல் சவுத் போல் திரஸ்ட் வகை ஆகும். முக்கிய சிலைதான் இந்த மையப்பகுதியில் வீற்றீருக்கும். அதை நாம் கர்ப்பகிரகம் அல்லது மூலஸ்தானம் என கூறுவோம்.

இந்த மூலஸ்தானம் இருக்கும் இடம் தான் அந்தச் சுற்று வட்டாரத்திலேயே காந்த மற்றும் பாஸிட்டிவ் எனர்ஜி அதிகம் காணப்படும். பொதுவாக இந்த மூலஸ்தானம் சுயம்பாக உருவாகும் அல்லது அங்கே கிடைக்கப் பெறும் சிலை அப்புறம் தான் கோயில் உருவாகும்.

நிறையக் கோயில்களின் கீழே அதுவும் இந்தக் கர்ப்பகிரகத்தின் கீழே சில செப்புத் தகடுகள் பதிக்கபட்டிருக்கும் அது எதற்கு தெரியுமா? அது தான் கீழே இருக்கும் அந்த சக்தியை அப்படி பன்மடங்காக்கி வெளிக் கொணரும்.

அதுபோக எல்லா மூலஸ்தானமும் மூன்று பக்கம் மூடி வாசல் மட்டும் தான் திறந்து இருக்கும் அளவுக்குக் கதவுகள் இருக்கும். இது அந்த சக்தியை விரயம் செய்யாமல் ஒரு வழியாக அதுவும் வாசலில் இடது மற்றும் வலது புறத்தில் இருந்து இறைவனை வணங்கும் ஆட்களுக்கு இந்தச் சக்தி கிடைக்கும்.

இது உடனே தெரியாமல் இருக்கும் ஒரு சக்தி வழக்கமாக கோயிலுக்குச் செல்லும் ஆட்களுக்குத் தெரியும் ஒருவித இனம்புரியாத சக்தி அந்தக் கோயிலில் கிடைக்கும் என்று.

அது போக கோயிலின் பிரகாரத்தை இடமிருந்து வலமாய் வரும் காரணம் சக்திச்சுற்றுப் பாதை இது தான். அதனால் தான் மூலஸ்தானத்தை சுற்றும் போது அப்படியே சக்திச் சுற்றுப்பாதை கூடச் சேர்ந்து அப்படியே உங்கள் உடம்பிலும் மனதிலும் சக்தி/ வலு வந்து சேரும். இந்தக் காந்த மற்றும் ஒருவித பாசிட்டிவ் மின்சார சக்தி நமது உடம்புக்கும் மனதிற்கும் ஏன் மூளைக்கும் தேவையான ஒரு பிரபஞ்ச சக்தி (பாஸிட்டிவ் காஸ்மிக் எனர்ஜி) ஆகும்.

மூலஸ்தானத்தில் ஒரு விளக்கு கண்டிப்பாய் தொடர்ந்து எரிந்து கொண்டிருக்கும். அது போக அந்த விக்கிரகத்திற்க்கு பின் ஒரு விளக்கு (இப்போது நிறைய கோயில்களில் பல்புதான்) அதைச் சுற்றிக் கண்ணாடி அது செயற்கை ஒளிவட்டம் வருவதற்க்கு அல்ல. அது அந்தச் சக்தியை அப்படித் திருப்பும் ஒரு உக்தியாகும்.

அது போக மந்திரம் சொல்லும் போதும், மணியடிக்கும் போதும் அங்கே செய்யபடும் அபிஷேகம் அந்த சக்தியை மென்மேலும் கூட்டி ஒரு கலவையாய் வரும் ஒரு அபரிதமான “எனர்ஜி ஃபேக்டரிதான்” மூலஸ்தானம்.

இவ்வளவு அபிஷேகம், கர்ப்பூர எரிப்பு, தொடர் விளக்கு எரிதல் இதை ஒரு அறையில் நீங்கள் செய்து பாருங்கள். இரண்டே நாளில் அந்த இடம் சாக்கடை நாற்றம் எடுக்கும். ஆனால் கோயிலில் உள்ள இந்தக் கர்ப்பக்கிரகம் மற்றும் எத்தனை வருடம் பால், தயிர், பஞ்சாமிர்தம், தேன், சந்தனம், குங்குமம், விபூதி மற்றும் எண்ணெய், சீயக்காய் போன்ற எவ்வளவு விஷயங்களை கொன்டு அபிஷேகம் செய்தாலும் இந்த இடம் நாற்றம் என்ற விஷயம் வரவே வராது.

அது போகக் கடைசியில் செய்யும் சொர்ணாபிஷேகம் இந்த சக்தியை ஒவ்வொரு நாளும் கூட்டிக்கொண்டே செல்லும். பூக்கள், கர்ப்பூரம் (பென்ஸாயின் கெமிக்கல்), துளசி (புனித பேஸில்), குங்குமப்பூ (சேஃப்ரான்),கிராம்பு (கிளவ்) இதை சேர்த்து அங்கு காப்பர் செம்பில் வைக்கபட்டு கொடுக்கும் தீர்த்தம் ஒரு அபரித சுவை மற்றும் அதன் சுவை கோயிலில் உள்ளது போல் எங்கும் கிடைக்காது.

இதை ஒரு சொட்டு அருந்தினால் கூட அதில் உள்ள மகிமை மிக அதிகம். இதை வழக்கமாக உட்கொண்டவர்களுக்கு இது ஒரு நோயெதிர்ப்பு “ஆன்டிபயாட்டிக்” என்றால் மிகையில்லை..

இதை மூன்று தடவை கொடுக்கும் காரணம் ஒன்று உங்கள் தலையில் தெளித்து இந்த உடம்பை புண்ணியமாக்க, மீதி இரண்டு சொட்டு உங்கள் உடம்பைப் பரிசுத்தமாக்குவதற்காகவேத் தரப்படுகின்றது..

இன்று ஆயிரம் பற்பசை அமெரிக்காவில் இருந்து வந்தாலும் ஏன் கிராம்பு, துளசி, வேம்பின் ஃபார்முலாவில் தயாரிக்கும் காரணம் இது தான் இந்த தீர்த்தம் வாய் நாற்றம், பல் சுத்தம் மற்றும் இரத்ததை சுத்தப்படுத்தும் ஒரு அபரிதமான கலவை தான் இந்தத் தீர்த்தம்.

கோயிலுக்கு முன்பெல்லாம் தினமும் சென்று வந்த இந்த மானிடர்களுக்கு எந்த வித நோயும் அண்டியது இல்லை என்பதற்கு இதுதான் காரணம்.

கோயிலின் அபிஷேகம் முடிந்து வஸ்த்திரம் சாத்தும் போது மற்றும் மஹா தீபாராதனை காட்டும் போது தான் கதவைத் திறக்கும் காரணம் அந்த சுயம்புக்கு செய்த அபிஷேக சக்தி எல்லாம் மொத்தமாக உருவெடுத்து அப்படியே அந்த ஜோதியுடன் ஒன்று சேர வரும்போது தான் கதவை அல்லது திரையைத் திறப்பார்கள். அது அப்படியே உங்களுக்கு வந்து சேரும். அது போக அந்த அபிஷேக நீரை எல்லோருக்கும் தெளிக்கும் போது உங்கள் உடம்பில் ஒரு சிலிர்ப்பு வரக் காரணமும் இது தான்.

கோயிலுக்கு மேல் சட்டை அணிந்து வர வேண்டாம் என கூறுவதற்கும் இது தான் முக்கிய காரணம். அந்த சக்தி அப்படியே மார்புக் கூட்டின் வழியே புகுந்து உங்கள் உடம்பில் சேர வேண்டும் என்பதனால்தான் நம் முன்னோர்கள் அவ்வாறு வகுத்தனர்.

பெண்களுக்கு தாலி அணியும் காரணமும் இது தான். நிறையப் பெண்களுக்கு ஆண்களை போன்று இதய நோய் வராமல் இருக்கும் காரணம் இந்த தங்க மெட்டல் இதயத்தின் வெளியே நல்ல “பாஸிட்டிவ் எனர்ஜியை” வாங்கி கொழுப்பைக் கூட கரைக்கும் சக்தி இருப்பதாக ஒரு கூடுதல் தகவல். மாங்கல்யம், கார் சாவி மற்றும் புது நகைகள் இதையெல்லாம் இங்கு வைத்து எடுத்தால் அந்த உலோகங்கள் இதன் சக்தியை அப்படியே பற்றிக் கொள்ளுமாம். இது சில பேனாக்கள் மற்றும் பத்திரிகை மற்றும் எல்லாவற்றுக்கும் பொருந்தும்.

கல்சிலையின் முன் வைத்து எடுப்பதனால் என்ன பலனென கேட்பவர்கள் தெரிந்து கொள்ளவேண்டியது என்னவென்றால், தொடர்ச்சியான வழிபாடுகளால் ஒருமுகப்படுத்தப்பட்ட பிரபஞ்ச சக்தியின் இருப்பிடமே அச்சிலை. அந்தச் சக்திதான் நாம் வழிபடும்போது அங்கிருந்து நம்மில் படும். பல மைல் தூரத்தில் இருந்து பயணம் செய்திருப்பினும் அந்த சில நொடிகளில் தரிசனம் கிட்டும்போது அந்த உடம்பில் ஒரு மென்மையான சிலிர்ப்பும், ஒரு வித நிம்மதியும் ஒரு சக்தி வந்து மிச்சம் உள்ள எவ்வளவு பெரிய பிரகாரத்தையும் சுற்றி வரும் ஒரு “எனர்ஜு ரீசார்ஜ் பாயின்ட் தான்” இந்தக் கோயிலின் மூலஸ்தானம்.

அது போக கோயிலின் கொடி மரத்திற்க்கும் இந்தப் பரிகாரத்திற்க்கும் ஒரு நேரடி “வயர்லெஸ்” தொடர்பு உண்டென்றால் அது மிகையாகாது.

கோயில் மேல் இருக்கும் கலசம் சில சமயம் இரிடியமாக மாற இது தான் காரணம். கீழ் இருந்து கிளம்பும் காந்த அலைகள் (மேக்னெட்டிக் வேவ்ஸ்) மற்றும் இடியின் தாக்கம் தான் ஒரு சாதாரண கலசத்தையும் இரிடியமாக மாற்றும் திறன் படைத்தது. கோயில்களில் இடி தாக்கும் அபாயம் இல்லாமல் போன காரணம் கோயில் கோபுரத்தில் உள்ள இந்தக் கலசங்கள் ஒரு சிறந்த மின்கடத்தி. ஆம்! இது தான் பிற்காலத்தில் கண்டெடுக்கப்பட்ட “லைட்னிங் அரெஸ்டர்ஸ்”.

அது போக கொடி மரம் இன்னொரு இடிதாங்கி மற்றும் இது தான் கோயிலின் வெளிப்பிரகாரத்தை காக்கும் இன்னொரு காப்பரண் (டெக்னிக்கல் புரட்டக்டர்). கோயில் கதவு என்றுமே மரத்தில் செய்யபட்டது ஏனென்றால் எல்லா “ஹை வோல்ட்டேஜெயும் நியூட்ர்ல்” செய்யும் ஆற்றல் இம்மரங்களுக்கு உண்டு..

இடி இறங்கினால் கோயிலின் கதவுகளில் உள்ள மணி கண்டிப்பாக அதிர்ந்து ஒருவித ஒலியை ஏற்படுத்தும் .நல்ல மானிடர் இருவேளை கோயிலுக்கு சென்று வந்தால் மனிதனின் உடல் மட்டுமல்ல அவனின் மனதும் மூளையும் சுத்தமாகும். இவ்வாறான கோயில் சுத்த சுவாதீனம் இல்லாதவர்களை கூட இந்தச் சக்தி ஒரு மாற்றத்தை அவர்களுள் ஏற்படுத்துவதனாலேயே கோயில்களில் இவர்கள் அமைதியாகின்றனர்.

கோயிலின் மடப்பள்ளியில் கிடைக்கும் புளியோதரை ஆகட்டும், சர்க்கரைப் பொங்கலாகட்டும் இந்த டேஸ்ட்டை எந்த ஒரு ஃபைவ் ஸ்டார் கிச்சனும் கொடுத்துவிட முடியாது என்பது தான் நியதி. சில கோயில்களில் இரண்டு அல்லது நாலு வாசல் இருக்கும் காரணம் இந்தச் சக்தி அப்படியே உங்களுடன் வெளியே செல்ல வேண்டும் எனற மூத்தோர்கள் நமக்கு வகுத்த சூத்திரம் தான் இந்தக் கோயில் “டெக்னாலஜி”

அறுகம்புல்லை உண்ணுகின்ற பசுமாட்டின் சாணத்தை எடுத்து உருண்டையாக்கி வெயிலில் காயவைக்க வேண்டும். பின் இதனை உமியினால் மூடி புடம் போட்டு எடுக்க வேண்டும். இப்போது இந்த உருண்டைகள் வெந்து நீறாகி இருக்கும். இதுவே உண்மையான திருநீறாகும்.
இது நல்ல அதிர்வுகளை மட்டும் உள்வாங்கும் திறன் கொண்டது. எம்மைச் சுற்றி அதிர்வுகள் இருக்கின்றன என்பது யாவரும் அறிந்ததே.

எம்மை அறியாமலே அதிர்வுகளின் மத்தியில்த் தான் நாம் வாழ்ந்து கொண்டிருக்கின்றோம். எமது உடலானது இவ் அதிர்வுகளை ஏற்றுக் கொள்ளுகின்றது. திருநீறானது நல்ல அதிர்வுகளை ஏற்றுக் கொள்ளும் தன்மை வாய்ந்தது. அந்தவகையில் உடலின் முக்கிய பாகங்களில் திருநீறு இட்டுக் கொள்ளும் வழக்கம் இந்துமதத்தவர்களிடம் காணப்படுகின்றது.

இதைவிட மனித உடலிலே நெற்றி முக்கிய பாகமாகக் கருதப்படுகின்றது. அந்த நெற்றியிலேயே வெப்பம் அதிகமாகவும் வெளியிடப்படுகின்றது, உள் இழுக்வும்படுகின்றது. சூரியக்கதிர்களின் சக்தியை இழுத்து சரியான முறையில் உள்ளனுப்பும் அற்புதமான தொழிலை திருநீறு செய்யும் அதனாலேயே திருநீறை நெற்றியில் இடுவார்கள்.

தனது உடலிலே சாம்பல் சத்துக் குறைந்துவிட்டால், இலங்கை போன்ற வெப்பமான நாடுகளில் வளரும் கோழி இனங்கள் சாம்பலிலே விழுந்து குளிப்பதைக் கண்டிருப்பீர்கள். புறவை இனமே தன் தேவை தெரிந்து சாம்பலை நாடுகின்றதல்லவா! அதே போல்த்தான் மனிதனும் தன் மூட்டுவலி தோற்றுவிக்கும் இடங்களில் நீர்த்தன்மையை உறிஞ்சவல்ல திருநீற்றை அணிகின்றான். பசுமாட்டுச்சாணத்தை எரித்து திருநீறு செய்கின்றார்கள். மாடு அறுகம்புல் போன்ற பலவகையான புல்வகைகளை உண்டு தனது உடலைத் தேற்றிச் சாணம் போடும். அச்சாணம் தீயிலிடப்படும் போது ஏற்படும் இரசாயண மாற்றங்கள் உடலுக்கு மருத்துவத்தன்மையைக் கொடுக்கின்றது.

இதைவிட இரு புருவங்களுக்கும் இடையிலுள்ள பகுதியில் மிக நுண்ணிய நரம்பு அதிர்வலைகளை உள்ளன. அதனால் அந்த இடத்தைப் பயன்படுத்தி மனவசியம் இலகுவாகச் செய்யமுடியும். அதனாலேயே மனவசியத்தைத் தடுக்க அந்த இடத்தில் திருநீறு, சந்தனம் போன்றவை இடப்படுகின்றன. சந்தனம் நெற்றியில் வெளியிடப்படும் வெப்பத்தை நீக்குகின்றது. அதிகமான வெப்பம் கூடிய நாடுகளில் ஞாபகங்கள் முதலில் பதியப்படல், திட்டமிடல் போன்றவற்றிற்குத் தொழிற்படுகின்ற நெற்றிப்பகுதியிலுள்ள frontal cortex என்னும் இடத்தில் அணியப்படும் சந்தனமானது வெப்பம் மிகுதியால் ஏற்படும் மூளைச்சோர்வை நீக்குகின்றது.

சந்தனம் இரு புருவங்களுக்கும் இடையில் இடுகின்ற போது, முளையின் பின்பகுதியில் ஞாபகங்கள் பதிவுசெய்து வைத்திருக்கும் Hippocampus என்னும் இடத்திற்கு ஞாபகங்களை சிறப்பான முறையில் அனுப்புவதற்கு இந்த frontal cortex சிறப்பான முறையில் தொழிற்படும். உடலுக்குக் குளிர்ச்சியூட்டும் சந்தனத்தை நெற்றியிலும் உடலின் பல பாகங்களிலும் இந்து சமயத்தவர் அணிந்திருக்கும் காட்சி நகைச்சுவையாகப் பார்வைக்குத் தோன்றினாலும் அற்புதமான காரணமும் அதில் உண்டு பார்த்தீர்களா!

நெற்றியின் இரு புருவங்களுக்கும் இடையிலுள்ள நெற்றிப் பொட்டிலே பட்டும்படாமலும் சுண்டுவிரலை நேராகப்பிடித்தால் மனதில் ஒருவகை உணர்வு தோன்றும். அந்த உணர்வை அப்படியே வைத்துத் தியானம் செய்தால் மனஒருமைப்பாடு தோன்றும், சிந்தனை தெளிவுபெறும், எதையும் தெளிவாகப் புரிந்து கொள்ளும் நிலை தோன்றும். அந்த நெற்றிப் பொட்டு குளிர்ச்சியுடன் இருக்க வேண்டாமா? இதற்குச் சந்தனம் சரியான மருந்து.

இந்த உண்மைகளைச் சாதாரணமாகக் கூறி விளங்கவைக்க முடியாத மக்களுக்கு நிலையில்லா வாழ்வின் நிலையை உணர்த்தி திருநீற்றை உடலில் அணிய வைத்திருக்கின்றார்கள். மதத்தைக் காட்டி விஞ்ஞான விளக்கத்தை மறைத்துக் கூறிய விளக்கங்களினால் மதம் வென்றது விளக்கம் மறைந்தது.

விபூதி இட்டுக் கொள்ளும் இடங்களும், பலன்களும்
1. புருவ மத்தியில்(ஆக்ஞா சக்கரம்) வாழ்வின் ஞானத்தை ஈர்த்துக் கொள்ளலாம்.

2.தொண்டைக்குழி(விசுத்தி சக்கரம்) நமது சக்தியை அதிகரித்துக் கொள்ளலாம்.

3.நெஞ்சுக்கூட்டின் மையப்பகுதி தெய்வீக அன்பைப் பெறலாம். மேலும், பூதியை எடுக்கும் போது, மோதிரவிரலால் எடுப்பது மிகவும் சிறந்தது. ஏனென்றால், நம் உடலிலேயே மிகவும் பவித்ரமான பாகம் என்று அதைச் சொல்லலாம். நம் வாழ்வையே கட்டுப்படுத்தும் சூட்சுமம் அங்கு உள்ளது.