Лаб. 4 Java

ProductList

package lab_3;

import java.lang.reflect.Field;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Random;

public class ProductList {

private ArrayList<Product> arrayList;

private LinkedList<Product> linkedList;

private LogProcessor logProcessor;

private long[] timeInformation;

//private ArrayList<Long> changeTime;

private static final int[] COLLECTION_SIZES = {10, 100, 1000, 10000, 100000};

private static final double REMOVAL_PERCENTAGE = 0.1;

private static final String LOG_FILE_PREFIX = "log_";

private static final String LOG_FILE_EXTENSION = ".txt";

public ProductList() {

arrayList = new ArrayList<>();

linkedList = new LinkedList<>();

logProcessor = new LogProcessor();

timeInformation = new long[4];

//changeTime = new ArrayList<>();

}

public long[] generateCollection(String collectionType, List<Product> collection, int size) {

String logFileName = LOG_FILE_PREFIX + collectionType + "_" + size + LOG_FILE_EXTENSION;

Random random = new Random();

logProcessor.writeHeadLog(logFileName, getCurrentDateTime(), collectionType);

//System.out.println("Размер:" + size);

long startTime;

//System.out.println("Размер коллекции:" + size);

//System.out.println("Коллекция:" + collection);

int capacity = 10;

long sumAddTotalTime = 0;

long currentTime = 0;

long oldTime = 0;

for (int i = 0; i < size; i++) {

// capacity = ((ArrayList<Product>) collection).trimToSize() + 1;

//((ArrayList<Product>) collection).trimToSize();

//System.out.println("Размер коллекции:" + collection.size());

//int capacity = collection.size() + 1;

//Product product = collection.get(i);

String randomType = generateRandomString();

Product product = new Product(randomType);

startTime = System.nanoTime();

collection.add(product);

currentTime = getCurrentTimeDifference(startTime);

logProcessor.writeAdd(logFileName, currentTime, i);

//writer.println("add, ID = " + (i + 1) + ", " + currentTime);

//product.load();

sumAddTotalTime += currentTime;

if ((i == 10 || i == 0) && collectionType.equals("ArrayList")) {

//changeTime.add(sumAddTotalTime/i);

System.out.println("Время добавления при размере ArrayList " + (i+1) + ": "+ currentTime );

//oldTime = sumAddTotalTime;

capacity = (int) ((capacity * 3)/2 + 1);

}

if (((i+1) == capacity && (i+1) != 10) && collectionType.equals("ArrayList")) {

//changeTime.add(sumAddTotalTime/i);

System.out.println("Время добавления при размере ArrayList " + (i+1) + ": "+ currentTime );

oldTime = sumAddTotalTime;

capacity = (int) ((capacity * 3)/2 + 1);

}

}

//System.out.println("Коллекция: " + collection);

long addTotalCount = size;

long addTotalTime = sumAddTotalTime;

long addMedianTime = sumAddTotalTime / size;

logProcessor.writeAddInformation(logFileName, addTotalCount, addTotalTime, addMedianTime);

int removalCount = (int) (size * REMOVAL_PERCENTAGE);

//System.out.println("Количество удалений:" + removalCount);

//Iterator<Product> iterator = collection.iterator();

//startTime = System.nanoTime();

currentTime = 0;

long sumRemoveTotalTime = 0;

for (int i = 0; i < removalCount; i++) {

int randomIndex = new Random().nextInt(collection.size());

startTime = System.nanoTime();

collection.remove(randomIndex);

//Product product = collection.get(randomIndex);

currentTime = getCurrentTimeDifference(startTime);

logProcessor.writeRemove(logFileName, currentTime, randomIndex);

//writer.println("remove, ID = " + (randomIndex + 1) + ", " + currentTime);

//product.load();

sumRemoveTotalTime += currentTime;

}

long removeTotalCount = removalCount;

long removeTotalTime = sumRemoveTotalTime;

long removeMedianTime = sumRemoveTotalTime / removalCount;

logProcessor.writeRemoveInformation(logFileName, removeTotalCount, removeTotalTime, removeMedianTime);

logProcessor.writeEndLog(logFileName, getCurrentDateTime());

//System.out.println("Файл: " + logFileName + " создан и заполнен успешно.");

//System.out.println("Коллекция c удалением: " + collection);

timeInformation[0] = addTotalTime;

timeInformation[1] = addMedianTime;

timeInformation[2] = removeTotalTime;

timeInformation[3] = removeMedianTime;

//System.out.println(timeInformation[0]);

return timeInformation;

}

public String generateRandomString() {

String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

Random random = new Random();

StringBuilder sb = new StringBuilder();

for (int i = 0; i < 6; i++) {

int index = random.nextInt(characters.length());

char randomChar = characters.charAt(index);

sb.append(randomChar);

}

return sb.toString();

}

public void generateCollections() {

for (int size : COLLECTION_SIZES) {

arrayList = new ArrayList<>();

linkedList = new LinkedList<>();

long[] aList = generateCollection("ArrayList", arrayList, size);

long[] arrList = new long[4];

System.arraycopy(aList, 0, arrList, 0, aList.length);

//System.out.println(arrList);

long[] linkList = generateCollection("LinkedList", linkedList, size);

//System.out.println(arrList[0]);

//System.out.println(linkList[0]);

//logProcessor.writeLog("ArrayList", arrayList, size);

//logProcessor.writeLog("LinkedList", linkedList, size);

if (arrList[0] > linkList[0]) {

System.out.println("Общее время выполнения добавления меньше у LinkedList.");

}

if (arrList[0] < linkList[0]) {

System.out.println("Общее время выполнения добавления меньше у ArrayList.");

}

if (arrList[0] == linkList[0]) {

System.out.println("Общее время выполнения добавления одинаково.");

}

if (arrList[1] > linkList[1]) {

System.out.println("Среднее время выполнения добавления меньше у LinkedList.");

}

if (arrList[1] < linkList[1]) {

System.out.println("Среднее время выполнения добавления меньше у ArrayList.");

}

if (arrList[1] == linkList[1]) {

System.out.println("Среднее время выполнения добавления одинаково.");

}

if (arrList[2] > linkList[2]) {

System.out.println("Общее время выполнения удаления меньше у LinkedList.");

}

if (arrList[2] < linkList[2]) {

System.out.println("Общее время выполнения удаления меньше у ArrayList.");

}

if (arrList[2] == linkList[2]) {

System.out.println("Общее время выполнения удаления одинаково.");

}

if (arrList[3] > linkList[3]) {

System.out.println("Среднее время выполнения удаления меньше у LinkedList.");

}

if (arrList[3] < linkList[3]) {

System.out.println("Среднее время выполнения удаления меньше у ArrayList.");

}

if (arrList[3] == linkList[3]) {

System.out.println("Среднее время выполнения удаления одинаково.");

}

System.out.println("Разница в нансекундах между общим и средним временем добавления в ArrayList: " + Math.abs(arrList[0] - arrList[1]));

System.out.println("Разница в нансекундах между общим и средним временем удаления в ArrayList: " + Math.abs(arrList[2] - arrList[3]));

System.out.println("Разница в нансекундах между общим и средним временем добавления в LinkedList: " + Math.abs(linkList[0] - linkList[1]));

System.out.println("Разница в нансекундах между общим и средним временем удаления в LinkedList: " + Math.abs(linkList[2] - linkList[3]));

System.out.println("\n");

arrayList.clear();

linkedList.clear();

}

}

private String getCurrentDateTime() {

LocalDateTime currentDateTime = LocalDateTime.now();

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm:ss");

return currentDateTime.format(formatter);

}

private long getCurrentTimeDifference(long startTime) {

return System.nanoTime() - startTime;

}

/*

static int getCapacity(ArrayList<?> list) {

Field dataField = ArrayList.class.getDeclaredField("elemData");

dataField.setAccessible(true);

return ((Object[]) dataField.get(list)).length;

}

*/

/*

public void trimToSize(ArrayList<Product> list) {

super.trimToSize();

}

*/

}

LogProcessor

package lab_3;

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileWriter;

import java.io.PrintWriter;

import java.sql.Date;

import java.text.DecimalFormat;

import java.text.SimpleDateFormat;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.List;

import java.util.Random;

public class LogProcessor{

private static final String LOG_FILE_PREFIX = "log_";

private static final String LOG_FILE_EXTENSION = ".txt";

//private ErrorProcessor errorCount;

private int errorCount;

//private PrintWriter writer;

//private ProductList productList;

public LogProcessor() {

errorCount = 0;

}

public void writeHeadLog(String logFileName, String currentTime, String collectionType) {

try (BufferedWriter writer = new BufferedWriter(new FileWriter(logFileName))) {

writer.write("Start program: " + currentTime);

writer.newLine();

writer.write(collectionType);

writer.newLine();

} catch (FileNotFoundException e) {

handleError("Ошибка при записи в файл: " + logFileName);

//errorCount.processError("Ошибка при записи в файл: " + logFileName);

}catch (Exception e) {

handleError("Ошибка в методе writeHeadLog");

//errorCount.processError("Ошибка в методе writeHeadLog");

}

}

public void writeAdd(String logFileName, long currentTime, int i) {

try (BufferedWriter writer = new BufferedWriter(new FileWriter(logFileName, true))) {

writer.write("add, ID = " + (i + 1) + ", " + currentTime);

writer.newLine();

} catch (FileNotFoundException e) {

handleError("Ошибка при записи в файл: " + logFileName);

//errorCount.processError("Ошибка при записи в файл: " + logFileName);

}catch (Exception e) {

handleError("Ошибка в методе writeAdd");

//errorCount.processError("Ошибка в методе writeAdd");

}

}

public void writeAddInformation(String logFileName, long addTotalCount, long addTotalTime, long addMedianTime) {

try (BufferedWriter writer = new BufferedWriter(new FileWriter(logFileName, true))) {

writer.write("addTotalCount = " + addTotalCount);

writer.newLine();

writer.write("addTotalTime = " + addTotalTime);

writer.newLine();

writer.write("addMedianTime = " + addMedianTime);

writer.newLine();

} catch (FileNotFoundException e) {

handleError("Ошибка при записи в файл: " + logFileName);

//errorCount.processError("Ошибка при записи в файл: " + logFileName);

}catch (Exception e) {

handleError("Ошибка в методе writeAddInformation");

//errorCount.processError("Ошибка в методе writeAddInformation");

}

}

public void writeRemove(String logFileName, long currentTime, int i) {

try (BufferedWriter writer = new BufferedWriter(new FileWriter(logFileName, true))) {

writer.write("remove, ID = " + (i + 1) + ", " + currentTime);

writer.newLine();

} catch (FileNotFoundException e) {

handleError("Ошибка при записи в файл: " + logFileName);

//errorCount.processError("Ошибка при записи в файл: " + logFileName);

}catch (Exception e) {

handleError("Ошибка в методе writeRemove");

//errorCount.processError("Ошибка в методе writeRemove");

}

}

public void writeRemoveInformation(String logFileName, long removeTotalCount, long removeTotalTime, long removeMedianTime) {

try (BufferedWriter writer = new BufferedWriter(new FileWriter(logFileName, true))) {

writer.write("removeTotalCount = " + removeTotalCount);

writer.newLine();

writer.write("removeTotalTime = " + removeTotalTime);

writer.newLine();

writer.write("removeMedianTime = " + removeMedianTime);

writer.newLine();

} catch (FileNotFoundException e) {

handleError("Ошибка при записи в файл: " + logFileName);

//errorCount.processError("Ошибка при записи в файл: " + logFileName);

}catch (Exception e) {

handleError("Ошибка в методе writeRemoveInformation");

//errorCount.processError("Ошибка в методе writeRemoveInformation");

}

}

public void writeEndLog(String logFileName, String currentTime) {

try (BufferedWriter writer = new BufferedWriter(new FileWriter(logFileName, true))) {

writer.write("Finish program: " + currentTime);

writer.newLine();

System.out.println("Файл: " + logFileName + " создан и заполнен успешно.");

} catch (FileNotFoundException e) {

handleError("Ошибка при записи в файл: " + logFileName);

//errorCount.processError("Ошибка при записи в файл: " + logFileName);

}catch (Exception e) {

handleError("Ошибка в методе writeEndLog");

//errorCount.processError("Ошибка в методе writeEndLog");

}

}

private void handleError(String errorMessage) {

System.err.println(errorMessage);

errorCount++;

}

public int getErrorCount() {

return errorCount;

}

public String generateRandomString() {

String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

Random random = new Random();

StringBuilder sb = new StringBuilder();

for (int i = 0; i < 6; i++) {

int index = random.nextInt(characters.length());

char randomChar = characters.charAt(index);

sb.append(randomChar);

}

return sb.toString();

}

}

ErrorProcessor

package lab_3;

public class ErrorProcessor {

private int errorCount;

public ErrorProcessor() {

errorCount = 0;

}

public void processError(String errorMessage) {

System.err.println(errorMessage);

errorCount++;

}

public int getErrorCount() {

return errorCount;

}

public void setErrorCount(int c) {

errorCount = c;

}

}

Main

ProductList generator = new ProductList();

generator.generateCollections();

LogProcessor logProcessor = new LogProcessor();

//ErrorProcessor errorProcessor = new ErrorProcessor();

int errorCount = logProcessor.getErrorCount();

if (errorCount > 0) {

System.out.println("Количество ошибок: " + errorCount);

} else {

System.out.println("Всё успешно выполнено.");

}