From 2010b21922dfe99987a93c9e04cfb6562f2fc654 Mon Sep 17 00:00:00 2001 From: RiRa25 <126353589+RiRa25@users.noreply.github.com> Date: Tue, 30 Apr 2024 19:56:39 +0530 Subject: [PATCH 1/2] Final Commit --- DataFrame/.classpath | 10 + DataFrame/.project | 17 + .../org.eclipse.core.resources.prefs | 2 + .../.settings/org.eclipse.jdt.core.prefs | 14 + DataFrame/bin/Pandas/DataFrame.class | Bin 0 -> 15076 bytes DataFrame/bin/Pandas/package-info.class | Bin 0 -> 112 bytes .../PandasImplementation/implementation.class | Bin 0 -> 6471 bytes .../PandasImplementation/package-info.class | Bin 0 -> 126 bytes DataFrame/bin/module-info.class | Bin 0 -> 148 bytes DataFrame/src/Pandas/DataFrame.java | 389 ++++++++++++++++++ DataFrame/src/Pandas/package-info.java | 1 + .../PandasImplementation/implementation.java | 205 +++++++++ .../PandasImplementation/package-info.java | 1 + DataFrame/src/module-info.java | 9 + 14 files changed, 648 insertions(+) create mode 100644 DataFrame/.classpath create mode 100644 DataFrame/.project create mode 100644 DataFrame/.settings/org.eclipse.core.resources.prefs create mode 100644 DataFrame/.settings/org.eclipse.jdt.core.prefs create mode 100644 DataFrame/bin/Pandas/DataFrame.class create mode 100644 DataFrame/bin/Pandas/package-info.class create mode 100644 DataFrame/bin/PandasImplementation/implementation.class create mode 100644 DataFrame/bin/PandasImplementation/package-info.class create mode 100644 DataFrame/bin/module-info.class create mode 100644 DataFrame/src/Pandas/DataFrame.java create mode 100644 DataFrame/src/Pandas/package-info.java create mode 100644 DataFrame/src/PandasImplementation/implementation.java create mode 100644 DataFrame/src/PandasImplementation/package-info.java create mode 100644 DataFrame/src/module-info.java diff --git a/DataFrame/.classpath b/DataFrame/.classpath new file mode 100644 index 0000000..57bca72 --- /dev/null +++ b/DataFrame/.classpath @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/DataFrame/.project b/DataFrame/.project new file mode 100644 index 0000000..fbdc09f --- /dev/null +++ b/DataFrame/.project @@ -0,0 +1,17 @@ + + + DataFrame + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/DataFrame/.settings/org.eclipse.core.resources.prefs b/DataFrame/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..99f26c0 --- /dev/null +++ b/DataFrame/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/DataFrame/.settings/org.eclipse.jdt.core.prefs b/DataFrame/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..8c9943d --- /dev/null +++ b/DataFrame/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,14 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=17 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=17 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=17 diff --git a/DataFrame/bin/Pandas/DataFrame.class b/DataFrame/bin/Pandas/DataFrame.class new file mode 100644 index 0000000000000000000000000000000000000000..5277a21cf0ec3a2dc4964e60789a4d6e713f0ce6 GIT binary patch literal 15076 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 literal 0 HcmV?d00001 diff --git a/DataFrame/bin/Pandas/package-info.class b/DataFrame/bin/Pandas/package-info.class new file mode 100644 index 0000000000000000000000000000000000000000..a3d20df2d70769f1e275c17eb06fed5e63276282 GIT binary patch literal 112 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 Za#zG0A}iu(F_&X81aAvAi+P1b{{@IIhaLa` literal 0 HcmV?d00001 diff --git a/DataFrame/bin/PandasImplementation/package-info.class b/DataFrame/bin/PandasImplementation/package-info.class new file mode 100644 index 0000000000000000000000000000000000000000..7f3242c6ea6cbfcbd04905833879c9b3e4c04c38 GIT binary patch literal 126 zcmX^0Z`VEs1_oOOc6J6PMh3-z#JrTmV$a-yoYdUZypqI{%=|q4g2d$P#Pn3%%)GRG zb_Nzk27#=^vPAuy#JqHU|D>$c&UdLYGO3=E76%s`t! NfRTX}NHQ_70RWgnAz=Uj literal 0 HcmV?d00001 diff --git a/DataFrame/bin/module-info.class b/DataFrame/bin/module-info.class new file mode 100644 index 0000000000000000000000000000000000000000..2509486617d96e224f3de1d39e1c9ab7fa02c9ba GIT binary patch literal 148 zcmX^0Z`VEs1_oOOE_MbcMh5QO{FKt1RNc(Hw0uSeuHgLAqU2P!%$!t41_2}~y{yEt zL`DWSU$AOn26jdUPM5@zM7N^E+*Dx(P9PVgLN6(?IJJR+fe~l}1TZl$0~t&VEDWqb RT8x1WEX>Hj(Ew&Z2mlUU9Q6PI literal 0 HcmV?d00001 diff --git a/DataFrame/src/Pandas/DataFrame.java b/DataFrame/src/Pandas/DataFrame.java new file mode 100644 index 0000000..3595799 --- /dev/null +++ b/DataFrame/src/Pandas/DataFrame.java @@ -0,0 +1,389 @@ +package Pandas; +import java.util.*; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.io.FileWriter; + +public class DataFrame { + + public List> data; + public Set columns; + + public DataFrame() { + this.data = new ArrayList<>(); + this.columns = new HashSet<>(); + } + + public void addColumn(String columnName, Object defaultValue) { + columns.add(columnName); + for (Map row : data) { + row.put(columnName, defaultValue); + } + } + + public void replace(String columnName, Object oldValue, Object newValue) { + for (Map row : data) { + if (row.containsKey(columnName) && Objects.equals(row.get(columnName), oldValue)) { + row.put(columnName, newValue); + } + } + } + + public List columns() { + List columnList = new ArrayList<>(columns); + Collections.sort(columnList); + return columnList; + } + + + public void addRow(Map row) { + for (String column : columns) { + row.putIfAbsent(column, null); + } + data.add(row); + } + + public int[] getShape() { + int numRows = data.size(); + int numColumns = columns.size(); + return new int[]{numRows, numColumns}; + } + + public void deleteColumn(String colName) { + if (columns.contains(colName)) { + columns.remove(colName); + for (Map entity : data) { + entity.remove(colName); + } + } else { + System.out.println("Column " + colName + " does not exist."); + } + } + + public void deleteRow(int index) { + if (index >= 0 && index < data.size()) { + data.remove(index); + } else { + throw new IndexOutOfBoundsException("Index " + index + " is out of range."); + } + } + // Retrieve a specific column + public List getColumn(String columnName) { + if (!columns.contains(columnName)) { + throw new IllegalArgumentException("Column does not exist"); + } + + List columnData = new ArrayList<>(); + for (Map row : data) { + columnData.add(row.get(columnName)); + } + return columnData; + } + + public void renameColumn(String oldName, String newName) { + if (!columns.contains(oldName)) { + throw new IllegalArgumentException("Column '" + oldName + "' does not exist."); + } + if (columns.contains(newName)) { + throw new IllegalArgumentException("Column '" + newName + "' already exists."); + } + + + columns.remove(oldName); + columns.add(newName); + + + for (Map row : data) { + if (row.containsKey(oldName)) { + row.put(newName, row.remove(oldName)); + } + } + } + + public Map getRow(int index) { + if (index < 0 || index >= data.size()) { + throw new IndexOutOfBoundsException("Row index out of bounds"); + } + + return data.get(index); + } + + + public DataFrame filter(String columnName, Object value) { + DataFrame filtered = new DataFrame(); + filtered.addColumn(columnName, null); + + for (Map row : data) { + if (Objects.equals(row.get(columnName), value)) { + filtered.addRow(new HashMap<>(row)); + } + } + + return filtered; + } + + public void read_csv(String filePath) throws IOException { + try (BufferedReader br = new BufferedReader(new FileReader(filePath))) { + + String headerLine = br.readLine(); + if (headerLine == null) { + throw new IllegalStateException("CSV file is empty"); + } + + + String[] headers = headerLine.split(","); + for (String columnName : headers) { + addColumn(columnName.trim(), null); + } + + + String line; + while ((line = br.readLine()) != null) + { + String[] rowValues = line.split(","); + + if (rowValues.length != headers.length) { + throw new IllegalArgumentException("Row length does not match header length"); + } + + + Map row = new HashMap<>(); + for (int i = 0; i < headers.length; i++) { + row.put(headers[i].trim(), rowValues[i].trim()); + } + + addRow(row); + } + } + } + + public List> head(int num) { + if(num > 0) + { + int numRows = Math.min(data.size(), num); + return data.subList(0, numRows); + } + else + { + return tail((-1)*num); + } + } + + public List> head() { + + int numRows = Math.min(data.size(), 5); + return data.subList(0, numRows); + + } + + public List> tail(int num) { + int totalRows = data.size(); + int start = Math.max(0, totalRows - num); + return data.subList(start, totalRows); + } + + public List> tail(){ + int totalRows = data.size(); + int start = Math.max(0, totalRows - 5); + return data.subList(start, totalRows); + } + + + public void displayDataTabular(List> rows) { + if (rows.isEmpty()) { + System.out.println("No data available"); + return; + } + + + List columnList = new ArrayList<>(columns); + + + Map columnWidths = new HashMap<>(); + for (String column : columnList) { + int maxLength = column.length(); + for (Map row : rows) { + Object value = row.get(column); + int valueLength = (value == null) ? 4 : value.toString().length(); + if (valueLength > maxLength) { + maxLength = valueLength; + } + } + columnWidths.put(column, maxLength); + } + + + StringBuilder formatBuilder = new StringBuilder(); + for (String column : columnList) { + formatBuilder.append("%-").append(columnWidths.get(column)).append("s | "); + } + String formatString = formatBuilder.toString(); + + + System.out.println(); + System.out.format(formatString, columnList.toArray()); + + + StringBuilder separator = new StringBuilder(); + for (String column : columnList) { + int width = columnWidths.get(column) + 3; + separator.append("-".repeat(width)); + } + System.out.println(); + System.out.println(separator); + + + for (Map row : rows) { + List rowData = new ArrayList<>(); + for (String column : columnList) { + Object value = row.get(column); + rowData.add(value == null ? "null" : value.toString()); + } + System.out.format(formatString, rowData.toArray()); + } + System.out.println(); + } + + public void info() { + if (data == null || data.isEmpty()) { + System.out.println("No data available"); + return; + } + + int totalRows = data.size(); + System.out.println("Total rows: " + totalRows); + + + Set uniqueColumns = new HashSet<>(); + for (Map row : data) { + uniqueColumns.addAll(row.keySet()); + } + List columnNames = new ArrayList<>(uniqueColumns); + + System.out.println("Column Information:"); + Map nonNullCounts = new HashMap<>(); + Map> columnTypes = new HashMap<>(); + + + for (String column : columnNames) { + int nonNullCount = 0; + Class columnType = null; + + for (Map row : data) { + Object value = row.get(column); + if (value != null) { + nonNullCount++; + if (columnType == null) { + columnType = value.getClass(); + } else if (!columnType.equals(value.getClass())) { + columnType = Object.class; + } + } + } + + nonNullCounts.put(column, nonNullCount); + columnTypes.put(column, columnType); + } + + for (String column : columnNames) { + int nonNullCount = nonNullCounts.get(column); + Class columnType = columnTypes.get(column); + System.out.printf(" - %s: %d non-null, type: %s%n", column, nonNullCount, + (columnType == null) ? "Unknown" : columnType.getSimpleName()); + } + + + long estimatedMemoryUsage = totalRows * columnNames.size() * 8; + System.out.println("Estimated memory usage: " + estimatedMemoryUsage + " bytes"); + } + + + public void toCSV(String fileName) throws IOException { + String str = fileName + ".csv"; + File myFile = new File(str); + try { + myFile.createNewFile(); + System.out.println("File created at: " + myFile.getAbsolutePath()); + } catch (IOException e) { + + e.printStackTrace(); + } + try (FileWriter writer = new FileWriter(str)) { + + List columnNames = new ArrayList<>(columns); + Collections.sort(columnNames); + writer.write(String.join(",", columnNames) + "\n"); + + + for (Map row : data) { + List values = new ArrayList<>(); + for (String column : columnNames) { + Object value = row.get(column); + if (value == null) { + values.add(""); + } else { + String strValue = value.toString(); + + if (strValue.contains(",") || strValue.contains("\"")) { + strValue = "\"" + strValue.replace("\"", "\"\"") + "\""; + } + values.add(strValue); + } + } + writer.write(String.join(",", values) + "\n"); + } + } + } + + public void sort_values(String columnName, boolean ascending) { + if (!columns.contains(columnName)) { + throw new IllegalArgumentException("Column " + columnName + " not found"); + } + + Comparator> comparator = (row1, row2) -> { + Object value1 = row1.get(columnName); + Object value2 = row2.get(columnName); + + + if (value1 == null && value2 == null) { + return 0; + } + if (value1 == null) { + return ascending ? -1 : 1; + } + if (value2 == null) { + return ascending ? 1 : -1; + } + + if (value1 instanceof Comparable && value2 instanceof Comparable) { + return ((Comparable) value1).compareTo(value2) * (ascending ? 1 : -1); + } + + throw new IllegalArgumentException("Values in column " + columnName + " are not comparable"); + }; + + data.sort(comparator); + } + + public void deleteRows(int startIndex, int endIndex) { + if (startIndex < 0 || endIndex >= data.size() || startIndex > endIndex) { + throw new IllegalArgumentException("Invalid index range for deletion"); + } + + + data.subList(startIndex, endIndex + 1).clear(); + } + + + public List> getData() { + return data; + } + + public Set getColumns() { + return columns; + } + + +} diff --git a/DataFrame/src/Pandas/package-info.java b/DataFrame/src/Pandas/package-info.java new file mode 100644 index 0000000..73ed990 --- /dev/null +++ b/DataFrame/src/Pandas/package-info.java @@ -0,0 +1 @@ +package Pandas; \ No newline at end of file diff --git a/DataFrame/src/PandasImplementation/implementation.java b/DataFrame/src/PandasImplementation/implementation.java new file mode 100644 index 0000000..7dadec5 --- /dev/null +++ b/DataFrame/src/PandasImplementation/implementation.java @@ -0,0 +1,205 @@ +package PandasImplementation; + +import java.io.IOException; + +import Pandas.DataFrame; +import Pandas.DataFrame.*; +import java.util.*; +public class implementation { + + public static void main(String[] args) throws IOException { + + Scanner sc = new Scanner(System.in); + + DataFrame df = new DataFrame(); + //df.read_csv("C:\\Users\\richa\\Downloads\\outputfinal.csv"); + + System.out.println("Enter the path of the csv file : "); + String path = sc.next(); + df.read_csv(path); + + int a = 1; + + while(a==1) + { + + System.out.println(); + System.out.println("---------- MENU ----------"); + System.out.println("1. Sort by Column values"); + System.out.println("2. Delete Column"); + System.out.println("3. Delete Row"); + System.out.println("4. Delete Rows in range"); + System.out.println("5. Get Column"); + System.out.println("6. Get Row"); + System.out.println("7. Rename Column"); + System.out.println("8. Get Shape"); + System.out.println("9. Get Info"); + System.out.println("10. Replace Columns value"); + System.out.println("11. Get all Column Names"); + System.out.println("12. Get Default Head"); + System.out.println("13. Get Custom Head"); + System.out.println("14. Get Default Tail"); + System.out.println("15. Get Custom Tail"); + System.out.println("16. Generate CSV"); + System.out.println("17. Exit"); + System.out.println(); + + System.out.println("Enter your choice : "); + int choice = sc.nextInt(); + + switch(choice) + { + + case 1: + System.out.println(); + System.out.println("----- Sort by Column values -----"); + System.out.println("Enter the column name you want to sort : "); + df.sort_values(sc.next(), false); + break; + + case 2: + System.out.println(); + System.out.println("----- Delete Column -----"); + System.out.println("Enter the column name you want to delete : "); + df.deleteColumn(sc.next()); + break; + + case 3: + System.out.println(); + System.out.println("----- Delete Row -----"); + System.out.println("Enter the sample index you want to delete : "); + df.deleteRow(sc.nextInt()); + break; + + case 4: + System.out.println(); + System.out.println("----- Delete Rows in Range -----"); + System.out.println("Enter start index : "); + int start = sc.nextInt(); + System.out.println("Enter end index : "); + int end = sc.nextInt(); + df.deleteRows(start, end); + break; + + case 5: + System.out.println(); + System.out.println("----- Get Column -----"); + System.out.println("Enter the Column name you want to view:"); + List column = df.getColumn(sc.next()); + Iterator it = column.iterator(); + + while (it.hasNext()) + { + System.out.println(it.next()); + } + break; + + case 6: + System.out.println(); + System.out.println("----- Get Row -----"); + System.out.println("Enter the row index you want to view:"); + Map row = df.getRow(sc.nextInt()); + for (Map.Entry set : row.entrySet()) { + + System.out.println(set.getKey() + " : "+ set.getValue()); + } + break; + + case 7: + System.out.println(); + System.out.println("----- Rename Column -----"); + System.out.println("Enter the initial column name : "); + String ini = sc.next(); + String commit = sc.next(); + df.renameColumn(ini, commit); + break; + + case 8: + System.out.println(); + System.out.println("----- Get Shape -----"); + int arr[] = df.getShape(); + System.out.println("Number of Rows:" + arr[0]); + System.out.println("Number of Columns:" + arr[1]); + break; + + case 9: + System.out.println(); + System.out.println("----- Get Info -----"); + df.info(); + break; + + case 10: + System.out.println(); + System.out.println("----- Replace Columns value -----"); + System.out.println("Enter Column Name : "); + String colname = sc.next(); + System.out.println("Enter the String you want to replace : "); + Object replace = sc.next(); + System.out.println("Enter the value you want to replace with"); + Object with = sc.next(); + + df.replace(colname, replace, with); + break; + + case 11: + System.out.println(); + System.out.println("----- Get all Column Names -----"); + System.out.println("Get Column Names"); + Set colname1 = df.getColumns(); + Iterator namesIterator = colname1.iterator(); + while(namesIterator.hasNext()) { + System.out.println(namesIterator.next()); + } + break; + + case 12: + System.out.println(); + System.out.println("----- Get Default Head -----"); + df.displayDataTabular(df.head()); + System.out.println(); + break; + + case 13: + System.out.println(); + System.out.println("----- Get Custom Head -----"); + System.out.println("Enter Number of Samples: "); + df.displayDataTabular(df.head(sc.nextInt())); + System.out.println(); + break; + + case 14: + System.out.println(); + System.out.println("----- Get Default Tail -----"); + df.displayDataTabular(df.tail()); + System.out.println(); + break; + + case 15: + System.out.println(); + System.out.println("----- Get Custom Head -----"); + System.out.println("Enter Number of Samples: "); + df.displayDataTabular(df.tail(sc.nextInt())); + System.out.println(); + break; + + case 16: + System.out.println(); + System.out.println("----- Generate CSV -----"); + System.out.println("Enter the file name: "); + df.toCSV(sc.next()); + break; + + case 17: + System.out.println(); + System.out.println("----- Exit -----"); + System.out.println("Thank You"); + a = 0; + break; + + } + } + + + } + +} diff --git a/DataFrame/src/PandasImplementation/package-info.java b/DataFrame/src/PandasImplementation/package-info.java new file mode 100644 index 0000000..1b02e18 --- /dev/null +++ b/DataFrame/src/PandasImplementation/package-info.java @@ -0,0 +1 @@ +package PandasImplementation; \ No newline at end of file diff --git a/DataFrame/src/module-info.java b/DataFrame/src/module-info.java new file mode 100644 index 0000000..d549775 --- /dev/null +++ b/DataFrame/src/module-info.java @@ -0,0 +1,9 @@ +/** + * + */ +/** + * @author richa + * + */ +module DataFrame { +} \ No newline at end of file From 5ca747678bc4e2b3d3b7b6bf8a5e887a8d9facec Mon Sep 17 00:00:00 2001 From: Richa <126353589+RiRa25@users.noreply.github.com> Date: Tue, 30 Apr 2024 19:58:20 +0530 Subject: [PATCH 2/2] Update README.md --- README.md | 47 ++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 40 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 910ff0f..96e244a 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,42 @@ -# Buffer-5.0 -Buffer is a Data Structures and Algorithms Project Series, in which students can participate as mentees in teams of 2-4. Under Buffer 5.0, the themes on which students can create a project are: +# RiRa25-TechTribe-24-PandasLibraryinJava -1. Public Welfare -2. Tourism -3. College level applications -4. Custom Data structure +Domain: Custom Data Structures + +# "Developing a Pandas Library in Java for Data Manipulation and Analysis" + +There are two Java Files: + +Path of Implemented Java file on GitHub : DataFrame -> src -> Pandas -> DataFrame.java + +Path of Main Java file on GitHub : DataFrame -> src -> PandasImplementation -> implementation.java + +15 days Report Part 1: https://drive.google.com/file/d/1R18rocuTFUHpl4HoBmyhC43PM5xzve0i/view?usp=sharing + +15 days Report Part 2: https://drive.google.com/file/d/1r1XOYNLR-jNCFrGRiiXkLr8ie9ou0C76/view?usp=sharing + +Project Report: https://drive.google.com/file/d/1gQ5SXzsoPDYgvIvs_0UGrSu2wuYWXHU0/view?usp=sharing + +Video Link: https://drive.google.com/file/d/14mhADGuM3zFoIYLIVzyW4ji9yQbVPAPh/view?usp=sharing + +Drive Link: https://drive.google.com/drive/folders/1Ix1RRPqXSxsXQb-TE0vpQPoTAEkEM_DV?usp=sharing + +# Description: + +This project aims to create a DataFrame library in Java, offering functionalities similar to Python's Pandas library. The Java DataFrame will allow users to perform key data manipulation tasks such as sorting, filtering, adding/removing columns and rows, reading and generating CSV files, and more. + +Python's Pandas DataFrame is a widely used data structure that allows users to work with two-dimensional data, similar to SQL tables or Excel spreadsheets. The DataFrame's flexibility and ease of use have made it a preferred choice for data science and analysis. + +By developing a DataFrame library for Java, this project will provide Java developers with a powerful tool for data manipulation and analysis. This will enable Java developers to conduct data science tasks without needing to switch to other programming languages. + +# Data Structures used: + +1. List of Maps (`List>`): The primary data structure for storing rows of the DataFrame. Each map represents a single row, with keys as column names and values as data. + +2. Set of Strings (`Set`): A set is used to maintain a unique collection of column names. This set helps ensure that column names are unique and provides a way to track which columns are part of the Pandas. + +3. ArrayList (`ArrayList`): Used in various operations, such as maintaining a list of column names in a specific order or returning a subset of rows. The `ArrayList` is preferred for its dynamic size and random-access performance. + +4. HashSet (`HashSet`): Used to store column names for fast membership checks. The `HashSet` provides quick lookup for column names, helping ensure uniqueness. + +5. HashMap (`HashMap`): The `HashMap` is used to represent individual rows within the DataFrame. It allows efficient key-based retrieval of column values and supports dynamic insertion and removal of key-value pairs. -This repository is created for all the teams to be able to upload their final project source code. While submitting, note that all the submission guidelines given are followed, and all the files are named appropiately. Also ensure that your README file contains the links of the progress reports and the drive link containing the video of the project.