number - Generar salida de formato formateado en Java

number format netbeans

Question

¿Hay bibliotecas para Java que acepten dos cadenas y devuelvan una cadena con salida formateada según el comando * nix diff?

por ejemplo, alimentar

test 1,2,3,4
test 5,6,7,8
test 9,10,11,12
test 13,14,15,16

y

test 1,2,3,4
test 5,6,7,8
test 9,10,11,12,13
test 13,14,15,16

como entrada, y te daría

test 1,2,3,4 test 1,2,3,4
test 5,6,7,8 test 5,6,7,8
test 9,10,11,12 | test 9,10,11,12,13
test 13,14,15,16 test 13,14,15,16

Exactamente lo mismo que si hubiera pasado los archivos a diff -y expected actual

Encontré esta pregunta y da algunos buenos consejos sobre bibliotecas generales para darte resultados programáticos, pero quiero los resultados de cadenas directas.

Podría llamar a diff directamente como una llamada al sistema, pero esta aplicación en particular se ejecutará en Unix y Windows, y no puedo estar seguro de que el entorno realmente tenga diff disponible.

Answer 1

Busybox tiene una implementación de diff que es muy delgada, no debería ser difícil de convertir a java, pero tendría que agregar la funcionalidad de dos columnas.

Answer 2

http://c2.com/cgi/wiki?DiffAlgorithm Encontré esto en Google y ofrece algunos buenos antecedentes y enlaces. Si le importa el algoritmo más allá de simplemente hacer el proyecto, un libro sobre algoritmo básico que cubre la Programación Dinámica o un libro sobre él. El conocimiento del algoritmo siempre es bueno :)

Answer 3

java-diff-utils

La biblioteca DiffUtils para calcular diffs, aplicando parches, generacióng lado a lado vista en Java

La biblioteca Diff Utils es una biblioteca OpenSource para realizar operaciones de comparación entre textos: cálculo de diffs, aplicación de parches, generación de diffs unificados o análisis, generación de salida de diff para visualización fácil en el futuro (como side-by-side view) y así sucesivamente.

La razón principal para construir esta biblioteca fue la falta de bibliotecas fáciles de usar con todas las cosas habituales que necesita mientras trabaja con archivos diff. Originalmente fue inspirado por la biblioteca de JRCS y es un bonito diseño del módulo diff.

Principales características

• calculando la diferencia entre dos textos.
• capaz de entregar más que simples ascci. Arrays o List de cualquier tipo que implementa hashCode () y equals () correctamente pueden estar sujetos a diferenciación usando esta biblioteca
• parchear y liberar el texto con el parche dado
• analizar el formato de diff unificado
• produciendo diferencias legibles para los humanos

Answer 4

Terminé de rodar el mío. No estoy seguro si es la mejor implementación, y es feo como el infierno, pero pasa frente a la entrada de prueba.

Utiliza java-diff para hacer el heavy diff lifting (cualquier apache común StrBuilder y StringUtils en lugar de stock Java StringBuilder)

public static String diffSideBySide(String fromStr, String toStr){
// this is equivalent of running unix diff -y command
// not pretty, but it works. Feel free to refactor against unit test.
String[] fromLines = fromStr.split("/n");
String[] toLines = toStr.split("/n");
List<Difference> diffs = (new Diff(fromLines, toLines)).diff();
int padding = 3;
int maxStrWidth = Math.max(maxLength(fromLines), maxLength(toLines)) + padding;
StrBuilder diffOut = new StrBuilder();
diffOut.setNewLineText("/n");
int fromLineNum = 0;
int toLineNum = 0;
for(Difference diff : diffs) {
int delStart = diff.getDeletedStart();
int delEnd = diff.getDeletedEnd();
int addStart = diff.getAddedStart();
int addEnd = diff.getAddedEnd();
boolean isAdd = (delEnd == Difference.NONE && addEnd != Difference.NONE);
boolean isDel = (addEnd == Difference.NONE && delEnd != Difference.NONE);
boolean isMod = (delEnd != Difference.NONE && addEnd != Difference.NONE);
//write out unchanged lines between diffs
while(true) {
String left = "";
String right = "";
if (fromLineNum < (delStart)){
left = fromLines[fromLineNum];
fromLineNum++;
}
if (toLineNum < (addStart)) {
right = toLines[toLineNum];
toLineNum++;
}
diffOut.append(StringUtils.rightPad(left, maxStrWidth));
diffOut.append(" "); // no operator to display
diffOut.appendln(right);
if( (fromLineNum == (delStart)) && (toLineNum == (addStart))) {
break;
}
}
if (isDel) {
//write out a deletion
for(int i=delStart; i <= delEnd; i++) {
diffOut.append(StringUtils.rightPad(fromLines[i], maxStrWidth));
diffOut.appendln("<");
}
fromLineNum = delEnd + 1;
} else if (isAdd) {
//write out an addition
for(int i=addStart; i <= addEnd; i++) {
diffOut.append(StringUtils.rightPad("", maxStrWidth));
diffOut.append("> ");
diffOut.appendln(toLines[i]);
}
toLineNum = addEnd + 1;
} else if (isMod) {
// write out a modification
while(true){
String left = "";
String right = "";
if (fromLineNum <= (delEnd)){
left = fromLines[fromLineNum];
fromLineNum++;
}
if (toLineNum <= (addEnd)) {
right = toLines[toLineNum];
toLineNum++;
}
diffOut.append(StringUtils.rightPad(left, maxStrWidth));
diffOut.append("| ");
diffOut.appendln(right);
if( (fromLineNum > (delEnd)) && (toLineNum > (addEnd))) {
break;
}
}
}
}
//we''ve finished displaying the diffs, now we just need to run out all the remaining unchanged lines
while(true) {
String left = "";
String right = "";
if (fromLineNum < (fromLines.length)){
left = fromLines[fromLineNum];
fromLineNum++;
}
if (toLineNum < (toLines.length)) {
right = toLines[toLineNum];
toLineNum++;
}
diffOut.append(StringUtils.rightPad(left, maxStrWidth));
diffOut.append(" "); // no operator to display
diffOut.appendln(right);
if( (fromLineNum == (fromLines.length)) && (toLineNum == (toLines.length))) {
break;
}
}
return diffOut.toString();
}
private static int maxLength(String[] fromLines) {
int maxLength = 0;
for (int i = 0; i < fromLines.length; i++) {
if (fromLines[i].length() > maxLength) {
maxLength = fromLines[i].length();
}
}
return maxLength;
}