Bien qu'il existe de nombreux outils qui comparent les différences de fichiers Je n'avais pas ce que je voulais J'ai créé un outil pour afficher la différence entre deux fichiers CSV.
Spécifiez le numéro de ligne clé dans l'argument, C'est un outil simple qui sort sur une autre ligne si la valeur de clé est différente.
CSVDiff.java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.charset.Charset;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
*Sortie différentielle CSV
*/
public class CSVDiff {
private String split = null;
/**
*Délimiteur
*/
private String delimiter = null ;
/**
*Index des éléments clés
** 0 Début
*/
private List<Integer> keyIndex = null;
/**
*Importer le dossier de placement de fichiers
*/
private String inputDir = null ;
/**
*Importer le fichier 1
*/
private String inputFile1 = null ;
/**
*Importer le fichier 2
*/
private String inputFile2 = null ;
/**
*Dossier de sortie du fichier de différence
*/
private String outputDir = null ;
/**
* */
private List<String[]> recordList1 = null;
/**
* */
private List<String[]> recordList2 = null;
private List <String> outputList = null ;
/**
*constructeur
* @param delimiterType Type de délimiteur (1: autre que la virgule 1: tabulation)
* @param args Index de l'élément clé
* @param inputDir Importer le dossier de placement des fichiers
* @param inputFile1 Importer le fichier 1
* @param inputFile2 Importer le fichier 2
* @param outputDir Dossier de sortie du fichier de différence
*/
public CSVDiff(String delimiterType, String args, String inputDir, String inputFile1, String inputFile2,String outputDir) {
//================================================================================
//1. 1. Jugement du type de délimiteur
//================================================================================
if ("1".equals(delimiterType)) {
this.delimiter = ",";
} else {
this.delimiter = "\t";
}
this.split = "*" + this.delimiter + "*" + this.delimiter + "*";
//================================================================================
//2. Convertir l'index d'élément clé lors de la comparaison des enregistrements au tableau
//================================================================================
this.keyIndex = new ArrayList<Integer> ();
String arr[] = args.split(",");
for (String item : arr) {
int index = Integer.parseInt(item);
if (! this.keyIndex.contains(index) ) {
this.keyIndex.add(index);
}
}
//================================================================================
//3. 3. Définir divers noms de dossier et noms de fichier
//================================================================================
this.inputDir = inputDir;
this.outputDir = outputDir;
this.inputFile1 = inputFile1;
this.inputFile2 = inputFile2;
}
/**
*
* @param outputType
* @param array1
* @param array2
* @return
*/
private String makeRecord (int outputType,String[] array1 ,String[] array2) {
StringBuilder outputRecord = new StringBuilder() ;
if (outputType == 0) {
//================================================================================
//Enregistrement 1 = Enregistrement 2
//→ Sortie enregistrement 1 et enregistrement 2
//================================================================================
//--------------------------------------------------------------------------------
//Enregistrement 1 sortie
//--------------------------------------------------------------------------------
for ( int i=0;i<array1.length;i++) {
if (i == 0) {
outputRecord.append(array1[i]);
} else {
outputRecord.append(this.delimiter + array1[i]);
}
}
//--------------------------------------------------------------------------------
//Sortie de délimiteur
//--------------------------------------------------------------------------------
outputRecord.append(this.delimiter);
outputRecord.append(split);
//--------------------------------------------------------------------------------
//Sortie Record 2
//--------------------------------------------------------------------------------
for ( int i=0;i<array2.length;i++) {
outputRecord.append(this.delimiter + array2[i]);
}
} else if (outputType == 1) {
//================================================================================
//Enregistrement 1 <Enregistrement 2
//→ Sortie uniquement enregistrement 1
//================================================================================
//--------------------------------------------------------------------------------
//Enregistrement 1 sortie
//--------------------------------------------------------------------------------
for ( int i=0;i<array1.length;i++) {
if (i == 0) {
outputRecord.append(array1[i]);
} else {
outputRecord.append(this.delimiter + array1[i]);
}
}
//--------------------------------------------------------------------------------
//Sortie de délimiteur
//--------------------------------------------------------------------------------
outputRecord.append(this.delimiter);
outputRecord.append(split);
//--------------------------------------------------------------------------------
//Sortie Record 2 (virgule ou tabulation uniquement)
//--------------------------------------------------------------------------------
for ( int i=0;i<array1.length;i++) {
outputRecord.append(this.delimiter);
}
} else if (outputType == 2) {
//================================================================================
//Enregistrement 1> Enregistrement 2
//→ Sortie uniquement enregistrement 2
//================================================================================
//--------------------------------------------------------------------------------
//Enregistrer 1 sortie (virgule ou tabulation uniquement)
//--------------------------------------------------------------------------------
for ( int i=0;i<array2.length;i++) {
outputRecord.append(this.delimiter);
}
//--------------------------------------------------------------------------------
//Sortie de délimiteur
//--------------------------------------------------------------------------------
// outputRecord.append(this.delimiter);
outputRecord.append(split);
//--------------------------------------------------------------------------------
//Sortie Record 2
//--------------------------------------------------------------------------------
for ( int i=0;i<array2.length;i++) {
outputRecord.append(this.delimiter + array2[i]);
}
}
return outputRecord.toString();
}
/**
*Sortie de liste de différences CSV
* @return 0: Terminaison normale 1: Terminaison anormale
*/
protected int outputCSVDiff () {
boolean isError = false ;
// --------------------------------------------------------------------------------
//(1) Fichier d'importation / sortie, vérification de l'existence du dossier
// --------------------------------------------------------------------------------
if (this.checkFileExists() != 0) {
System.err.println("Le fichier ou le dossier pour l'importation / la sortie n'existe pas");
return 1;
}
// --------------------------------------------------------------------------------
//(1) Lire le fichier
// --------------------------------------------------------------------------------
if (this.readFile() != 0) {
System.err.println("Erreur de lecture de fichier");
return 1;
}
// --------------------------------------------------------------------------------
//(2) Génération de liste de sortie
// --------------------------------------------------------------------------------
this.outputList = new ArrayList<String> () ;
int i_file1 = 0 ;
int i_file2 = 0 ;
while (i_file1 < this.recordList1.size() && i_file2 < this.recordList2.size()) {
String[] record1 = this.recordList1.get(i_file1);
String[] record2 = this.recordList2.get(i_file2);
String outputRecord = null ;
if (record1.length != record2.length) {
System.err.println("Il existe une différence dans le nombre d'enregistrements entre le fichier 1 et le fichier 2.");
isError = true ;
break ;
}
//========================================================================
//Jugement de correspondance des éléments clés
//========================================================================
int diffType = 0 ;
for (int keyIndex :this.keyIndex) {
if (record1[keyIndex].compareTo(record2[keyIndex]) < 0 ) {
//Enregistrement du fichier 1 <Enregistrement du fichier 2
diffType = 1;
break;
} else if (record1[keyIndex].compareTo(record2[keyIndex]) > 0 ) {
//Enregistrement du fichier 1> Enregistrement du fichier 2
diffType = 2;
break;
}
}
if (diffType == 0) {
//Enregistrement du fichier 1 = enregistrement du fichier 2
outputRecord = this.makeRecord(diffType, record1, record2) ;
System.out.println(outputRecord);
this.outputList.add(outputRecord);
i_file1 ++;
i_file2 ++;
} else if (diffType == 1) {
//Enregistrement du fichier 1 <Enregistrement du fichier 2
outputRecord = this.makeRecord(diffType, record1, null);
System.out.println(outputRecord);
this.outputList.add(outputRecord);
i_file1 ++;
} else {
//Enregistrement du fichier 1> Enregistrement du fichier 2
outputRecord = this.makeRecord(diffType, null, record2);
System.out.println(outputRecord);
this.outputList.add(outputRecord);
i_file2 ++;
}
} // end-of-while
if (isError) { return 1; }
while (i_file1 < this.recordList1.size() ) {
String[] record1 = this.recordList1.get(i_file1);
String outputRecord = this.makeRecord(1, record1, null);
System.out.println(outputRecord);
this.outputList.add(outputRecord);
i_file1 ++;
}
while (i_file2 < this.recordList2.size()) {
String[] record2 = this.recordList2.get(i_file2);
String outputRecord = this.makeRecord(2, null, record2) ;
System.out.println(outputRecord);
this.outputList.add(outputRecord);
i_file2 ++;
}
// --------------------------------------------------------------------------------
//(3) Sortie de fichier
// --------------------------------------------------------------------------------
this.writeFile();
return 0 ;
}
private void writeFile () {
FileOutputStream fos = null;
OutputStreamWriter osw = null;
// --------------------------------------------------------------------------------
//(1) Génération d'horodatage du fichier de sortie
// --------------------------------------------------------------------------------
Timestamp timestamp = new Timestamp(System.currentTimeMillis());
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String fileName = "csvdiff_"+sdf.format(timestamp)+".txt" ;
try {
fos = new FileOutputStream(this.outputDir+"/"+fileName);
osw = new OutputStreamWriter(fos,"Shift_JIS");
for (String record : this.outputList) {
osw.write(record + "\r\n") ;
}
osw.close();
fos.close();
} catch (IOException ex) {
ex.printStackTrace();
} finally {
if (osw != null ) {
try {
osw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null ) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
*Vérifiez l'existence de fichiers et de dossiers d'importation / sortie
* @return 0: fichier d'importation / sortie, avec dossier 1: fichier d'importation / sortie, le dossier n'existe pas
*/
private int checkFileExists () {
// --------------------------------------------------------------------------------
//(1) Vérification d'existence du fichier d'importation 1
// --------------------------------------------------------------------------------
File file1 = new File(this.inputDir+"/"+this.inputFile1) ;
if (!file1.exists()) {
System.err.println("Erreur->Importer le fichier 1 ""+this.inputDir+"/"+this.inputFile1+""N'existe pas! !!");
return 1;
}
// --------------------------------------------------------------------------------
//(2) Vérification d'existence du fichier d'importation 2
// --------------------------------------------------------------------------------
File file2 = new File(this.inputDir+"/"+this.inputFile2) ;
if (!file2.exists()) {
System.err.println("Erreur->Importer le fichier 2 ""+this.inputDir+"/"+this.inputFile2+""N'existe pas! !!");
return 1;
}
// --------------------------------------------------------------------------------
//(3) Vérifiez le dossier de placement du fichier de sortie
// --------------------------------------------------------------------------------
File outputDir = new File(this.outputDir) ;
if (!outputDir.exists()) {
System.err.println("Erreur->Dossier de sortie ""+this.outputDir+""N'existe pas! !!");
return 1;
}
return 0 ;
}
/**
*Lisez le fichier et placez-le dans la liste des tableaux
* @retour 0: lecture OK 1: lecture NG
*/
private int readFile() {
int retVal = 0 ;
File file1 = new File(this.inputDir+"/"+this.inputFile1) ;
File file2 = new File(this.inputDir+"/"+this.inputFile2) ;
try {
this.recordList1 = this.makeRecordList(file1);
this.recordList2 = this.makeRecordList(file2);
} catch (Exception e) {
e.printStackTrace();
retVal = 1;
}
return retVal;
}
/**
*Recharger le contenu du fichier CSV dans une liste de tableaux
* @param file
* @return
* @throws Exception
*/
private List<String[]> makeRecordList (File file) throws Exception {
boolean isError = false;
List<String[]> recordList = new ArrayList<String[]>() ;
FileInputStream fis = null;
InputStreamReader isr = null ;
BufferedReader br = null ;
try {
fis = new FileInputStream(file);
isr = new InputStreamReader(fis, Charset.forName("MS932"));
br = new BufferedReader(isr);
int i = 1 ;
String record = null ;
while((record = br.readLine()) != null) {
String[] recordArray = record.split(this.delimiter);
System.out.println("["+i+"]Ligne:"+Arrays.toString(recordArray));
recordList.add(recordArray);
// System.out.println("["+i_file1+"]Ligne:"+record);
i ++ ;
}
} catch(FileNotFoundException e ) {
e.printStackTrace();
isError = true;
} catch(IOException e ) {
e.printStackTrace();
isError = true;
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
isError = true;
}
}
if (isr != null) {
try {
isr.close();
} catch (IOException e) {
e.printStackTrace();
isError = true;
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
isError = true;
}
}
}
if (isError) { throw new Exception(); }
return recordList ;
}
Ce qui suit est la classe d'exécution
CSVDiffExecute.java
/**
*Classe d'exécution de sortie différentielle CSV
*
*/
public class CSVDiffExecute {
/**
*Méthode principale
* @param args [0]Type de délimiteur (1: autre que la virgule 1: tabulation)
* [1]Index des éléments clés (plusieurs spécifications peuvent être spécifiées séparées par des virgules demi-largeur)
* [2]Importer le dossier de placement de fichiers
* [3]Importer le fichier 1
* [4]Importer le fichier 2
* [5]Dossier de sortie du fichier de différence
*/
public static void main(String[] args) {
//================================================================================
//Vérification des arguments
//================================================================================
if (args.length != 6) {
System.err.println("Erreur->Il n'y a pas assez d'arguments.");
System.exit(1);
}
//================================================================================
//Exécution de la sortie différentielle CSV
//================================================================================
CSVDiff csvDiff = new CSVDiff(args[0], args[1], args[2], args[3], args[4], args[5]);
csvDiff.outputCSVDiff();
}
}
Recommended Posts