importar java.io.BufferedReader;
importar java.io.BufferedWriter;
importar java.io.FileNotFoundException;
importar java.io.FileReader;
importar java.io.FileWriter;
importar java.io.IOException;
importar java.util.Collections;
importar java.util.Iterator;
importar java.util.LinkedList;
importar java.util.Random;
clase pública LargeMappedFiles {
/**
* Clasificación y fusión de big data
*
* argumentos @param
*/
public static void main (String[] args) lanza IOException {
//Ruta para escribir el archivo
Cadena filePath = "D://456";
// Ruta para dividir el archivo
Cadena sqlitFilePath = "D://456//123";
//Número de datos
int NúmerosDeCuenta=10000000;
//El número de subarchivos
int ContarArchivo=10;
//Precisión
int countAccuracy=30*CountFile;
long startNumber=System.currentTimeMillis();
//Escribir archivo de big data
WriteData(filePath,CountNumbers);
System.out.println("Almacenamiento completado");
// Divide el archivo de big data en otros diez archivos pequeños
sqlitFileDate(filePath, sqlitFilePath,CountFile);
System.out.println("¡Se completó el corte del archivo!");
// Ordena los datos de cada archivo
singleFileDataSort(sqlitFilePath,CountFile);
System.out.println("¡Cada subarchivo está ordenado!");
// Ajuste de precisión, comparación e integración de diez datos de archivos
deathDataFile(filePath,sqlitFilePath,countAccuracy,CountFile);
System.out.println("Integración completada");
númerodeparada largo=System.currentTimeMillis();
System.out.println("Consume mucho tiempo"+(stopNumber-startNumber)/1000+"milisegundos");
}
//Escribir archivo de big data
WriteData público estático vacío (ruta de cadena, int CountNumbers) lanza IOException {
ruta = ruta + "//12114.txt";
FileWriter fs = nuevo FileWriter(ruta);
BufferedWriter fw=nuevo BufferedWriter(fs);
for (int i = 0; i < ContarNúmeros; i++) {
fw.write(new Random().nextInt(Integer.MAX_VALUE) + "/r/n");
}
fw.close();
fs.close();
}
// Divide el archivo de big data en otros diez archivos pequeños
public static void sqlitFileDate (ruta de archivo de cadena, sqlitPath de cadena,
int CountFile) lanza IOException {
FileWriter fs = nulo;
BufferedWriter fw=null;
FileReader fr = nuevo FileReader(filepath + "//12114.txt");
BufferedReader br = new BufferedReader(fr); // Lee y obtiene la línea completa de datos
int yo = 1;
LinkedList WriterLists=new LinkedList(); //Inicializa la colección de objetos de flujo de archivos.
ListaEnlazada fwLists=nueva ListaEnlazada();
for (int j = 1; j <= CountFile; j++) {
//Declarar objeto
fs = nuevo FileWriter(sqlitPath + "//12" + j + ".txt",false);
fw=nuevo BufferedWriter(fs);
//Cargamos el objeto en la colección
Listas de escritores.add(fs);
fwLists.add(fw);
}
//Determinar si todavía hay datos para devolver en la secuencia del archivo
mientras (br.listo()) {
int count=1;//Inicializa la primera secuencia de archivos
for (Iterador iterador = fwLists.iterator(); iterator.hasNext();) {
Tipo BufferedWriter = (BufferedWriter) iterator.next();
if(i==count)//Determinar en qué secuencia de archivos es el turno de escribir datos
{
//Escribe datos, salta, pasa a la siguiente secuencia de archivos y escribe los siguientes datos
type.write(br.readLine() + "/r/n");
romper;
}
contar++;
}
//Determinar si se ha alcanzado la última secuencia de archivos
if (i >= ContarArchivo) {
yo = 1;
} demás
yo ++;
}
br.cerrar();
fr.cerrar();
for (Iterador iterador = fwLists.iterator(); iterator.hasNext();) {
Objeto BufferedWriter = (BufferedWriter) iterator.next();
objeto.cerrar();
}
//Recorre y cierra todas las secuencias de subarchivos
for (Iterador iterador = WriterLists.iterator(); iterator.hasNext();) {
Objeto FileWriter = (FileWriter) iterador.next();
objeto.cerrar();
}
}
// Ordena los datos de cada archivo
public static void singleFileDataSort (String path1, int CountFile) lanza IOException {
números de lista enlazada = nulo;
for (int i = 1; i <= CountFile; i++) {
números = nueva ListaEnlazada();
Ruta de cadena = ruta1 + "//12" + i + ".txt";
intentar {
FileReader fr = nuevo FileReader(ruta);
BufferedReader br = nuevo BufferedReader(fr);
mientras (br.listo()) {
// Agrega los datos únicos leídos a la colección
nums.add(Integer.parseInt(br.readLine()));
}
// Ordenar la colección
Colecciones.sort(nums);
//Escribe los datos ordenados en el archivo fuente
numberSort(numeros, ruta);
br.cerrar();
fr.cerrar();
} captura (NumberFormatException e) {
e.printStackTrace();
} captura (FileNotFoundException e) {
e.printStackTrace();
} captura (IOException e) {
e.printStackTrace();
}
}
}
// Ordena los datos de cada archivo y luego los escribe en el archivo fuente
Ordenación de números vacíos estáticos públicos (lista enlazada, ruta de cadena) {
intentar {
FileWriter fs = nuevo FileWriter(ruta);
BufferedWriter fw=nuevo BufferedWriter(fs);
for (Iterador iterador = lista.iterador(); iterador.hasNext();) {
Objeto objeto = (Objeto) iterador.next();
fw.write(objeto + "/r/n");
}
fw.close();
fs.close();
} captura (IOException e) {
e.printStackTrace();
}
}
//Integración final de datos del archivo (ajuste de precisión)
deathDataFile vacío estático público (ruta de archivo de cadena, cadena sqlitFilePath1,
int countAccuracy, int CountFile) lanza IOException {
LinkedList nums = new LinkedList() //Agregar datos y ordenar
Object temp = null // Registra el último número que queda en cada clasificación
ispass booleano = falso;
LinkedList ispasses = null //Registra la información de estado del archivo de datos.
FileWriter fs = new FileWriter(filepath + "//Sort.txt", false //Crea una secuencia de archivos para la escritura de datos integrada).
BufferedWriter bw=nuevo BufferedWriter(fs);
FileReader fr = null //Declarar flujo de archivo de lectura
BufferedReader br = null //Declarar BufferedReader
LinkedList WriterLists = new LinkedList() // Inicializa la colección de objetos de flujo de archivos.
Lista Vinculada WriterListFile = nueva Lista Vinculada();
for (int j = 1; j <= CountFile; j++) {
// Declara el objeto y abre todas las secuencias de subarchivos para acceder a los datos de todos los subarchivos
fr = nuevo FileReader(sqlitFilePath1 + "//12" + j + ".txt");
//Abre todos los BufferedReaders para facilitar la lectura de la línea completa la próxima vez
br = nuevo BufferedReader(fr);
//Carga todos los objetos FileReader en la colección
WriterListFile.add(fr);
//Carga todos los objetos BufferedReader en la colección
WriterLists.add(br);
}
para (;;) {
// Almacene el estado de los datos de los diez archivos fuente en una colección para facilitar el juicio posterior.
ispasses = nueva ListaEnlazada();
// Lee datos individuales de diez archivos fuente respectivamente
for (Iterador iterador = WriterLists.iterator(); iterator.hasNext();) {
Objeto BufferedReader = (BufferedReader) iterator.next();
Objeto obj = nulo;
mientras (objeto.listo()) {
//Añadir datos para cada secuencia de archivos
nums.add(Integer.parseInt(object.readLine().toString()));
romper;
}
si (objeto.listo() == falso)
ispasses.add("true"); //Guarda el estado de los datos de cada archivo en la colección.
}
// Determinar si es la primera vez que entra
if (nums.size() % countAccuracy == 0 && ispass == false) {
// Ordenar la colección
Colecciones.sort(nums);
// Recibe los datos más grandes y escribe otros datos en el archivo de clasificación total
temp = numberSortData(nums, filepath, false, countAccuracy, bw);
//Reinicializa la colección
números = nueva ListaEnlazada();
//Agregar los datos restantes del conjunto anterior de comparaciones
números.add(temp);
ispass = verdadero;
//Registra la cantidad de datos del archivo fuente para el siguiente recorrido
continuar;
}
si (pasar) {
if (nums.size() % countAccuracy == 1 && nums.size() > 1) {
// Ordenar la colección
Colecciones.sort(nums);
// Recibe los datos más grandes y escribe otros datos en el archivo de clasificación total
temp = numberSortData(nums, filepath, true, countAccuracy,
peso corporal);
números = nueva ListaEnlazada();
números.add(temp);
continuar;
}
}
//Registra la ubicación del siguiente conjunto de datos
// Determinar si los diez archivos no tienen datos
if (ispasses.size() == CountFile) {
Colecciones.sort(nums);
temp = numberSortData(nums, filepath, true, countAccuracy, bw);
números = nueva ListaEnlazada();
romper;
}
}
bw.cerrar();
//Cerrar la secuencia de escritura
fs.close();
//Cerrar todos los lectores buffer
for (Iterador iterador = WriterLists.iterator(); iterator.hasNext();) {
BufferedReader objeto2 = (BufferedReader) iterator.next();
objeto2.cerrar();
}
//Cerrar todos los lectores de archivos
for (Iterador iterador = WriterListFile.iterator(); iterator.hasNext();) {
Objeto FileReader = (FileReader) iterador.next();
objeto.cerrar();
}
}
// Ordena los datos y los escribe en el archivo final (ajuste de precisión)
número de objeto estático públicoSortData (lista enlazada, ruta de archivo de cadena,
booleano ispass, int countAccuracy,BufferedWriter fs) {
Temp del objeto = 0; //Registra el último valor
int tempCount = 0; //Registra la ubicación de los datos escritos
intentar {
for (Iterador iterador = lista.iterador(); iterador.hasNext();) {
Objeto objeto = (Objeto) iterador.next();
// Determinar si es el último número
if (tempCount == lista.tamaño() - 1) {
// Juicio de que hay menos de 100 en el conjunto
if (list.size() <countAccuracy + 1 && ispass) {
temperatura = nulo;
} demás {
temperatura = objeto;
romper;
}
}
//Escribir en la fuente de datos
fs.write(objeto + "/r/n");
//El subíndice de los datos registrados
tempCount++;
}
} captura (IOException e) {
e.printStackTrace();
}
temperatura de retorno;
}
}