[](https://travis-ci.org/wumpz/java-diff-utils)[](https://www.codacy.com/app/wumpz/java-diff-utils?utm_source=github.com&utm_medium=referral&utm_content=wumpz/java-diff-utils&utm_campaign=Badge_Grade)

[](http://maven-badges.herokuapp.com/maven-central/com.github.wumpz/diffutils)

**After a while using it, at least for me, this one seems to be feature complete. If someone finds bugs or has improvement ideas, please file an issue. I wonder why that this project is a zero issue project.**

Diff Utils library is an OpenSource library for performing the comparison operations between texts: computing diffs, applying patches, generating unified diffs or parsing them, generating diff output for easy future displaying (like side-by-side view) and so on.

But it can easily replaced by any other which is better for handing your texts. I have plan to add implementation of some in future.

* Version 3.0-SNAPSHOT

* Due to licensing issues Delta.java and DiffAlgorithm.java were removed.

* Version 2.3-SNAPSHOT

* Introduced a process listener to diff algorithms. For long running

diffs one could implement some progress information.

* automatic module name for JDK 9 and higher usage

* Version 2.2

* released at maven central

<groupId>com.github.wumpz</groupId>

<artifactId>diffutils</artifactId>

<packaging>jar</packaging>

<version>2.3-SNAPSHOT</version>

<version>3.0-SNAPSHOT</version>

<name>java-diff-utils</name>

<description>The DiffUtils library for computing diffs, applying patches, generationg side-by-side view in Java.</description>

<url>https://github.com/wumpz/java-diff-utils</url>

packagecom.github.difflib;

importcom.github.difflib.algorithm.DiffAlgorithm;

importcom.github.difflib.algorithm.DiffAlgorithmI;

importcom.github.difflib.algorithm.DiffAlgorithmListener;

importcom.github.difflib.algorithm.DiffException;

importcom.github.difflib.algorithm.myers.MyersDiff;

importcom.github.difflib.patch.Delta;

importcom.github.difflib.patch.AbstractDelta;

importcom.github.difflib.patch.Patch;

importcom.github.difflib.patch.PatchFailedException;

importjava.util.ArrayList;

publicfinalclassDiffUtils {

publicstatic <T>Patch<T>diff(List<T>original,List<T>revised,DiffAlgorithmListenerprogress)throwsDiffException {

returnDiffUtils.diff(original,revised,newMyersDiff<>(),progress);

}

publicstatic <T>Patch<T>diff(List<T>original,List<T>revised)throwsDiffException {

returnDiffUtils.diff(original,revised,newMyersDiff<>());

returnDiffUtils.diff(original,revised,newMyersDiff<>(),null);

}

publicstaticPatch<String>diff(StringoriginalText,StringrevisedText)throwsDiffException {

returnDiffUtils.diff(Arrays.asList(originalText.split("\n")),Arrays.asList(revisedText.split("\n")));

publicstaticPatch<String>diff(StringsourceText,StringtargetText,

DiffAlgorithmListenerprogress)throwsDiffException {

returnDiffUtils.diff(

Arrays.asList(sourceText.split("\n")),

Arrays.asList(targetText.split("\n")),progress);

}

publicstatic <T>Patch<T>diff(List<T>original,List<T>revised,

publicstatic <T>Patch<T>diff(List<T>source,List<T>target,

BiPredicate<T,T>equalizer)throwsDiffException {

if (equalizer !=null) {

returnDiffUtils.diff(original,revised,

returnDiffUtils.diff(source,target,

newMyersDiff<>(equalizer));

}

returnDiffUtils.diff(original,revised,newMyersDiff<>());

returnDiffUtils.diff(source,target,newMyersDiff<>());

}

publicstatic <T>Patch<T>diff(List<T>original,List<T>revised,

DiffAlgorithm<T>algorithm)throwsDiffException {

DiffAlgorithmI<T>algorithm,DiffAlgorithmListenerprogress)throwsDiffException {

Objects.requireNonNull(original,"original must not be null");

Objects.requireNonNull(revised,"revised must not be null");

Objects.requireNonNull(algorithm,"algorithm must not be null");

returnPatch.generate(original,revised,algorithm.diff(original,revised));

returnPatch.generate(original,revised,algorithm.computeDiff(original,revised,progress));

}

publicstatic <T>Patch<T>diff(List<T>original,List<T>revised,

DiffAlgorithmI<T>algorithm)throwsDiffException {

returndiff(original,revised,algorithm,null);

}

revList.add(character.toString());

}

Patch<String>patch =DiffUtils.diff(origList,revList);

for (Delta<String>delta :patch.getDeltas()) {

delta.getOriginal().setLines(compressLines(delta.getOriginal().getLines(),""));

delta.getRevised().setLines(compressLines(delta.getRevised().getLines(),""));

for (AbstractDelta<String>delta :patch.getDeltas()) {

delta.getSource().setLines(compressLines(delta.getSource().getLines(),""));

delta.getTarget().setLines(compressLines(delta.getTarget().getLines(),""));

}

returnpatch;

}

importcom.github.difflib.patch.ChangeDelta;

importcom.github.difflib.patch.Chunk;

importcom.github.difflib.patch.Delta;

importcom.github.difflib.patch.AbstractDelta;

importcom.github.difflib.patch.Patch;

importjava.util.ArrayList;

importjava.util.List;

ret.add("--- " +originalFileName);

ret.add("+++ " +revisedFileName);

List<Delta<String>>patchDeltas =newArrayList<>(

List<AbstractDelta<String>>patchDeltas =newArrayList<>(

patch.getDeltas());

List<Delta<String>>deltas =newArrayList<>();// current

List<AbstractDelta<String>>deltas =newArrayList<>();// current

Delta<String>delta =patchDeltas.get(0);

AbstractDelta<String>delta =patchDeltas.get(0);

deltas.add(delta);// add the first Delta to the current set

if (patchDeltas.size() >1) {

for (inti =1;i <patchDeltas.size();i++) {

intposition =delta.getOriginal().getPosition();// store

intposition =delta.getSource().getPosition();// store

Delta<String>nextDelta =patchDeltas.get(i);

if ((position +delta.getOriginal().size() +contextSize) >= (nextDelta

.getOriginal().getPosition() -contextSize)) {

AbstractDelta<String>nextDelta =patchDeltas.get(i);

if ((position +delta.getSource().size() +contextSize) >= (nextDelta

.getSource().getPosition() -contextSize)) {

deltas.add(nextDelta);

}else {

privatestaticList<String>processDeltas(List<String>origLines,

List<Delta<String>>deltas,intcontextSize) {

List<AbstractDelta<String>>deltas,intcontextSize) {

List<String>buffer =newArrayList<>();

intorigTotal =0;// counter for total lines output from Original

intrevTotal =0;// counter for total lines output from Original

intline;

Delta<String>curDelta =deltas.get(0);

AbstractDelta<String>curDelta =deltas.get(0);

intorigStart =curDelta.getOriginal().getPosition() +1 -contextSize;

intorigStart =curDelta.getSource().getPosition() +1 -contextSize;

if (origStart <1) {

origStart =1;

}

intrevStart =curDelta.getRevised().getPosition() +1 -contextSize;

intrevStart =curDelta.getTarget().getPosition() +1 -contextSize;

if (revStart <1) {

revStart =1;

}

intcontextStart =curDelta.getOriginal().getPosition() -contextSize;

intcontextStart =curDelta.getSource().getPosition() -contextSize;

if (contextStart <0) {

contextStart =0;// clamp to the start of the file

}

for (line =contextStart;line <curDelta.getOriginal().getPosition();line++) {//

for (line =contextStart;line <curDelta.getSource().getPosition();line++) {//

buffer.add(" " +origLines.get(line));

origTotal++;

revTotal++;

}

buffer.addAll(getDeltaText(curDelta));

origTotal +=curDelta.getOriginal().getLines().size();

revTotal +=curDelta.getRevised().getLines().size();

origTotal +=curDelta.getSource().getLines().size();

revTotal +=curDelta.getTarget().getLines().size();

intdeltaIndex =1;

while (deltaIndex <deltas.size()) {// for each of the other Deltas

Delta<String>nextDelta =deltas.get(deltaIndex);

intintermediateStart =curDelta.getOriginal().getPosition()

+curDelta.getOriginal().getLines().size();

for (line =intermediateStart;line <nextDelta.getOriginal()

AbstractDelta<String>nextDelta =deltas.get(deltaIndex);

intintermediateStart =curDelta.getSource().getPosition()

+curDelta.getSource().getLines().size();

for (line =intermediateStart;line <nextDelta.getSource()

.getPosition();line++) {

buffer.add(" " +origLines.get(line));

origTotal++;

revTotal++;

}

buffer.addAll(getDeltaText(nextDelta));// output the Delta

origTotal +=nextDelta.getOriginal().getLines().size();

revTotal +=nextDelta.getRevised().getLines().size();

origTotal +=nextDelta.getSource().getLines().size();

revTotal +=nextDelta.getTarget().getLines().size();

curDelta =nextDelta;

deltaIndex++;

}

contextStart =curDelta.getOriginal().getPosition()

+curDelta.getOriginal().getLines().size();

contextStart =curDelta.getSource().getPosition()

+curDelta.getSource().getLines().size();

for (line =contextStart; (line < (contextStart +contextSize))

&& (line <origLines.size());line++) {

buffer.add(" " +origLines.get(line));

StringBufferheader =newStringBuffer();

StringBuilderheader =newStringBuilder();

header.append("@@ -");

header.append(origStart);

header.append(",");

privatestaticList<String>getDeltaText(Delta<String>delta) {

privatestaticList<String>getDeltaText(AbstractDelta<String>delta) {

List<String>buffer =newArrayList<>();

for (Stringline :delta.getOriginal().getLines()) {

for (Stringline :delta.getSource().getLines()) {

buffer.add("-" +line);

}

for (Stringline :delta.getRevised().getLines()) {

for (Stringline :delta.getTarget().getLines()) {

buffer.add("+" +line);

}

returnbuffer;

publicclassChange {