Sets usage optimization in comparison of two excel files

[Ramaram Shankar]

Below is a simple method which compares contents of two excel files ignoring the line order. Also needs to print the mismatched lines in a logger.
This method is working as expected.
But, one of my peers in their code review mentioned that initializing and using 4 sets for this might not be the best way performance/memory-consumption wise and that the code can be optimized by using lesser number of sets.
I can't figure out how to reduce the number of sets though, to achieve the same functionality.

Any clue/suggestions? Thank you.

Code:

/** Compares contents of two excel files. Ignores line order of the contents.
     * @param logger            Logger instance
     * @param actualFilePath    Actual xlsx file
     * @param baselineFilePath   Baseline xlsx file
     * @return                  true if the files match, false otherwise
     * @throws Exception
     */
    public boolean compareTwoXlsxFilesIgnoreLineOrder(Logger logger, String actualFilePath, String baselineFilePath) throws Exception {
        File baselineFile = new File(baselineFilePath);
        File actualFile = new File(actualFilePath);
        FileInputStream baselineFileStream = null;
        FileInputStream actualFileStream = null;
        XSSFWorkbook baselineWorkbook = null;
        XSSFWorkbook actualWorkbook = null;
        XSSFExcelExtractor baselineExtractor = null;
        XSSFExcelExtractor actualExtractor = null;
        try {
            if (!baselineFile.exists()) {
                logger.severe("FAIL: Could not access the baseline file: " + baselineFile.getPath());
                return false;
            }
            logger.info("baseline file: " + baselineFilePath);
            if (!actualFile.exists()) {
                logger.severe("FAIL: Could not access the actual file: " + actualFile.getPath());
                return false;
            }
            logger.info("Actual file: " + actualFilePath);
            baselineFileStream = new FileInputStream(baselineFile);
            actualFileStream = new FileInputStream(actualFile);
            baselineWorkbook = new XSSFWorkbook(baselineFileStream);
            actualWorkbook = new XSSFWorkbook(actualFileStream);
            baselineExtractor = new XSSFExcelExtractor(baselineWorkbook);
            actualExtractor = new XSSFExcelExtractor(actualWorkbook);
            String baselineFileText = baselineExtractor.getText();
            String actualFileText = actualExtractor.getText();
            //Split by line break, trim whitespaces and remove empty lines.
            Set<String> baselineLinesSet = Arrays.stream(baselineFileText.split("\\r?\\n")).map(String::trim).filter(line -> !line.isEmpty()).collect(Collectors.toSet());
            Set<String> actualLinesSet = Arrays.stream(actualFileText.split("\\r?\\n")).map(String::trim).filter(line -> !line.isEmpty()).collect(Collectors.toSet());
            Set<String> actualMinusbaseline = new HashSet<>(actualLinesSet);
            actualMinusbaseline.removeAll(baselineLinesSet);
            logger.fine("Size of actualMinusbaseline: " + actualMinusbaseline.size());
            Set<String> baselineMinusActual = new HashSet<>(baselineLinesSet);
            baselineMinusActual.removeAll(actualLinesSet);
            logger.fine("Size of baselineMinusActual: " + baselineMinusActual.size());

            if (!actualMinusbaseline.isEmpty() || !baselineMinusActual.isEmpty()) {
                logger.info("FAIL: Lines present in actual file but not in baseline file: " + actualMinusbaseline);
                logger.info("FAIL: Lines present in baseline file but not in actual file: " + baselineMinusActual);
                logger.info("**************** Mismatch info End *******************");
                return false;
            } else {
                logger.info("VERIFIED: Actual file contents match with the baseline file contents.");
                return true;
            }
        } catch (IOException e) {
            logger.severe("Error while comparing files: " + e.getMessage());
            throw e;
        } finally {
            if (baselineExtractor != null) {
                baselineExtractor.close();
            }
            if (actualExtractor != null) {
                actualExtractor.close();
            }
            if (baselineWorkbook != null) {
                baselineWorkbook.close();
            }
            if (actualWorkbook != null) {
                actualWorkbook.close();
            }
            if (baselineFileStream != null) {
                baselineFileStream.close();
            }
            if (actualFileStream != null) {
                actualFileStream.close();
            }
        }
    }

[Carey Brown]

You can use the equals method to check if two sets are identical. The equals method compares the elements of the sets and returns true if they contain the same elements, regardless of the order.

If POI supports auto-close you could tidy things up greatly by using try-with-resources.

[Carey Brown]

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.poi.xssf.extractor.XSSFExcelExtractor;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class TryCompareTwo
{
	static final Logger logger = new Logger();
	
	public boolean compareTwoXlsxFilesIgnoreLineOrder( Logger logger,
			String actualFilePath, String baselineFilePath )
	throws Exception
	{
		File baselineFile = new File( baselineFilePath );
		File actualFile = new File( actualFilePath );
		
		if( !baselineFile.exists() )
		{
			logger.severe( "FAIL: Could not access the baseline file: "
					+ baselineFile.getPath() );
			return false;
		}
		logger.info( "baseline file: " + baselineFilePath );
		if( !actualFile.exists() )
		{
			logger.severe( "FAIL: Could not access the actual file: "
					+ actualFile.getPath() );
			return false;
		}
		
		logger.info( "Actual file: " + actualFilePath );

		try(
			FileInputStream baselineFileStream = new FileInputStream( baselineFile );
			FileInputStream actualFileStream = new FileInputStream( actualFile );
			XSSFWorkbook baselineWorkbook = new XSSFWorkbook( baselineFileStream );
			XSSFWorkbook actualWorkbook = new XSSFWorkbook( actualFileStream );
			XSSFExcelExtractor baselineExtractor = new XSSFExcelExtractor( baselineWorkbook );
			XSSFExcelExtractor actualExtractor = new XSSFExcelExtractor( actualWorkbook );
			)
		{
			String baselineFileText = baselineExtractor.getText();
			String actualFileText = actualExtractor.getText();
			
			// Split by line break, trim whitespaces and remove empty lines.
			Set<String> baselineLinesSet = Arrays
					.stream( baselineFileText.split( "\\r?\\n" ) )
					.map( String::trim ).filter( line -> !line.isEmpty() )
					.collect( Collectors.toSet() );
			Set<String> actualLinesSet = Arrays
					.stream( actualFileText.split( "\\r?\\n" ) )
					.map( String::trim ).filter( line -> !line.isEmpty() )
					.collect( Collectors.toSet() );

			if( ! baselineLinesSet.equals( actualLinesSet ) )
			{
				logger.info( "FAIL: file contents don't match."  );
				return false;
			}
			else
			{
				logger.info( "VERIFIED: file contents match." );
				return true;
			}
		}
		catch( IOException e )
		{
			logger.severe( "Error while comparing files: " + e.getMessage() );
			throw e;
		}
	}
	
	static class Logger
	{
		public void severe( String s ) { }
		public void info( String s ) { }
	}
}

[Ramaram Shankar]

Thank you Carey.

But, the suggested revised code doesn't print the non-matching lines, which is a requirement.

[Carey Brown]

Ah, you didn't mention that requirement.

[Ramaram Shankar]

Thanks for pointing it out. Updated original post.

[Ron McLeod]

If you can, try to reduce duplicated code by encapsulating it in a method - something like this:

private Set<String> extractTextFromFile(String filePathStr) {
    Path path = Paths.get(filePathStr);
    try (InputStream inputStream = Files.newInputStream(path);
            XSSFWorkbook workbook = new XSSFWorkbook(inputStream);
            XSSFExcelExtractor extractor = new XSSFExcelExtractor(workbook)) {
        String text = extractor.getText();
        return Pattern.compile("\\r?\\n")
                .splitAsStream(text)
                .map(String::trim)
                .filter(line -> !line.isEmpty())
                .collect(Collectors.toSet());
    }
}

public boolean compareTwoXlsxFilesIgnoreLineOrder(Logger logger, String actualFilePath, String baselineFilePath) throws Exception {
    try {
        Set<String> baselineLinesSet = extractTextFromFile(baselineFilePath);
        Set<String> actualLinesSet = extractTextFromFile(actualFilePath);
        
        Set<String> actualMinusbaseline = new HashSet<>(actualLinesSet);
        actualMinusbaseline.removeAll(baselineLinesSet);
        logger.fine("Size of actualMinusbaseline: " + actualMinusbaseline.size());
        Set<String> baselineMinusActual = new HashSet<>(baselineLinesSet);
        baselineMinusActual.removeAll(actualLinesSet);
        logger.fine("Size of baselineMinusActual: " + baselineMinusActual.size());

        if (!actualMinusbaseline.isEmpty() || !baselineMinusActual.isEmpty()) {
            logger.info("FAIL: Lines present in actual file but not in baseline file: " + actualMinusbaseline);
            logger.info("FAIL: Lines present in baseline file but not in actual file: " + baselineMinusActual);
            logger.info("**************** Mismatch info End *******************");
            return false;
        } else {
            logger.info("VERIFIED: Actual file contents match with the baseline file contents.");
            return true;
        }
    } catch (IOException e) {
        logger.severe("Error while comparing files: " + e.getMessage());
        throw e;
    }
}

[Stephan van Hulst]

Ramaram Shankar wrote:Thanks for pointing it out. Updated original post.

I've left your post as is, but in the future, please don't update posts that have already been replied to. It just makes the topic more confusing to read.