Escribiendo y leyendo en un archivo de texto con java

Es un código simple escrito para ustedes, donde implemento las dos operaciones basica para este tipo de problemas, lectura y escritura de un archivo plano de texto (El resto de operaciones posibles se desprenden de estas), espero les sea de utilidad.

Aparte les dejo al final el proyecto hecho en Netbeans usando interface grafica.

Nota: En la ruta si usan Windows al igual que en Linux deben usar el "/".

Codigo de la clase Archivo:

//Autor: Rey Salcedo Padilla
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;

public class Archivo{

 public void escribir(String ruta, String cadena){
  File archivo = new File(ruta);
   try {
    FileWriter escribirArchivo = new FileWriter(archivo, true);
    BufferedWriter buffer = new BufferedWriter(escribirArchivo);
    buffer.write(cadena);
    buffer.newLine();
    buffer.close();
   }catch (Exception ex) {
   }
 }

 public String leer(String ruta) {
  ArrayList array = new ArrayList();
  String linea = "";
  String retornar = "";
  File archivo = new File(ruta);
  try {
   FileReader leerArchivo = new FileReader(archivo);
   BufferedReader buffer = new BufferedReader(leerArchivo);
   while ((linea = buffer.readLine()) != null){
    retornar += linea + "\n";
   }
   buffer.close();
   }catch (Exception ex){
   }
 return retornar;
 }            
}

//Autor:Rey
Salcedo Padilla
public class Main{
 public static void main(String []args){
  Archivo archivo = new Archivo();
  String ruta = "/home/rey/Escritorio/ArchivoDeTexto/hola.txt";
  
   archivo.escribir(ruta,"Todos obedecen con gusto cuando el que manda es justo.");
   archivo.escribir(ruta,"Los años dan enseñanzas que los dias no alcanzan a comprender.");
 
  System.out.println(archivo.leer(ruta));
 }
}

Comenta acerca del código.

Implementacion de pila y cola.

Tal vez le interese leer sobre listas enlazadas

Según lo que he aprendido, las pilas y colas no son estructura de datos, mas bien son formas de acceder a la información contenida en una estructura de dato como puede ser una lista o vector, entre otras.

Definiciones: 

Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. (por wikipedia).


Operaciones de la pila: Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las pilas se suelen añadir más de uso habitual.
Crear: se crea la pila vacía (size).
Apilar: se añade un elemento a la pila.(push)
Desapilar: se elimina el elemento frontal de la pila.(pop)
Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)
Vacía: devuelve cierto si la pila está vacía o falso en caso contrario (empty).

Una cola (también llamada fila) es una estructura de datos (no estoy deacuerdo), caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.(por wikipedia)


Operaciones Básicas de una Cola
Crear: se crea la cola vacía.
Encolar (añadir, entrar, insertar): se añade un elemento a la cola. Se añade al final de esta.
Desencolar (sacar, salir, eliminar): se elimina el elemento frontal de la cola, es decir, el primer elemento que entró.
Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primer elemento que entró.
Vacía: devuelve cierto si la pila está vacía o falso en caso contrario (empty).

Tal vez tambien te interese esto: Implementacion de una lista simple enlazada.


Mas informacion: Pila, cola.


 
Codigo Pila:

//Autor: Rey Salcedo Padilla
import java.util.ArrayList;
public class Pila extends ArrayList{
 
 //se añade un elemento a la pila.(push)
 public void apilar(Object dato){
  if(dato != null){
   this.add(dato);
  }else{
   System.out.println("Introduzca un dato no nulo");
  }  
 }
 
 //se elimina el elemento frontal de la pila.(pop)
 public void desapilar(){
  if(size() > 0){
   this.remove(this.size()-1);
  }
 }
 
 //devuelve el elemento que esta en la cima de la pila. (top o peek)
 public Object cima(){
  Object datoAuxiliar = null;
  if(this.size() > 0){
   datoAuxiliar = this.get(this.size()-1);
  }
  return datoAuxiliar;  
 }
 
 //devuelve cierto si la pila está vacía o falso en caso contrario (empty).
 public boolean vacia(){
  return this.isEmpty();
 }
}

//Autor:Rey Salcedo Padilla
import java.util.ArrayList;
public class Cola extends ArrayList{
 
 //se añade un elemento a la cola. Se añade al final de esta.
 public void encolar(Object dato){
  if(dato != null){
   this.add(dato);
  }else{
   System.out.println("Introduzca un dato no nulo");
  }  
 }

 //se elimina el elemento frontal de la cola, es decir, el primer elemento que entró.
 public void desencolar(){
  if(this.size() > 0){
   this.remove(0);
  }
 }
 
 //se devuelve el elemento frontal de la cola, es decir, el primer elemento que entró.
 public Object frente(){
  Object datoAuxiliar = null;
  if(this.size() > 0){
   datoAuxiliar = this.get(0);
  }
  return datoAuxiliar;  
 }
 
 //devuelve cierto si la pila está vacía o falso en caso contrario (empty).
 public boolean vacia(){
  return this.isEmpty();
 }
}

//Autor:Rey Salcedo Padilla
public class Main{
 public static void main(String []args){
  
  System.out.println("------Pila------");
  Pila pila = new Pila();
  pila.apilar("A");
  pila.apilar("B");
  pila.apilar("C");
  pila.apilar("D");
  
  System.out.println("Esta vacia la pila?:" + pila.vacia());
  System.out.println("Tamaño de la pila:" + pila.size());
  
  System.out.println(pila.cima());
  pila.desapilar();
  System.out.println(pila.cima());
  pila.desapilar();
  System.out.println(pila.cima());
  pila.desapilar();
  System.out.println(pila.cima());
  pila.desapilar();
  
  System.out.println("Esta vacia la pila?:" + pila.vacia());
    
  System.out.println("------Cola------");
  Cola cola = new Cola();
  cola.encolar("A");
  cola.encolar("B");
  cola.encolar("C");
  cola.encolar("D");
  
  System.out.println("Esta vacia la cola?:" + cola.vacia());
  System.out.println("Tamaño de la cola:" + cola.size());
  
  System.out.println(cola.frente());
  cola.desencolar();
  System.out.println(cola.frente());
  cola.desencolar();
  System.out.println(cola.frente());
  cola.desencolar();
  System.out.println(cola.frente());
  cola.desencolar();
  
  System.out.println("Esta vacia la cola?:" + cola.vacia());
 }
}

Invertir el contenido de un vector o arreglo:

Es un problema basico, pero veo que en muchas parte lo preguntan, asi que lo escribir, espero sea de utilidad.
Código:

//Autor: Rey Salcedo Padilla
public class InvertirVector{
 public static int []invertir(int []vector){
  int longitud = vector.length;
  
  /*creo un vector auxuliar con la misma longitud
  del vector a invertir*/
  int []vectorAuxiliar = new int[longitud];
  
  for(int i = 0; i < longitud; i++){
   /*la razon del - 1, es porque la posicion de un
    vector de n longitud (tamaño) es n - 1; ejemplo:
    la ultima posicion de un vector de longitud 5
    es 4
   */
   vectorAuxiliar[(longitud - 1) - i] = vector[i];
  }
  return vectorAuxiliar;
 }
  
 public static void imprimirVector(int []vector){
  for(int i = 0; i < vector.length; i++){
   System.out.print(vector[i] + ",");
  }
 }
 public static void main (String []args){
  int [] vector = {1,2,3,4,5,6,7,8,9};
  imprimirVector(vector);
  System.out.println();
  imprimirVector(invertir(vector));
 }
}

Comenta acerca del código.