![Page 1: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/1.jpg)
CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING
7-8: Resizable Arrays
Alexandra PapoutsakiLECTURES
Mark KampeLABS
Some slides adopted from Princeton C0S226 course or Algorithms, 4th Edition
BASIC DATA STRUCTURES
![Page 2: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/2.jpg)
TODAY’S LECTURE IN A NUTSHELL
Lecture 7: Resizable Arrays
▸ Background
▸ ArrayList
▸ Java Collections
�2
Some slides adopted from Algorithms 4th Edition and Oracle tutorials
![Page 3: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/3.jpg)
BACKGROUND
Why do we need data structures?
▸ To organize and store data so that we can perform efficient operations on them based on our needs.
▸ Imagine walking to an unorganized library and trying to find your favorite title or books from your favorite author.
▸ We can define efficiency in different ways.
▸ Time: How fast can we perform certain operations?
▸ Space: How much memory do we need to organize our data?
▸ There is no data structure that fits all needs.
▸ That’s why we’re spending a semester looking at different data structures.
▸ So far, the only data structure we have encountered is arrays.
�3
![Page 4: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/4.jpg)
BACKGROUND
Types of operations on data structures
▸ Insertion: adding a new element in a data structure.
▸Deletion: Removing (and possibly returning) an element.
▸Searching: Searching for a specific data element.
▸Replacement: Replacing an existing element with a new one (and possibly returning old).
▸Traversal: Going through all the elements.
▸Sorting: Sorting all elements in a specific way.
▸Check if empty: Check if data structure contains any elements.
▸Not a single data structure does all these things efficiently.
▸You need to know both the kind of data you have, the different operations you will need to perform on them, and any technical limitations to pick an appropriate data structure.
�4
![Page 5: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/5.jpg)
BACKGROUND
Linear vs non-linear data structures
▸ Linear: elements arranged in a linear sequence based on a specific order.
▸ E.g., Arrays, arrayLists, linked lists, stacks, queues.
▸ Linear memory allocation: all elements are placed in a contiguous block of memory. E.g., arrays.
▸ Use of pointers/links: elements don’t need to be placed in contiguous blocks. The linear relationship is formed through pointers. E.g., singly and doubly linked lists.
▸ Non-linear: elements arranged in non-linear, mostly hierarchical relationship.
▸ E.g., trees and graphs.
�5
![Page 6: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/6.jpg)
TODAY’S LECTURE IN A NUTSHELL
Lecture 7: Resizable Arrays
▸ Background
▸ ArrayList
▸ Java Collections
�6
![Page 7: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/7.jpg)
ARRAYLIST
Limitations of arrays
�7
‣ Fixed-size. ‣ Do not work with Generics. ‣ Adding or removing from the middle is hard. ‣ Limited functionality (in Java, requires the use of Arrays class)
![Page 8: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/8.jpg)
ARRAYLIST
Resizable array or ArrayList
�8
‣ Dynamic linear data structure that is zero-indexed. ‣ Sequential data structure that requires consecutive memory
cells. ‣ Implemented with an underlying array of a specific capacity.
CS062 ROCKS !
0 1 2 3 4 5 6 7
![Page 9: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/9.jpg)
ARRAYLIST
Standard Operations of ArrayList<Item> class
�9
‣ ArrayList(): Constructs an empty ArrayList with an initial capacity of 2 (can vary across implementations).
‣ ArrayList(int capacity): Constructs an empty ArrayList with the specified initial capacity.
‣ isEmpty(): Returns true if the ArrayList contains no items. ‣ size(): Returns the number of items in the ArrayList. ‣ get(int index): Returns the item at the specified index. ‣ add(Item item): Appends the item to the end of the ArrayList. ‣ add(int index, Item item): Inserts the item at the specified index. ‣ Item remove(): Retrieves and removes the item from the end of the ArrayList. ‣ Item remove(int index): Retrieves and removes the item at the specified index. ‣ set(int index, Item item): Replaces the item at the specified index with the
specified item.
![Page 10: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/10.jpg)
ARRAYLIST
ArrayLists
�10
CS062 ROCKS !
0 1 2 3 4 5 6 7
Front End/Rear
Capacity = 8
Number of items = 3
![Page 11: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/11.jpg)
ARRAYLIST
ArrayList(): Constructs an ArrayList
�11
0 1
Front End/Rear
Capacity = 2
Number of items = 0
ArrayList<String> al = new ArrayList<String>();
What should happen?
al.add(“CS062”);
![Page 12: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/12.jpg)
ARRAYLIST
add(Item item):Appends the item to the end of the ArrayList
�12
CS062
0 1
Front End/Rear
Capacity = 2
Number of items = 1
al.add(“CS062”);
What should happen?
al.add(“ROCKS”);
![Page 13: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/13.jpg)
ARRAYLIST
add(Item item):Appends the item to the end of the ArrayList
�13
CS062 ROCKS
0 1
Front End/Rear
Capacity = 2
Number of items = 2
al.add(“ROCKS”);
What should happen?
al.add(“!”);
![Page 14: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/14.jpg)
ARRAYLIST
add(Item item):Appends the item to the end of the ArrayList
�14
CS062 ROCKS
0 1
Front End/Rear
Capacity = 4
Number of items = 3
!
2 3
al.add(“!”);
DOUBLE CAPACITY SINCE IT’S FULL AND THEN ADD NEW ITEM
What should happen?
al.add(1, “THROWS”);
![Page 15: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/15.jpg)
ARRAYLIST
add(int index, Item item):Adds item at the specified index
�15
CS062 THROWS
0 1
Front End/Rear
Capacity = 4
Number of items = 4
ROCKS !
2 3
al.add(1, “THROWS”);
SHIFT ELEMENTS TO THE RIGHTADD NEW ITEM
What should happen?
al.add(3, “?”);
![Page 16: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/16.jpg)
ARRAYLIST
add(int index, Item item):Adds item at the specified index
�16
CS062 THROWS
0 1
Front End/Rear
Capacity = 8
Number of items = 5
ROCKS ?
2 3
al.add(3, “?”);
!
4 5 6 7
RESIZE SHIFT ELEMENTS TO THE RIGHTADD NEW ITEM
What should happen?
al.remove();
![Page 17: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/17.jpg)
ARRAYLIST �17
CS062 THROWS
0 1
Front End/Rear
Capacity = 8
Number of items = 4
ROCKS ?
2 3
al.remove();
4 5 6 7
What should happen?
al.remove();
remove():Retrieves and removes item from the end of ArrayList
![Page 18: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/18.jpg)
ARRAYLIST �18
CS062 THROWS
0 1
Front End/Rear
Capacity = 8
Number of items = 3
ROCKS
2 3
al.remove();
4 5 6 7
What should happen?
al.remove();
remove():Retrieves and removes item from the end of ArrayList
![Page 19: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/19.jpg)
ARRAYLIST
remove():Retrieves and removes item from the end of ArrayList
�19
CS062 THROWS
0 1
Front End/Rear
Capacity = 4
Number of items = 2
2 3
al.remove();
REMOVE ITEM FROM THE ENDHALVE CAPACITY WHEN 1/4 FULL
What should happen?
al.remove(0);
![Page 20: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/20.jpg)
ARRAYLIST
remove(int index):Retrieves and removes item from specified index
�20
THROWS
0 1
Front End/Rear
Capacity = 2
Number of items = 1
al.remove(0);
REMOVE ITEM FROM INDEX SHIFT ELEMENTS TO THE LEFT HALVE CAPACITY WHEN 1/4 FULL
![Page 21: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/21.jpg)
ARRAYLIST
Our own implementation of ArrayLists
�21
‣ We will follow the textbook style. ‣ It does not offer a class for this so we will build our own. We will also test our
implementation in lab! ‣ We will work with generics because we don’t want to offer multiple
implementations. ‣ We will use an array and we will keep track of how many elements we have in
our arrayList.
![Page 22: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/22.jpg)
ARRAYLIST
Instance variables and constructors
�22
public class ArrayList<Item> implements Iterable<Item> {private Item[] a; // underlying array of itemsprivate int n; // number of items in arraylist
/** * Constructs an ArrayList with an initial capacity of 2. */@SuppressWarnings("unchecked")public ArrayList() {
a = (Item[]) new Object[2];n = 0;
}
/** * Constructs an ArrayList with the specified capacity. */@SuppressWarnings("unchecked")public ArrayList(int capacity) {
a = (Item[]) new Object[capacity];n = 0;
}
![Page 23: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/23.jpg)
ARRAYLIST
Check if is empty and how many items
�23
/** * Returns true if the ArrayList contains no items. * * @return true if the ArrayList does not contain any item */public boolean isEmpty() {
return n == 0;}
/** * Returns the number of items in the ArrayList. * * @return the number of items in the ArrayList */public int size() {
return n;}
![Page 24: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/24.jpg)
ARRAYLIST
Resize underlying array’s capacity
�24
/** * Resizes the ArrayList's capacity to the specified capacity. */@SuppressWarnings("unchecked")private void resize(int capacity) {
assert capacity >= n;// textbook implementation.Item[] temp = (Item[]) new Object[capacity];for (int i = 0; i < n; i++)
temp[i] = a[i];
a = temp;
// alternative implementation// a = java.util.Arrays.copyOf(a, capacity);
}
![Page 25: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/25.jpg)
ARRAYLIST
Append an item to the end of ArrayList
�25
/** * Appends the item to the end of the ArrayList. Doubles its capacity if necessary. * * @param item * the item to be inserted */public void add(Item item) {
if (n == a.length)resize(2 * a.length);
a[n++] = item;}
![Page 26: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/26.jpg)
ARRAYLIST
Check if index is >=0 and <n
�26
/** * A helper method to check if an index is in range 0<=index<n * * @param index * the index to check */private void rangeCheck(int index) {
if (index > n || index < 0)throw new IndexOutOfBoundsException("Index " + index + " out of bounds");
}
![Page 27: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/27.jpg)
ARRAYLIST
Add an item at a specified index
�27
/** * Inserts the item at the specified index. Shifts existing elements * to the right and doubles its capacity if necessary. * * @param index * the index to insert the item * @param item * the item to be inserted */public void add(int index, Item item) {
rangeCheck(index);
if (n == a.length)resize(2 * a.length);
// shift elements to the rightfor (int i = n++; i > index; i--)
a[i] = a[i - 1];
a[index] = item;}
![Page 28: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/28.jpg)
ARRAYLIST
Replace an item at a specified index
�28
/** * Replaces the item at the specified index with the specified item. * * @param index * the index of the item to replace * @param item * item to be stored at specified index * @return the old item that was changed. */public Item set(int index, Item item) {
rangeCheck(index);
Item old = a[index];a[index] = item;
return old;}
![Page 29: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/29.jpg)
ARRAYLIST
Retrieve and remove item from the end of ArrayList
�29
/** * Retrieves and removes the item from the end of the ArrayList. * @return the removed item * @pre n>0 */public Item remove() {
if (isEmpty())throw new NoSuchElementException("The list is empty");
Item item = a[--n];a[n] = null; // Avoid loitering (see text).
// Shrink to save space if possibleif (n > 0 && n == a.length / 4)
resize(a.length / 2);
return item;}
![Page 30: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/30.jpg)
ARRAYLIST
Retrieve and remove item from a specific index
�30
/** * Retrieves and removes the item at the specified index. * * @param index * the index of the item to be removed * @return the removed item */public Item remove(int index) {
rangeCheck(index);
Item item = a[index];n--;
for (int i = index; i < n; i++)a[i] = a[i + 1];
a[n] = null; // Avoid loitering (see text).
// shrink to save space if necessaryif (n > 0 && n == a.length / 4)
resize(a.length / 2);
return item;}
![Page 31: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/31.jpg)
ARRAYLIST
Clear all elements
�31
/** * Clears the ArrayList of all elements. */public void clear() {
// Help garbage collector.for (int i = 0; i < n; i++)
a[i] = null;
n = 0;}
![Page 32: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/32.jpg)
TODAY’S LECTURE IN A NUTSHELL
Lecture 7: Resizable Arrays
▸ Background
▸ ArrayList
▸ Java Collections
�32
![Page 33: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/33.jpg)
JAVA COLLECTIONS
The Java Collections Framework
▸ Collection: an object that groups multiple elements into a single unit, allowing us to store, retrieve, manipulate data.
▸ Collections Framework:
▸ Interfaces: ADTs that represent collections.
▸ Implementations: The actual data structures.
▸ Algorithms: methods that perform useful computations, such as searching and sorting.
�33
https://docs.oracle.com/javase/tutorial/collections/intro/index.html
![Page 34: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/34.jpg)
JAVA COLLECTIONS
The Java Collections Framework
�34
https://en.wikipedia.org/wiki/Java_collections_framework
![Page 35: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/35.jpg)
JAVA COLLECTIONS
List ADT
�35
https://en.wikipedia.org/wiki/Java_collections_framework
▸ A collection storing elements in an ordered fashion.
▸ Elements are accessed in a zero-based fashion.
▸ Typically allow duplicate elements and null values but always check the specifications of implementation.
![Page 36: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/36.jpg)
JAVA COLLECTIONS
ArrayList in Java Collections
�36
https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html
▸ Resizable list that increases by 50% when full and does NOT shrink.
▸ Not thread-safe (more later in course).
java.util.ArrayList;
public class ArrayList<E> extends AbstractList<E> implements List<E>
![Page 37: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/37.jpg)
JAVA COLLECTIONS
Vector in Java Collections
�37
https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html
▸ Java has one more class for resizable arrays.
▸ Doubles when full.
▸ Is synchronized (more later in the course).
java.util.Vector;
public class Vector<E> extends AbstractList<E> implements List<E>
![Page 38: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/38.jpg)
TODAY’S LECTURE IN A NUTSHELL
Lecture 7: Resizable Arrays
▸ Background
▸ ArrayList
▸ Java Collections
�38
![Page 39: DATA STRUCTURES AND ADVANCED PROGRAMMING · CS062 DATA STRUCTURES AND ADVANCED PROGRAMMING 7-8: Resizable Arrays Alexandra Papoutsaki LECTURES Mark Kampe LABS Some slides adopted](https://reader030.vdocument.in/reader030/viewer/2022040207/5e1779d569e23e1fd519fe24/html5/thumbnails/39.jpg)
ASSIGNED READINGS AND PRACTICE PROBLEMS
Readings:
▸ Oracle’s guides:
▸ Collections: https://docs.oracle.com/javase/tutorial/collections/intro/index.html
▸ ArrayLists: https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html
▸ Textbook:
▸ Chapter 1.3 (Page 136–137)
▸ Textbook Website:
▸ Resizable arrays: https://algs4.cs.princeton.edu/13stacks/
�39