java文本对比工具源码8（java比较文本相似度）

/**

* Parse a textual representation of patches and return a List of Patch

* objects.

* @param textline Text representation of patches.

* @return List of Patch objects.

* @throws IllegalArgumentException If invalid input.

*/

public List<Patch> patch_fromText(String textline)

throws IllegalArgumentException {

List<Patch> patches = new LinkedList<Patch>();

if (textline.length() == 0) {

return patches;

}

List<String> textList = Arrays.asList(textline.split("\n"));

LinkedList<String> text = new LinkedList<String>(textList);

Patch patch;

Pattern patchHeader

= Pattern.compile("^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@#34;);

Matcher m;

char sign;

String line;

while (!text.isEmpty()) {

m = patchHeader.matcher(text.getFirst());

if (!m.matches()) {

throw new IllegalArgumentException(

"Invalid patch string: " + text.getFirst());

}

patch = new Patch();

patches.add(patch);

patch.start1 = Integer.parseInt(m.group(1));

if (m.group(2).length() == 0) {

patch.start1--;

patch.length1 = 1;

} else if (m.group(2).equals("0")) {

patch.length1 = 0;

} else {

patch.start1--;

patch.length1 = Integer.parseInt(m.group(2));

}

patch.start2 = Integer.parseInt(m.group(3));

if (m.group(4).length() == 0) {

patch.start2--;

patch.length2 = 1;

} else if (m.group(4).equals("0")) {

patch.length2 = 0;

} else {

patch.start2--;

patch.length2 = Integer.parseInt(m.group(4));

}

text.removeFirst();

while (!text.isEmpty()) {

try {

sign = text.getFirst().charAt(0);

} catch (IndexOutOfBoundsException e) {

// Blank line? Whatever.

text.removeFirst();

continue;

}

line = text.getFirst().substring(1);

line = line.replace("+", "%2B"); // decode would change all "+" to " "

try {

line = URLDecoder.decode(line, "UTF-8");

} catch (UnsupportedEncodingException e) {

// Not likely on modern system.

throw new Error("This system does not support UTF-8.", e);

} catch (IllegalArgumentException e) {

// Malformed URI sequence.

throw new IllegalArgumentException(

"Illegal escape in patch_fromText: " + line, e);

}

if (sign == '-') {

// Deletion.

patch.diffs.add(new Diff(Operation.DELETE, line));

} else if (sign == '+') {

// Insertion.

patch.diffs.add(new Diff(Operation.INSERT, line));

} else if (sign == ' ') {

// Minor equality.

patch.diffs.add(new Diff(Operation.EQUAL, line));

} else if (sign == '@') {

// Start of next patch.

break;

} else {

// WTF?

throw new IllegalArgumentException(

"Invalid patch mode '" + sign + "' in: " + line);

}

text.removeFirst();

}

}

return patches;

}

/**

* Class representing one diff operation.

*/

public static class Diff {

/**

* One of: INSERT, DELETE or EQUAL.

*/

public Operation operation;

/**

* The text associated with this diff operation.

*/

public String text;

/**

* Constructor. Initializes the diff with the provided values.

* @param operation One of INSERT, DELETE or EQUAL.

* @param text The text being applied.

*/

public Diff(Operation operation, String text) {

// Construct a diff with the specified operation and text.

this.operation = operation;

this.text = text;

}

/**

* Display a human-readable version of this Diff.

* @return text version.

*/

public String toString() {

String prettyText = this.text.replace('\n', '\u00b6');

return "Diff(" + this.operation + ",\"" + prettyText + "\")";

}

/**

* Create a numeric hash value for a Diff.

* This function is not used by DMP.

* @return Hash value.

*/

@Override

public int hashCode() {

final int prime = 31;

int result = (operation == null) ? 0 : operation.hashCode();

result += prime * ((text == null) ? 0 : text.hashCode());

return result;

}

/**

* Is this Diff equivalent to another Diff?

* @param obj Another Diff to compare against.

* @return true or false.

*/

@Override

public boolean equals(Object obj) {

if (this == obj) {

return true;

}

if (obj == null) {

return false;

}

if (getClass() != obj.getClass()) {

return false;

}

Diff other = (Diff) obj;

if (operation != other.operation) {

return false;

}

if (text == null) {

if (other.text != null) {

return false;

}

} else if (!text.equals(other.text)) {

return false;

}

return true;

}

}

/**

* Class representing one patch operation.

*/

public static class Patch {

public LinkedList<Diff> diffs;

public int start1;

public int start2;

public int length1;

public int length2;

/**

* Constructor. Initializes with an empty list of diffs.

*/

public Patch() {

this.diffs = new LinkedList<Diff>();

}

/**

* Emulate GNU diff's format.

* Header: @@ -382,8 +481,9 @@

* Indices are printed as 1-based, not 0-based.

* @return The GNU diff string.

*/

public String toString() {

String coords1, coords2;

if (this.length1 == 0) {

coords1 = this.start1 + ",0";

} else if (this.length1 == 1) {

coords1 = Integer.toString(this.start1 + 1);

} else {

coords1 = (this.start1 + 1) + "," + this.length1;

}

if (this.length2 == 0) {

coords2 = this.start2 + ",0";

} else if (this.length2 == 1) {

coords2 = Integer.toString(this.start2 + 1);

} else {

coords2 = (this.start2 + 1) + "," + this.length2;

}

StringBuilder text = new StringBuilder();

text.append("@@ -").append(coords1).append(" +").append(coords2)

.append(" @@\n");

// Escape the body of the patch with %xx notation.

for (Diff aDiff : this.diffs) {

switch (aDiff.operation) {

case INSERT:

text.append('+');

break;

case DELETE:

text.append('-');

break;

case EQUAL:

text.append(' ');

break;

}

try {

text.append(URLEncoder.encode(aDiff.text, "UTF-8").replace('+', ' '))

.append("\n");

} catch (UnsupportedEncodingException e) {

// Not likely on modern system.

throw new Error("This system does not support UTF-8.", e);

}

}

return unescapeForEncodeUriCompatability(text.toString());

}

}

/**

* Unescape selected chars for compatability with JavaScript's encodeURI.

* In speed critical applications this could be dropped since the

* receiving application will certainly decode these fine.

* Note that this function is case-sensitive. Thus "%3f" would not be

* unescaped. But this is ok because it is only called with the output of

* URLEncoder.encode which returns uppercase hex.

*

* Example: "%3F" -> "?", "%24" -> "#34;, etc.

*

* @param str The string to escape.

* @return The escaped string.

*/

private static String unescapeForEncodeUriCompatability(String str) {

return str.replace("%21", "!").replace("%7E", "~")

.replace("%27", "'").replace("%28", "(").replace("%29", ")")

.replace("%3B", ";").replace("%2F", "/").replace("%3F", "?")

.replace("%3A", ":").replace("%40", "@").replace("%26", "&")

.replace("%3D", "=").replace("%2B", "+").replace("%24", "#34;)

.replace("%2C", ",").replace("%23", "#");

}

}