Fatal编程技术网
  • java/
  • Java：比较、标记和解释Java中的HTML文本

Java：比较、标记和解释Java中的HTML文本

java html string

Java：比较、标记和解释Java中的HTML文本,java,html,string,string-comparison,Java,Html,String,String Comparison,我正在从事一个Java项目，其中有一个HTML编辑器，用户可以在HTML编辑器（ckeditor）中输入文本，实际的HTML文本保存在数据库中 现在，当用户下次再来编辑相同的文本时，我想通过比较数据库中的文本来显示两者之间的差异 我面临的最重要的问题是，即使任何比较器工具都知道斜体的样式已更改为粗体，比较器的输出是它的strike through单词Italic，并显示插入了Bold来代替它 但这并不能解释实际编辑的意图或行为。目的/行动是用户将其从斜体改为粗体。我要找的是一个工具，它不是显示删

我正在从事一个Java项目，其中有一个HTML编辑器，用户可以在HTML编辑器（ckeditor）中输入文本，实际的HTML文本保存在数据库中

现在，当用户下次再来编辑相同的文本时，我想通过比较数据库中的文本来显示两者之间的差异

我面临的最重要的问题是，即使任何比较器工具都知道斜体的样式已更改为粗体，比较器的输出是它的
strike through
单词
Italic
，并显示插入了
Bold
来代替它

但这并不能解释实际编辑的意图或行为。目的/行动是用户将其从斜体改为粗体。我要找的是一个工具，它不是显示删除了斜体字，而是添加了粗体字，而是首先显示删除了斜体字/句子的
斜体字/句子，然后替换为
粗体字/句子

我希望我的意思是清楚的。我一直在努力实现这一目标已经有相当一段时间了。我试过diff_match_patch、daisydiff等，都没用

我的审判：


/*

            String oldTextHtml = mnotes1.getMnotetext();
            String newTextHTML = mnotes.getMnotetext();


            oldTextHtml = oldTextHtml.replace("<br>","\n");
            oldTextHtml = Jsoup.clean(oldTextHtml, Whitelist.basic());
           oldTextHtml = Jsoup.parse(oldTextHtml).text();

            newTextHTML = newTextHTML.replace("<br>","\n");
            newTextHTML = Jsoup.clean(newTextHTML,Whitelist.basic());
            newTextHTML = Jsoup.parse(newTextHTML).text();


            diff_match_patch diffMatchPatch = new diff_match_patch();
            LinkedList<diff_match_patch.Diff> deltas = diffMatchPatch.diff_main(oldTextHtml, newTextHTML);
            diffMatchPatch.diff_cleanupSemantic(deltas);
            newText += diffMatchPatch.diff_prettyHtml(deltas);
            groupNoteHistory.setWhatHasChanged("textchange");
            groupNoteHistory.setNewNoteText(newText);
            noEdit = true;
*/


           List<String> oldTextList = Arrays.asList(mnotes1.getMnotetext().split("(\\.|\\n)"));
            List<String> newTextList = Arrays.asList(mnotes.getMnotetext().split("(\\.|\\n)"));
            if (oldTextList.size() == newTextList.size()) {

                for (int current = 0; current < oldTextList.size(); current++) {
                    if (isLineDifferent(oldTextList.get(current), newTextList.get(current))) {
                        noEdit = true;
                        diff_match_patch diffMatchPatch = new diff_match_patch();
                        LinkedList<diff_match_patch.Diff> deltas = diffMatchPatch.diff_main(oldTextList.get(current), newTextList.get(current));
                        diffMatchPatch.diff_cleanupSemantic(deltas);
                        newText += diffMatchPatch.diff_prettyHtml(deltas);
                        groupNoteHistory.setWhatHasChanged("textchange");
                        groupNoteHistory.setNewNoteText(newText);
                    }
                }
            } else {
                if (!(mnotes.getMnotetext().equals(mnotes1.getMnotetext()))) {
                    if (isLineDifferent(mnotes1.getMnotetext(), mnotes.getMnotetext())) {
                        diff_match_patch diffMatchPatch = new diff_match_patch();

                        LinkedList<diff_match_patch.Diff> deltas = diffMatchPatch.diff_main(mnotes1.getMnotetext(),
                                mnotes.getMnotetext());
                        diffMatchPatch.diff_cleanupSemantic(deltas);
                        newText += diffMatchPatch.diff_prettyHtml(deltas);
                        groupNoteHistory.setWhatHasChanged("textchange");
                        noEdit = true;
                    }
                    groupNoteHistory.setNewNoteText(newText);
                    groupNoteHistory.setWhatHasChanged("textchange");
                }
            }



/*
字符串oldTextHtml=mnotes1.getMnotetext（）；
字符串newTextHTML=mnotes.getMnotetext（）；
oldTextHtml=oldTextHtml.replace（“
”，“\n”）；
oldTextHtml=Jsoup.clean（oldTextHtml，Whitelist.basic（））；
oldTextHtml=Jsoup.parse（oldTextHtml.text（）；
newtextml=newtextml.replace（“
”，“\n”）；
newtextml=Jsoup.clean（newtextml，Whitelist.basic（））；
newTextHTML=Jsoup.parse（newTextHTML.text（）；
diff_match_patch diffMatchPatch=新的diff_match_patch（）；
LinkedList Delta=diffMatchPatch.diff_main（oldTextHtml，newTextHTML）；
diffMatchPatch.diff_cleanuspemantic（delta）；
newText+=diffMatchPatch.diff_prettyHtml（增量）；
groupNoteHistory.setWhatHasChanged（“textchange”）；
groupNoteHistory.setNewNoteText（newText）；
noEdit=true；
*/
List oldTextList=Arrays.asList（mnotes1.getMnotetext（）.split（“（\\.\\\n）”）；
List newTextList=Arrays.asList（mnotes.getMnotetext（）.split（“（\\.\\\n）”）；
如果（oldTextList.size（）==newTextList.size（））{
对于（int current=0；current

如果有人知道我如何做到这一点，请告诉我。非常感谢。：-）

编辑

有人问我要一张照片。解释，然后是图像


Old text : <style= bold>Hello</style>
new Text : <style = Italic>Hello</style>



旧文本：您好
新文本：你好


预期产出差异：


最近，我探讨了一个开源库的概念，该库在java上实现了diff命令和许多其他功能

基本上，我比较了两个java文件，得到了它们之间的修改行，有了这些信息，我认为很容易实现您想要的

基本上，我在
src/test/resources/files
文件夹下有两个java文件

文件1


package com.onuba.car.javadiff；
导入difflib.Chunk；
导入difflib.Delta；
导入difflib.DiffUtils；
导入difflib.Patch；
导入java.io.BufferedReader；
导入java.io.File；
导入java.io.FileReader；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.List；
公共类文件比较器{
私人最终文件原件；
修改私人最终文件；
公共文件比较器（文件原件、文件修订版）{
this.original=原件；
this.revised=修订；
}
public List getChangesFromOriginal（）引发IOException{
返回getChunksByType（Delta.TYPE.CHANGE）；
}
公共列表getInsertsFromOriginal（）引发IOException{
返回getChunksByType（Delta.TYPE.INSERT）；
}
公共列表getDeletesFromOriginal（）引发IOException{
返回getChunksByType（Delta.TYPE.DELETE）；
}
私有列表getChunksByType（Delta.TYPE类型）引发IOException{
最终列表更改=新的ArrayList（）；
最终列表增量=getDeltas（）；
对于（三角洲：三角洲）{
if（delta.getType（）==类型）{
add（delta.getRevised（））；
}
}
返回更改列表；
}
私有列表getDeltas（）引发IOException{

package com.onuba.car.javadiff;

import difflib.Chunk;
import difflib.Delta;
import difflib.DiffUtils;
import difflib.Patch;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class FileComparator {

    private final File original;

    private final File revised;

    public FileComparator(File original, File revised) {
        this.original = original;
        this.revised = revised;
    }

    public List<Chunk> getChangesFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.CHANGE);
    }

    public List<Chunk> getInsertsFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.INSERT);
    }

    public List<Chunk> getDeletesFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.DELETE);
    }

    private List<Chunk> getChunksByType(Delta.TYPE type) throws IOException {
        final List<Chunk> listOfChanges = new ArrayList<Chunk>();
        final List<Delta> deltas = getDeltas();
        for (Delta delta : deltas) {
            if (delta.getType() == type) {
                listOfChanges.add(delta.getRevised());
            }
        }
        return listOfChanges;
    }

    private List<Delta> getDeltas() throws IOException {

        final List<String> originalFileLines = fileToLines(original);
        final List<String> revisedFileLines = fileToLines(revised);

        final Patch patch = DiffUtils.diff(originalFileLines, revisedFileLines);

        return patch.getDeltas();
    }

    private List<String> fileToLines(File file) throws IOException {
        final List<String> lines = new ArrayList<String>();
        String line;
        final BufferedReader in = new BufferedReader(new FileReader(file));
        while ((line = in.readLine()) != null) {
            lines.add(line);
        }

        return lines;
    }

    <style= bold>Hello</style>

}



package com.onuba.car.javadiff;

import difflib.Chunk;
import difflib.Delta;
import difflib.DiffUtils;
import difflib.Patch;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class FileComparator {

    private final File original;

    private final File revised;

    public FileComparator(File original, File revised) {
        this.original = original;
        this.revised = revised;
    }

    public List<Chunk> getChangesFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.CHANGE);
    }

    public List<Chunk> getInsertsFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.INSERT);
    }

    public List<Chunk> getDeletesFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.DELETE);
    }

    private List<Chunk> getChunksByType(Delta.TYPE type) throws IOException {
        final List<Chunk> listOfChanges = new ArrayList<Chunk>();
        final List<Delta> deltas = getDeltas();
        for (Delta delta : deltas) {
            if (delta.getType() == type) {
                listOfChanges.add(delta.getRevised());
            }
        }
        return listOfChanges;
    }

    private List<Delta> getDeltas(String nuevoParam) throws IOException {

        final List<String> originalFileLines = fileToLines(original);
        final List<String> revisedFileLines = fileToLines(revised);

        final Patch patch = DiffUtils.diff(originalFileLines, revisedFileLines);

        return patch.getDeltas();
    }

    private List<String> fileToLines(File file, String nuevoParam) throws IOException {
        final List<String> lines = new ArrayList<String>();
        String line;
        final BufferedReader in = new BufferedReader(new FileReader(file));
        while ((line = in.readLine()) != null) {
            lines.add(line);
        }

        return lines;
    }

    <style = Italic>Hello</style>

    private void nuevoMetodoCool(File file) {

    }

}



package com.onuba.car.javadiff;

import difflib.Chunk;
import difflib.Delta;
import difflib.DiffUtils;
import difflib.Patch;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class FileComparator {

    private final File original;

    private final File revised;

    public FileComparator(File original, File revised) {
        this.original = original;
        this.revised = revised;
    }

    public List<Chunk> getChangesFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.CHANGE);
    }

    public List<Chunk> getInsertsFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.INSERT);
    }

    public List<Chunk> getDeletesFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.DELETE);
    }

    private List<Chunk> getChunksByType(Delta.TYPE type) throws IOException {
        final List<Chunk> listOfChanges = new ArrayList<Chunk>();
        final List<Delta> deltas = getDeltas();
        for (Delta delta : deltas) {
            if (delta.getType() == type) {
                listOfChanges.add(delta.getRevised());
            }
        }
        return listOfChanges;
    }

    private List<Delta> getDeltas() throws IOException {

        final List<String> originalFileLines = fileToLines(original);
        final List<String> revisedFileLines = fileToLines(revised);

        final Patch patch = DiffUtils.diff(originalFileLines, revisedFileLines);

        return patch.getDeltas();
    }

    private List<String> fileToLines(File file) throws IOException {
        final List<String> lines = new ArrayList<String>();
        String line;
        final BufferedReader in = new BufferedReader(new FileReader(file));
        while ((line = in.readLine()) != null) {
            lines.add(line);
        }

        return lines;
    }

}



package com.onuba.car.javadiff.test;

import static org.junit.Assert.fail;

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.junit.Test;

import com.everis.car.javadiff.FileComparator;

import difflib.Chunk;

public class FileComparatorTest {

    private final File original = new File("./src/test/resources/files/FileComparatorv1.java");

    private final File revised = new File("./src/test/resources/files/FileComparatorv2.java");

    @Test
    public void shouldGetChangesBetweenFiles() {

        final FileComparator comparator = new FileComparator(original, revised);

        try {
            final List<Chunk> changesFromOriginal = comparator.getChangesFromOriginal();

            final int changeNum = changesFromOriginal.size();
            System.out.println("Tamaño de cambios: " + changeNum);

            for (int i = 0; i < changeNum; i++) {

                final Chunk change = changesFromOriginal.get(i);
                final int firstLineOfFirstChange = change.getPosition() + 1;
                final int changeSize = change.size();
                //final String changeText = change.getLines().get(0).toString();

                System.out.println("Cambio nº " + i);
                System.out.println("firstLineOfFirstChange: " + firstLineOfFirstChange);
                System.out.println("changeSize: " + changeSize);
                System.out.println("change text: ");
                showTest(change.getLines());

            }

            /*assertEquals(3, changesFromOriginal.size());

            final Chunk firstChange = changesFromOriginal.get(0);
            final int firstLineOfFirstChange = firstChange.getPosition() + 1;
            final int firstChangeSize = firstChange.size();
            assertEquals(2, firstLineOfFirstChange);
            assertEquals(1, firstChangeSize);
            final String firstChangeText = firstChange.getLines().get(0).toString();
            assertEquals("Line 3 with changes", firstChangeText);

            final Chunk secondChange = changesFromOriginal.get(1);
            final int firstLineOfSecondChange = secondChange.getPosition() + 1;
            final int secondChangeSize = secondChange.size();
            assertEquals(4, firstLineOfSecondChange);
            assertEquals(2, secondChangeSize);
            final String secondChangeFirstLineText = secondChange.getLines().get(0).toString();
            final String secondChangeSecondLineText = secondChange.getLines().get(1).toString();
            assertEquals("Line 5 with changes and", secondChangeFirstLineText);
            assertEquals("a new line", secondChangeSecondLineText);

            final Chunk thirdChange = changesFromOriginal.get(2);
            final int firstLineOfThirdChange = thirdChange.getPosition() + 1;
            final int thirdChangeSize = thirdChange.size();
            assertEquals(11, firstLineOfThirdChange);
            assertEquals(1, thirdChangeSize);
            final String thirdChangeText = thirdChange.getLines().get(0).toString();
            assertEquals("Line 10 with changes", thirdChangeText);*/

        } catch (IOException ioe) {
            fail("Error running test shouldGetChangesBetweenFiles " + ioe.toString());
        }
    }

    @Test
    public void shouldGetInsertsBetweenFiles() {

        final FileComparator comparator = new FileComparator(original, revised);

        try {
            final List<Chunk> insertsFromOriginal = comparator.getInsertsFromOriginal();

            final int changeNum = insertsFromOriginal.size();
            System.out.println("Tamaño de inserciones: " + changeNum);

            for (int i = 0; i < changeNum; i++) {

                final Chunk change = insertsFromOriginal.get(i);
                final int firstLineOfFirstChange = change.getPosition() + 1;
                final int changeSize = change.size();
                //final String changeText = change.getLines().get(0).toString();

                System.out.println("insercion nº " + i);
                System.out.println("firstLineOfFirstInsertion: " + firstLineOfFirstChange);
                System.out.println("insertion Size: " + changeSize);
                System.out.println("insertion text: ");
                showTest(change.getLines());

            }
        } catch (IOException ioe) {
            fail("Error running test shouldGetInsertsBetweenFiles " + ioe.toString());
        }
        /*try {
            final List<Chunk> insertsFromOriginal = comparator.getInsertsFromOriginal();
            assertEquals(1, insertsFromOriginal.size());

            final Chunk firstInsert = insertsFromOriginal.get(0);
            final int firstLineOfFirstInsert = firstInsert.getPosition() + 1;
            final int firstInsertSize = firstInsert.size();
            assertEquals(7, firstLineOfFirstInsert);
            assertEquals(1, firstInsertSize);
            final String firstInsertText = firstInsert.getLines().get(0).toString();
            assertEquals("new line 6.1", firstInsertText);

        } catch (IOException ioe) {
            fail("Error running test shouldGetInsertsBetweenFiles " + ioe.toString());
        }*/
    }

    @Test
    public void shouldGetDeletesBetweenFiles() {

        final FileComparator comparator = new FileComparator(original, revised);

        try {
            final List<Chunk> deletesFromOriginal = comparator.getDeletesFromOriginal();

            final int changeNum = deletesFromOriginal.size();
            System.out.println("Tamaño de deletes: " + changeNum);

            for (int i = 0; i < changeNum; i++) {

                final Chunk change = deletesFromOriginal.get(i);
                final int firstLineOfFirstChange = change.getPosition() + 1;
                final int changeSize = change.size();
                //final String changeText = change.getLines().get(0).toString();

                System.out.println("delete nº " + i);
                System.out.println("firstLineOfFirstDelete: " + firstLineOfFirstChange);
                System.out.println("delete Size: " + changeSize);
                System.out.println("delete text: ");
                showTest(change.getLines());

            }
        } catch (IOException ioe) {
            fail("Error running test shouldGetInsertsBetweenFiles " + ioe.toString());
        }

        /*try {
            final List<Chunk> deletesFromOriginal = comparator.getDeletesFromOriginal();
            assertEquals(1, deletesFromOriginal.size());

            final Chunk firstDelete = deletesFromOriginal.get(0);
            final int firstLineOfFirstDelete = firstDelete.getPosition() + 1;
            assertEquals(1, firstLineOfFirstDelete);

        } catch (IOException ioe) {
            fail("Error running test shouldGetDeletesBetweenFiles " + ioe.toString());
        }*/
    }

    private void showTest(List<?> texts) {

        if (texts != null) {
            for (Object s : texts) {
                System.out.println(s.toString());
            }
        }
    }
}



<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.onuba.car</groupId>
    <artifactId>javadiffpoc</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>JavaDiff ::  POC</name>

    <url>http://maven.apache.org</url>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!-- GUAVA -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>15.0</version>
        </dependency>

        <dependency>
            <groupId>com.googlecode.java-diff-utils</groupId>
            <artifactId>diffutils</artifactId>
            <version>1.2.1</version>
        </dependency>

        <!-- Logger -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-access</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.6.4</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.4</version>
            </plugin>
        </plugins>
    </build>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
</project>



package com.onuba.car.javadiff;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.List;

import difflib.Chunk;

public class Comparer {

    private final File original = new File("./src/test/resources/files/FileComparatorv1.java");

    private final File revised = new File("./src/test/resources/files/FileComparatorv2.java");

    public static void main(String[] args) {

        final Comparer comparer = new Comparer();

        comparer.createDiffFile();
    }

    private void createDiffFile() {

        PrintWriter diffFile = null;
        //RandomAccessFile diffFile = null;
        RandomAccessFile oldFile = null;

        try {

            //diffFile = new RandomAccessFile(new File("./diffFile_" + System.currentTimeMillis()), "rw");
            diffFile = new PrintWriter("./diffFile_" + System.currentTimeMillis(), "UTF-8");
            oldFile = new RandomAccessFile(original, "r");

            final FileComparator comparator = new FileComparator(original, revised);

            final List<Chunk> changesFromOriginal = comparator.getChangesFromOriginal();

            final int changeNum = changesFromOriginal.size();
            System.out.println("Tamaño de cambios: " + changeNum);

            final List<Integer> changesIndex = new ArrayList<Integer>();

            for (Chunk change : changesFromOriginal) {

                changesIndex.add(change.getPosition());
            }

            String line = oldFile.readLine();
            int lineIndex = 0;
            while (line != null) {

                if (changesIndex.contains(lineIndex)) {

                    String strikeLine = "From: <strike-through color=yellow>" + line + "</strike-through>"; 
                diffFile.print(strikeLine + " To: <strong>");

                for (Object s : changesFromOriginal.get(changesIndex.indexOf(lineIndex)).getLines()) {
                    diffFile.println(s.toString());
                }
                diffFile.print("</strong>");

                } else {

                    diffFile.println(line);
                }

                line = oldFile.readLine();
                lineIndex++;
            }

        } catch (IOException e) {

        } finally {
            try {
                if (diffFile != null) {
                    diffFile.close();
                }

                if (oldFile != null) {
                    oldFile.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}



package com.onuba.car.javadiff;

import difflib.Chunk;
import difflib.Delta;
import difflib.DiffUtils;
import difflib.Patch;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class FileComparator {

    private final File original;

    private final File revised;

    public FileComparator(File original, File revised) {
        this.original = original;
        this.revised = revised;
    }

    public List<Chunk> getChangesFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.CHANGE);
    }

    public List<Chunk> getInsertsFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.INSERT);
    }

    public List<Chunk> getDeletesFromOriginal() throws IOException {
        return getChunksByType(Delta.TYPE.DELETE);
    }

    private List<Chunk> getChunksByType(Delta.TYPE type) throws IOException {
        final List<Chunk> listOfChanges = new ArrayList<Chunk>();
        final List<Delta> deltas = getDeltas();
        for (Delta delta : deltas) {
            if (delta.getType() == type) {
                listOfChanges.add(delta.getRevised());
            }
        }
        return listOfChanges;
    }

From: <strike-through color=yellow>    private List<Delta> getDeltas() throws IOException {</strike-through> To: <strong>    private List<Delta> getDeltas(String nuevoParam) throws IOException {
</strong> 
        final List<String> originalFileLines = fileToLines(original);
        final List<String> revisedFileLines = fileToLines(revised);

        final Patch patch = DiffUtils.diff(originalFileLines, revisedFileLines);

        return patch.getDeltas();
    }

From: <strike-through color=yellow>    private List<String> fileToLines(File file) throws IOException {</strike-through> To: <strong>    private List<String> fileToLines(File file, String nuevoParam) throws IOException {
</strong>        final List<String> lines = new ArrayList<String>();
        String line;
        final BufferedReader in = new BufferedReader(new FileReader(file));
        while ((line = in.readLine()) != null) {
            lines.add(line);
        }

        return lines;
    }

From: <strike-through color=yellow>    <style= bold>Hello</style></strike-through> To: <strong>    <style = Italic>Hello</style>

    private void nuevoMetodoCool(File file) {

    }
</strong> 
}