Unit 4 Oops With Java
Uploaded by
AkUnit 4 Oops With Java
Uploaded by
AkCollection 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 the[Link] 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.a dd("A" );
[Link] [Link] [Link] list.a dd("B" );
[Link] [Link] list.a dd("C" );
➔ Implementations: These are the concrete implementationsof the
collection interfaces. Essentially, they are reusable data structures. Iterator<S tring>iterator=list.iterator();
[Link] 3. LinkedList [Link] while(iterator.h asNext()){
[Link] [Link] [Link] Stringelement=iterator.n ext();
System.out.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 the[Link]package.
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:
[Link] [Link] [Link]
CollectionInterface MapInterface ➔ Usage:
| |
+---List Interface +---HashMap ◆ The Collection interface provides the base functionality
| +---ArrayList +---LinkedHashMap for all collections.
| +---LinkedList +---TreeMap
| +---Vector +---Hashtable
| | +---Stack
ollection<String>collection=newArrayList<>();
C
| collection.add("A" );
+---Set Interface collection.add("B" );
| +---HashSet
collection.add("C" );
| +---LinkedHashSet
| +---TreeSet
| for(Stringelement:collection){
+---Queue Interface System.out.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 [Link] 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) [Link] 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.util.* ;
element at the specified position in this list.
◆ E get(int index):Returns the element at the specified publicclassArrayListExample{
position in this list. publicstaticvoidmain(S tring[]args){
◆ E set(int index, E element): Replaces the elementat the // Creating an ArrayList
specified position in this list with the specified element. List<S tring>arrayList=newArrayList<>();
◆ E remove(int index):Removes the element at the
/ / Adding elements
specified position in this list.
arrayList.a dd("A" );
◆ int indexOf(Object o):Returns the index of the first arrayList.a dd("B" );
occurrence of the specified element in this list. arrayList.a dd("C" );
◆ ListIterator<E> listIterator(): Returns a list iteratorover arrayList.a dd("D");
the elements in this list.
➔ Implementations: / / Accessing elements
[Link] 2. LinkedList 3. Vector [Link] System.o ut.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(element);
contain duplicate elements. }
// Modifying elements
List<String>list=newArrayList<>();
arrayList.s et(1,"E" );
// List<Integer> numbers = [Link](5, 2, 8, 1, 3); method 1
System.o ut.println("After modification:"+arrayList);
// method 2
// Removing elements
list.add("A" );
arrayList.r emove("C");
list.add("B" );
System.o ut.println("After removal:"+arrayList);
list.add("C" );
// Checking size
System.o ut.println("Size of ArrayList:"+arrayList.s ize());
for(inti=0;i<list.s ize();i++){
// Checking if ArrayList contains an element
System.out.println(list.get(i));
System.o ut.println("Does ArrayList contain'A'?"+
}
arrayList.c ontains("A"));
Iterator vs ListIterator / / Clearing the ArrayList
arrayList.c lear();
System.o
ut.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 the[Link]
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 the[Link]
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.u
til.*;
➔ Key Points:
➔ Unlike arrays in Java, ArrayList can grow and shrink in size publicclassLinkedListExample{
dynamically. publicstaticvoidmain(String[]args){
// Create a LinkedList
➔ Allows duplicate elements.
LinkedList<String>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(S tring[]args){
linkedList.set(1
,"O
range"); // Modifyelement Vector<String>vector=newVector<>();
linkedList.add(2,"Grape"); // Add an element
linkedList.remove("Apple"); // Remove element v ector.add("A" ); // Adding elements
vector.add("B" );
/ / Check if "Banana" is present vector.add("C" );
booleancontainsBanana=linkedList.c ontains("Banana");
System.out.println("Does LinkedList contain'Banana'?"+ / / Accessing elements
containsBanana); System.o ut.println("Element at index 1:"+vector.g et(1
));
// Removing element
S ystem.out.println("Printforward order element"); vector.remove(2 ) ;
ListIterator<String>iterator=linkedList.listIterator(); // Size of vector
while(iterator.h asNext()){ System.o
ut.println("Size of vector:"+vector.size());
System.out.println(iterator.n
ext()); }
} }
S ystem.out.println("Printreverse order element");
while(iterator.h asPrevious()){ 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<String>existingList=Arrays.a sList("A","B" ,"C
");
ArrayList<String>list=newArrayList<>(existingList); importjava.u
til.S tack;
System.out.println(list);// Output: [A, B, C]
publicclassStackExample{
publicstaticvoidmain(S tring[]args){
LinkedList(Collection<? extends E> c) Stack<S tring>stack=newStack<>();
List<String>arrayList=newArrayList<>();
arrayList.add("Apple"); / / Pushing elements
arrayList.add("Banana"); stack.p ush("A" );
arrayList.add("Cherry"); stack.p ush("B" );
stack.p
ush("C" );
/ / Create a LinkedList using the ArrayListelements
LinkedList<String>linkedList=newLinkedList<>(arrayList); / / Peeking the top element
System.o ut.println("Top element:"+stack.p
eek());
// Popping elements
LinkedList vs ArrayList
System.o ut.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.o
ut.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.L inkedList;
importjava.util.Q
ueue; / / LinkedHashSet example
Set<S tring>linkedHashSet=newLinkedHashSet<>();
publicclassQueueExample{ linkedHashSet.add("B");
publicstaticvoidmain(S tring[]args){ linkedHashSet.add("A");
Queue<String>queue=newLinkedList<>(); linkedHashSet.add("C");
System.out.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.peek()); System.out.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.s ize());
} }
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.H
ashMap;
➔ Does not maintain the insertion order. importjava.util.M
ap;
➔ Allows null elements.
publicclassHashMapExample{
LinkedHashSet publicstaticvoidmain(String[]args){
➔ E xtends HashSet and maintains a doubly-linked list of entries to Map<String,Integer>hashMap=newHashMap<>();
preserve the insertion order.
ashMap.p
h ut("One",1) ;
➔ Iterates over elements in insertion order.
hashMap.p ut("Two",2) ;
➔ Slower thanHashSetfor basic operations due to maintainingorder. hashMap.p
ut("Three",3) ;
➔ Allows null elements.
System.o
ut.p
rintln("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.L inkedHashMap;
➔ Slower performance for basic operations compared toHashSetand importjava.util.M
ap;
LinkedHashSet.
➔ Does not allow null elements. publicclassLinkedHashMapExample{
publicstaticvoidmain(String[]args){
Example Of All Sets interface Map<String,Integer>linkedHashMap=newLinkedHashMap<>();
import [Link].*; linkedHashMap.p ut("One",1) ;
publicclassSetExamples{ linkedHashMap.p ut("Two",2) ;
publicstaticvoidmain(String[]args){ linkedHashMap.p
ut("Three",3) ;
// HashSet example
Set<S tring>hashSet=newHashSet<>(); System.o
ut.p
rintln("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.out.p rintln("\nKey-Value pairs in theMap:");
for(Map.E ntry<String,Integer>entry:map.entrySet()){
importjava.util.Map; System.o ut.p
rintln("Key:"+entry.g etKey()+", Value:"+
importjava.util.T reeMap; entry.getValue());
}
publicclassTreeMapExample{ }
publicstaticvoidmain(String[]args){ }
Map<String,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 ⇒[Link]()
}
} int[]nums={5,2,8,1,3} ;
Arrays.s ort(nums);// 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.[Link]():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(names);// Sorts alphabetically (naturalorder)
➔ Hashtable is synchronized,
[Link] with Comparator: ascending order use :
➔ Neither keys nor values can be null
[Link]() and descending order use :
importjava.util.Hashtable; [Link]()
publicclassHashtableExample{ L ist<String>names=newArrayList<>();
publicstaticvoidmain(String[]args){ names.a dd("Alice");
// Using Hashtable names.a dd("Bob");
Hashtable<String,Integer>hashtable=newHashtable<>(); Collections.s ort(names,Comparator.reverseOrder());// Sorts in
hashtable.put("One",1) ; reverse order
hashtable.put("Two",2) ;
// [Link](null, 3); // Throws NullPointerException Comparable Interface
System.out.println("Hashtable:"+hashtable);
➔
C omparable is an interface in the [Link] 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 like[Link]()or[Link]().
importjava.util.*;
publicclassSetMapIterationExample{ publicinterfaceComparable<T> {
publicstaticvoidmain(String[]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(element); this.n ame=name;
} this.a ge=age;
}
/ / Create a HashMap
Map<String,Integer>map=newHashMap<>();
publicintcompareTo(Studentother){ Properties Class
// Compare students based on age
returnInteger.compare(this.age,other.a ge); ➔
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(String[]args){
List<S tudent>students=newArrayList<>(); ➔ Default values can be set and queried if a property is not found in the
students.add(newStudent("Alice",20)); current instance.
students.add(newStudent("Bob",18)); ➔ Java system properties ([Link]())areaccessible through
students.add(newStudent("Charlie",22)); a Properties object.
➔ Example usage involves setting, saving to file, loading, and accessing
// Sorting using [Link]() (uses Comparable)
properties.
Collections.sort(students);
➔ It provides persistence for application settings likedatabase
/ / Printing sorted students connectionsandUI configurations.
System.out.println("Sorted Students by Age:"); ➔ methods:
for(Studentstudent: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 [Link] 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.u
til.*;
[Link]()for lists or[Link]()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.s etProperty("[Link]","jdbc:mysql://localhost:3306/mydb");
publicclassStudent{
privateStringname;
prop.s etProperty("[Link]","r oot");
privateintage; prop.s etProperty("[Link]","password");
publicStudent(Stringname,intage){ / / Saving properties to a file
this.name=name; try(OutputStreamoutput=new
this.age=age; FileOutputStream("[Link]")){
} prop.store(output,"D atabase Configuration");
System.o ut.p
rintln("Properties saved successfully.");
intgetAge(){r eturnthis.a ge;}
}catch(IOExceptione){
publicstaticvoidmain(S tring[]args){ e.printStackTrace();
List<Student>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("[Link]")){
prop.load(input);
/ / Using Comparator to sort by age in descendingorder
System.o
ut.p rintln("Properties loadedsuccessfully.");
Comparator<S tudent>ageComparator=newComparator<S tudent>(){
@Override
publicintcompare(S tudents1,Students2){ / / Display properties
returnInteger.c ompare(s 2.g etAge(),s1.g etAge());// Descending order prop.forEach((key,value)->{
} System.o
ut.println(key+": "+value);
}; });
/ / Sorting students list using ageComparator / / Accessing individual property
Collections.s ort(students,ageComparator);
StringdbUrl=prop.g etProperty("[Link]");
/ / Printing sorted students
System.o ut.p
rintln("Database URL:"+dbUrl);
System.o ut.p
rintln("Sorted Students by Age(Descending):"); }catch(IOExceptione){
for(Studentstudent:students){ e.printStackTrace();
System.out.p
rintln(student); }
} }
} }
}
You might also like
- 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
- Tsel Erp - User Manual For Bapk Form v01.1No ratings yetTsel Erp - User Manual For Bapk Form v01.117 pages
- S3900 Series: Innovative Virtual Cluster Switching TechniqueNo ratings yetS3900 Series: Innovative Virtual Cluster Switching Technique6 pages
- LabVIEW Real-Time Module User Manual (en-US, 2024-08-31)No ratings yetLabVIEW Real-Time Module User Manual (en-US, 2024-08-31)182 pages
- Assignment - 3 Hardware Design Methodology: Submitted By: Shaily Garg MEC2019010 M.Tech (MI)No ratings yetAssignment - 3 Hardware Design Methodology: Submitted By: Shaily Garg MEC2019010 M.Tech (MI)31 pages
- Basic Programming Algorithms and FlowchartsNo ratings yetBasic Programming Algorithms and Flowcharts4 pages
- Memory and Its Types: Primary and Secondary Memory M Husnain BS Chemistry 4th Bsf1907949No ratings yetMemory and Its Types: Primary and Secondary Memory M Husnain BS Chemistry 4th Bsf19079497 pages
- Free 3D file RC Plane - SU-29 1100mm・Template to download and 3D print・Cults100% (2)Free 3D file RC Plane - SU-29 1100mm・Template to download and 3D print・Cults4 pages
- Azure Free Account Benefits and ServicesNo ratings yetAzure Free Account Benefits and Services4 pages
- AFBR-1555ARZ, AFBR-2555ARZ (SMA TX/RX For SERCOS)No ratings yetAFBR-1555ARZ, AFBR-2555ARZ (SMA TX/RX For SERCOS)9 pages
