The Collections Framework (java.util)- Collections overview, Collection Interfaces, The Collection classes- Array List, Linked List, Hash Set, Tree Set, Priority Queue, Array Deque. Accessing a Collection via an Iterator, Using an Iterator, The For-Each alternative, Map Interfaces and Classes, Comparators, Collection algorithms, Arrays, The Legacy Classes and Interfaces- Dictionary, Hashtable ,Properties, Stack, Vector More Utility classes, String Tokenizer, Bit Set, Date, Calendar, Random, Formatter, Scanner
Java abstract class & abstract methods,Abstract class in java
Abstract classes are classes that contain one or more abstract methods. An abstract method is a method that is declared, but contains no implementation. Abstract classes may not be instantiated, and require subclasses to provide implementations for the abstract methods.
This presentation introduces some concepts about the Java Collection framework. These slides introduce the following concepts:
- Collections and iterators
- Linked list and array list
- Hash set and tree set
- Maps
- The collection framework
The presentation is took from the Java course I run in the bachelor-level informatics curriculum at the University of Padova.
Super keyword is a reference variable that is used for refer parent class object. Super keyword is used in java at three level, at variable level, at method level and at constructor level.
Java abstract class & abstract methods,Abstract class in java
Abstract classes are classes that contain one or more abstract methods. An abstract method is a method that is declared, but contains no implementation. Abstract classes may not be instantiated, and require subclasses to provide implementations for the abstract methods.
This presentation introduces some concepts about the Java Collection framework. These slides introduce the following concepts:
- Collections and iterators
- Linked list and array list
- Hash set and tree set
- Maps
- The collection framework
The presentation is took from the Java course I run in the bachelor-level informatics curriculum at the University of Padova.
Super keyword is a reference variable that is used for refer parent class object. Super keyword is used in java at three level, at variable level, at method level and at constructor level.
core & advanced java classes in Mumbai
best core & advanced java classes in Mumbai with job assistance.
our features are:
expert guidance by it industry professionals
lowest fees of 5000
practical exposure to handle projects
well equiped lab
after course resume writing guidance
Exception handling - Fundamentals of exception handling, Exception types, Termination or resumptive models, Uncaught exceptions, using try and catch, multiple catch clauses, nested try statements, throw, throws and finally, built- in exceptions, creating own exception sub classes.
Multithreading- Differences between thread-based multitasking and process-based multitasking, Java thread model, creating threads, thread priorities, synchronizing threads, inter thread communication
Packages- Defining a Package, CLASSPATH, Access protection, importing packages. Interfaces- defining an interface, implementing interfaces, Nested interfaces, applying interfaces, variables in interfaces and extending interfaces.
Stream based I/O (java.io) – The Stream classes-Byte streams and Character streams, Reading console Input and Writing Console Output, File class, Reading and writing Files, Random access file operations, The Console class, Serialization, Enumerations, auto boxing, generics.
Object-Oriented Thinking- A way of viewing world – Agents and Communities, messages and methods, Responsibilities, Classes and Instances, Class Hierarchies- Inheritance, Method binding, Overriding and Exceptions, Summary of Object-Oriented concepts. Java buzzwords, An Overview of Java, Data types, Variables and Arrays, operators, expressions, control statements, Introducing classes, Methods and Classes, String handling.
Inheritance– Inheritance concept, Inheritance basics, Member access, Constructors, Creating Multilevel hierarchy, super uses, using final with inheritance, Polymorphism-ad hoc polymorphism, pure polymorphism, method overriding, abstract classes, Object class, forms of inheritance specialization, specification, construction, extension, limitation, combination, benefits of inheritance, costs of inheritance
JSP
The Anatomy of a JSP Page, JSP Processing, Declarations, Directives, Expressions, Code Snippets, implicit objects, Using Beans in JSP Pages, Using Cookies and session for session tracking, connecting to database in JSP.
Servlet
Common Gateway Interface (CGI), Lifecycle of a Servlet, deploying a servlet, The Servlet API, Reading Servlet parameters, Reading Initialization parameters, Handling Http Request & Responses, Using Cookies and Sessions, connecting to a database using JDBC.
Introduction to XML, Defining XML tags, their attributes and values, Document Type Definition, XML Schemas, Document Object Model, XHTML Parsing XML Data - DOM and SAX Parsers in java.
Introduction to PHP: Declaring variables, data types, arrays, strings, operators, expressions, control structures, functions, Reading data from web form controls like text boxes, radio buttons, lists etc., Handling File Uploads, Connecting to database (MySQL as reference), executing simple queries, handling results, Handling sessions and cookies File Handling in PHP: File operations like opening, closing, reading, writing, appending, deleting etc. on text and binary files, listing directories
Machine-Independent Optimizations: The Principal Sources of Optimization, Introduction to Data-Flow Analysis, Foundations of Data-Flow Analysis, Constant Propagation, Partial Redundancy Elimination, Loops in Flow Graphs
Run-Time Environments: Storage organization, Stack Allocation of Space, Access to Nonlocal Data on the Stack, Heap Management, Introduction to Garbage Collection, Introduction to Trace-Based Collection. Code Generation: Issues in the Design of a Code Generator, The Target Language, Addresses in the Target Code, Basic Blocks and Flow Graphs, Optimization of Basic Blocks, A Simple Code Generator, Peephole Optimization, Register Allocation and Assignment, Dynamic Programming Code-Generation
Syntax-Directed Translation: Syntax-Directed Definitions, Evaluation Orders for SDD's, Applications of Syntax-Directed Translation, Syntax-Directed Translation Schemes, and Implementing L-Attributed SDD's. Intermediate-Code Generation: Variants of Syntax Trees, Three-Address Code, Types and Declarations, Type Checking, Control Flow, Back patching, Switch-Statements
Syntax Analysis: Introduction, Context-Free Grammars, Writing a Grammar, Top-Down Parsing, Bottom-Up Parsing, Introduction to LR Parsing: Simple LR, More Powerful LR Parsers, Using Ambiguous Grammars, Parser Generators.
Introduction: Language Processors, the structure of a compiler, the science of building a compiler, programming language basics.
Lexical Analysis: The Role of the Lexical Analyzer, Input Buffering, Recognition of Tokens, The Lexical-Analyzer Generator Lex, Finite Automata, From Regular Expressions to Automata, Design of a Lexical-Analyzer Generator, Optimization of DFA-Based Pattern Matchers
E-Mail Security: Pretty Good Privacy, S/MIME IP Security: IP Security overview, IP Security architecture, Authentication Header, Encapsulating security payload, Combining security associations, Internet Key Exchange Case Studies on Cryptography and security: Secure Multiparty Calculation, Virtual Elections, Single sign On, Secure Inter-branch Payment Transactions, Cross site Scripting Vulnerability.
Security Concepts: Introduction, The need for security, Security approaches, Principles of security, Types of Security attacks, Security services, Security Mechanisms, A model for Network Security Cryptography Concepts and Techniques: Introduction, plain text and cipher text, substitution techniques, transposition techniques, encryption and decryption, symmetric and asymmetric key cryptography, steganography, key range and key size, possible types of attacks
Working with Windows and DOS Systems: understanding file systems, exploring Microsoft File Structures, Examining NTFS disks, Understanding whole disk encryption, windows registry, Microsoft startup tasks, MS-DOS startup tasks, virtual machines
More from Jyothishmathi Institute of Technology and Science Karimnagar (20)
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
Connector Corner: Automate dynamic content and events by pushing a buttonDianaGray10
Here is something new! In our next Connector Corner webinar, we will demonstrate how you can use a single workflow to:
Create a campaign using Mailchimp with merge tags/fields
Send an interactive Slack channel message (using buttons)
Have the message received by managers and peers along with a test email for review
But there’s more:
In a second workflow supporting the same use case, you’ll see:
Your campaign sent to target colleagues for approval
If the “Approve” button is clicked, a Jira/Zendesk ticket is created for the marketing design team
But—if the “Reject” button is pushed, colleagues will be alerted via Slack message
Join us to learn more about this new, human-in-the-loop capability, brought to you by Integration Service connectors.
And...
Speakers:
Akshay Agnihotri, Product Manager
Charlie Greenberg, Host
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Unsubscribed: Combat Subscription Fatigue With a Membership Mentality by Head...
JAVA PROGRAMMING - The Collections Framework
1. JAVA PROGRAMMING - The
Collections Framework
Dr R Jegadeesan Prof-CSE
Jyothishmathi Institute of Technology and Science,
Karimnagar
2. SYLLABUS
The Collections Framework (java.util)- Collections overview,
Collection Interfaces, The Collection classes- Array List, Linked
List, Hash Set, Tree Set, Priority Queue, Array Deque. Accessing
a Collection via an Iterator, Using an Iterator, The For-Each
alternative, Map Interfaces and Classes, Comparators,
Collection algorithms, Arrays, The Legacy Classes and
Interfaces- Dictionary, Hashtable ,Properties, Stack, Vector
More Utility classes, String Tokenizer, Bit Set, Date, Calendar,
Random, Formatter, Scanner
3. UNIT IV : COLLECTION FRAMEWORK
Topic Name : Introduction to Collection Framework
Topic : Introduction to Collection Framework
Aim & Objective : To make the student understand the concept of Collection
Interfaces and Collection Classes and Legacy Classes and Interfaces.
Application With Example :Java Program Using Collection Interfaces and Collection
Classes
Limitations If Any :
Reference Links :
• Java The complete reference, 9th edition, Herbert Schildt, McGraw Hill Education
(India) Pvt. Ltd.
• https://www.javatpoint.com/collections-in-java
• Video Link details
• https://www.youtube.com/watch?v=v9zg9g_FbJY
4. Universities & Important Questions :
• What is the Collection framework in Java?
• What are the main differences between array and collection?
• Explain various interfaces used in Collection framework?
• What is the difference between ArrayList and Vector?
• What is the difference between ArrayList and LinkedList?
• What is the difference between Iterator and ListIterator?
• What is the difference between Iterator and Enumeration?
• What is the difference between List and Set?
• What does the hashCode() method?
• What is the Dictionary class?
5. ▪ Collection Overview
▪ Collection Classes
▪ Collection Interfaces
▪ Legacy Classes
▪ Legacy Interfaces
UNIT – IV
CONTENTS
6. 6
Collection Overview
• List<E> is a generic type (furthermore it’s a generic interface)
• ArrayList<E> is a generic class, which implements List<E>
public class ArrayList<E>
implements List<E> {
private E[] elementData;
private int size;
... //stuff
public boolean add(E o) {
elementData[size++] = o;
return true;
}
public E get(int i) {
return elementData[i];
} //etc...
}
E is a type variable/
type parameter
List<Money> list = new ArrayList<Money>();
List/ArrayList both
parameterised with Money
When you parameterise ArrayList<E>
with Money, think of it as:
E “becomes” Money
public class ArrayList
implements List<Money> {
private Money[] elementData;
private int size;
... //stuff
public boolean add(Money o) {
elementData[size++] = o;
return true;
}
public Money get(int i) {
return elementData[i];
} //etc...
}
7. 7
More than just Lists…
• ArrayLists and LinkedLists are just two of the many classes
comprising the Java Collections Framework (JCF)
• A collection is an object that maintains references to others
objects
– Essentially a subset of data structures
• JCF forms part of the java.util package and provides:
– Interfaces
• Each defines the operations and contracts for a particular type of
collection (List, Set, Queue, etc)
• Idea: when using a collection object, it’s sufficient to know its interface
– Implementations
• Reusable classes that implement above interfaces (e.g. LinkedList,
HashSet)
– Algorithms
• Useful polymorphic methods for manipulating and creating objects
whose classes implement collection interfaces
• Sorting, index searching, reversing, replacing etc.
8. 8
Interfaces
Root interface for operations
common to all types of collections
Specialises collection with
operations for FIFO and priority
queues.
Stores a sequence of elements,
allowing indexing methods
A special
Collection that
cannot contain
duplicates.
Special Set that retains
ordering of elements.
Stores mappings from
keys to values
Special map in
which keys are
ordered
Generalisation
Specialisation
Collection
Set List Queue
SortedSet
Map
SortedMap
10. 10
java.util.Iterator<E>
• Think about typical usage scenarios for Collections
– Retrieve the list of all patients
– Search for the lowest priced item
• More often than not you would have to traverse every element in
the collection – be it a List, Set, or your own datastructure
• Iterators provide a generic way to traverse through a collection
regardless of its implementation
a
f
g
d
b
c
e
i
h
a b c d e f g h i
a b c d e f g h i
Iterator
next():d
iterator()
iterator()
Set
List
hasNext()?
11. 11
Using an Iterator
• Quintessential code snippet for collection iteration:
public void list(Collection<Item> items) {
Iterator<Item> it = items.iterator();
while(it.hasNext()) {
Item item = it.next();
System.out.println(item.getTitle());
}
}
+hasNext():boolean
+next():E
+remove():void
<<interface>>
Iterator<E>
Design notes:
Above method takes in an object whose class implements Collection
List, ArrayList, LinkedList, Set, HashSet, TreeSet, Queue, MyOwnCollection, etc
We know any such object can return an Iterator through method iterator()
We don’t know the exact implementation of Iterator we are getting, but we
don’t care, as long as it provides the methods next() and hasNext()
Good practice: Program to an interface!
12. 12
java.lang.Iterable<T>
• This is called a “for-each” statement
– For each item in items
• This is possible as long as items is of type Iterable
– Defines single method iterator()
• Collection (and hence all its subinterfaces) implements
Iterable
• You can do this to your own implementation of Iterable
too!
– To do this you may need to return your own implementation
of Iterator
Iterator<Item> it = items.iterator();
while(it.hasNext()) {
Item item = it.next();
System.out.println(item);
}
for (Item item : items) {
System.out.println(item);
}
=
<<interface>>
Iterable<T>
+iterator():Iterator<T>
Collection<T> MyBag<T>
List<T>
Set<T>
etc
13. 13
java.util.Collections
• Offers many very useful utilities and
algorithms for manipulating and creating
collections
– Sorting lists
– Index searching
– Finding min/max
– Reversing elements of a list
– Swapping elements of a list
– Replacing elements in a list
– Other nifty tricks
• Saves you having to implement
them yourself → reuse
14. 14
Collections.sort()
• Java’s implementation of merge sort – ascending order
public static <T extends Comparable<? super T>> void sort(List<T> list)
1)
public static <T> void sort(List<T> list, Comparator<? super T> c)
2)
Translation:
1. Only accepts a List parameterised with type implementing Comparable
2. Accepts a List parameterised with any type as long as you also give it a
Comparator implementation that defines the ordering for that type
What types of objects can you sort? Anything that has an ordering
Two sort() methods: sort a given List according to either 1) natural
ordering of elements or an 2) externally defined ordering.
e b c d
0 1 2 3 4
b f
5 6
a a b b c
0 1 2 3 4
d e
5 6
f
15. 15
java.lang.Comparable<T>
• A generic interface with a single method: int compareTo(T)
– Return 0 if this = other
– Return any +’ve integer if this > other
– Return any –’ve integer if this < other
• Implement this interface to define natural ordering on objects of type T
public class Money implements Comparable<Money> {
...
public int compareTo( Money other ) {
if( this.cents == other.cents ) {
return 0;
}
else if( this.cents < other.cents ) {
return -1;
}
else {
return 1;
}
}
A more concise way of doing this? (hint: 1 line)
return this.cents – other.cents;
m1 = new Money(100,0);
m2 = new Money(50,0);
m1.compareTo(m2) returns 1;
16. 16
Natural-order sorting
List<Money> funds = new ArrayList<Money>();
funds.add(new Money(100,0));
funds.add(new Money(5,50));
funds.add(new Money(-40,0));
funds.add(new Money(5,50));
funds.add(new Money(30,0));
Collections.sort(funds);
System.out.println(funds);
List<CD> albums = new ArrayList<CD>();
albums.add(new CD("Street Signs","Ozomatli",2.80));
//etc...
Collections.sort(albums);
public static <T extends Comparable<? super T>> void sort(List<T> list)
What’s the output?
[-40.0,
5.50,
5.50,
30.0,
100.0]
CD does not implement a
Comparable interface
Wildcard (later)
17. 17
java.util.Comparator<T>
• Useful if the type of elements to be sorted is not
Comparable, or you want to define an alternative ordering
• Also a generic interface that defines methods
compare(T,T) and equals(Object)
– Usually only need to define compare(T,T)
• Define ordering by CD’s getPrice() → Money
– Note: PriceComparator implements a Comparator para-
meterised with CD → T “becomes” CD
public class PriceComparator
implements Comparator<CD> {
public int compare(CD c1, CD c2) {
return c1.getPrice().compareTo(c2.getPrice());
}
}
+compare(T o1, T o2):int
+equals(Object other):boolean
<<interface>>
Comparator<T>
CD
+getTitle():String
+getArtist():String
+getPrice():Money
Comparator and Comparable
going hand in hand ☺
18. 18
Comparator sorting
• Note, in sort(), Comparator overrides natural
ordering
– i.e. Even if we define natural ordering for CD, the given comparator is still going to
be used instead
– (On the other hand, if you give null as Comparator, then natural ordering is used)
List<CD> albums = new ArrayList<CD>();
albums.add(new CD("Street Signs","Ozomatli",new Money(3,50)));
albums.add(new CD("Jazzinho","Jazzinho",new Money(2,80)));
albums.add(new CD("Space Cowboy","Jamiroquai",new Money(5,00)));
albums.add(new CD("Maiden Voyage","Herbie Hancock",new Money(4,00)));
albums.add(new CD("Here's the Deal","Liquid Soul",new Money(1,00)));
Collections.sort(albums, new PriceComparator());
System.out.println(albums);
public static <T> void sort(List<T> list, Comparator<? super T> c)
implements Comparator<CD>
19. 19
Set<E>
• Mathematical Set abstraction – contains no duplicate elements
– i.e. no two elements e1 and e2 such that e1.equals(e2)
+add(E):boolean
+remove(Object):boolean
+contains(Object):boolean
+isEmpty():boolean
+size():int
+iterator():Iterator<E>
etc…
<<interface>>
Set<E>
remove(c)
→true
a
b
c
d
remove(x)
→false
add(x)
→true a b
c
d
x
add(b)
→false
contains(e)
→true
?
contains(x)
→false
a b
c
d
e
isEmpty()
→false
size()
→5
+first():E
+last():E
etc…
<<interface>>
SortedSet<E>
20. 20
HashSet<E>
• Typically used implementation of Set.
• Hash? Implemented using HashMap (later)
• Parameterise Sets just as you parameterise Lists
• Efficient (constant time) insert, removal and contains
check – all done through hashing
• x and y are duplicates if x.equals(y)
• How are elements ordered? Quiz:
Set<String> words = new HashSet<String>();
words.add("Bats");
words.add("Ants");
words.add("Crabs");
words.add("Ants");
System.out.println(words.size());
for (String word : words) {
System.out.println(word);
}
?
a) Bats, Ants, Crabs
b) Ants, Bats, Crabs
c) Crabs, Bats, Ants
d) Nondeterministic
+add(E):boolean
+remove(Object):boolean
+contains(Object):boolean
+size():int
+iterator():Iterator<E>
etc…
<<interface>>
Set<E>
HashSet<E>
3
21. 21
TreeSet<E> (SortedSet<E>)
• If you want an ordered set, use an implementation
of a SortedSet: TreeSet
• What’s up with “Tree”? Red-black tree
• Guarantees that all elements are ordered (sorted)
at all times
– add() and remove() preserve this condition
– iterator() always returns the elements in a
specified order
• Two ways of specifying ordering
– Ensuring elements have natural ordering (Comparable)
– Giving a Comparator<E> to the constructor
• Caution: TreeSet considers x and y are duplicates if
x.compareTo(y) == 0 (or compare(x,y) == 0)
+first():E
+last():E
etc…
<<interface>>
SortedSet<E>
TreeSet<E>
22. 22
TreeSet construction
• String has a natural
ordering, so empty
constructor
Set<String> words = new TreeSet<String>();
words.add("Bats");
words.add("Ants");
words.add("Crabs");
for (String word : words) {
System.out.println(word);
}
Set<CD> albums = new TreeSet<CD>(new PriceComparator());
albums.add(new CD("Street Signs","O",new Money(3,50)));
albums.add(new CD("Jazzinho","J",new Money(2,80)));
albums.add(new CD("Space Cowboy","J",new Money(5,00)));
albums.add(new CD("Maiden Voyage","HH",new Money(4,00)));
albums.add(new CD("Here’s the Deal","LS",new Money(2,80)));
System.out.println(albums.size());
for (CD album : albums) {
System.out.println(album);
}
But CD doesn’t, so you must pass in a Comparator to the constructor
What’s the output?
4
Jazzinho; Street; Maiden; Space
What’s the output?
Ants; Bats; Crabs
23. 23
Map<K,V>
• Stores mappings from (unique) keys (type K) to values (type V)
– See, you can have more than one type parameters!
• Think of them as “arrays” but with objects (keys) as indexes
– Or as “directories”: e.g. "Bob" → 021999887
+put(K,V):V
+get(Object):V
+remove(Object):V
+size():int
+keySet():Set<K>
+values():Collection<V>
etc…
<<interface>>
Map<K,V>
+firstKey():K
+lastKey():K
etc…
<<interface>>
SortedMap<K,V>
get(k)
→a a
b
c
b
k
m
p
n
get(x)
→null
keys values
put(x,e)
→null
a
b
c
b
k
m
p
n
e
x
put(k,f)
→a
a
b
c
b
k
m
p
n
f
size()
→4
remove(n)
→b
remove(x)
→null
a
b
c
b
k
m
p
n
keySet()
→Set
k
m p
n
values()
→Collection
a b
c b
24. 24
HashMap<K,V>
• aka Hashtable (SE250)
• keys are hashed using Object.hashCode()
– i.e. no guaranteed ordering of keys
• keySet() returns a HashSet
• values() returns an unknown Collection
+put(K,V):V
+get(Object):V
+remove(Object):V
+size():int
+keySet():Set<K>
+values():Collection<V>
etc…
<<interface>>
Map<K,V>
HashMap<K,V>
Map<String, Integer> directory
= new HashMap<String, Integer>();
directory.put("Mum", new Integer(9998888));
directory.put("Dad", 9998888);
directory.put("Bob", 12345678);
directory.put("Edward", 5553535);
directory.put("Bob", 1000000);
System.out.println(directory.size());
for (String key : directory.keySet()) {
System.out.print(key+"'s number: ");
System.out.println(directory.get(key));
}
System.out.println(directory.values());
4 or 5?
Set<String>
“autoboxing”
What’s Bob’s number?
25. 25
TreeMap<K,V>
• Guaranteed ordering of keys (like TreeSet)
– In fact, TreeSet is implemented using TreeMap ☺
– Hence keySet() returns a TreeSet
• values() returns an unknown Collection – ordering depends
on ordering of keys
+firstKey():K
+lastKey():K
etc…
<<interface>>
SortedMap<K,V>
TreeMap<K,V>
Map<String, Integer> directory
= new TreeMap<String, Integer>();
directory.put("Mum", new Integer(9998888));
directory.put("Dad", 9998888);
directory.put("Bob", 12345678);
directory.put("Edward", 5553535);
directory.put("Bob", 1000000);
System.out.println(directory.size());
for (String key : directory.keySet()) {
System.out.print(key+"'s #: ");
System.out.println(directory.get(key));
}
System.out.println(directory.values());
Loop output?
Bob's #: 1000000
Dad's #: 9998888
Edward's #: 5553535
Mum's #: 9998888
4
?
Empty constructor
→ natural ordering
26. 26
TreeMap with Comparator
• As with TreeSet, another way of constructing TreeMap is to give a Comparator →
necessary for non-Comparable keys
Map<CD, Double> ratings
= new TreeMap<CD, Double>(new PriceComparator());
ratings.put(new CD("Street Signs","O",new Money(3,50)), 8.5);
ratings.put(new CD("Jazzinho","J",new Money(2,80)), 8.0);
ratings.put(new CD("Space Cowboy","J",new Money(5,00)), 9.0);
ratings.put(new CD("Maiden Voyage","H",new Money(4,00)), 9.5);
ratings.put(new CD("Here's the Deal","LS",new Money(2,80)), 9.0);
System.out.println(ratings.size());
for (CD key : ratings.keySet()) {
System.out.print("Rating for "+key+": ");
System.out.println(ratings.get(key));
}
System.out.println("Ratings: "+ratings.values());
4
Depends on
key ordering
Ordered by key’s
price