FOET

Unit – 2 Department of IT

Array, String & Java Programming

Collection Classes 01IT0404

Prof. Tarannum
Bloch
 Group oflike-typed variables

Referred by a common name

Arrays
 Advantages ofArray
• Wecanstore multiple elements of the sametype under asingle
variable.
• Wecanimplement other data structures suchasStack,Queue,
Tree, etc. with the help of anarray.
• Wecanfetch data elements usingthe index at run time.

Array Disadvantages ofArray

• Before usinganarray,it is mandatory to declare its size.
• It is astatic structure, sowe cannot increaseor decreases memory
allocation.
• Insertion and deletion operations are difficultbecause elements
stored at the contiguous memory location. It also increases the
cost.
• Allocate more memory than required isthe wastageof memory.
 type var-name[ ];
int month_days[ ];
//OR
type[ ] var name;
int[ ] month_days;
One-
Dimensional array-var = new type[size];

Arrays Example:
month_days = new int[12];

int month_days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,30, 31};
This is called compile-time initialization OR static
initialization of array.
 1. int array1[]= {5,10,15,20,25};

2. intarray1[] = new int[5];

for(j=0;j<5;j++)
Initialization array1[j] =j+5;
ofArray
3. intarray1[] = new int[5];
array1[0]=5;
array1[1]=10;
array1[2]=15;
array1[3]=20;
array1[4]=25;
 class Testarray{
public static void main(String args[]){

int a[] = new int[5];//declaration and instantiation

a[0]=10;//initialization
a[1]=20;
Example a[2]=70;
a[3]=40;
a[4]=50;
//traversing array
for(int i=0;i<a.length;i++)//length is the property of array
System.out.println(a[i]);
}
}
 int twoD[][] = new int[4][5]

Multi-
dimensional
Arrays

Conceptual View of a 4 by 5 two dimensional array

JaggedArray
Three
Dimensiona
l Array
Processing
Array
 Data in a table or a matrix can be represented using a two-
dimensional array.
An element in atwo-dimensional arrayis accessedthrough arow
and columnindex.
Two- Syntax:
elementType[ ][ ] arrayRefVar;
Dimensional OR
Array elementType arrayRefVar[ ][];
Ex:
int[ ][ ] matrix;
OR
int matrix[ ][ ];
Two-
Dimensional
Array
 Ex:
x = new int[3][4], x[0], x[1], and x[2] are one-dimensional
arrays and each contains four elements. So, x.length is 3,
and x[0].length, x[1].length, and x[2].length are 4.

Obtaining
length of2-D
Array
 class MultidimensionalArray {
public static void main(String[] args) {

// create a 2d array
int[][] a = {
{1, 2, 3},
{4, 5, 6, 9},
{7},
};

// calculate the length of each row

System.out.println("Length of row 1: " + a[0].length);
System.out.println("Length of row 2: " + a[1].length);
System.out.println("Length of row 3: " + a[2].length);
}
}

OUTPUT
Length of row 1: 3
Length of row 2: 4
Length of row 3: 1
Processing 2-
D Arrays
Processing 2-
D Arrays
m[0].length meaning the number of columns in row 0
 String is basically an object that represents sequence of char values. An array of
characters works same as Java string.

char[] ch={'j','a','v','a','p',‘r',‘o',‘g',‘r‘,’a’,’m’};
String s=new String(ch);

String is same as
String s="javaprogram";

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.
 java.lang.Stringclassprovidesalot of methodsto work on a string.

The java.lang.String class

implements Serializable, Comparable and CharSequence interfaces.

String Class
 The CharSequence interface is used to represent the sequence of
characters.

String, StringBuffer and StringBuilder classes implement it. It

means, we can create strings in Java by using these three classes.
CharSequence
Interface

Note: String Builder class is not in the syllabus of this course.

 • OnceaString object iscreated it cannot be changed.Strings are
Immutable.
• Toget changeable strings usethe classcalled StringBuffer.
String anyString= null;
• Array ofString:
Stringnames[ ] =newString[5];

String Class • Initialization of arrayof String:

Stringnames[ ]= {“Red”, “Orange”, “Yellow”, “Green”,

“Blue”, “Indigo”,“Violet”};
 There are two ways to create String object:
1.By string literal
2.By new keyword

1. Java String literal is created by using double quotes. For Example:

String s="welcome";
How to create
Each time you create a string literal, the JVM checks the "string constant pool"
a string object? 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. For example:

String s1="Welcome";
String s2="Welcome";//It doesn't create a new instance
 Why Java uses the concept of String literal?
How to create
To make Java more memory efficient (because no new objects
a string are created if it exists already in the string constant pool).
object?
 2. By new keyword

String s=new String("Welcome");

How to create
a string In such case, JVM will create a new string object in normal (non-
object? 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).
 public class StringExample{
public static void main(String args[]){
String s1="java";//creating string by Java string literal
char ch[]={'s','t','r','i','n','g','s'};
How to create a
String s2=new String(ch);//converting char array to string
string object?
String s3=new String("example");//creating Java string by new key
word System.out.println(s1);
Output
System.out.println(s2); Java
System.out.println(s3); strings
example
}}
 1. DefaultConstructor:
•Stringstr =newString( );

String Class
Constructors 2. Stringobject using anarrayofCharacters
• String(char charArray[ ])
• char Name[ ] ={‘J’, ‘A’, ‘V’, ‘A’, ‘P’, ‘R’, ‘O’, ‘G’};
• StringstrName =newString(Name);
 3. StringObject Initialized by rangefrom char array
String(char charArray[ ],intstartindex, intno_of_char)

startIndex : starting index is inclusive

endIndex : ending index is exclusive
String Class • char Name[ ] ={‘J’, ‘A’, ‘V’, ‘A’, ‘P’, ‘R’, ‘O’, ‘G’};
Constructors • StringstrName =newString(Name,3,5); // APR

4. Stringobject usinganotherStringObject:
• String (StringstrObject);
• char Name[ ] ={‘J’, ‘A’, ‘V’, ‘A’, ‘P’, ‘R’, ‘O’, ‘G’};
• StringstrName =newString(Name);
StringstrName2 =newString(strName);
 StringLiterals:

•char Name[ ] ={‘J’, ‘A’, ‘V’, ‘A’, ‘P’, ‘R’, ‘O’, ‘G’};
String Class • StringstrName =newString(Name);
OR
• String strName= “JAVAPROG”;
 •Thelength()method returns the length of the string.

Ex:System.out.println(“Hello”.length());// prints 5

String • The +operator is usedto concatenatetwo or more strings.

Operations Eg:Stringmyname =“Harry”;

Stringstr =“My name is” +myname+ “.”;

• For string concatenation the Java compiler converts an operandto

aString wheneverthe other operand of the +is a Stringobject.
 •Charactersin astring canbeextracted in anumber of ways.
public char charAt(int index)

Returns the character at the specified index. An index ranges from 0 to

String length() - 1. The first character of the sequence is at index 0, the next
Operations at index 1,andsoon, as for arrayindexing.

char ch;
ch=“abc”.charAt(1); // ch=“b”
 getChars() -Copiescharacters from this string into the
destination characterarray.

public void getChars(int srcBegin,int srcEnd,char[] dst,

int dstBegin)

• srcBegin - index of the first character in the string to

String copy.
Operations • srcEnd- index after the last character in the string to
copy.
• dst - the destination array.
• dstBegin - the start offset in the destination array.
Example
public class StringGetCharsExample{
public static void main(String args[]){
String str = new String("hello tarannum how r u");
char[] ch = new char[10];
try{
str.getChars(6, 15, ch, 0);
System.out.println(ch);
}catch(Exception ex){System.out.println(ex);}
}}

Output
tarannum h
 equals()-Comparesthe invoking string to the specified object.
The result is true if and only if the argument is not null and
is a String object that represents the same sequence of
charactersas the invokingobject.

public boolean equals(ObjectanObject)

String
Operations equalsIgnoreCase()- Compares this String to another String,
ignoring case considerations. Two strings are considered equal
ignoring case if they are of the same length, and corresponding
characters in the two strings areequal ignoringcase.

public boolean equalsIgnoreCase(StringanotherString)

 startsWith()– Testsif this string starts with the specified prefix.

public boolean startsWith(String prefix)

“Figure”.startsWith(“Fig”); //true

endsWith()- Testsif this string endswith the specified suffix. public

String boolean endsWith(String suffix)

“Figure”.endsWith(“re”); //true
Operations
String str1= “JAVA”;
String str2= “JAVA PROGRAMMING”;
String str3= “MING”;
str2.startWith(str1);
str2.endsWith(str3);
 startsWith()-Testsif this string starts with the specified
prefix beginning at aspecified index.

public boolean startsWith(String prefix, int toffset)

String prefix - the prefix.
Operations toffset - whereto begin looking in the string.

“figure”.startsWith(“gure”,2);// true
 compareTo() - Comparestwo strings lexicographically.
Theresult is anegative integer if this String object
lexicographically precedesthe argument string.

Theresult is apositive integer if this String object

lexicographically follows the argument string.

String Theresult is zeroif the strings areequal.

Operations compareToreturns 0 exactly when the equals(Object) method would

return true.

public intcompareTo(String anotherString)

public int compareToIgnoreCase(Stringstr)
 indexOf– Searchesfor the first occurrenceof acharacter or
substring. Returns-1if the character doesnot occur.

public int indexOf(intch)- Returnsthe indexwithin this string

of the first occurrenceof the specified character.
String
Operations public int indexOf(Stringstr) - Returnsthe index within this
stringof the first occurrenceof the specified substring.

Stringstr =“How wasyour day today?”;

str.indexof(‘t’);
str.indexof(“was”);
 public int indexOf(int ch, int fromIndex)- Returns the index within this string of
the first occurrence of the specified character, starting the search at the specified
index.

publicint indexOf(String str,int fromIndex)- Returnsthe index within this string

of the first occurrence of the specifiedsubstring,starting at the specifiedindex.

String Stringstr =“How wasyourdaytoday?”;

Operations str.indexof(‘a’, 6);

str.indexof(“was”,2);

lastIndexOf() –Searches for the last occurrence of a character or substring.

 public class IndexOfExample{

public static void main(String args[]){

String s1="this is index of example";

//passing substring
int index1=s1.indexOf("is");//returns the index of is substring
int index2=s1.indexOf("index");//returns the index of index substring
String System.out.println(index1+" "+index2);//

Operations //passing substring with from index

int index3=s1.indexOf("is",4);//returns the index of is substring after 4th index
System.out.println(index3);//i.e. the index of another is

//passing char value

int index4=s1.indexOf('s');//returns the index of s char value
System.out.println(index4);
}
}
 substring() - Returns a new string that is a substring of this
string. The substring begins with the character at the
specified index andextendsto the end of this string.
publicString substring(int beginIndex)

String
Eg:"unhappy".substring(2)
Operations returns "happy"

publicString substring(int beginIndex,int endIndex)

Eg:"smiles".substring(1, 5) returns “mile”
 concat()-Concatenates the specified string to the endof thisstring.

If the length of the argumentstring is 0, then this String object is

String returned.
Operations
Otherwise, anewString object iscreated, containing the invoking string
with the contents of the str appended to it.

public String concat(String str)

"to".concat("get").concat("her") returns"together"
 replace()-Returnsanewstring resultingfrom replacing all
occurrencesof oldChar in this string with newChar.

publicStringreplace(char oldChar,char newChar)

"mesquite in yourcellar".replace('e','o')
returns"mosquito in yourcollar"
String
Operations
trim()-Returnsacopy of the string, with leading andtrailing
whitespaceomitted.
public Stringtrim()

String s=“ Hi Mom! “.trim();

returns “HiMom!”
 No. Method Description

1 char charAt(int index) returns char value for the particular index

2 int length() returns string length

3 String substring(int beginIndex) returns substring for given begin index.

4 String substring(int beginIndex, int returns substring for given begin index and end index.
endIndex)

5 boolean contains(CharSequences) returns true or false after matching the sequence of char value.

6 static String join(CharSequence delimiter, returns a joined string.

CharSequence... elements)

Summary 7 boolean equals(Object another) checks the equality of string with the given object.

8 boolean isEmpty() checks if string is empty.

9 String concat(String str) concatenates the specified string.

10 static String equalsIgnoreCase(String compares another string. It doesn't check case.

another)

11 String[] split(String regex) returns a split string matching regex.

12 int indexOf(int ch) returns the specified char value index.

13 int indexOf(String substring) returns the specified substring index.

14 String toLowerCase() returns a string in lowercase.

15 String toUpperCase() returns a string in uppercase.

 Randommethod :This method generatesarandom double value
greater than or equal to 0.0 and less than 1.0

(0 <= Math.random()<1.0)

Math.random()
• Ex.(int)(Math.random() * 10)- - >Returnsarandom
integer between 0and9.
• a+Math.random() * b - - >Returnsarandom number
betweenaand a+b, excludinga+b.
• Ex.50+(int)(Math.random() * 100)- - >Returnsa
randominteger between 50and99.
 • AStringBuffer is like aString, but can be modified.

StringBuffer is a peer class of String that provides much of the

functionality of strings. String represents fixed-length, immutable
character sequences while StringBuffer represents growable and writable
character sequences.

The length and content of the StringBuffer sequence can be changed

String Buffer through certain method calls.

StringBuffer defines three constructors:

• StringBuffer()
• StringBuffer(intsize)
• StringBuffer(Stringstr)
 The principal operations on a StringBuffer are the append and insert
methods, which are overloadedsoasto accept data ofany type.

Here are few append methods:

StringBuffer append(String str)
StringBuffer append(intnum)

The append method alwaysaddsthese characters at the end ofthe buffer.

StringBuffer
 The insert method addsthe characters at aspecified point.

Here are few insert methods:

StringBufferinsert(int index,Stringstr)
StringBuffer StringBufferinsert(int index, char ch)

Index specifies at which point the string will be inserted into the
invokingStringBuffer object.
 delete() - Removes the characters in a substring of this
StringBuffer. Thesubstring begins at the specified start and extends
to the character at index end - 1or to the end of the StringBuffer if
StringBuffer no such character exists. If start is equal to end, no changes are
made.

publicStringBufferdelete(int start, int end)

 replace()-Replacesthe characters in asubstring of this
StringBufferwith characters in the specifiedString.
publicStringBuffer replace(int start, int end,Stringstr)

StringBuffer substring() - Returns a new String that contains a

subsequence of characters currently contained in this
StringBuffer.Thesubstring begins at the specified index and
extendsto the end of the StringBuffer.
publicStringsubstring(int start)
 reverse()-The character sequencecontained in this string
buffer is replacedby the reverseof the sequence.

public StringBufferreverse()

StringBuffer
length()-Returnsthe length of this string buffer.

public int length()

 capacity()- Returnsthe current capacityof the Stringbuffer.
The capacityis the amount of storageavailable for newly
insertedcharacters.

public intcapacity()
StringBuffer
charAt()-The specified character of the sequencecurrently
represented by the string buffer, as indicated by the index
argument, isreturned.

public char charAt(intindex)

 getChars() - Characters are copied from this string buffer
into the destination character array dst. The first character
to be copied is at index srcBegin; the last character to be
copied isat index srcEnd-1.
public void getChars(int srcBegin,int srcEnd, char[] dst,
StringBuffer int dstBegin)

setLength() - Setsthe length of the StringBuffer.

public void setLength(int newLength)
 No. Method Description
1 length() The length of a StringBuffer can be found by the
length( ) method
2 capacity() the total allocated capacity can be found by the
capacity( ) method.
3 append() It is used to add text at the end of the existence text
4 insert() It is used to insert text at the specified index position.

Summary
5 reverse() It can reverse the characters within a StringBuffer
object
6 delete(int startIndex, It can delete characters within a StringBuffer by using
int endIndex) the methods delete( )
7 replace() t can replace one set of characters with another set
8 indexOf(String str) This method returns the index within this string of the first
occurrence of the specified substring.
9 lastIndexOf(String str) This method returns the index within this string of the
last occurrence of the specified substring.
10 substring(int start) This method returns a new String that contains a
subsequence of characters
public class buffer {
public static void main(String[] args)
{
StringBuffer a = new StringBuffer(“stringbuffer”);
a.append(“in Java”);
System.out.println(a);
a.append(0);
System.out.println(a);
}
}
import java.io.*;
public class buffer {
public static void main(String[] args)
{
StringBuffer a = new StringBuffer(“stringbuffer”);
a.insert(5, “for”);
System.out.println(a);
a.insert(0, 5);
System.out.println(a);
a.insert(3, false);
System.out.println(a);
a.insert(5, 41.55d);
System.out.println(a);
a.insert(8, 41.55f);
System.out.println(a);
char arr[] = { ‘j’, ‘a’, ‘v’, ‘a’ };
a.insert(2, arr);
System.out.println(a);
}
}
import java.io.*;
public class buffer {
public static void main(String[] args)
{
StringBuffer a = new StringBuffer(“stringbuffer”);
a.replace(5, 8, “are”);
System.out.println(a);
}
}

output
strinareffer
 String
Vs.
StringBuffer
 • All Objects will be stores at HeapArea.
• String Constant Pool or String Literal Pool is an area in heap
memory where java stores String literal values.
== &equals •== operator always compare address or reference.
method • Equals method always compares Content.
difference
 The wrapper class in Java provides the mechanism to convert
primitive into object and object into primitive.

Since J2SE 5.0, autoboxing and unboxing feature convert

primitives into objects and objects into primitives automatically.
Wrapper class The automatic conversion of primitive into an object is known as
autoboxing and vice-versa unboxing.
 Change the value in Method: Java supports only call by value. So, if we
pass a primitive value, it will not change the original value. But, if we
convert the primitive value in an object, it will change the original value.

Serialization: We need to convert the objects into streams to perform

the serialization. If we have a primitive value, we can convert it in
objects through the wrapper classes.
Use of Wrapper Synchronization: Java synchronization works with objects in
class Multithreading.

java.util package: The java.util package provides the utility classes to

deal with objects.

Collection Framework: Java collection framework works with objects

only. All classes of the collection framework (ArrayList, LinkedList,
Vector, HashSet, LinkedHashSet, TreeSet, PriorityQueue, ArrayDeque,
etc.) deal with objects only.
 • Eachwrapper classimplements methods specific to each
data type exceptvoid class.
• Common methods implemented in all wrapper class:
 ClassType(type)
WrapperClass  type typeValue()
 int hashCode()
String toString()
boolean equals(Objectobj)
static boolean valueOf(Strings)
 Constructor
Primitive Data Type Wrapper Class
Argument

boolean Boolean boolean or String

byte Byte byte or String

char Character char
Wrapper Class int Integer int or String

float Float float, double or String

double Double double or String

long Long long or String

short Short short or String
WrapperClass
 1. ClassType(type):
Ex.Character c1=newCharacter(‘x’);
2. typeValue( ):
Ex. char c2 = c1.typeValue();
Common
3. toString( ):
Methods in Ex. System.out.println(c1.toString());
WrapperClass 4. equals():
Ex.S1.equals(s2);
5. valueOf():
Ex. Byte b1=valueOf(“101”,2);
 BooleanClass:
static boolean getBoolean(Stringname)

Boolean, ByteClass:
Byte,Short static byte parseByte(String s,int radix)
static byte parseByte(String s)
Class
ShortClass:
shortValue()
 isLowerCase() & isUpperCase()
static booleanisLowerCase(char ch)
staticboolean isUpperCase(char ch)
Ex.Characterc=newCharacter(‘g’);
boolean isLower= Character.isLowerCase(c);
Character isDigit( )
class static boolean isDigit(charch)
Ex. boolean isDigit= Character.isDigit(‘7’);
isSpace()
static boolean isSpace(charch)
Ex. boolean isSpace =Character.isSpace(‘\t’);
 toLowerCase( ) & toUpperCase( )
static char toLowerCase(char ch)
static char toUpperCase(charch)
Ex. char c1 = Character.toUpperCase(‘g’);
char c2 =Character.toLowerCase(‘M’);
digit( )
Character static int digit(char ch, int radix)
class Ex. char c1 =‘4’;
char c2 =‘c’;
int four =Character.digit(c1,10);
int twelve =Character.digit(c2,16);
forDigit( )
static char forDigit(int digit, int radix)
int i=10;
char c =Character.forDigit(I,16);
 Integer & Long Class
parseInt( )
static int parseInt(String s, int radix)
Integer static int parseInt(String s)
& Ex. Integer i = new Integer(17);
float f = i.floatValue();
LongClass
getInteger( )
static Integer getInteger(String name)
static Integer getInteger(String name, int val)
static Integer getInteger(String name, Integer val)
 Float & Double Class:
isNaN( )
boolean isNaN( )
static boolean isNaN(floatv)
Ex. Double d1 = newDouble(23.70);
Float System.out.println(“is d1 is not a number?”
+d1.isNaN());
& isInfinite( )
DoubleClass boolean isInfinite( )
static boolean isInfinite(floatv)
VoidClass:
void class has no constructors or methods & only one
member constantTYPE.
 • Theautomatic conversionof primitive datatype into its
correspondingwrapperclassisknownasautoboxing.
Forexample,byte to Byte,charto Character,int to Integer, longto Long,float
to Float,booleanto Boolean,doubleto Double,andshortto Short.
SinceJava5,wedonot needto usethe valueOf()methodof wrapperclassesto
converttheprimitive into objects.

Autoboxing public classWrapperExample1

{
public static void main(String args[])
{
int a=20;
Integeri=Integer.valueOf(a); //converting int into Integer explicitly

Integerj=a;
//autoboxing, now compiler will write Integer.valueOf(a) internally

System.out.println(a+" "+i+" "+j);

}
}
 The automatic conversion of wrapper type into its
corresponding primitive type is known as unboxing. It is the
reverse process ofautoboxing.

SinceJava5,we do not needto usethe intValue() method of

wrapper classesto convert the wrapper type into primitives.

Unboxing public classWrapperExample2

{
public static void main(String args[])
{
Integer a=newInteger(3);
int i=a.intValue();
//converting Integer to int explicitly
int j=a;
//unboxing, now compiler will write a.intValue()internally
System.out.println(a+" "+i+" "+j);
}
}
 1. Import theclass java.util.Random
2. Makethe instanceof the class Random
i.e., Randomr =new Random();
Random
3. Invokeone of the following methods of r object:
class nextInt(upperbound) generatesrandomnumbersin the
range 0 toupperbound-1.
nextFloat() generatesafloat between 0.0and 1.0.
nextDouble() generatesadouble between0.0 and 1.0.
 import java.util.Random;

classGenerateRandom
{
public static void main(String args[] )
{
Randomrand =new Random(); //instanceof random class

Random int upperbound= 25; //generate random values from0-24

int int_random = rand.nextInt(upperbound);
class double double_random=rand.nextDouble();
float float_random=rand.nextFloat();
Example
System.out.println("Random integer value from 0to" +
(upperbound-1) +" : "+ int_random);
System.out.println("Random float value between 0.0 and1.0: "+float_random);
System.out.println("Random double value between 0.0 and 1.0: "+double_random);
}
}
 The java command-line argument is an argument i.e. passed at the time of
running the java program.

The arguments passed from the console can be received in the java program
and it can be used as an input.

Command So, it provides a convenient way to check the behavior of the program for the
different values. You can pass N (1,2,3 and so on) numbers of arguments
Line from the command prompt.

Argument Check Program: commandLineArg.java

 Collection
Classes in Java
 The AbstractList class in Java is a part of the Java Collection Framework and
implements the Collection interface and the AbstractCollection class.

Abstract List
class

This class provides a skeletal implementation of the List interface to

minimize the effort required to implement this interface backed by a
Random Access data store (such as an array). For sequential access data
(such as a linked list), AbstractSequentialList should be used in preference to
this class.
 To implement an unmodifiable list, for which one needs to only extend this
AbstractList Class and implement the get(int) and the size() methods.

To implement a modifiable list, for which one additionally override the

set​(int index, E element) method (which otherwise throws an
UnsupportedOperationException).
Abstract List If the list is variable-size, for which one should override the add(int, E) and
class remove(int) methods.

methods
 Declaration:
public abstract class AbstractList<E> extends AbstractCollection<E>
implements List<E>

where E is the type of elements maintained by this collection.

Constructor:
protected AbstractList() – The default constructor, but being protected, it
doesn’t allow to create an AbstractList object.
Abstract List
class AbstractList<E> al = new ArrayList<E>();

Check example: AbstractListDemo.java

 The ArrayList class implements the List interface. It uses a dynamic array to
store the duplicate element of different data types.

The ArrayList class maintains the insertion order and is non-synchronized.

The elements stored in the ArrayList class can be randomly accessed.

Java ArrayList class uses a dynamic array for storing the elements. It is like
an array, but there is no size limit. We can add or remove elements
anytime. So, it is much more flexible than the traditional array. It is found in
Array List the java.util package. It is like the Vector in C++.

The ArrayList in Java can have the duplicate elements also. It implements the
List interface so we can use all the methods of the List interface here. The
ArrayList maintains the insertion order internally.

It inherits the AbstractList class and implements List interface.

ArrayList<int> al = ArrayList<int>(); // does not work

ArrayList<Integer> al = new ArrayList<Integer>(); // works fine

Check Program: ArrayListDemo.java

 ArrayList Constructors :

Array List
Array List
Methods
Array List
Methods
Array List
Methods
 Java LinkedList class uses a doubly linked list
to store the elements. It provides a linked-list
data structure. It inherits the AbstractList
class and implements List and Deque
interfaces.

The important points about Java LinkedList

Linked List are:
Java LinkedList class can contain duplicate
elements.
Java LinkedList class maintains insertion
order.
Java LinkedList class is non synchronized.
In Java LinkedList class, manipulation is fast
because no shifting needs to occur.
Java LinkedList class can be used as a list,
stack or queue.
 Linked List Class Declaration:

the declaration for java.util.LinkedList class.

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>,

Deque<E>, Cloneable, Serializable

Linked List Constructors of Java LinkedList

Constructors
Linked List
Methods
Linked List
Methods
Linked List
Methods
Linked List
Methods

Check Programs: LinkedListAddDemo.java, LinkedListRemoveDemo.java,

LinkedListSortingDemo.java
 A Java Cursor is an Iterator, which is used to iterate or traverse or retrieve a
Collection or Stream object’s elements one by one. There are three cursors in
Java.

1. Iterator
2. Enumeration
3. ListIterator
Enumeration Enumeration is It is an interface used to get elements of legacy
Iterative collections(Vector, Hashtable). Enumeration is the first iterator present
from JDK 1.0, rests are included in JDK 1.2 with more functionality.
Statements
Enumerations are also used to specify the input streams to a
SequenceInputStream. We can create an Enumeration object by calling
elements() method of vector class on any vector object .

// Here "v" is an Vector class object. e is of

// type Enumeration interface and refers to "v"

Enumeration e = v.elements();
 here are two methods in the Enumeration interface namely :

1. public boolean hasMoreElements(): This method tests if this enumeration

contains more elements or not.

2. public Object nextElement(): This method returns the next element of this
enumeration. It throws NoSuchElementException if no more element is
Enumeration present.

Iterative
Methods
 Vector is like the dynamic array which can grow or shrink its size. Unlike array,
we can store n-number of elements in it as there is no size limit. It is a part of
Java Collection framework since Java 1.2. It is found in the java.util package and
implements the List interface, so we can use all the methods of List interface
here.

It is recommended to use the Vector class in the thread-safe implementation

Vector Class only. If you don't need to use the thread-safe implementation, you should use
the ArrayList, the ArrayList will perform better in such case.
 It is similar to the ArrayList, but with two differences-

• Vector is synchronized.

• Java Vector contains many legacy methods that are not the part of a
collections framework.

Vector Class Java Vector class Declaration

public class Vector<E>

extends Object<E>
implements List<E>, Cloneable, Serializable
Vector Class
Constructor
Vector Class
Methods
Vector Class
Methods
Vector Class
Methods
Vector Class
Methods
END OF UNIT 2