La siguiente duda es la siguiente

El programa trata de que dado un archivo con (n) lineas debe de ser leido y escrito en otro archivo acomodandolo de menor a mayor.

Tengo un archivo con extension h (extension de c o c++) este archivo contiene 131 lineas y su contenido esta dividido en 4 columnas.
El cual contiene numero y letras.

myArchivo.h
 01254152634152   2312    085465200012   FDDG4152
 05432105454321   15513  084527203321   NBN1321N
 46543131215465   12        094552254515   GFDG121F
 46546532154514    01       184543254855   DFG223D2
 .
 .
 .
 .
 asi hasta 131 lineas
ETC.

El contenido de este archivo esta desordenado y para ordenarlo se toma encuenta la 3 columna ya que si se fijan el 7 carcter siempre es un 2 y la tercer columna empieza desde la columna 25 contando los espacios enblanco (entodas las filas) y desde la columna 25 hasta la columna 31 de la misma fila se obtiene un numero.
Por ejemplo de la linea 1 obtenemos el numero (columna 25)084526(columna 31)
y nos sobran estos caracteres 200012 (este numero no importa) y asi es con la fila 2 085465 y la fila 3  094552 y asi hasta la 131.
y con esos numero se puede saber que linea es mas menor a aquien. Este pedazo ya lo tengo

aqui codigo lo pondre con la etiqueta de py porq no hay para java

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;
 
import org.omg.CORBA.TRANSACTION_REQUIRED;
 
public class ordenarConSort {
	public static void main(String[] args) {
 
		String ArchivoAnomalias = "C:/refo/Anomalias.D"; // se le asigna el nombre al archivo
		String ArchivoRefoleo = "C:/refo/Refoleo.D";
 
		FileWriter fw1 = null; // la extension al archivo
		FileWriter fw3 = null; // la extension al archivo
		BufferedReader leer = null;
		BufferedReader leer2 = null;
 
		try {
 
			FileReader entrada = null;
			FileReader entrada2 = null;
 
			entrada = new FileReader("C:/refo/1333206.D"); //Obtenemos el archivo a leer
			int c;
			int columna = 1;	
			int renglon = 1;
			int indice = 0;
 
			int arreglo[] = new int[131]; arreglo donde aguardaremos los 131 numero ya que es un numero por fila del archivo
			String numero = ""; //Aqui se guardara caracter por caracter hasta formar el numero que se ocupa
 
			while ((c = entrada.read()) != -1) { //Para saber si no se ha llegado a fin del archivo
 
				if (((char) c) == 10) { //Para saber si no se a llegado hasta el final del renglon (salto de linea) que se esta leyendo del archivo
					renglon++;
					columna = 1;
				}
 
				if (renglon >= 2 && renglon <= 130) {//PAra empezar desde el renglon numero dos del archivo a leer
					if (columna > 123 && columna < 131) {//PAra saber si ya se posiciono en la columna 123 del primer renglon
						numero += String.valueOf((char) c);//Se guarda el primer caracter y se le concatena el siguiente caracter mientras se cumpla la condicion	
					}
 
					columna += 1;
 
					if (columna == 131) {  //Para saber si ya se leyeron los primeros 8 carcteres de nuestro renglon
						arreglo[indice] = Integer.valueOf(numero); //Se convierte el la variable numero a un entero para guardarlo en un arreglo de tipo entero
						numero = "";//limpiamos la variable numero para que cuando vuelva a concatenar los 
                                                                     caracteres no tenga guardado el numero de la concatenacion anterior
						indice++;		
					}
				}
			}
			entrada.close();//Se cierra el archivo de lectura
 

una vez que ya tengo todo el arreglo lleno con los numero que necesito para saber que renglon es mas chio que quien.
Ahora paso a ordenar los numero de mi arreglo del menor a mayor con el metodo de sort y para eso utilizo la siguiente funcion

Arrays.sort(arreglo); //y con esto estan ordenados mis numeros del menor al mayor (este metodo es de java Arrays.sort())

Despues paso a leer el archivo nuevamente pero ahora obtengo todo el renglon y lo guardo
en un arreglo

String pala[]=new String [131];//Arreglo para guardar la linea completa del arhivo a leer
int i = 0; //contador inicializado
String line = "";//Se guardara la linea leida momentaneamente
 
BufferedReader br = new BufferedReader(new FileReader("C:/refo/1333206.D"));//Archivo a leer
  while ((line = br.readLine()) != null) // lee la linea (br.readLine) y pasalo a la variable linea luego pregunta Mientras no se llegue a fin de archivo
 {
	pala[i]=line;//guardamos la linea obtenido dentro de nuestro arreglo a utilizar
	i++;//incrementa contador
 }
br.close();
 
 

Una vez que ya tengo gurdadas todas las lineas de mi arhcivo en my arreglo ahora paso a crear el nuevo archivo y he ir guardando las lineas del menor a mayor

         int cont=0;               
	FileWriter fw2 = new FileWriter( "C:/refo/Lecturas.D"); //Archivo a crear
	PrintWriter salArch = new PrintWriter(fw2); //Archivo al cual se le va escribir
 
//Se hara un for anidado, el pimer FOR para recorrer el arreglo en donde tenemos los numeros ya acomodados del menor al mayor
//y el segundo FOR para ir buscando el reglon que cumpla con el patron del numero
 
			for(i=1; i<arreglo.length; ++i)//Primer for para recorrer el arreglo de los numero ordenados
			{
				for(int index=0; index<arreglo.length; ++index)//Segundo for para recorrer el arreglo donde se guardo todo el renglon completo
				{
                                        //Pregunto que si en el primer renglon que se encuentra guardado dentro de mi arreglo pala. En ese renglon en el que estoy ahorita
                                        //hay una coincidencia con el numero que se esta guardado dentro del arreglo si no existe ese patron la funcion indexOf regresa un -1
                                        //ejemplo en mi renglo pala recordemos que tengo todas las lineas del archivo y en mi arreglo tengo todos los numeros ordenados
                                       // del menor al mayor:
                                       //pala
                                       //pos 0 -  01254152634152   2312    085465200012   FDDG4152
                                       //pos 1 -  05432105454321   15513  084527203321   NBN1321N
                                       //pos 2 -  46543131215465   12        094552254515   GFDG121F
                                       //pos 3 -  46546532154514    01       184543254855   DFG223D2
                                       //pos 4 - .
                                       //pos 5 - .
                                       //pos 6 - .
                                        asi hasta 131 lineas
 
                                        // y en mi arreglo los numero obtenidos anteriormente
                                       //pos 0 -  084527
                                       //pos 1 -  085465
                                       //pos 2 -  094552
                                       //pos 3 -  184543
                                       //pos 4 - .
                                       //pos 5 - .
                                       //pos 6 - .
                                                                     //esta es la posicion 0                                                                                                     //posicion 0
                                      //if(pala[01254152634152   2312    085465200012   FDDG4152] hay una coincidencia con este numero arreglo[084527] )
                                      //si no la hubo busca en el siguiente reglon (si no es diferente de -1)
 
                                       //                                //esta es la posicion 1                                                                                                     //posicion 0
                                      //if(pala[05432105454321   15513  084527203321   NBN1321N] hay una coincidencia con este numero arreglo[084527] )
                                      //En este caso si hubo una coincidencia y se cumple la condicion porque no se regresa -1 sino 0 y por lo tanto este es el renglon mas chico
                                      //de todos y terminamos con este FOR para aumentar la posicion en el arreglo y se vuelve otra vez arrecorrer el arreglo pala para buscar la
                                      //proxima coincidencia
					if(pala[index].indexOf(String.valueOf(arreglo[i])) != -1)
					{
						//Se guarda exactamente el renglon que si cumplio con la condicion
 
						salArch.println(pala[index]);
						//System.out.println(pala[index]);
						cont++;
						break;
					}
				}
			}
			System.out.println(i+" cont: "+cont);//PAra saber cuantas veces se cumplio la condicion (cont) y la i para saber corraborar que si se dio las 131 bueltas
		} //MAnejo de cualquier tipo de excepcion
                catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
 

bueno el error esta en que cuando lo mando a imprimir en el archivo que yo creo no guarda todas las lineas sino 105 lineas y ya comprobe en consola
de que si se emprimen las 131 lineas pero en el archivo no y no entiendo porq alguien me podria decir en donde esta my error porq por mas que lo busco no
lo encuentro de ehco ahi se ve que hago una impresion a consola y en consola si salen todas las lineas (131 )y ordenadas del menor a mayor
pero como lo escribi antes en el archivo si se guardan las lineas del menor al mayor pero no las 131 lineas y ya revise que si se entra en la condicion 131 veces y si
entra ese numero de veces. No se si sea si despues de un rato el archivo se cierra solo autmaticamente o que es lo q pasa q solo pòne 105 lineas y no las
131 lineas que deben de ser.

PDT: NO acostumbro a documentar asi mi codigo solo lo hice para que se obtuviera una mejor comprencion de que es lo q estoy haciendo
y asi no haya con fuciones bueno eso espero jajajaja.


espero y puedan ayudarme ya que solo me falta resolver ese problemaa