Examples

All examples are part of the tests sourcecode at diffutils/examples or are simply tests. The examples are reduced to present the interesting parts of it.

Compute the difference between two files and print its deltas

File: ComputeDifference.java

//build simple lists of the lines of the two testfiles
List<String> original = Files.readAllLines(new File(ORIGINAL).toPath());
List<String> revised = Files.readAllLines(new File(RIVISED).toPath());

//compute the patch: this is the diffutils part
Patch<String> patch = DiffUtils.diff(original, revised);

//simple output the computed patch to console
for (AbstractDelta<String> delta : patch.getDeltas()) {
    System.out.println(delta);
}      

Get the file in unified format and apply it as the patch to given text

File: ApplyPatch.java

List<String> original = Files.readAllLines(new File(ORIGINAL).toPath());
List<String> patched = Files.readAllLines(new File(PATCH).toPath());

// At first, parse the unified diff file and get the patch
Patch<String> patch = UnifiedDiffUtils.parseUnifiedDiff(patched);

// Then apply the computed patch to the given text
List<String> result = DiffUtils.patch(original, patch);

//simple output to console
System.out.println(result);

Generate a file in unified diff format import it and apply the patch

List<String> text1=Arrays.asList("this is a test","a test");
List<String> text2=Arrays.asList("this is a testfile","a test");

//generating diff information.
Patch<String> diff = DiffUtils.diff(text1, text2);

//generating unified diff format
List<String> unifiedDiff = UnifiedDiffUtils.generateUnifiedDiff("original-file.txt", "new-file.txt", text1, diff, 0);

unifiedDiff.forEach(System.out::println);

//importing unified diff format from file or here from memory to a Patch
Patch<String> importedPatch = UnifiedDiffUtils.parseUnifiedDiff(unifiedDiff);

//apply patch to original list
List<String> patchedText = DiffUtils.patch(text1, importedPatch);

System.out.println(patchedText);

Compute the difference between two texts and print it in human-readable markup style

one liner

Test: DiffRowGeneratorTest.testGeneratorExample1

The DiffRowGenerator does the main part in producing readable texts. Its instantiated using a builder pattern.

//create a configured DiffRowGenerator
DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .mergeOriginalRevised(true)
                .inlineDiffByWord(true)
                .oldTag(f -> "~")      //introduce markdown style for strikethrough
                .newTag(f -> "**")     //introduce markdown style for bold
                .build();

//compute the differences for two test texts.
List<DiffRow> rows = generator.generateDiffRows(
                Arrays.asList("This is a test senctence."),
                Arrays.asList("This is a test for diffutils."));
        
System.out.println(rows.get(0).getOldLine());

output is:

This is a test senctencefor diffutils.

multi liner

Test: DiffRowGeneratorTest.testGeneratorExample2

The DiffRowGenerator does the main part in producing readable texts. Its instantiated using a builder pattern.

DiffRowGenerator generator = DiffRowGenerator.create()
                .showInlineDiffs(true)
                .inlineDiffByWord(true)
                .oldTag(f -> "~")
                .newTag(f -> "**")
                .build();
List<DiffRow> rows = generator.generateDiffRows(
                Arrays.asList("This is a test senctence.", "This is the second line.", "And here is the finish."),
                Arrays.asList("This is a test for diffutils.", "This is the second line."));
        
System.out.println("|original|new|");
System.out.println("|--------|---|");
for (DiffRow row : rows) {
    System.out.println("|" + row.getOldLine() + "|" + row.getNewLine() + "|");
}

output is:

original	new
This is a test senctence.	This is a test for diffutils.
This is the second line.	This is the second line.
And here is the finish.

Compute the difference between two non textual inputs

The difference computing part is generified. Therefore a List of objects could be used. Here is an example, that demonstrates a patch for an Integer List. Test: DiffUtilsTest.testDiffIntegerList

List<Integer> original = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> revised = Arrays.asList(2, 3, 4, 6);

Patch<Integer> patch = DiffUtils.diff(original, revised);
        
for (Delta delta : patch.getDeltas()) {
    System.out.println(delta);
}

output is:

[DeleteDelta, position: 0, lines: [1]]
[ChangeDelta, position: 4, lines: [5] to [6]]