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;
classe pública LargeMappedFiles {
/**
* Classificação e fusão de big data
*
* @param argumentos
*/
public static void main(String[] args) lança IOException {
//Caminho para gravar o arquivo
String caminho do arquivo = "D://456";
// Caminho para dividir o arquivo
String sqlitFilePath = "D://456//123";
//Número de dados
int NúmerosdeContagem=10000000;
//O número de subarquivos
int ArquivoContagem=10;
//Precisão
int contagemAccuracy=30*CountFile;
startNumber longo=System.currentTimeMillis();
//Escreve arquivo de big data
WriteData(caminhoArquivo,Números);
System.out.println("Armazenamento concluído");
// Divida o arquivo de big data em dez outros arquivos pequenos
sqlitFileDate(filePath, sqlitFilePath,CountFile);
System.out.println("Corte de arquivo concluído!");
//Ordena os dados de cada arquivo
singleFileDataSort(sqlitFilePath,CountFile);
System.out.println("Cada subarquivo é classificado!");
//Ajuste de precisão, comparação e integração de dez dados de arquivo
deathDataFile(filePath,sqlitFilePath,countAccuracy,CountFile);
System.out.println("Integração concluída");
stopNumber longo=System.currentTimeMillis();
System.out.println("Demorado"+(stopNumber-startNumber)/1000+"milissegundos");
}
//Escreve arquivo de big data
public static void WriteData(String path,int CountNumbers) lança IOException {
caminho = caminho + "//12114.txt";
FileWriter fs = novo FileWriter(caminho);
BufferedWriter fw = novo BufferedWriter (fs);
for (int i = 0; i <ContNumbers; i++) {
fw.write(new Random().nextInt(Integer.MAX_VALUE) + "/r/n");
}
close();
close();
}
// Divida o arquivo de big data em dez outros arquivos pequenos
public static void sqlitFileDate(String caminho do arquivo, String sqlitPath,
int CountFile) lança IOException {
FileWriter fs = null;
BufferedWriterfw=null;
FileReader fr = new FileReader(caminho do arquivo + "//12114.txt");
BufferedReader br = new BufferedReader(fr); // Lê e obtém toda a linha de dados
int eu = 1;
LinkedList WriterLists=new LinkedList(); //Inicializa a coleção de objetos de fluxo de arquivo
LinkedList fwLists=new LinkedList();
for (int j = 1; j <= ArquivoContagem; j++) {
//Declara objeto
fs = novo FileWriter(sqlitPath + "//12" + j + ".txt",falso);
fw=novo BufferedWriter(fs);
//Carrega o objeto na coleção
WriterLists.add(fs);
fwLists.add(fw);
}
//Determina se ainda há dados para retornar no fluxo de arquivos
enquanto (br.ready()) {
int count=1; // Inicializa o primeiro fluxo de arquivo
for (Iterador iterador = fwLists.iterator(); iterator.hasNext();) {
Tipo BufferedWriter = (BufferedWriter) iterator.next();
if(i==count)//Determina em qual fluxo de arquivo é a vez de gravar os dados
{
//Escreve os dados, salta, prossegue para o próximo fluxo de arquivo e grava os próximos dados
type.write(br.readLine() + "/r/n");
quebrar;
}
contar++;
}
//Determina se o último fluxo de arquivo foi alcançado
if (i >=ContArquivo) {
eu = 1;
} outro
eu++;
}
close();
fr.close();
for (Iterador iterador = fwLists.iterator(); iterator.hasNext();) {
Objeto BufferedWriter = (BufferedWriter) iterator.next();
objeto.fechar();
}
//Percorre e fecha todos os fluxos de subarquivos
for (Iterador iterador = WriterLists.iterator(); iterator.hasNext();) {
Objeto FileWriter = (FileWriter) iterator.next();
objeto.fechar();
}
}
//Ordena os dados de cada arquivo
public static void singleFileDataSort(String path1,int CountFile) lança IOException {
Números do LinkedList = null;
for (int i = 1; i <= ArquivoContagem; i++) {
nums = new LinkedList();
String caminho = caminho1 + "//12" + i + ".txt";
tentar {
FileReader fr = novo FileReader(caminho);
BufferedReader br = novo BufferedReader(fr);
enquanto (br.ready()) {
//Adiciona os dados únicos lidos à coleção
nums.add(Integer.parseInt(br.readLine()));
}
//Ordena a coleção
Coleções.sort(nums);
//Escreve os dados classificados no arquivo fonte
numeroSort(números, caminho);
close();
fr.close();
} catch (NumberFormatException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// Classifica os dados de cada arquivo e depois grava-os no arquivo de origem
public static void numberSort (lista LinkedList, caminho da string) {
tentar {
FileWriter fs = novo FileWriter(caminho);
BufferedWriter fw = novo BufferedWriter (fs);
for (Iterador iterador = list.iterator(); iterator.hasNext();) {
Objeto objeto = (Objeto) iterator.next();
fw.write(objeto + "/r/n");
}
close();
close();
} catch (IOException e) {
e.printStackTrace();
}
}
//Integração final dos dados do arquivo (ajuste de precisão)
public static void deathDataFile(String caminho do arquivo, String sqlitFilePath1,
int countAccuracy, int CountFile) lança IOException {
LinkedList nums = new LinkedList(); //Adicionar dados e classificar
Object temp = null; // Registra o último número restante em cada classificação
booleano ispass = falso;
LinkedList ispasses = null; //Registra as informações de status do arquivo de dados
FileWriter fs = new FileWriter(filepath + "//Sort.txt", false); //Cria um fluxo de arquivo para gravação de dados integrada
BufferedWriter bw=new BufferedWriter(fs);
FileReader fr = null; //Declara fluxo de arquivo de leitura
BufferedReader br = null; //Declara BufferedReader
LinkedList WriterLists = new LinkedList(); // Inicializa a coleção de objetos de fluxo de arquivo
LinkedList WriterListFile = new LinkedList();
for (int j = 1; j <= ArquivoContagem; j++) {
// Declare o objeto e abra todos os fluxos de subarquivos para acessar os dados de todos os subarquivos
fr = novo FileReader(sqlitFilePath1 + "//12" + j + ".txt");
//Abre todos os BufferedReaders para facilitar a leitura de toda a linha na próxima vez
br = novo BufferedReader(fr);
//Carrega todos os objetos FileReader na coleção
WriterListFile.add(fr);
//Carrega todos os objetos BufferedReader na coleção
WriterLists.add(br);
}
para (;;) {
// Armazene o status dos dados dos dez arquivos de origem em uma coleção para facilitar o julgamento subsequente.
ispasses = new LinkedList();
// Ler dados individuais de dez arquivos de origem respectivamente
for (Iterador iterador = WriterLists.iterator(); iterator.hasNext();) {
Objeto BufferedReader = (BufferedReader) iterator.next();
Objeto obj = nulo;
enquanto (objeto.ready()) {
//Adiciona dados para cada fluxo de arquivo
nums.add(Integer.parseInt(object.readLine().toString()));
quebrar;
}
if (object.ready() == falso)
ispasses.add("true"); //Salva o status dos dados de cada arquivo na coleção
}
// Determina se é a primeira vez que entra
if (nums.size()% countAccuracy == 0 && ispass == false) {
//Ordena a coleção
Coleções.sort(nums);
//Recebe os maiores dados e grava outros dados no arquivo de classificação total
temp = numberSortData(nums, caminho do arquivo, false, countAccuracy, bw);
//Reinicializa a coleção
nums = new LinkedList();
//Adiciona os dados restantes do conjunto anterior de comparações
nums.add(temp);
ispass = verdadeiro;
//Registra a quantidade de dados do arquivo de origem para a próxima travessia
continuar;
}
if (é aprovado) {
if (nums.size() % contagemPrecisão == 1 && nums.size() > 1) {
//Ordena a coleção
Coleções.sort(nums);
//Recebe os maiores dados e grava outros dados no arquivo de classificação total
temp = numberSortData(nums, caminho do arquivo, true, countAccuracy,
bw);
nums = new LinkedList();
nums.add(temp);
continuar;
}
}
//Registra a localização do próximo conjunto de dados
// Determina se todos os dez arquivos não possuem dados
if (ispasses.size() == CountFile) {
Coleções.sort(nums);
temp = numberSortData(nums, caminho do arquivo, true, countAccuracy, bw);
nums = new LinkedList();
quebrar;
}
}
close();
//Fecha o fluxo de gravação
close();
//Fecha todos os BufferedReaders
for (Iterador iterador = WriterLists.iterator(); iterator.hasNext();) {
BufferedReader object2 = (BufferedReader) iterator.next();
object2.close();
}
//Fecha todos os leitores de arquivos
for (Iterador iterador = WriterListFile.iterator(); iterator.hasNext();) {
Objeto FileReader = (FileReader) iterator.next();
objeto.fechar();
}
}
// Classifica os dados e grava-os no arquivo final (ajuste de precisão)
número de objeto estático públicoSortData (lista LinkedList, String filePath,
boolean ispass, int countAccuracy,BufferedWriter fs) {
Object temp = 0; //Registra o último valor
int tempCount = 0; //Registra o local dos dados gravados
tentar {
for (Iterador iterador = list.iterator(); iterator.hasNext();) {
Objeto objeto = (Objeto) iterator.next();
// Determina se é o último número
if (tempCount == list.size() - 1) {
// Julgamento de que há menos de 100 no conjunto
if (list.size() <countAccuracy + 1 && ispass) {
temp = nulo;
} outro {
temperatura = objeto;
quebrar;
}
}
//Escreve na fonte de dados
fs.write(objeto + "/r/n");
//O subscrito dos dados registrados
ContagemTemp++;
}
} catch (IOException e) {
e.printStackTrace();
}
temperatura de retorno;
}
}