Scribd
Upload
46 views26 pages

Collections Framework

The document provides an overview of the Java Collections Framework, detailing various collection types such as List, Map, Set, and Queue, along with their implementations like ArrayList, HashMap, HashSet, and PriorityQueue. Each section includes sample code demonstrating the creation, manipulation, and output of these collections. The document highlights key operations and behaviors of each collection type, such as size, capacity, and element retrieval.

Uploaded by

rajkirannaidu123
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
46 views26 pages

Collections Framework

The document provides an overview of the Java Collections Framework, detailing various collection types such as List, Map, Set, and Queue, along with their implementations like ArrayList, HashMap, HashSet, and PriorityQueue. Each section includes sample code demonstrating the creation, manipulation, and output of these collections. The document highlights key operations and behaviors of each collection type, such as size, capacity, and element retrieval.

Uploaded by

rajkirannaidu123
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Collections Framework:

Collection:
List:
1) ArrayList:

import [Link].*;
public class ArrayList1
{
public static void main(String args[]){
ArrayList<Integer> a=new ArrayList<Integer>();
[Link](a);
[Link](34);
[Link](0,78);
[Link](a);
[Link](5);
[Link]("Size:"+[Link]());
[Link](19);
[Link](24);
[Link](36);
[Link](48);
[Link](57);
[Link](63);
[Link](72);
[Link](86);
[Link](94);
[Link]("Size:"+[Link]());
// we cant get "capacity" for ArrayList
[Link](a);
[Link]([Link](7));
[Link]([Link](48));
[Link]([Link](1,10));
[Link](a);
[Link]([Link](5));
[Link](a);
[Link]([Link](a));
[Link](a);
}
}

Output:

[]
[78, 34]
Size:3
Size:12
[78, 34, 5, 19, 24, 36, 48, 57, 63, 72, 86, 94]
57
true
34
[78, 10, 5, 19, 24, 36, 48, 57, 63, 72, 86, 94]
36
[78, 10, 5, 19, 24, 48, 57, 63, 72, 86, 94]
true
[]

2) Vector

import [Link].*;
public class Vector1
{
public static void main(String args[]){
Vector<String> v=new Vector<String>();
[Link](v);
[Link]("Ayush");
[Link](0,"Ashish");
[Link](v);
[Link]("a");
[Link]("Size:"+[Link]());
[Link]("Capacity:"+[Link]());
[Link]("b");
[Link]("c");
[Link]("d");
[Link]("e");
[Link]("g");
[Link]("g");
[Link]("h");
[Link]("x");
[Link]("y");
[Link]("Size:"+[Link]());
[Link]("Capacity:"+[Link]());
[Link](v);
[Link]([Link](5));
[Link]([Link]("t"));
[Link]([Link](1,"y"));
[Link](v);
[Link]([Link](5));
[Link](v);
[Link]([Link]("g"));
[Link](v);
[Link]([Link](v));
[Link](v);
}
}
Output:

[]
[Ashish, Ayush]
Size:3
Capacity:10
Size:12
Capacity:20
[Ashish, Ayush, a, b, c, d, e, g, g, h, x, y]
d
false
Ayush
[Ashish, y, a, b, c, d, e, g, g, h, x, y]
d
[Ashish, y, a, b, c, e, g, g, h, x, y]
true
[Ashish, y, a, b, c, e, g, h, x, y]
true
[]

3) Stack

import [Link].*;
public class Stack1
{
public static void main(String args[]){
Stack<Integer> a=new Stack<Integer>();
[Link](a);
[Link](34);
[Link](0,78);
[Link](a);
[Link](5);
[Link]("Size:"+[Link]());
[Link]("Capacity:"+[Link]());
[Link](19);
[Link](24);
[Link](36);
[Link](48);
[Link](57);
[Link](63);
[Link](72);
[Link](86);
[Link](94);
[Link]("Size:"+[Link]());
[Link]("Capacity:"+[Link]());
[Link](a);
[Link]([Link](7));
[Link]([Link](48));
[Link]([Link](1,10));
[Link](a);
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
// we cant place certain value in pop method because top element only removed.
[Link](a);
[Link]([Link](5));
[Link]([Link](78));
[Link]([Link](a));
[Link](a);
}
}

Output:

[]
[78, 34]
Size:3
Capacity:10
Size:12
Capacity:20
[78, 34, 5, 19, 24, 36, 48, 57, 63, 72, 86, 94]
57
true
34
[78, 10, 5, 19, 24, 36, 48, 57, 63, 72, 86, 94]
94
86
72
[78, 10, 5, 19, 24, 36, 48, 57, 63, 72]
8
0
true
[]

4) LinkedList

import [Link].*;
public class LinkedList1
{
public static void main(String args[]){
LinkedList<String> v=new LinkedList<String>();
[Link](v);
[Link]("r");
[Link](0,"e");
[Link](v);
[Link]("a");
[Link]("Size:"+[Link]());
[Link]("b");
[Link]("c");
[Link]("d");
[Link]("e");
[Link]("g");
[Link]("g");
[Link]("h");
[Link]("x");
[Link]("y");
[Link]("Size:"+[Link]());
[Link](v);
[Link]([Link](5));
[Link]([Link]("t"));
[Link]([Link](1,"y"));
[Link](v);
[Link]([Link](5));
[Link](v);
[Link]([Link]("g"));
[Link](v);
[Link]([Link](v));
[Link](v);
}
}

Output:

[]
[e, r]
Size:3
Size:12
[e, r, a, b, c, d, e, g, g, h, x, y]
d
false
r
[e, y, a, b, c, d, e, g, g, h, x, y]
d
[e, y, a, b, c, e, g, g, h, x, y]
true
[e, y, a, b, c, e, g, h, x, y]
true
[]

Map:

5)HashMap

import [Link].*;
public class HashMap1
{
public static void main(String args[]){
HashMap<Integer,String> h=new HashMap<Integer,String>();
[Link](h);
[Link](1,"r");
[Link](2,"e");
[Link](h);
[Link](3,"a");
[Link]("Size:"+[Link]());
[Link](5,"b");
[Link](7,"c");
[Link](8,"d");
[Link](23,"e");
[Link](23,"e");
[Link](23,"z");
[Link](56,"g");
[Link](34,"g");
[Link](32,"h");
[Link](18,"x");
[Link](29,"y");
[Link]("Size:"+[Link]());
[Link](h);
[Link]([Link](23));// 23 is key to get regarding value
[Link]([Link](56));
[Link]([Link]("e"));
[Link](h);
[Link]();
[Link](h);

//The clear method in HashMap does not return a value


//(it has a return type of void),
//so you cannot directly use it as an argument to [Link]().
}
}

Output:

{}
{1=r, 2=e}
Size:3
Size:12
{32=h, 1=r, 2=e, 34=g, 18=x, 3=a, 5=b, 7=c, 23=z, 8=d, 56=g, 29=y}
z
true
true
{32=h, 1=r, 2=e, 34=g, 18=x, 3=a, 5=b, 7=c, 23=z, 8=d, 56=g, 29=y}
{}

6)LinkedHashMap

import [Link].*;
public class LinkedHashMap1
{
public static void main(String args[]){
LinkedHashMap<Integer,String> a=new LinkedHashMap<Integer,String>();
[Link](a);
[Link](34,"a");
[Link](5,"b");
[Link]("Size:"+[Link]());
[Link](19,"c");
[Link](24,"d");
[Link](36,"e");
[Link](48,"f");
[Link](57,"g");
[Link](63,"h");
[Link](72,"i");
[Link](a);
[Link]("Size:"+[Link]());
[Link](a);
[Link]([Link](57));
[Link](a);
}
}

Output:

{}
Size:2
{34=a, 5=b, 19=c, 24=d, 36=e, 48=f, 57=g, 63=h, 72=i}
Size:9
{34=a, 5=b, 19=c, 24=d, 36=e, 48=f, 57=g, 63=h, 72=i}
g
{34=a, 5=b, 19=c, 24=d, 36=e, 48=f, 63=h, 72=i}

7) TreeMap

import [Link].*;
public class TreeMap1
{
public static void main(String args[]){
TreeMap<Integer,String> a=new TreeMap<Integer,String>();
[Link](a);
[Link](34,"a");
[Link](5,"b");
[Link]("Size:"+[Link]());
[Link](78,"c");
[Link](3,"g");
[Link](8,"e");
[Link](7,"v");
[Link](12,"r");
[Link](1,"q");
[Link](72,"m");
[Link](a);
[Link](86,"p");
[Link](94,"z");
//values are displayed as sorted order . not in a specified way
[Link]("Size:"+[Link]());
[Link](a);
[Link]([Link](12));
[Link](a);
}
}

Output:

{}
Size:2
{1=q, 3=g, 5=b, 7=v, 8=e, 12=r, 34=a, 72=m, 78=c}
Size:11
{1=q, 3=g, 5=b, 7=v, 8=e, 12=r, 34=a, 72=m, 78=c, 86=p, 94=z}
r
{1=q, 3=g, 5=b, 7=v, 8=e, 34=a, 72=m, 78=c, 86=p, 94=z}
Set

8) HashSet

import [Link].*;
public class HashSet1
{
public static void main(String args[]){
HashSet<Integer> a=new HashSet<Integer>();
[Link](a);
[Link](34);
[Link](5);
[Link]("Size:"+[Link]());
[Link](19);
[Link](24);
[Link](36);
[Link](48);
[Link](57);
[Link](63);
[Link](72);
[Link](a);
[Link](72);
// try to duplicate.
[Link](a);// 72 is not stored again.
[Link](86);
[Link](94);
//values are displayed as random order . not in a specified way
[Link]("Size:"+[Link]());
[Link]([Link](48));
[Link](a);
[Link]([Link](57));
[Link](a);
}
}

Output:

[]
Size:2
[48, 34, 19, 36, 5, 24, 72, 57, 63]
[48, 34, 19, 36, 5, 24, 72, 57, 63]
Size:11
true
[48, 34, 19, 36, 5, 86, 24, 72, 57, 94, 63]
true
[48, 34, 19, 36, 5, 86, 24, 72, 94, 63]

9) LinkedHashSet

import [Link].*;
public class LinkedHashSet1
{
public static void main(String args[]){
LinkedHashSet<Integer> a=new LinkedHashSet<Integer>();
[Link](a);
[Link](34);
[Link](5);
[Link]("Size:"+[Link]());
[Link](19);
[Link](24);
[Link](36);
[Link](48);
[Link](57);
[Link](63);
[Link](72);
[Link](a);
//It follows the insertion order .
[Link]("Size:"+[Link]());
[Link]([Link](48));
[Link](a);
[Link]([Link](57));
[Link](a);
}
}

Output:
[]
Size:2
[34, 5, 19, 24, 36, 48, 57, 63, 72]
Size:9
true
[34, 5, 19, 24, 36, 48, 57, 63, 72]
true
[34, 5, 19, 24, 36, 48, 63, 72]

10) TreeSet

import [Link].*;
public class TreeSet1
{
public static void main(String args[]){
TreeSet<Integer> a=new TreeSet<Integer>();
[Link](a);
[Link](34);
[Link](5);
[Link]("Size:"+[Link]());
[Link](5);
[Link](3);
[Link](8);
[Link](7);
[Link](12);
[Link](1);
[Link](72);
[Link](a);
[Link](72);
// try to duplicate.
[Link](a);// 72 is not stored again.
[Link](86);
[Link](94);
//values are displayed as sorted order . not in a specified way
[Link]("Size:"+[Link]());
[Link]([Link](48));
[Link](a);
[Link]([Link](57));
[Link](a);
}
}

Output:

[]
Size:2
[1, 3, 5, 7, 8, 12, 34, 72]
[1, 3, 5, 7, 8, 12, 34, 72]
Size:10
false
[1, 3, 5, 7, 8, 12, 34, 72, 86, 94]
false
[1, 3, 5, 7, 8, 12, 34, 72, 86, 94]

Queue:

11)Priority Queue
import [Link].*;
public class PriorityQueue1
{
public static void main(String args[]){
PriorityQueue<Integer> a=new PriorityQueue<Integer>();
[Link](a);
[Link](34);
[Link](a);
[Link](5);
[Link]("Size:"+[Link]());
[Link](19);
[Link](24);
[Link](36);
[Link](48);
[Link](57);
[Link](63);
[Link](72);
[Link](86);
[Link](94);
[Link]("Size:"+[Link]());
//the interger which is small that has highest
//priority that is stored in "head/front".
//remaining all stored in random order.
[Link](a);
[Link]([Link](48));
[Link]([Link](5));
//5 is least element deleted.
//then searching performed the small integer now is 19
//so 19 placed at "head"
[Link](a);
[Link]([Link]());
// displayed the "front " element then deleted.
[Link](a);
[Link]([Link](a));
[Link](a);
}
}

Output:

[]
[34]
Size:2
Size:11
[5, 24, 19, 34, 36, 48, 57, 63, 72, 86, 94]
true
true
[19, 24, 48, 34, 36, 94, 57, 63, 72, 86]
19
[24, 34, 48, 63, 36, 94, 57, 86, 72]
true
[]
12) Array Deque

import [Link].*;
public class ArrayDeque1
{
public static void main(String args[]){
ArrayDeque<Integer> a=new ArrayDeque<Integer>();
[Link](a);
[Link](34);
[Link](5);
[Link]("Size:"+[Link]());
[Link](19);
[Link](24);
[Link](36);
[Link](48);
[Link](57);
[Link](63);
[Link](72);
[Link](32);
[Link](86);
[Link](59);
[Link](64);
[Link](19);
[Link](94);
[Link]("Size:"+[Link]());
[Link](a);
[Link]([Link](48));
[Link]([Link](59));
[Link](a);
[Link]([Link]());
[Link]([Link]());
[Link](a);
[Link]([Link]());
// displayed the "front " element then deleted.
[Link]([Link]());
[Link]([Link]());
[Link](a);
[Link]([Link]());
// displayed the first element
[Link]([Link]());
[Link]([Link]());
//displayed the last element
[Link](a);
[Link]([Link](a));
[Link](a);
}
}

Output:

[]
Size:2
Size:15
[59, 86, 63, 57, 34, 5, 19, 24, 36, 48, 72, 32, 64, 19, 94]
true
true
[86, 63, 57, 34, 5, 19, 24, 36, 48, 72, 32, 64, 19, 94]
86
94
[63, 57, 34, 5, 19, 24, 36, 48, 72, 32, 64, 19]
63
57
19
[34, 5, 19, 24, 36, 48, 72, 32, 64]
34
34
64
[34, 5, 19, 24, 36, 48, 72, 32, 64]
true
[]

13)LinkedList

import [Link].*;
public class LinkedList2
{
public static void main(String args[]){
LinkedList<String> a=new LinkedList<String>();
[Link](a);
[Link]("a");
[Link]("b");
[Link]("Size:"+[Link]());
[Link]("c");
[Link]("d");
[Link]("f");
[Link]("g");
[Link]("h");
[Link]("i");
[Link]("j");
[Link]("k");
[Link]("l");
[Link]("m");
[Link]("n");
[Link]("o");
[Link]("p");
[Link]("Size:"+[Link]());
//stored in a specified order.
[Link](a);
[Link]([Link]("k"));
[Link]([Link]("i"));
[Link](a);
[Link]([Link]());
[Link]([Link]());
[Link](a);
[Link]([Link]());
// displayed the "front " element then deleted.
[Link]([Link]());
[Link]([Link]());
[Link](a);
[Link]([Link]());
// displayed the first element
[Link]([Link]());
[Link]([Link]());
//displayed the last element
[Link](a);
[Link]([Link](a));
[Link](a);
}
}

Output:
[]
Size:2
Size:15
[m, l, i, h, a, b, c, d, f, g, j, k, n, o, p]
true
true
[m, l, h, a, b, c, d, f, g, j, k, n, o, p]
m
p
[l, h, a, b, c, d, f, g, j, k, n, o]
l
h
o
[a, b, c, d, f, g, j, k, n]
a
a
n
[a, b, c, d, f, g, j, k, n]
true
[]

You might also like