MODULE 4 PYQ
a) Illustrate the usage of the following methods related to String with
appropriate sample code. (i) length( ) (ii) charAt( ) (iii) equalsIgnoreCase( )
b) Discuss the need for thread synchronization. Explain how a method can be
synchronized with an example.
Why Thread Synchronization is Needed:
In Java, multithreading allows multiple threads to access shared resources
(like variables or methods) simultaneously. If threads are not properly
coordinated, data inconsistency and race conditions may occur.
Example Problem Without Synchronization:
If two threads update a shared variable at the same time, their operations may
interfere, leading to incorrect or unpredictable results.
Solution: Thread Synchronization
Java provides a mechanism called synchronization to ensure that only one
thread can access a method or block of code at a time. This prevents data
corruption and ensures consistency.
Explain the characteristics of the List interface in Java and its implementation
by classes such as ArrayList and LinkedList. Provide examples demonstrating
list operations.
Sure! Let’s break this down into easy parts so you can understand and
remember it well.
1. What is the List Interface in Java?
• List is a part of the Java Collections Framework.
• It represents an ordered collection (also known as a sequence).
• Allows duplicate elements.
• Elements can be accessed by their index (position).
• Commonly used classes that implement List:
o ArrayList
o LinkedList
o Vector
o Stack
2. Key Characteristics of List Interface
Feature Description
Ordered Maintains the insertion order
Index-based You can use get(index) to access items
access
Allows You can store the same element multiple times
duplicates
Grows/shrinks as elements are added/removed
Resizable (unlike arrays)
Null values Allows null values
3. ArrayList vs LinkedList
Feature ArrayList LinkedList
Structure Uses a dynamic array Uses a doubly linked list
Access Slower for access
Faster for get(index)
speed
Slower (elements need Faster (just changes links)
Insert/Delete
shifting)
Frequent
Best for Random access insertions/deletions
4. Example: Using ArrayList
import java.util.*;
public class ArrayListExample {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
// Add elements
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");
fruits.add("Banana"); // Duplicates allowed
// Access element by index
System.out.println("First fruit: " + fruits.get(0));
// Remove an element
fruits.remove("Banana"); // Removes first "Banana"
// Loop through list
System.out.println("All fruits:");
for (String fruit : fruits) {
System.out.println(fruit);
}
// Check if list contains an item
System.out.println("Contains Apple? " + fruits.contains("Apple"));
}
}
5. Example: Using LinkedList
import java.util.*;
public class LinkedListExample {
public static void main(String[] args) {
List<Integer> numbers = new LinkedList<>();
// Add elements
numbers.add(10);
numbers.add(20);
numbers.add(30);
// Add element at start and end
((LinkedList<Integer>) numbers).addFirst(5);
((LinkedList<Integer>) numbers).addLast(40);
// Remove element
numbers.remove(Integer.valueOf(20));
// Print all elements
System.out.println("Numbers in list:");
for (int num : numbers) {
System.out.println(num);
}
}
}
6. Summary Points to Remember
• Use ArrayList when you need fast access.
• Use LinkedList when you need frequent insert/delete.
• Both implement List, so you can use common methods like:
o add(), remove(), get(), size(), contains(), etc.
Let me know if you want a table with methods and meanings or a practice
question!
Write a Java program to reverse a given string.
Explain how to concatenate two String objects in Java. Provide syntax and an
example. 3 8 Describe the sleep(), wait() and suspend() methods in a thread.
Explain how to concatenate two String objects in Java. Provide syntax and an
example. 3 8 Describe the sleep(), wait() and suspend() methods in a thread.
Sure! Let’s break down both your questions into clear, easy-to-study sections:
7. Concatenating Two Strings in Java
What is Concatenation?
Concatenation means joining two strings together.
Ways to Concatenate Strings in Java:
Method Description
+ operator Most common and simple
concat() method Built-in method of the String class
StringBuilder or Useful when joining many strings inside
StringBuffer loops
Syntax and Example
➤ Using + Operator:
String s1 = "Hello ";
String s2 = "World";
String result = s1 + s2;
System.out.println(result); // Output: Hello World
➤ Using concat() Method:
String s1 = "Good ";
String s2 = "Morning";
String result = s1.concat(s2);
System.out.println(result); // Output: Good Morning
8. Thread Methods: sleep(), wait(), suspend()
Let’s look at each one clearly:
1. sleep() Method
• Belongs to the Thread class.
• Makes the thread pause for a specified time (in milliseconds).
• Does not release the lock if the thread is holding one.
Syntax:
Thread.sleep(milliseconds);
Example:
try {
System.out.println("Sleeping for 2 seconds...");
Thread.sleep(2000); // 2000 ms = 2 seconds
System.out.println("Awake!");
} catch (InterruptedException e) {
e.printStackTrace();
}
2. wait() Method
• Defined in the Object class (not Thread).
• Causes the thread to wait until another thread calls notify() or notifyAll() on
the same object.
• Releases the lock during waiting.
Syntax:
synchronized (object) {
object.wait();
}
Example:
Used in thread communication – not usually shown alone.
3. suspend() Method (Deprecated)
• Suspends a thread’s execution until resumed.
• Deprecated due to the risk of deadlocks (it doesn’t release locks).
• Avoid using it. Use wait() or other safer techniques instead.
Example (Not recommended):
thread.suspend(); // Deprecated
thread.resume(); // Deprecated
Summary Table
Release Status
Method Class Usefulness
s Lock
Threa Pause Safe
sleep() No
d thread
Thread
wait() Object Yes coordinatio Safe
n
Release Status
Method Class Usefulness
s Lock
suspend( Threa Deprecate
No Old method
) d d
Let me know if you'd like visu
Draw and Explain the lifecycle of a thread showing the different states and
methods invoked.
Sure! Here's a clear explanation and diagram of the Thread Lifecycle in Java,
broken into parts for easy studying.
Thread Lifecycle in Java
A thread in Java goes through various states from creation to termination.
States of a Thread:
1. New
2. Runnable
3. Running
4. Blocked/Waiting
5. Timed Waiting
6. Terminated (Dead)
Lifecycle Diagram of a Thread
Let me describe it visually first (text-based) — I can also provide a proper
diagram image if you'd like.
+---------+ start() +-----------+
| New | ---------------------------> | Runnable |
+---------+ +-----------+
|
| (Scheduler picks thread)
v
+-----------+
| Running |
+-----------+
/ | \
/ | \
sleep()/wait() | completed/stop
/ |
+------------+<-----+ +-----------+
| Timed Wait | | Terminated|
+------------+ +-----------+
1. New State
• Thread is created but not started yet.
• Code:
• Thread t = new Thread();
2. Runnable State
• Thread is ready to run, waiting for CPU time.
• It may be picked anytime by the thread scheduler.
• Code:
• t.start();
3. Running State
• Thread is currently executing.
• Only one thread runs at a time on a single core.
• Comes here from Runnable when scheduler picks it.
4. Blocked / Waiting / Timed Waiting
Thread temporarily stops execution:
Type Method Description
synchronized Waiting to acquire a
Blocked lock
block/object
Waiting wait() Waiting indefinitely
Timed Waits for a specific
sleep(ms), join(ms) time
Waiting
5. Terminated (Dead) State
• Thread has finished execution or was stopped.
• Code:
o After run() method ends.
o Or when stop() (not recommended) is called.
Summary Table
State Trigger / Method Description
New new Thread() Thread created
Runnable start() Ready to run
Running CPU assigned Executing
Waiting wait() Waiting to be notified
Timed Waiting sleep(), join() Paused for a time
Blocked Enters locked block Waiting for lock
Terminated run() ends Finished
Would you like me to generate a neat diagram image for this thread lifecycle?
Sure! Here's a clear explanation and sample code for each of the String
methods you mentioned in Java. I've divided it into parts so it's easy to study.
(i) substring() Method
Purpose:
Extracts a portion of a string based on start and end index.
Syntax:
string.substring(startIndex); // from startIndex to end
string.substring(startIndex, endIndex); // from startIndex to endIndex-1
Example:
public class SubstringExample {
public static void main(String[] args) {
String text = "HelloWorld";
System.out.println(text.substring(5)); // Output: World
System.out.println(text.substring(0, 5)); // Output: Hello
}
}
(ii) replace() Method
Purpose:
Replaces one character or substring with another.
Syntax:
string.replace('oldChar', 'newChar');
string.replace("oldString", "newString");
Example:
public class ReplaceExample {
public static void main(String[] args) {
String text = "Java is fun";
System.out.println(text.replace("fun", "powerful")); // Output: Java is
powerful
}
}
(iii) equals() Method
Purpose:
Checks if two strings are exactly equal (case-sensitive).
Syntax:
string1.equals(string2)
Example:
public class EqualsExample {
public static void main(String[] args) {
String s1 = "Hello";
String s2 = "hello";
System.out.println(s1.equals(s2)); // Output: false
}
}
(iv) toLowerCase() Method
Purpose:
Converts all characters in the string to lowercase.
Syntax:
string.toLowerCase()
Example:
public class ToLowerCaseExample {
public static void main(String[] args) {
String text = "JAVA Programming";
System.out.println(text.toLowerCase()); // Output: java programming
}
}
Summary Table:
Method Description Example Output
Extracts part of a "HelloWorld".substring(5) →
substring() "World"
string
Replaces
replace() characters or "fun".replace("f", "r") → "run"
substrings
Compares two
equals() strings (case- "Hi".equals("hi") → false
sensitive)
Converts to "HELLO".toLowerCase() →
toLowerCase() "hello"
lowercase
Let me know if you'd like all these in a combined runnable Java file!
Write a java program to count the occurrence of a particular word within a
sentence using string handling methods.
Here's a simple Java program that counts the occurrence of a particular word
within a sentence using String handling methods like split(), equals(), and
toLowerCase():
Java Program: Count Word Occurrence in a Sentence
import java.util.Scanner;
public class WordCountExample {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// Input sentence
System.out.print("Enter a sentence: ");
String sentence = sc.nextLine();
// Input word to search
System.out.print("Enter the word to count: ");
String word = sc.nextLine();
// Convert both to lowercase to ignore case differences
String[] words = sentence.toLowerCase().split(" ");
String target = word.toLowerCase();
int count = 0;
for (String w : words) {
if (w.equals(target)) {
count++;
}
}
System.out.println("The word '" + word + "' occurs " + count + " time(s).");
sc.close();
}
}
Sample Output:
Enter a sentence: Java is easy. Java is powerful. Java is everywhere.
Enter the word to count: Java
The word 'Java' occurs 3 time(s).
String Methods Used:
• split(" ") → Splits sentence into words.
• equals() → Checks word match.
• toLowerCase() → Case-insensitive comparison.
Let me know if you’d like a version that removes punctuation as well.
Describe the different character extraction methods of String class along with
their syntax. 3 8 Write notes on Array List in java.
Sure! Here's a concise 3-mark answer for each question as per typical exam
expectations:
1. Character Extraction Methods of String Class in Java
Java’s String class provides several methods to extract characters from a
string:
(i) charAt(int index)
• Returns the character at the specified index (0-based).
• Syntax:
• char ch = str.charAt(2);
(ii) getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
• Copies characters from the string into a character array.
• Syntax:
• str.getChars(0, 4, charArray, 0);
(iii) toCharArray()
• Converts the entire string into a character array.
• Syntax:
• char[] chars = str.toCharArray();
These methods are useful when individual characters or sub-parts of a string
need to be accessed or manipulated.
2. Notes on ArrayList in Java
• ArrayList is a resizable array implementation of the List interface in Java.
• It is present in java.util package and allows dynamic memory allocation.
Features:
• Can store duplicate elements.
• Maintains insertion order.
• Allows random access via index.
• Automatically resizes when elements are added/removed.
Example:
import java.util.ArrayList;
public class Example {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
System.out.println(list); // [Apple, Banana]
}
}
ArrayLists are widely used for managing lists of data where resizing is
required frequently.
Let me know if you want these formatted for handwritten notes or flashcards!
Write short note on any four methods of String class.
Sure! Here's a short note on four commonly used methods of the String
class in Java, suitable for a 3-mark answer:
Short Note on Four String Methods:
1. length()
• Returns the number of characters in the string.
• Syntax: str.length();
• Example: "Hello".length() → 5
2. charAt(int index)
• Returns the character at the specified index (0-based).
• Syntax: str.charAt(2);
• Example: "Java".charAt(1) → 'a'
3. substring(int beginIndex, int endIndex)
• Returns a part of the string from beginIndex to endIndex - 1.
• Syntax: str.substring(0, 4);
• Example: "HelloWorld".substring(0, 5) → "Hello"
4. toLowerCase()
• Converts the entire string to lowercase.
• Syntax: str.toLowerCase();
• Example: "JAVA".toLowerCase() → "java"
Let me know if you want two more for a 5-mark question!
Write any three constructors of String class.
Here are three constructors of the String class in Java:
Three Constructors of the String Class:
1. String()
• Purpose: Creates an empty string (a string with no characters).
• Syntax:
• String str = new String();
• Example:
• String emptyStr = new String(); // Creates an empty string
• System.out.println(emptyStr); // Output: (empty string)
2. String(String original)
• Purpose: Creates a string that is a copy of the given string.
• Syntax:
• String str = new String("Hello");
• Example:
• String str = new String("Hello");
• System.out.println(str); // Output: Hello
3. String(char[] value)
• Purpose: Creates a string from an array of characters.
• Syntax:
• String str = new String(char[] value);
• Example:
• char[] chars = {'J', 'a', 'v', 'a'};
• String str = new String(chars);
• System.out.println(str); // Output: Java
These constructors are helpful in creating strings in different ways depending
on the available data (empty, copied, or from a character array).
