AP Classroom Unit 7

NOTEBOOK ENTRIES:

7.1 Videos
Notes/Definitions:
●​ ArrayList is a class in Java that implements a dynamic array-like data structure. It is part of the
java.util package and provides methods to add, remove, and access elements.
●​ ArrayList is resizable, meaning it can grow or shrink as elements are added or removed, unlike
regular arrays which have a fixed size.
●​ The elements in an ArrayList are indexed, starting from 0, just like arrays.
●​ ArrayLists can only store objects, not primitive types. For primitive types, wrapper classes like
Integer for int, Double for double, etc., must be used.

●​ Common operations for ArrayLists:

○​ add(E element): Adds an element to the end of the ArrayList.
○​ get(int index): Retrieves the element at the specified index.
○​ set(int index, E element): Replaces the element at the specified index with a new
element.
○​ remove(int index): Removes the element at the specified index.
○​ size(): Returns the number of elements in the ArrayList.
○​ clear(): Removes all elements from the ArrayList.
○​ contains(Object o): Checks if a specific element is in the ArrayList.
○​ isEmpty(): Checks if the ArrayList is empty.
○​ ArrayLists offer a greater degree of flexibility than arrays because of their dynamic
resizing. When the list exceeds its current capacity, it automatically grows to
accommodate additional elements.
○​ Arrays, on the other hand, have a fixed size, and resizing them requires creating a new
array and copying the elements manually.
Summary:
In this lesson, we explored the ArrayList class in Java, which allows us to work with dynamically
resizing arrays. Unlike traditional arrays with fixed sizes, ArrayLists can grow and shrink as needed,
providing flexibility in managing data. We also learned common ArrayList operations, such as adding,
removing, and accessing elements, and how ArrayLists are preferred when dealing with unknown or
changing data sizes. The lesson emphasized the differences between arrays and ArrayLists,
particularly in terms of size flexibility and ease of use.
Code:
1)​

2)​
 3)​

Reflection:
Learning about ArrayLists has significantly improved my understanding of how to manage dynamic
data in Java. Prior to this, I mostly worked with arrays, which required me to anticipate the number of
elements. With ArrayLists, I feel more confident in handling cases where the size of the data set isn't
known beforehand. The automatic resizing feature is particularly useful, and I now see the
advantages of using ArrayLists over arrays in situations where the data size can change. Overall, this
lesson has made me more comfortable with Java collections and ready to apply ArrayLists in my
projects.

7.2 Videos
Notes/Definitions:

●​ add(E element): Adds the specified element to the end of the ArrayList.
●​ add(int index, E element): Inserts the specified element at the specified index in the
ArrayList, shifting elements if necessary.
●​ get(int index): Retrieves the element at the specified index.
●​ set(int index, E element): Replaces the element at the specified index with the new element.
●​ remove(int index): Removes the element at the specified index, shifting subsequent
elements.
●​ remove(Object o): Removes the first occurrence of the specified element from the ArrayList.
●​ clear(): Removes all elements from the ArrayList, making it empty.
●​ size(): Returns the number of elements in the ArrayList.
 ●​ isEmpty(): Returns true if the ArrayList is empty, otherwise returns false.
●​ contains(Object o): Checks if the ArrayList contains the specified element. Returns true if the
element is found.
●​ indexOf(Object o): Returns the index of the first occurrence of the specified element or -1 if
not found.
●​ lastIndexOf(Object o): Returns the index of the last occurrence of the specified element or -1
if not found.
●​ toArray(): Converts the ArrayList to an array and returns it.
●​ forEach(Consumer<? super E> action): Iterates over the ArrayList and applies the given
action to each element.

●​ Performance Considerations:
○​ add(E element) is generally constant time (O(1)) when adding elements at the end.
○​ add(int index, E element) and other insertion operations at the beginning or middle of
the ArrayList can take O(n) time because elements have to be shifted.
○​ Removing elements (e.g., remove(int index)) also involves shifting elements, so it can
take O(n) time.
○​ Searching operations like contains(Object o) and indexOf(Object o) have O(n) time
complexity, as they may require checking every element.
○​ Methods like size(), isEmpty(), and toArray() typically run in O(1) time.

●​ Common Usage:
○​ ArrayLists are useful when you need a dynamic collection that can grow and shrink as
needed.
○​ Methods like add() and remove() provide flexibility in modifying the ArrayList's contents.
○​ get() and set() are useful for accessing and updating specific elements in the list.
○​ clear() is handy for resetting the ArrayList when all elements need to be removed.

Summary:
In this lesson, we focused on the various methods available for manipulating and accessing elements
in an ArrayList in Java. These methods allow you to add, remove, update, and search for elements in
the ArrayList. We also examined the time complexities associated with these methods, noting that
operations like adding or removing elements at the beginning or middle can be less efficient than
those at the end due to the need to shift elements. Understanding these methods and their
performance helps ensure that ArrayLists are used efficiently and effectively in Java programs.
Code:
1)
2)
3)

Reflection:
After learning about the ArrayList methods, I now feel more confident in utilizing them to manipulate
data in a list format. The ability to dynamically add, remove, and modify elements provides great
flexibility compared to using traditional arrays. I found the time complexity considerations particularly
important because they help me understand the performance of different operations. This lesson
deepened my understanding of how to use ArrayLists effectively, especially for situations where the
size of the data set might change frequently. I look forward to applying these methods in my coding
projects, particularly where the flexibility of dynamically sized collections is required.

7.3 Videos
Notes/Definitions:

●​ Traversing an ArrayList means accessing and processing each element in the list, typically
using loops.
●​ The most common method for traversing an ArrayList is using a for loop.
○​ Standard for loop: You can loop through an ArrayList using an index variable.
 ●​ Enhanced for loop (for-each loop): A more concise way to iterate through each element without
needing an index.
●​ The index-based loop (for loop) gives you the ability to modify the list during traversal (if
needed) and access the index of each element.
●​ The enhanced for loop is generally used when you don't need the index, and it's simpler to
read.
●​ When traversing an ArrayList, you typically:
○​ Access individual elements with get(int index).
○​ Modify elements using set(int index, E element) (when using an index-based
loop).
○​ Perform checks (e.g., if an element meets a certain condition) inside the loop.
●​ Traversal can also be done using while loops or iterators (although these are less commonly
used than for loops in this context).
●​ Performance considerations:
○​ Both the for loop and enhanced for loop have O(n) time complexity, where n is the
number of elements in the ArrayList.
○​ Accessing elements with get(index) is O(1), but methods like add() or remove()
can be O(n) due to shifting elements.

Summary:
In this lesson, we learned how to traverse ArrayLists in Java using different types of loops. The most
common approaches include the standard for loop, which uses an index to access each element, and
the enhanced for loop, which is a simpler syntax for directly iterating through the elements without
needing the index. Both approaches have O(n) time complexity, and their usage depends on whether
or not the index of the element is needed during the iteration. The lesson also highlighted when and
how to modify elements or perform checks during traversal.
Code:
1)
2)
3)

Reflection:
In this lesson, we learned how to traverse ArrayLists in Java using different types of loops. The most
common approaches include the standard for loop, which uses an index to access each element, and
the enhanced for loop, which is a simpler syntax for directly iterating through the elements without
needing the index. Both approaches have O(n) time complexity, and their usage depends on whether
or not the index of the element is needed during the iteration. The lesson also highlighted when and
how to modify elements or perform checks during traversal.

7.4 Videos
Notes/Definitions:
●​ Developing algorithms using ArrayLists involves designing solutions that interact with and
manipulate ArrayLists efficiently.
●​ ArrayLists can be used for a variety of purposes such as searching for elements, sorting data,
or filtering elements based on conditions.

●​ Common operations include:

○​ Searching for an element: Use loops (for or enhanced for) to check if an element exists
in the ArrayList.
■​ Example: Iterating through the list to find a specific value and returning the index.
 ○​ Adding elements: Elements can be added to the end of the list using add(), or at
specific positions using add(int index, E element).
○​ Removing elements: Use remove(int index) or remove(Object o) to delete
elements from the ArrayList based on their index or value.
○​ Modifying elements: Use set(int index, E element) to update elements in the
ArrayList.
○​ Sorting elements: Sorting can be done manually or with Java’s built-in sorting
mechanisms such as Collections.sort().
○​ Filtering elements: Algorithms can be designed to iterate through the ArrayList and
select elements that meet certain conditions, creating a new list with only the matching
elements.

●​ Performance Considerations:
○​ Time complexity of searching: Searching with a loop is O(n) because each element
must be checked one by one.
○​ Time complexity of adding/removing elements: Adding elements at the end of the list is
O(1), but adding/removing at the beginning or middle is O(n) due to shifting elements.
○​ Time complexity of sorting: Using Collections.sort(), which implements a
modified merge sort, has an average time complexity of O(n log n).
○​ Efficiency: ArrayLists are generally efficient for tasks that require dynamic resizing or
when you need frequent element retrieval using an index.

Summary:
This lesson covered how to develop algorithms using ArrayLists to solve problems. The key concepts
include adding, removing, modifying, searching, sorting, and filtering elements within an ArrayList. We
learned how to design algorithms to manipulate ArrayLists efficiently, depending on the task. For
example, searching for an element involves iterating through the list, while sorting can be done using
Java’s built-in methods. Performance considerations, such as time complexities for various
operations, are important when choosing the right algorithm for a task. These techniques are
essential for efficiently handling data stored in ArrayLists.
Code:
1)
2)
3)

Reflection:
The lesson on developing algorithms using ArrayLists was particularly insightful as it connected
theoretical concepts with practical implementation. I now feel more confident in designing algorithms
that interact with ArrayLists to solve common problems like searching, filtering, and sorting. The
performance considerations were a useful reminder to think about the efficiency of each operation,
especially when dealing with larger lists. I’m excited to apply these techniques in real coding projects,
knowing that I can optimize performance and design clean, effective algorithms using ArrayLists. This
lesson has provided me with the tools to manipulate data structures more effectively.

7.5 Videos
Notes/Definitions:
●​ Searching algorithms are used to find a specific element within a data structure such as an
ArrayList.
●​ The two primary types of search algorithms are linear search and binary search.
●​ Linear Search:
○​ Involves checking each element of the ArrayList, one by one, until the target element is
found.
○​ If the element is found, return its index; otherwise, return -1 to indicate that the element
is not in the list.
○​ Time complexity: O(n), where n is the number of elements in the ArrayList. It may need
to check every element in the worst case.
 ●​ Binary Search:
○​ A more efficient search algorithm than linear search, but it only works on sorted lists.
○​ The list is divided in half repeatedly, comparing the target value to the middle element,
and adjusting the search range accordingly.
○​ Time complexity: O(log n), where n is the number of elements. This is much faster than
linear search for large datasets.

●​ Linear Search vs Binary Search:

○​ Linear search works on unsorted lists, while binary search requires the list to be sorted
beforehand.
○​ Linear search is simple and easy to implement but slower for large datasets.
○​ Binary search is much faster for large sorted datasets but requires sorting the list first
(which can take O(n log n) time).

●​ Performance Considerations:
○​ Linear search is generally used for smaller datasets or when the list is unsorted.
○​ Binary search is highly efficient for large datasets but requires the list to be sorted,
which may add overhead.
○​ If the data changes frequently (e.g., items are added or removed), sorting may need to
be re-done, affecting performance.

●​ Searching with built-in Java methods:

○​ Java provides methods such as indexOf() and contains() in ArrayList to simplify
searching.
○​ These methods internally use linear search to find elements in the list.

Summary:

This lesson focused on searching algorithms, specifically linear search and binary search, for finding
elements in an ArrayList. Linear search is straightforward but inefficient for large datasets as it
requires checking each element one by one. Binary search, on the other hand, is much faster,
operating with a time complexity of O(log n), but requires the list to be sorted beforehand. The lesson
covered when each search algorithm is appropriate to use and highlighted performance
considerations. It also touched on Java’s built-in methods for searching in ArrayLists, which use linear
search internally.

Code:
1)
2)
3)

Reflection:

The lesson on searching algorithms helped me understand the trade-offs between different search
techniques. While linear search is simple and versatile, I can see that binary search will be much
more efficient when dealing with large, sorted datasets. It was also helpful to learn about the
performance considerations, especially when using built-in Java methods like indexOf() and
contains(). I now feel more confident in choosing the appropriate search algorithm depending on the
context and data structure I am working with. This lesson has given me a deeper understanding of
how to efficiently search through collections in Java, and I look forward to applying this knowledge in
my future projects.

7.6 Videos
Notes/Definitions:
●​ Sorting algorithms are used to arrange elements in a specific order, either ascending or
descending.
●​ Sorting algorithms improve the efficiency of searching and other operations that require
ordered data.
●​ Common sorting algorithms include:

●​ Selection Sort:
○​ Repeatedly selects the smallest (or largest) element from the unsorted portion of the list
and swaps it with the first unsorted element.
○​ Time complexity: O(n^2), where n is the number of elements in the list. It is inefficient for
large datasets.
○​ Simple to implement but not optimal for large lists.
●​ Bubble Sort:
○​ Repeatedly steps through the list, compares adjacent elements, and swaps them if they
are in the wrong order. This process is repeated until the list is sorted.
○​ Time complexity: O(n^2) in the worst case. Like selection sort, bubble sort is inefficient
for large datasets.
○​ It is easy to understand but not ideal for performance.
●​ Insertion Sort:
○​ Builds the sorted list one element at a time by inserting elements into their correct
position in the sorted portion of the list.
○​ Time complexity: O(n^2) in the worst case, but it performs well for small or partially
sorted lists.
○​ More efficient than selection and bubble sort for smaller datasets.
●​ Merge Sort:
○​ A divide-and-conquer algorithm that splits the list into halves, recursively sorts each
half, and then merges the sorted halves back together.
○​ Time complexity: O(n log n), which is significantly faster than the previous algorithms for
large datasets.
○​ Stable sort (preserves the order of equal elements) and efficient for large datasets.
●​ Quick Sort:
○​ Another divide-and-conquer algorithm that selects a pivot element, partitions the list into
two sublists, and recursively sorts the sublists.
○​ Time complexity: O(n log n) on average, but can degrade to O(n^2) if the pivot selection
is poor.
○​ Efficient for large datasets and often faster than merge sort in practice due to lower
overhead.

●​ Java's Built-in Sorting:

○​ Java provides built-in sorting methods like Collections.sort() for ArrayLists and
Arrays.sort() for arrays.
○​ These methods use efficient sorting algorithms like TimSort, which is a hybrid sorting
algorithm derived from merge sort and insertion sort.
○​ TimSort is efficient with a time complexity of O(n log n) in the worst case.
 ●​ Performance Considerations:
○​ Selection Sort, Bubble Sort, and Insertion Sort have quadratic time complexity (O(n^2))
and are inefficient for large lists.
○​ Merge Sort and Quick Sort are faster with O(n log n) time complexity and perform well
with larger datasets.
○​ Sorting stability matters when preserving the relative order of equal elements is
important.
○​ Built-in sorting methods in Java are optimized and generally use O(n log n) algorithms
like TimSort, making them ideal for most cases.

Summary:
This lesson focused on various sorting algorithms used to arrange elements in a list, such as
Selection Sort, Bubble Sort, Insertion Sort, Merge Sort, and Quick Sort. It covered the time
complexities of each algorithm, with O(n^2) algorithms being inefficient for large datasets, and O(n log
n) algorithms like merge sort and quick sort being much more efficient for larger datasets. Java’s
built-in sorting methods, which utilize algorithms like TimSort, are generally optimized for real-world
use. The lesson emphasized understanding the performance characteristics of different sorting
algorithms to choose the most appropriate one depending on the dataset size and requirements.
Code:
1)
2)
3)

Reflection:
The lesson on sorting algorithms was highly informative, as it provided an in-depth look at various
sorting methods and their performance characteristics. I was familiar with some sorting algorithms like
bubble sort and quick sort, but understanding their time complexities in relation to the data size really
helped me appreciate the importance of choosing the right sorting algorithm. The efficiency of Merge
Sort and Quick Sort for large datasets stood out, and it was helpful to see the built-in sorting
mechanisms in Java. I feel more confident in understanding when to use different sorting algorithms
and how to optimize sorting for various scenarios. This knowledge will be valuable for improving the
performance of my programs, especially when dealing with large amounts of data.

7.7 Videos
Notes/Definitions:
●​ Data collection involves gathering information, which can be used for various purposes such
as research, marketing, or improving services.
●​ Ethical issues arise when data is collected or used in ways that may harm individuals or
groups.

●​ Privacy Concerns:
○​ Individuals have the right to control their personal information.
○​ Ethical issues arise when personal data is collected without consent or when data is
shared without permission.
○​ Data collection practices must respect users’ privacy and follow regulations like GDPR
(General Data Protection Regulation) in the EU or CCPA (California Consumer Privacy
Act).

●​ Informed Consent:
○​ Collecting data ethically requires obtaining consent from individuals who are fully aware
of how their data will be used.
○​ Consent should be clear, transparent, and specific about what data will be collected and
how it will be utilized.
○​ People should have the option to withdraw their consent at any time.

●​ Data Security:
○​ Organizations must take steps to protect collected data from unauthorized access or
breaches.
○​ Ethical concerns arise if organizations fail to implement proper data security measures,
putting individuals’ information at risk.

●​ Bias in Data Collection:

○​ Bias can occur if the data collected does not represent a diverse or accurate sample of
the population.
○​ Ethical problems arise when biased data leads to unfair or discriminatory outcomes,
such as decisions that negatively affect certain groups.
○​ Ensuring that data collection processes are fair and representative is essential.

●​ Data Ownership:
○​ The question of who owns the data collected is important. Is it the individual, the
organization collecting the data, or another party?
○​ Ethical concerns arise when individuals’ data is used without their knowledge or without
fair compensation.
○​ Clear agreements about ownership and usage rights must be established.
 ●​ Data Usage and Purpose:
○​ Data should only be used for the purpose it was collected for.
○​ Ethical issues arise when data is used for other purposes without informing individuals
or when data is sold to third parties without consent.

●​ Data Minimization:
○​ Collect only the data that is necessary for the stated purpose, and avoid collecting
excessive or irrelevant information.
○​ Ethical data collection practices prioritize the principle of data minimization to reduce the
potential for misuse.

●​ Transparency:
○​ Organizations must be transparent about their data collection practices, including how
data is gathered, stored, and used.
○​ Transparency ensures accountability and helps individuals make informed decisions
about sharing their data.

●​ Accountability:
○​ Organizations must be accountable for how they collect, store, and use data, ensuring
compliance with legal and ethical standards.
○​ They should be prepared to explain and justify their data practices to regulators and the
public.

Summary:
In this lesson, the focus was on the ethical issues surrounding data collection. It discussed the
importance of respecting privacy, obtaining informed consent, ensuring data security, and avoiding
bias in the collection process. Ethical considerations also include transparency about how data is
used, ownership of data, and ensuring that data is only used for the intended purpose. The lesson
emphasized the need for organizations to follow ethical practices and legal standards to protect
individuals and prevent misuse of personal data.

Reflection:
The lesson on ethical issues in data collection made me realize how complex and important it is to
handle data responsibly. I now understand the critical importance of privacy, consent, and
transparency in the process of collecting and using data. It's clear that when data is mishandled or
used unethically, it can have far-reaching consequences for individuals and society. I feel more
informed about the ethical considerations organizations should account for, and I am now more aware
of the regulations and standards that guide data collection. This knowledge will help me make
responsible decisions when dealing with data in future projects or work.

--------------------------------------------------------------------------------------------------------------------------------------------------
COMPLETION STATUS ON AP CLASSROOM: