• Create an ADODB connection object which is required step for connecting to database as below.

Authentication using Id, Password and details.

• • Provider: For SQL server database the provider is “sqloledb”
  • Server: Open the SQL Server in your machine and Right click on the required Database/ click on properties.

• Click on “View connection Properties”

• User Name and Server details are required from this dialogue box

• objConnection.open “provider=sqloledb; Server=SDWA-160-PC; User Id=SDWA-160; Password=; Database=sample; Trusted_Connection=Yes”
• Hence, Connection setup completed and ready for execution.

• Enter the required SQL query to be executed.
• Execution of the query with the statement below.

• The above mentioned sample script has been executed and the value from the database is retrieved.

• Given an array of integers, our task is to write a program that efficiently finds the second largest element present in the array.

• Initialize two variables first and second to INT_MIN as,
  • first = second = INT_MIN

• • Start traversing the array,

a) If the current element in array say arr[i] is greater than first. Then update first and second as,

• • second = first
  • first = arr[i]

b) If the current element is in between first and second, then update second to store the value of current variable as
• • second = arr[i]

• Return the value stored in second.

• Iterate the given array.

• If current array value is greater than largest value then move the largest value to secondLargest and make current value as largest

• If the current value is smaller than largest and greater than secondLargest then the current value becomes secondLargest.

• A Linked list contains two things data and the address of the node each node is linked to the next node.
• There can be two solution to reverse a linked list in java.
  • Iterative
  • Recursive

• Here we have three nodes i.e previousNode, currentNode and nextNode
• When currentNode is starting node, then previousNode will be null
• Assign currentNode.next to previousNode to reverse the link.
• In each iteration move currentNode and previousNode by 1 node.

• Java garbage collection is the method by which Java programs achieve automatic memory management.
• Java programs compile to bytecode which will be run on a Java Virtual Machine.
• Once java programs run on the JVM, objects are created on the heap, which is a portion of memory dedicated to the program. Finally, some objects cannot be required.
• The garbage collector finds these unused objects and deletes them to free up memory.

• Java garbage collection is an automatic process.
• The programmer does not need to explicitly mark objects to be deleted. The garbage collection implementation lives in the JVM. Every JVM will implement garbage collection however it satisfies the only requirement is that it meets the JVM specification.
• Although there are many JVMs, Oracle’s HotSpot is the most common. It offers a robust and complete set of garbage collection options.
• While HotSpot has multiple garbage collectors that are optimized for various use cases, all its garbage collectors follow the same basic process.
  • In the first step, unreferenced objects are identified and marked as ready for garbage collection.
  • In the second step, marked objects are deleted.
  • Optionally, memory can be compacted after the garbage collector deletes objects, so remaining objects are in a contiguous block at the start of the heap. The compaction process makes it easier to allocate memory to new objects sequentially after the block of memory allocated to existing objects.
• All of HotSpot’s garbage collectors implement a generational garbage collection strategy that categorizes objects by age. The rationale behind generational garbage collection is that most objects are short-lived and will be ready for garbage collection soon after creation.

• Newly created objects start in the Young Generation. The Young Generation is further subdivided into an Eden space, where all new objects start, and two Survivor spaces, where objects are moved from Eden after surviving one garbage collection cycle.
• When objects are garbage collected from the Young Generation, it is a minor garbage collection event.

• Objects that are long-lived are ultimately moved from the Young Generation to the Old Generation. When objects are garbage collected from the Old Generation, it is a major garbage collection event.

• Metadata classes and methods are stored in the Permanent Generation. Classes that are no longer in use may be garbage collected from the Permanent Generation.

• The benefit of Java garbage collection is that it automatically handles the deletion of unused objects or objects that are out of reach to free up memory resources.
• Programmers working in languages without garbage collection (like C and C++) must implement manual memory management in their code.
• Some programmers maintain in favor of manual memory management over garbage collection, primarily for reasons of control and performance.
• While the discussion over memory management approaches continues to rage on, garbage collection is now a standard component of many popular programming languages.
• For situations in which the garbage collector is negatively impacting performance, Java offers several options for tuning the garbage collector to improve its efficiency.

• In this program an approach using Hashmap in Java.
  • Declare a Hashmap in Java of {char, int}.
  • Traverse in the string, check if the Hashmap already contains the traversed character or not.
  • If it is present, then increase its count using get() and put() function in Hashmap.
  • Once the traversal is completed, traverse in the Hashmap and print the character and its frequency.

• Given an array of integers greater than zero, find if it is possible to split it in two subarrays (without reordering the elements), such that the sum of the two subarrays is the same. For example,

• Given an array of integers, find if it’s possible to remove exactly one integer from the array that divides the array into two subarrays with the same sum. For Example,

• On removing element 2 at index 1, the array gets divided into two subarrays [6] and [3, 2, 1] having equal sum.

• In an array, to display the Next Greater Element (NGE) for every element.
• The Next greater Element for an element x is the first greater element on the right side of x value in an array.
• While the elements for which no greater element exist, consider the next greater element as 0.

• For any array, rightmost element always has next greater element as 0.
• Next greater element of an array element array[i], is an integer array[j], such that
  • array[i] < array[j]
  • i < j
  • j – i is minimum
• i.e. array[j] is the first element on the right of array[i] which is greater than array[i].
• For Example the Input array is 88, 13, 44, 2, 10, 5, 17

• To find Next Great Element Using two loops.
• All the elements one by one to picks in the outer loop.
• The outer loop picked the first greater element from the inner loop.
• If a greater element is found then that element is printed as next, otherwise 0 is printed.

• To count the amount of ‘x’ characters that are in a string, and print out the number using java program.

• Pattern is an underlying structure that organizes surfaces or structures in a consistent, regular manner. Pattern can be described as a repeating unit of shape or form.
• Given a positive integer n.The problem is to print the pyramid pattern as designed the sample code is given below.

• The number of occurrences of each character to be count and also the occurrences of duplicate characters it should not be display repeatedly. The following steps are given below,
  • First, we split the strings by spaces.
  • Take a variable count = 0 and in every true condition we increment the count by 1.
  • Now run a loop at 0 to length of string.
  • And then check if our string is equal to the word.
  • If condition true then we increment the value of count by 1.

• Java provides inbuilt methods to copy array. Whether we want a full copy or partial copy of array, we can do it easily using java inbuilt classes.

• Object class provides clone() method and since array in java is also an Object, we can use this method to achieve full array copy.
• If you want partial copy of the array we cant’t use this method.

• • The following standard Java coding practices to solve this problem.
  • We have an encapsulated two co-ordinates in a Point class and have Rectangle has two Point instance variable and an instance method like equals() to check if another rectangle is overlapping or not.

• A rectangle can be represented by two coordinates, top left, and bottom right. As part of the problem you will be given four coordinates L1, R1 and L2, R2, top left and bottom right coordinate of two rectangles and you need to write a function isOverlapping() which should return true if rectangles are overlapping or false if they are not.

• One of the simplest Sorting techniques is a linear sort.
• Linear sort is the selection of an element and keeping it in sorted order.
• In linear sort, the strategy is to find the smallest number in the array and exchange it with the value in first position of array.
• Now, find the second smallest element in the remainder of array and exchange it with a value in the second position, carry on till you have reached the end of array.
• Now all the elements have been sorted in ascending order.

• The same URL can be encoded multiple times, we need to decode it until the URL cannnot be decoded further. For example, “video%252Fmp4” is the result of two encodings. Upon decoding it once, we get “video%2Fmp4”. Now the URL needs to be further decoded so that we get “video/mp4”, which is the result.
• We use the decode method of a predefined Java class named URLDecoder.
• The decode method of URLDecoder takes two arguments:
  • The first argument defines the URL to be decoded.
  • The second argument defines the decoding scheme to be used.
• After decoding, the resulting decoded URL is returned.
• We create two variables: prevURL, which is empty, and decodeURL, which contains the URL to be decoded.
• We create an iteration that runs until prevURL!=decodeURL
• Now we update prevURL to decodeURL and update decodeURL with the decoded value of the URL passed.
• As you can see, prevURL!=decodeURL, so we run it again and again.
• Now, prevURL=decodeURL, so the decoded URL is returned.

Sample Code

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
 
public class DecodeURLExample {
    public static void main(String a[]){
        try {
            System.out.println(URLDecoder.decode("special+chars%3A+%26%25*+", "UTF-8"));
        } catch (UnsupportedEncodingException ex) {
            ex.printStackTrace();
        }
    }
}

special chars: &%* 

• A palindrome is a word, phrase, number, or other sequence of characters which reads the same backward as forward, example as madam.
• Write a java program to find the longest palindrome present in a given string.

• The string can be of odd or even length and hence the findLongestPalindromeWithSpecifiedParameter() is called twice for each string.
• In the method, findLongestPalindromeWithSpecifiedParameter() left will decrement and move towards the start of the string until it reaches start and then right will increment and move towards the end of the string until it reaches the end.
• And any left and right reach destination (i.e. start and end respectively)at any point then the method will return.