Unit 4 java
Uploaded by
Sattwik MannaUnit 4 java
Uploaded by
Sattwik MannaCollection in Java Iterator Interface
➔ A collection in Java is a framework that provides an architecture to store ➔ T he Iterator interface provides a way to access elements of a collection
and manipulate a group of objects. sequentially without exposing the underlying structure.
➔ Java Collections can achieve all the operations that you perform on data ➔ It is part of thejava.util packageand is a universaliterator for all
such assearching,sorting,insertion,manipulation,anddeletion. collections.
➔ Key Points: ➔ Key Points:
➔ Collections are used tostore,retrieve,manipulate,and ➔ Methods:
communicate aggregate data. ◆ boolean hasNext(): Returns true if there are more
➔ Collections can hold both homogeneous and heterogeneous data. elements to iterate over.
➔ They can dynamically grow and shrink in size. ◆ E next(): Returns the next element in the iteration.
◆ void remove():Removes the last element returned by
Collection Framework in Java the iterator (optional operation).
➔ T he Collection Framework provides a unified architecture for ➔ Usage:
representing and manipulating collections. ◆ The Iterator interface is used to traverse collections such
➔ All the collections frameworks contain the following: asList,Set, andMap.
➔ Interfaces: These are abstract data types that represent ◆ It supports bothreadandremoveoperations.
collections. The interfaces allow collections to be manipulated
L ist<S tring>list=newArrayList<>();
independently of the details of their representation. list.add("A");
1.Collection 3.Set 5.Map list.add("B" );
2.List 4.Queue list.add("C");
➔ Implementations: These are the concrete implementationsof the
collection interfaces. Essentially, they are reusable data structures. Iterator<S tring>iterator=list.iterator();
1.ArrayList 3. LinkedList 5.HashSet while(iterator.hasNext()){
2.TreeSet 4.HashMap 6.TreeMap Stringelement=iterator.n ext();
System.o
ut.p
rintln(e lement);
➔ Algorithms: These are the methods that perform useful
}
computations, such assearchingandsorting, on objectsthat
implement collection interfaces.
Collection Interface
Advantages of Collection Framework ➔
The Collection interface is the root of the collection hierarchy.
➔ C onsistent API:The collection interfaces have a basicset of operations ➔ It represents a group of objects known as elements.
(such asaddingandremoving) that are extended byall ➔ The Collection interface is part of thejava.utilpackage.
implementations. ➔ Key Points:
➔ Reduces Programming Effort:By providing useful datastructures and ➔ Methods:
algorithms, the Collections Framework reduces the programming effort. ◆ boolean add(E e):Ensures that this collection contains
the specified element.
Java Collections Framework Hierarchy ◆ boolean remove(Object o): Removes a single instance
➔ T he Java Collections Framework is structured as a unified architecture of the specified element from this collection.
for representing and manipulating collections. ◆ int size(): Returns the number of elements in this
➔ The hierarchy is broadly divided into three majorgroups: collection.
➔ List, Set,andQueue, which extend theCollectioninterface, ◆ boolean isEmpty():Returns true if this collection
➔ Map, which is a separate hierarchy. contains no elements.
➔ Here are the important points for each component: ◆ boolean contains(Object o):Returns true if this
➔ Collection Interface collection contains the specified element.
◆ The root interface of the collections framework. ◆ Iterator<E> iterator():Returns an iterator over the
◆ It provides common methods likeadd(),remove(), elements in this collection.
size(),clear(), contains(), anditerator() ◆ boolean addAll(Collection<? extends E> c):Adds allof
➔ Map Interface the elements in the specified collection to this
◆ Represents a mapping between akeyand avalue. collection.
◆ Does not extend the Collection interface. ◆ void clear(): Removes all of the elements from this
◆ Provides methods toput,get,removeelements based collection.
on a key. ➔ Subinterfaces:
1.List 2.Set 3.Queue
CollectionInterface MapInterface ➔ Usage:
| |
+---List Interface +---HashMap ◆ The Collection interface provides the base functionality
| +---ArrayList +---LinkedHashMap for all collections.
| +---LinkedList +---TreeMap
| +---Vector +---Hashtable
| | +---Stack
ollection<S tring>collection=newArrayList<>();
C
| collection.add("A");
+---Set Interface collection.add("B");
| +---HashSet
collection.add("C");
| +---LinkedHashSet
| +---TreeSet
| for(S tringelement:collection){
+---Queue Interface System.o
ut.p
rintln(e lement);
+---PriorityQueue
+---DequeInterface
}
+---ArrayDeque
+---LinkedList Deque
List Interface ➔ B
asic Operations
➔ T he List interface extends the Collection interface and represents an 1.boolean add( e) .void add(int index, element)
6
ordered collection (also known as a sequence). 2. get(int index) 7. set(int index, element)
➔ The user can access elements by their integer index (position in the list) 3. remove(int index) 8.boolean remove(e)
and search for elements in the list. 4. int size() 9. void clear()
➔ Key Points: 5. boolean contains(e)
➔ Methods:
◆ void add(int index, E element):Inserts the specified
importjava.u
til.*;
element at the specified position in this list.
◆ E get(int index):Returns the element at the specified publicclassArrayListExample{
position in this list. publicstaticvoidmain(String[]args){
◆ E set(int index, E element): Replaces the elementat the // Creating an ArrayList
specified position in this list with the specified element. List<String>arrayList=newArrayList<>();
◆ E remove(int index):Removes the element at the
/ / Adding elements
specified position in this list.
arrayList.add("A");
◆ int indexOf(Object o):Returns the index of the first arrayList.add("B");
occurrence of the specified element in this list. arrayList.add("C");
◆ ListIterator<E> listIterator(): Returns a list iteratorover arrayList.add("D");
the elements in this list.
➔ Implementations: / / Accessing elements
1.ArrayList 2. LinkedList 3. Vector 4.Stack System.out.println("Element at index 2:"+arrayList.get(2 ) );
// Iterating elements
➔ Usage: for(S tringelement:arrayList){
◆ T he List interface allows for ordered collections that can System.o ut.p rintln(e lement);
contain duplicate elements. }
// Modifying elements
List<S tring>list=newArrayList<>();
arrayList.set(1 ,"E");
// List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 3); method 1
System.out.println("After modification:"+arrayList);
// method 2
// Removing elements
list.add("A");
arrayList.remove("C");
list.add("B");
System.out.println("After removal:"+arrayList);
list.add("C");
// Checking size
System.out.println("Size of ArrayList:"+arrayList.size());
for(inti=0; i<list.size();i++){
// Checking if ArrayList contains an element
System.out.println(list.get(i) );
System.out.println("Does ArrayList contain'A'?"+
}
arrayList.c ontains("A"));
Iterator vs ListIterator / / Clearing the ArrayList
arrayList.clear();
System.out.println("After clearing:"+arrayList);
}
}
LinkedList
➔
L inkedList is a doubly linked list implementation of the List interface.
➔ It is part of the Java Collections Framework and is found in thejava.util
package.
➔ Unlike ArrayList, which uses a dynamic array, LinkedList uses a doubly
linked list to store elements.
➔ Key Points:
➔ Doubly Linked: Each element in a LinkedList is storedin a node that
contains a reference to the next and previous elements.
➔ Dynamic Size:Can grow and shrink dynamically.
ArrayList ➔ Allows duplicate elements.
➔ Efficient for adding or removing elements anywhere in the list.
➔
A rrayList is a resizable array implementation of the List interface.
➔ Slower than ArrayList for random access (get()), as it requires traversing
➔ It is part of the Java Collections Framework and is found in thejava.util
from the head or tail.
package.
➔ Basic Operations:(Same as ArrayList )
➔ ArrayList allows for dynamic arrays that can grow as needed,
➔ which means it can change its size during runtime. importjava.util.*;
➔ Key Points:
➔ Unlike arrays in Java, ArrayList can grow and shrink in size publicclassLinkedListExample{
dynamically. publicstaticvoidmain(S tring[]args){
// Create a LinkedList
➔ Allows duplicate elements.
LinkedList<S tring>linkedList=newLinkedList<>();
➔ Provides fast random access to elements.
➔ Initial capacity is 10, but it grows automatically as elements are
added.
➔
// Adding elements importjava.u
til.Vector;
linkedList.add("Apple");
linkedList.add("Banana"); publicclassVectorExample{
linkedList.add("Cherry"); publicstaticvoidmain(String[]args){
linkedList.set(1
,"O
range"); // Modifyelement Vector<String>vector=newVector<>();
linkedList.add(2 ,"G
rape"); // Add an element
linkedList.remove("Apple"); // Remove element v ector.a dd("A"); // Adding elements
vector.a dd("B");
/ / Check if "Banana" is present vector.a dd("C" );
booleancontainsBanana=linkedList.contains("Banana");
System.out.println("Does LinkedList contain'Banana'?"+ / / Accessing elements
containsBanana); System.out.println("Element at index 1:"+vector.get(1 ));
// Removing element
S ystem.out.println("Printforward order element"); vector.r emove(2) ;
ListIterator<S tring>iterator=linkedList.listIterator(); // Size of vector
while(iterator.hasNext()){ System.out.println("Size of vector:"+vector.size());
System.out.println(iterator.n
ext()); }
} }
S ystem.out.println("Printreverse order element");
while(iterator.hasPrevious()){ Stack
System.out.println(iterator.p
revious()); ➔ S tack is a subclass of Vector that implements a last-in, first-out (LIFO)
}
stack of objects.
} }
➔ Methods:
rrayList(Collection<? extends E> c)
A ➔ push(E item):Pushes an item onto the top of the stack.
➔ Creates a list containing the elements of the specified collection, in the ➔ pop():Removes the object at the top of the stackand returns it.
order they are returned by the collection's iterator. ➔ peek(): Looks at the object at the top of the stackwithout
➔ It is same For Linked List removing it.
➔ isEmpty(): Checks if the stack is empty.
L ist<S tring>existingList=Arrays.asList("A","B" ,"C
");
ArrayList<S tring>list=newArrayList<>(existingList); importjava.util.Stack;
System.out.println(list);// Output: [A, B, C]
publicclassStackExample{
publicstaticvoidmain(String[]args){
LinkedList(Collection<? extends E> c) Stack<S tring>stack=newStack<>();
List<S tring>arrayList=newArrayList<>();
arrayList.add("Apple"); / / Pushing elements
arrayList.add("Banana"); stack.push("A");
arrayList.add("Cherry"); stack.push("B");
stack.push("C" );
/ / Create a LinkedList using the ArrayListelements
LinkedList<S tring>linkedList=newLinkedList<>(arrayList); / / Peeking the top element
System.out.println("Top element:"+stack.peek());
// Popping elements
LinkedList vs ArrayList
System.out.println("Popped element:"+stack.p op());
➔ L inkedList provides methods likeaddFirst, addLast,getFirst, getLast,
// Checking if stack is empty
removeFirst, removeLast, offerFirst, offerLast, peekFirst, peekLast, System.out.println("Is stack empty?"+stack.isEmpty());
pollFirst, pollLast, descendingIteratorfor efficientinsertion,removal, }
andtraversaloperations from both ends. }
➔ ArrayListis optimized for random access and efficientelement
insertion/removalin the middle.
➔ Choosing between them depends on the use case: Queue Interface
➔ Use LinkedList for frequentinsertions/removalsatboth ends or ➔
ueue is a collection designed for holding elements prior to processing.
Q
sequential traversal. ➔ It typically orders elements in aFIFO (first-in,first-out)manner.
➔ Use ArrayList for scenarios requiring random access or faster ➔ Implementations includeLinkedListandPriorityQueue.
access byindex. ➔ Methods:
➔ add(e):Inserts the specified element into the queue(throws an
Vector exception if it fails).
➔ V ector is a part of the Java Collections Framework and implements a ➔ offer(e): Inserts the specified element into the queue(returns
growable array of objects. false if it fails).
➔ It is synchronized, making it thread-safe, but can have performance ➔ remove(): Retrieves and removes theheadof the queue(throws
overhead due to synchronization. NoSuchElementException an exception if the queue is empty).
➔ Methods: ➔ poll(): Retrieves and removes theheadof the queue(returns null
➔ add(e):Adds an element to the end of the vector. if the queue is empty).
➔ get(int index): Returns the element at the specifiedposition. ➔ peek():Retrieves, but does not remove, theheadofthe queue
➔ remove(int index): Removes the element at the specifiedposition. (returns null if the queue is empty).
➔ size(): Returns the number of elements in the vector.
importjava.util.LinkedList;
importjava.util.Queue; / / LinkedHashSet example
Set<S tring>linkedHashSet=newLinkedHashSet<>();
publicclassQueueExample{ linkedHashSet.a dd("B");
publicstaticvoidmain(S tring[]args){ linkedHashSet.a dd("A");
Queue<S tring>queue=newLinkedList<>(); linkedHashSet.a dd("C");
System.o
ut.p
rintln("LinkedHashSet:"+linkedHashSet); // B A C
/ / Adding elements
queue.add("A"); / / TreeSet example
queue.add("B"); Set<S tring>treeSet=newTreeSet<>();
queue.add("C"); treeSet.a dd("B");
treeSet.a dd("A");
/ / Peeking the head element treeSet.a dd("C");
System.out.println("Head element:"+queue.p
eek()); System.o
ut.p
rintln("TreeSet:"+treeSet); // A B C
}
/ / Polling elements }
System.out.println("Polled element:"+queue.p
oll());
“”” HashSet: Fastest for basic operations, noguaranteed order.
/ / Checking the size L inkedHashSet: Maintains insertion order,slower than HashSet.
TreeSet: Maintains elements in sorted order,slower than HashSet and LinkedHashSet. “””
System.out.println("Size of queue:"+queue.size());
} }
Map Interface
Set Interface ➔
R epresents a collection of key-value pairs where each key is unique.
➔ Maps keys to values and does not allow duplicate keys.
➔
Represents a collection that cannot contain duplicate elements.
➔ methods for adding, accessing, removing, and checking for key-value
➔ It models the mathematical set abstraction.
pairs.
➔ Does not guarantee the order of elements.
➔ Allows at most one null element.
➔ Implementations includeHashSet,LinkedHashSet, andTreeSet. HashMap Class
➔
Implements theMap interfaceusing ahash table.
HashSet ➔ Does not guarantee the order of key-value pairs.
➔ Implements the Set interface using a hash table. It does not guarantee ➔ Providesconstant-timeperformance for basic operations(p
ut, get,
the order of elements. remove) on average.
➔ Offers constant-time performance for basic operations (add,remove, ➔ Allows null values and one null key.
contains).
importjava.util.HashMap;
➔ Does not maintain the insertion order. importjava.util.Map;
➔ Allows null elements.
publicclassHashMapExample{
LinkedHashSet publicstaticvoidmain(S tring[]args){
➔ E xtends HashSet and maintains a doubly-linked list of entries to Map<S tring,Integer>hashMap=newHashMap<>();
preserve the insertion order.
ashMap.put("One",1) ;
h
➔ Iterates over elements in insertion order.
hashMap.put("Two",2) ;
➔ Slower thanHashSetfor basic operations due to maintainingorder. hashMap.put("Three",3) ;
➔ Allows null elements.
System.o
ut.println("HashMap:"+hashMap);
SortedSet Interface }
➔ E xtends Set and maintains elements in sorted order defined by their }
natural ordering or a comparator.
➔ Provides methods for accessing elements bytheir positionin the sorted LinkedHashMap Class
set. ➔
E xtendsHashMapand maintains insertion order of keys.
➔ Implementations includeTreeSet. ➔ Iterates over elements in the order they were inserted.
➔ Slower performance for basic operations compared to HashMap due to
TreeSet
maintaining order.
➔
Implements SortedSet using a tree structure(red-blacktree).
➔ Allows null values and one null key.
➔ Maintains elements in sorted order (ascending by default or based on a
custom comparator). importjava.util.LinkedHashMap;
➔ Slower performance for basic operations compared toHashSetand importjava.util.Map;
LinkedHashSet.
➔ Does not allow null elements. publicclassLinkedHashMapExample{
publicstaticvoidmain(S tring[]args){
Example Of All Sets interface Map<S tring,Integer>linkedHashMap=newLinkedHashMap<>();
import java.util.*; linkedHashMap.put("One",1) ;
publicclassSetExamples{ linkedHashMap.put("Two",2) ;
publicstaticvoidmain(S tring[]args){ linkedHashMap.put("Three",3);
// HashSet example
Set<S tring>hashSet=newHashSet<>(); System.o
ut.println("LinkedHashMap:"+linkedHashMap);
hashSet.add("B"); }
hashSet.add("A"); }
hashSet.add("C");
System.out.println("HashSet:"+hashSet);// C B A
TreeMap Class / / Add key-value pairs to the Map
map.p ut("One",1) ;
➔
Implements the SortedMap interface using a Red-Black tree.
map.p ut("Two",2) ;
➔ Maintains keys in ascending order (natural order or custom map.p
ut("Three",3) ;
Comparator).
➔ Slower performance for basic operations compared to HashMap and
LinkedHashMap due to sorting. // Iterating over the Map using for-each loop
➔ Does not allow null keys but allows null values. System.o ut.p rintln("\nKey-Value pairs in theMap:");
for(M
ap.Entry<String,Integer>entry:map.entrySet()){
importjava.util.Map; System.o ut.println("Key:"+entry.g etKey()+", Value:"+
importjava.util.TreeMap; entry.getValue());
}
publicclassTreeMapExample{ }
publicstaticvoidmain(S tring[]args){ }
Map<S tring,Integer>treeMap=newTreeMap<>();
Sorting
t reeMap.put("Three",3) ; ➔ S orting in Java refers to arranging elements in a collection in a specific
treeMap.put("One",1); order, typically ascending or descending based on certain criteria.
treeMap.put("Two",2) ; ➔ Java provides several ways to achieve sorting depending on the data
structure and requirements:
System.out.println("TreeMap:"+treeMap);
➔ Sorting Arrays ⇒Arrays.sort()
}
} int[]nums={5,2,8,1,3} ;
Arrays.s ort(n
ums);// Sorts nums array in ascendingorder
“””HashMap: Fastest for basic operations, no orderguarantee.
LinkedHashMap: Maintains insertion order, inheritsfrom HashMap.
TreeMap: Maintains keys in sorted order, slower forbasic operations due to sorting.”” “
➔ Sorting Collections
1.Collections.sort():Sorts collections such as listsusing natural
ordering (if elements implement Comparable) or a specified
Hashtable Class
Comparator.
➔ T he Hashtable class in Java provides a basic implementation of a hash
table, which maps keys to values. L ist<String>names=newArrayList<>();
➔ It inherits from the Dictionary class and implements the Map interface, names.a dd("Alice");
making it similar to HashMap but with some differences : names.a dd("Bob");
Collections.s ort(n
ames);// Sorts alphabetically (naturalorder)
➔ Hashtable is synchronized,
2.Sorting with Comparator: ascending order use :
➔ Neither keys nor values can be null
Comparator.naturalOrder() and descending order use :
importjava.util.Hashtable; Comparator.reverseOrder()
publicclassHashtableExample{ L ist<String>names=newArrayList<>();
publicstaticvoidmain(S tring[]args){ names.a dd("Alice");
// Using Hashtable names.a dd("Bob");
Hashtable<S tring,Integer>hashtable=newHashtable<>(); Collections.s ort(n
ames,Comparator.reverseOrder());// Sorts in
hashtable.put("One",1) ; reverse order
hashtable.put("Two",2) ;
// hashtable.put(null, 3); // Throws NullPointerException Comparable Interface
System.out.println("Hashtable:"+hashtable);
➔
C omparable is an interface in the java.lang package.
} ➔ It declares one method compareTo() which compares the current object
} (this) with another object of the same type.
➔ Classes that implement Comparable can be sorted automatically using
Iterators used in Map and Set methods likeArrays.sort()orCollections.sort().
importjava.util.*;
publicclassSetMapIterationExample{ publicinterfaceComparable<T > {
publicstaticvoidmain(S tring[]args){ publicintcompareTo(T o) ;
// Create a HashSet }
Set<S tring>set=newHashSet<>();
// Add elements to the Set Example of Comparable InterFace
set.add("Apple");
set.add("Banana"); publicclassStudentimplementsComparable<S tudent>{
set.add("Orange"); privateStringname;
privateintage;
/ / Iterating over the Set using for-eachloop
System.out.println("Elements in the Set:"); / / Constructor
for(S tringelement:set){ publicStudent(S tringname,intage){
System.out.println(e lement); this.name=name;
} this.age=age;
}
/ / Create a HashMap
Map<S tring,Integer>map=newHashMap<>();
publicintcompareTo(S tudentother){ Properties Class
// Compare students based on age
returnInteger.compare(t his.a ge,other.age); ➔
P roperties stores key-value pairs where both keys and values are strings.
} ➔ It supports loading from and saving to files usingload() andstore()
// Example usage in main method
methods.
publicstaticvoidmain(S tring[]args){
List<S tudent>students=newArrayList<>(); ➔ Default values can be set and queried if a property is not found in the
students.add(n ewStudent("Alice",20)); current instance.
students.add(n ewStudent("Bob",18)); ➔ Java system properties (System.getProperties())areaccessible through
students.add(n
ewStudent("Charlie",22)); a Properties object.
➔ Example usage involves setting, saving to file, loading, and accessing
// Sorting using Collections.sort() (uses Comparable)
properties.
Collections.sort(s tudents);
➔ It provides persistence for application settings likedatabase
/ / Printing sorted students connectionsandUI configurations.
System.out.println("Sorted Students by Age:"); ➔ methods:
for(S tudentstudent:students){ ➔ setProperty(String key, String value):Sets a key-valuepair in the
System.out.println(s tudent); Properties object.
}
➔ getProperty(String key):Retrieves the value associatedwith a
}
specified key.
}
➔ store(OutputStream out, String comments): Saves propertiesto
Comparator Interface an output stream, with optional comments.
➔
T he Comparator interface in Java is located in the java.util package. ➔ load(InputStream in): Loads properties from an inputstream.
➔ It defines two methods:compare(T o1, T o2) andequals(Objectobj). ➔ stringPropertyNames(): Returns keys where both thekey and
➔ You typically create an instance of Comparator either as an anonymous value are strings.
class.
importjava.io.*;
➔ Comparator is commonly used with sorting methods like importjava.util.*;
Collections.sort()for lists orArrays.sort()forarrays to define the order
in which elements should be sorted. publicclassStudent{
publicstaticvoidmain(String[]args){
Example of Comparator Interface Propertiesprop=newProperties();
importjava.util.* ; / / Setting properties
prop.setProperty("database.url","jdbc:mysql://localhost:3306/mydb");
publicclassStudent{
privateStringname;
prop.setProperty("database.user","r oot");
privateintage; prop.setProperty("database.password","password");
publicStudent(S tringname,intage){ / / Saving properties to a file
this.name=name; try(O utputStreamoutput=new
this.age=age; FileOutputStream("config.properties")){
} prop.store(o utput,"Database Configuration");
System.o ut.println("Properties saved successfully.");
intgetAge(){returnthis.age;}
}catch(IOExceptione) {
publicstaticvoidmain(String[]args){ e.printStackTrace();
List<S tudent>students=newArrayList<>(); }
students.a dd(n ewStudent("Alice",20));
students.a dd(n ewStudent("Bob",18)); / / Loading properties from a file
students.a dd(n
ewStudent("Charlie",22)); try(InputStreaminput=newFileInputStream("config.properties")){
prop.load(input);
/ / Using Comparator to sort by age in descendingorder
System.o
ut.println("Properties loadedsuccessfully.");
Comparator<Student>ageComparator=newComparator<S tudent>(){
@O verride
publicintcompare(Students1,Students2){ / / Display properties
returnInteger.compare(s2.getAge(),s1.getAge());// Descending order prop.forEach((key,value)->{
} System.out.println(k ey+": "+value);
}; });
/ / Sorting students list using ageComparator / / Accessing individual property
Collections.sort(s tudents,ageComparator);
StringdbUrl=prop.getProperty("database.url");
/ / Printing sorted students
System.o ut.println("Database URL:"+dbUrl);
System.out.println("Sorted Students by Age(Descending):"); }catch(IOExceptione) {
for(S tudentstudent:students){ e.printStackTrace();
System.out.println(s tudent); }
} }
} }
}
You might also like
- Buyer'S Inspection Waiver: 3980 Colonial Way, Sacramento, CA 95817No ratings yetBuyer'S Inspection Waiver: 3980 Colonial Way, Sacramento, CA 958171 page
- Defined Manner.: Collections Are Nothing But Group of Objects Stored in WellNo ratings yetDefined Manner.: Collections Are Nothing But Group of Objects Stored in Well5 pages
- UNIT - IV - Syllabus The Collections Framework (Java - Util)No ratings yetUNIT - IV - Syllabus The Collections Framework (Java - Util)24 pages
- Lecture 28, 29, 30 Collection Framework in JavaNo ratings yetLecture 28, 29, 30 Collection Framework in Java133 pages
- Mastering Java Collections: From Basics to Expert ProficiencyFrom EverandMastering Java Collections: From Basics to Expert ProficiencyNo ratings yet
- Lexicon of Programming Terminology: Lexicon of Tech and Business, #17From EverandLexicon of Programming Terminology: Lexicon of Tech and Business, #175/5 (1)
- GIR Workshop (Nov 24) Batch Notes - CA MonkNo ratings yetGIR Workshop (Nov 24) Batch Notes - CA Monk155 pages
- 3-4 Autotransformer and Three Phase ConnectionNo ratings yet3-4 Autotransformer and Three Phase Connection9 pages
- Kincentric 2021 How Engagement Shifted in 2020 What It Means For 2021No ratings yetKincentric 2021 How Engagement Shifted in 2020 What It Means For 20215 pages
- Species Composition and Seasonal Abundance of Family Nemipteridae From Nyaungtan Jetty, Pazuntung Township, Yangon Region, MyanmarNo ratings yetSpecies Composition and Seasonal Abundance of Family Nemipteridae From Nyaungtan Jetty, Pazuntung Township, Yangon Region, Myanmar3 pages
- A Comparative Analysis of Multiphase Interleaved Buck Converter For High Step Down VoltageNo ratings yetA Comparative Analysis of Multiphase Interleaved Buck Converter For High Step Down Voltage7 pages
- Derivatives Regulation Lecture Daniele 2024No ratings yetDerivatives Regulation Lecture Daniele 202458 pages
- American National Special (Unified Special) : Recommended Shaft/Spindle Thread Dimensions100% (1)American National Special (Unified Special) : Recommended Shaft/Spindle Thread Dimensions2 pages
- CSE 473 Pattern Recognition: Instructor: Dr. Md. Monirul IslamNo ratings yetCSE 473 Pattern Recognition: Instructor: Dr. Md. Monirul Islam43 pages
- Invention, Innovation & EntrepreneurshipNo ratings yetInvention, Innovation & Entrepreneurship82 pages
- Sharepoint Permissions Best Practices: The Ultimate Guide ToNo ratings yetSharepoint Permissions Best Practices: The Ultimate Guide To22 pages
- SiemensWhitePaper SoftwareBasedValidationNo ratings yetSiemensWhitePaper SoftwareBasedValidation7 pages
- Zenitel-P-8300 MkII Sound Reception Display Unit-4000019415No ratings yetZenitel-P-8300 MkII Sound Reception Display Unit-40000194154 pages
- Stat Power Sensor Model 7022: Operation ManualNo ratings yetStat Power Sensor Model 7022: Operation Manual21 pages
- Book Review: "Facing Mount Kenya" by Jomo KenyattaNo ratings yetBook Review: "Facing Mount Kenya" by Jomo Kenyatta2 pages
- Sanitarry Fittings, Traps, Plumbing SystemsNo ratings yetSanitarry Fittings, Traps, Plumbing Systems20 pages
- 22449/porvotr S Krnti Third Ac Economy (3E)No ratings yet22449/porvotr S Krnti Third Ac Economy (3E)2 pages