Unit-2.Arrays and Strings.pptx.................

Arrays and Strings
Ms. Shilpa
Department of IT

Arrays in Java
• Array is an object which contains elements of a similar data type.
Additionally, It is a data structure where we store similar elements.
• The elements of an array are stored in a contiguous memory location.
• Array in Java is index-based, the first element of the array is stored at
the 0th index, 2nd element is stored on 1st index and so on.

Declaring an Array:
To declare an array in Java, you specify the data type of the array elements followed by
square brackets [] and then the array name.
Example:
int[] numbers;
String[] names;
Creating an Array:
To create an array, you use the new keyword along with the data type and the size
(number of elements) of the array.
Example:
int[] numbers = new int[5]; // Creates an array of 5 integers

Initializing an Array:
You can initialize the elements of an array at the time of declaration or later:
// Initializing at the time of declaration
int[] numbers = {1, 2, 3, 4, 5};
String[] names = {"Alice", "Bob", "Charlie", "David", "Eva"};
// Initializing later
numbers[0] = 10;
numbers[1] = 20;
// ...

Accessing Elements:
Array elements are accessed using an index. The index starts from 0 for the first
element and goes up to length - 1 for an array of length length.
For example:
int firstElement = numbers[0];
Array Length:
The length property is used to get the number of elements in an array
int arrayLength = numbers.length;

Sorting an array
The sorting is a way to arrange elements of a list or array in a certain
order. The order may be in ascending or descending order.
Sorting an array in Java can be done using the Arrays.sort() method for
primitive arrays (eg, int[])

How you can declare and initialize an array to store 5
numbers in Java:
public class ArrayExample {
public static void main(String[] args) {
// Declare and initialize an array to store 5 numbers
int[] numbers = {10, 20, 30, 40, 50};
// Access and print each element of the array
for (int i = 0; i < numbers.length; i++) {
System.out.println("Element at index " + i + ": " + numbers[i]);
}
}
}
Output:
Element at index 0: 10
The for loop will iterate for values of i starting from 0 up
to numbers.length, which is 5 in this case. Therefore,
the loop will run for i equal to 0, 1, 2, 3 and 4 making a
total of 5 iterations

Java program to sort an array of integers
import java.util.Arrays;
public class ArraySorting {
// Array of integers
int[] numbers = {5, 2, 8, 1, 6};
// Sorting the array in ascending order
Arrays.sort(numbers);
// Displaying the sorted array
System.out.println("Sorted Array (Ascending): " + Arrays.toString(numbers));
}
}
• An array named numbers is declared and initialized with five integer values: 5, 2, 8, 1, and 6.
• The Arrays.sort() method is used to sort the elements of the numbers array in ascending order
• Arrays.toString(numbers) method is used to convert the array into a readable string representation.

Java program to sort the array of strings
import java.util.Arrays;
public class StringArraySorting {
// Array of strings
String[] names = {"Eva" , "Alice", "Charlie", "Bob", "David"};
// Sorting the array in ascending order
Arrays.sort(names);
// Displaying the sorted array
System.out.println("Sorted Array (Ascending): " +
Arrays.toString(names));
}
}

Multidimensional Array
A multidimensional array is an array that contains other arrays. The
most common types are 2D and 3D arrays, representing matrices and
cubes, respectively.
// Declaration and Initialization of a 2D array
int[][] twoDArray = new int[3][4];
int[][] twoDArray = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};

public class MultidimensionalArrayExample {
// Declaration and Initialization of a 2D array
int[][] twoDArray = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
// Accessing and printing elements
System.out.println("Element at row 1, column 2: " + twoDArray[0][1]);
System.out.println("Element at row 2, column 3: " + twoDArray[1][2]);
}
}
In the example above, we have twoDArray with three rows and four columns. The key idea
is that each element in the array is accessed using two indices: the row index and the
column index.

String
• String is an object that represents a sequence of characters.
The java.lang.String class is used to create a string object.
• Java String class provides a lot of methods to perform operations on
strings such as compare(), concat(), equals(), split(), length(),
replace(), compareTo(), intern(), substring() etc.

How to create a string object?
• There are two ways to create String object:
• By string literal
• By new keyword
1) String Literal
Java String literal is created by using double quotes.
For Example: String s="welcome";
Each time you create a string literal, the JVM checks the "string
constant pool" first. If the string already exists in the pool, a reference
to the pooled instance is returned. If the string doesn't exist in the
pool, a new string instance is created and placed in the pool

String s1="Welcome";
String s2="Welcome";//It doesn't create a new instance
String objects are stored in a special
memory area known as the "string constant
pool"
Here only one object will be created. Firstly, JVM will not find any string
object with the value "Welcome" in string constant pool that is why it will
create a new object. After that it will find the string with the value
"Welcome" in the pool, it will not create a new object but will return the
reference to the same instance

2. By new keyword
• String s=new String("Welcome");//creates two objects and one reference
variable
• In such case, JVM will create a new string object in normal (non-pool)
heap memory, and the literal "Welcome" will be placed in the string
constant pool. The variable s will refer to the object in a heap (non-pool).

Declaration and Initialization:
// Using String literal
String str1 = "Hello";
// Using the new keyword
String str2 = new String("World");
String Concatenation: Strings can be concatenated using the + operator:
String firstName = "John";
String lastName = “AB";
String fullName = firstName + " " + lastName;
String class:

String Comparison:
You can compare strings using the equals() method for content equality
Example:
String str1 = "Hello";
String str2 = "hello";
boolean isEqual = str1.equals(str2); // Returns false

String charAt() Method
The String class charAt() method returns a character at specified index.
Example:
public class Stringoperation4
{
public static void main(String args[])
{
String s="Sachin";
System.out.println(s.charAt(0)); //S
System.out.println(s.charAt(3));//h
}
}

String length() Method
• The String class length() method returns length of the specified String.i e you can
find the length of a string.
Example:
{
{
String s="Sachin";
System.out.println(s.length());//6
}
}

String startsWith() and endsWith() method
The method startsWith() checks whether the String starts with the letters
passed as arguments and endsWith() method checks whether the String
ends with the letters passed as arguments.
Example:
{
public static void main(String ar[])
{
String s="Sachin";
System.out.println(s.startsWith("Sa"));//true
System.out.println(s.endsWith("n"));//true
}
}

String replace() Method
The String class replace() method replaces all occurrence of first sequence of character
with second sequence of character.
Example:
{
{
String s1="Java is fun.";
String replaceString=s1.replace(“fun",“Awesome");//replaces all occurrences of “fun" to “
Awesome "
System.out.println(replaceString);
}
}

String trim() method
The String class trim() method eliminates white spaces before and after the
String.
Example:
{
{
String s=" Sachin ";
System.out.println(s);// Sachin
System.out.println(s.trim());//Sachin
}
}

String Case Conversion:
The Java String toUpperCase() method converts this String into uppercase letter and
String toLowerCase() method into lowercase letter.
Example:
{
{
String s="Sachin";
System.out.println(s.toUpperCase());//SACHIN
System.out.println(s.toLowerCase());//sachin
System.out.println(s);//Sachin(no change in original)
}
}

StringBuffer Class
• StringBuffer class is used to create mutable (modifiable) String objects. i.e. it can
be changed.
• A String that can be modified or changed is known as mutable String.
• StringBuffer is synchronized, which means it is thread-safe. Multiple threads can
safely access a StringBuffer object without any issues.
• StringBuffer contains various methods for string manipulation, such as append,
insert, delete, reverse, etc
Constructor Description
StringBuffer() It creates an empty String buffer with the initial capacity of 16.
StringBuffer(String str) It creates a String buffer with the specified string..
StringBuffer(int capacity) It creates an empty String buffer with the specified capacity as length

StringBuffer append() Method:
The append() method concatenates the given argument with this String.
Example:
class StringBufferExample{
public static void main(String args[]){
StringBuffer sb=new StringBuffer("Hello ");
sb.append("Java");//now original string is changed
System.out.println(sb);//prints Hello Java
}
}

StringBuffer insert() Method:
The insert() method inserts the given String with this string at the given
position.
Example:
class StringBufferExample2{
StringBuffer sb=new StringBuffer("Hello ");
sb.insert(1,"Java");//now original string is changed
System.out.println(sb);//prints HJavaello
}
}

StringBuffer delete() Method:
The delete() method of the StringBuffer class deletes the String from the
specified beginIndex to endIndex.
Example:
StringBuffer sb=new StringBuffer("Hello");
sb.delete(1,3);
System.out.println(sb);//prints Hlo
}
}
The delete(1, 3) method deletes characters from index 1 to index 2
(excluding index 3).

StringBuffer reverse() Method:
The reverse() method of the StringBuilder class reverses the current String.
Example:
StringBuffer sb=new StringBuffer("Hello");
sb.reverse();
System.out.println(sb);//prints olleH
}
}

StringBuilder Class
Java StringBuilder class is used to create mutable (modifiable) String.
The Java StringBuilder class is same as StringBuffer class except that it is
non-synchronized.
Constructor Description
StringBuilder() It creates an empty String Builder with the initial capacity of 16.
StringBuilder(String str) It creates a String Builder with the specified string.
StringBuilder(int length) It creates an empty String Builder with the specified capacity as
length.

StringBuilder append() method:
The StringBuilder append() method concatenates the given argument with
this String.
class StringBuilderExample{
StringBuilder sb=new StringBuilder("Hello ");
sb.append("Java");//now original string is changed
System.out.println(sb);//prints Hello Java
}
}

StringBuilder insert() method
The StringBuilder insert() method inserts the given string with this string at the
given position.
class StringBuilderExample2{
StringBuilder sb=new StringBuilder("Hello ");
sb.insert(1,"Java");//now original string is changed
System.out.println(sb);//prints HJavaello
}
}

StringBuilder replace() method
• The StringBuilder replace() method replaces the given string from the
specified beginIndex and endIndex.
StringBuilder sb=new StringBuilder("Hello");
sb.replace(1,3,"Java");
System.out.println(sb);//prints HJavalo
}
}

StringBuilder delete() method:
The delete() method of StringBuilder class deletes the string from the
specified beginIndex to endIndex.
sb.delete(1,3);
System.out.println(sb);//prints Hlo
}
}

StringBuilder reverse() method:
The reverse() method of StringBuilder class reverses the current string.
sb.reverse();
System.out.println(sb);//prints olleH
}
}

String Constructor.
1. Empty Constructor:
2. Constructor with String Argument:
3. Constructor with Byte Array Argument:
4. Constructor with Character Array Argument:

1. Empty Constructor: This creates an empty string object with no
characters.
Example:
public class StringClassExample {
String str = new String();
System.out.print("Value of str is ""+str+""");
}
}
Here an empty string is created using the String constructor with no
arguments.

2. Constructor from another string
Creates a string object initialized with the specified string.
Example:
String greeting = new String("Hello, World!");
System.out.println("Greeting: " + greeting);

3. Constructor with Byte Array:
Creates a string from an array of bytes.
// Create a byte array
byte[] byteArray = {72, 101, 108, 108, 111};
String str = new String(byteArray);

4. Constructor with Character Array:
This creates a string object from a character array.
char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String fromCharArray = new String(charArray);

Java program demonstrating the use of string constructors:
public class StringConstructorExample {
// Using different string constructors
String str1 = new String(); // Empty constructor
String str2 = new String("Hello"); // Constructor with string argument
char[] charArray = {'W', 'o', 'r', 'l', 'd'};
String str3 = new String(charArray); // Constructor with char array argument
// Displaying the strings
System.out.println("String 1: " + str1);
}
}

Unit-2.Arrays and Strings.pptx.................

More Related Content

Similar to Unit-2.Arrays and Strings.pptx................. (20)

Recently uploaded (20)

Unit-2.Arrays and Strings.pptx.................