crear un vector productos para registrar , reportar eliminar , mostrar productos de la categoria dada y reportar todos los productos


package proyectoproductos;



public class Productos{
 private String codigo;
 private String descripcion;
 private double precio;
 private int  stock;
 private String categoria;
 private static  final String  VEGETALES="VEGETALES";
 private static final String VERDURAS="VERDURAS";
 private static final String ENLATADOS="ENLATADOS";

    public Productos(String codigo, String decripcion, double precio, int stock, String categoria) {
        this.codigo = codigo;
        this.descripcion = decripcion;
        this.precio = precio;
        this.stock = stock;
        this.categoria = categoria;
    }


    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }

    public void setDescripcion(String descripcion) {
        this.descripcion = descripcion;
    }

    public void setPrecio(double precio) {
        this.precio = precio;
    }

    public void setStock(int  stock) {
        this.stock = stock;
    }

    public void setCategoria(String categoria) {
        this.categoria = categoria;
    }

    public String getCodigo() {
        return codigo;
    }

    public String getDescripcion() {
        return descripcion;
    }

    public double getPrecio() {
        return precio;
    }

    public int  getStock() {
        return stock;
    }

    public String getCategoria() {
        return categoria;
    }

    @Override
    public String toString() {
        return  "codigo=" + codigo + ", decripcion=" + descripcion + ", precio=" + precio + ", stock=" + stock + ", categoria=" + categoria ;
    }


}

PRINCIAPL
package proyectoproductos;



import java.util.Scanner;

/**
 *
 * @author Administrador
 */
public class ProyectoProductos {

   VectorProducto vectorProducto; 
static Scanner entrada=new Scanner(System.in);
   
    public static void main(String[] args) {
     Scanner entrada=new Scanner(System.in);
   
   int op;
  
    ProyectoProductos proyectoProductos =new ProyectoProductos();
    proyectoProductos.vectorProducto=new VectorProducto(100);
    do{
     
        System.out.println("MENU");
        System.out.println("1. Registrar los productos : ");
        System.out.println("2. Reportar los datos del producto:");
        System.out.println("3. Eliminar el producto de la lista:");
        System.out.println("4. Reportar los productos de la categoria:");
        System.out.println("5. reportar todos los productos:");
        System.out.println("6. SALIR:");
        System.out.println("ingrese opcion (1-6)");
        op=entrada.nextInt();
        switch(op){
            case 1: proyectoProductos.registrarProducto();
            break;
            case 2:proyectoProductos.buscarProducto();
            break;
            case 3: proyectoProductos.eliminarProducto();
            break;
            case 4:proyectoProductos.reportarProductosCategoria();
            break;
            case 5: proyectoProductos.mostrarProductos(proyectoProductos.vectorProducto);
            break;
                
        }
    }while(op!=6);
    }


   public void registrarProducto(){
      
      String codigo,descripcion,categoria;
      double precio;
      int stock;
      Productos j;
       System.out.println("codigo:");
       codigo=entrada.next();
       System.out.println("Descripcion:");
       descripcion=entrada.next();
       System.out.println(" STOCK :");
       stock=entrada.nextInt();
       System.out.println("Categoria:");
       categoria=entrada.next();
       System.out.println(" Precio :");
       precio=entrada.nextDouble();
       j=new Productos (codigo,descripcion,precio,stock,categoria);
       vectorProducto.agregar(j);
     

   } 

public void buscarProducto(){
  
   String codigo;
   int indice;
   Productos j;
    System.out.println(" ingrese codigo del producto a buscar:");
    codigo=entrada.nextLine();
    indice=vectorProducto.buscar(codigo);
    if(indice!=-1){
        j=vectorProducto.getProducto(indice);
        System.out.println(j);
    }
    else
        System.out.println("No esta el producto");
    }

public void eliminarProducto(){
 Scanner entrada=new Scanner(System.in); 
 String codigo;
  int indice;
  Productos j;
    System.out.println("ingrese codigo del producto a eliminar :");
    codigo=entrada.nextLine();
    indice=vectorProducto.buscar(codigo);
    if(indice !=-1){
        j=vectorProducto.getProducto(indice);
        vectorProducto.eliminar(indice);
        System.out.println("producto eliminado."+j);
    }
else
        System.out.println("el codigo no esta en la lista:");
}

public void mostrarProductos(VectorProducto productos){
    Productos producto ;
    int i;
    for(i=0;i<productos.getTotalElementos();i++){
        producto=vectorProducto.getProducto(i);
    System.out.println(producto);
    }
}

public void reportarProductosCategoria(){
String categoria;

System.out.println("ingrese categoria a buscar :");
categoria=entrada.next();

    VectorProducto producto=vectorProducto.obtenerProducto(categoria);
    mostrarProductos(producto);
    

}
}

VECTOR


/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package proyectoproductos;

/**
 *
 * @author Administrador
 */
public class VectorProducto {
 private Productos[] productos;
 private int totalElementos;

 public VectorProducto() {
 productos = new Productos[12];
 totalElementos = 0;
 }
  public VectorProducto(int limite) {
 productos = new Productos[limite];
 totalElementos = 0;
 }

 public void agregar(Productos producto){
   if(totalElementos<productos.length) {
      productos [totalElementos] = producto;
      totalElementos++;
   }
 } 
  public int buscar (String codigo){
     int i;
      for(i=0;i<totalElementos;i++){
          if(productos[i].getCodigo().equals(codigo))
       return i;       

  } 
  return -1;
}
public boolean eliminar(int indice){
    if(indice>= 0 && indice<totalElementos){
        for(int i=indice; i<totalElementos-1;i++)
            productos[i]=productos[i+1];
        totalElementos--;
        return true;
    }
    else
        return false;
    
}
public VectorProducto obtenerProducto(String producto)
{
    VectorProducto categoria=new VectorProducto(productos.length);
    for(int i=0;i<totalElementos;i++){
        if(productos[i].getCategoria().equals(producto))
            categoria.agregar(productos[i]);
    }
    return categoria;
}

public Productos getProducto(int indice){
    return productos[indice];
}
public int getTotalElementos(){
 return totalElementos;
 }

        
}
Share:

crear un vector profesor donde agrege , muestre la edad promedio del grupo , profesor mas joven , profesores mayores al promedio

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package proyectoprofesor;

/**
 *
 * @author Administrador
 */
public class Profesor {
   private String nombre;
   private String sexo;
   private int edad;

    public Profesor() {
    }

    public Profesor(String nombre, String sexo, int edad) {
        this.nombre = nombre;
        this.sexo = sexo;
        this.edad = edad;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getSexo() {
        return sexo;
    }

    public void setSexo(String sexo) {
        this.sexo = sexo;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }

    @Override
    public String toString() {
        return "Profesor{" + "nombre=" + nombre + ", sexo=" + sexo + ", edad=" + edad + '}';
    }
 
 

}

PRINCIPAL
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package proyectoprofesor;

import java.util.Scanner;

/**
 *
 * @author Administrador
 */
public class ProyectoProfesor {

   static Scanner sc=new Scanner (System.in);
   VectorProfesor vectorProfesor;
   Profesor profesor;
   String nombre;
   String sexo;
   int edad;
   public void registrarPorfesores(){
       System.out.println("NOMBRE ");
       nombre=sc.next();
       System.out.println("SEXO (masculino / femenino)");
       sexo=sc.next();
       System.out.println("EDAD ");
       edad=sc.nextInt();
       profesor=new Profesor(nombre,sexo,edad);
       vectorProfesor.agregar(profesor);
   }
   
   public void mostrarDatos(VectorProfesor a){
       for(int i=0;i<a.getTotalElementos();i++){
           profesor=vectorProfesor.getProfesor(i);
           System.out.println(profesor);
       }
   }
  
   public void numeroProfesoresMayorPromedio(){
       System.out.println("NUMERO DE PROFESOREES ES "+vectorProfesor.profesorMasMayor());
   }
     public void numeroProfesoresMenorPromedio(){
      System.out.println("NUMERO DE PROFESOREES ES "+vectorProfesor.profesorMasJoven());
   }
     public void nombreMasJoven(){
         Profesor a=vectorProfesor.profesorMasJoven();
         
         System.out.println("El profesor mas joven  es: "+a);
         
       
        
     }
       public void nombreMasMayor(){
          Profesor a=vectorProfesor.profesorMasMayor();
          System.out.println("PROFESOR MAS MAYOR ES "+a);
        
       }
     
       
     
  
    public static void main(String[] args) {
        ProyectoProfesor profe=new ProyectoProfesor();
        profe.vectorProfesor=new VectorProfesor();
        int opcion;
        do{
            System.out.println("MENU PRINCIPAL");
            System.out.println("1.AGREGAR DOCENTE ");
            System.out.println("2.EDAD PROMEDIO DEL GRUPO");
            System.out.println("3.PROFESOR MAS JOVEN ");
            System.out.println("4.PROFESOR MAS MAYOR");
            System.out.println("5.NUMERO DE PROFESORES MAYORES AL PROMEDIO");
            System.out.println("6.NUMERO DE PROFESORES MENORES AL PROMEDIO");
            System.out.println("7.SALIR");
             opcion=sc.nextInt();
            switch(opcion){
           
                case 1:profe.registrarPorfesores();break;
                case 2:System.out.print("\n"+profe.vectorProfesor.Promedio());break;
                case 3:profe.nombreMasJoven();break;
                case 4:profe.nombreMasMayor();break;
                case 5:System.out.println("profesor mayor al promedio "+profe.vectorProfesor.profesoresMayoresPromedio());break;
                case 6:System.out.println("profesor menor al promedio "+profe.vectorProfesor.profesoresMenoresPromedio());break;
                
                    
            }
        }while(opcion!=7);
   
     
    }
    
}

VECTOR
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package proyectoprofesor;

import com.sun.corba.se.impl.oa.toa.TOA;

/**
 *
 * @author Administrador
 */
public class VectorProfesor {
    
    private Profesor[] profesores;
    private int totalElementos;
    
    public VectorProfesor(){
      profesores=new Profesor[8];
      totalElementos=0;
         
    }

  public VectorProfesor(int limite){
      profesores = new Profesor[limite];
      totalElementos++;
  } 
  public void agregar(Profesor profesor){
     
 if(totalElementos < profesores.length){
 profesores[totalElementos] = profesor;
 totalElementos++;
 } 
  }

 public int Promedio(){
     int suma=0;
     for(int i=0;i<totalElementos;i++){
         suma+=profesores[i].getEdad();
     }
     int promedio=suma/totalElementos;
     return promedio;
 }
 public Profesor  profesorMasJoven(){
    
     int a=profesores[0].getEdad();
     int p=0;
     for(int i=0;i<totalElementos;i++){
         if(profesores[i].getEdad()<a){
           p=i;
         }
     }
     return profesores[p];
 }
 public Profesor  profesorMasMayor(){
    
     int a=profesores[0].getEdad();
     int p=0;
     for(int i=0;i<totalElementos;i++){
         if(profesores[i].getEdad()>a){
           
           p=i;
         }
     }
     return profesores[p];
 }

 public int profesoresMayoresPromedio(){
     int j=0;
     for(int i=0;i<totalElementos;i++){
         if(profesores[i].getEdad()>=Promedio())
             j++;
     }
     return j;
 }
  public int profesoresMenoresPromedio(){
     int j=0;
     for(int i=0;i<totalElementos;i++){
         if(profesores[i].getEdad()<=Promedio())
             j++;
     }
     return j;
 }
  public Profesor getProfesor(int limite){
      return profesores[limite];
  }
  public int getTotalElementos(){
      return totalElementos;
  }

}




Share:

crear un vector alumno donde puede agregar eliminar , reportar por carrera , tambien mostrar aprobados y desaprobados

package proyectoAlumno;

public class Alumno {
    private String codigo;
    private String apellidos;
    private String nombre;
    private String carrera;
    private String ciclo;
    private double promedio;

    public Alumno(String codigo, String apellidos, String nombre, String carrera, String ciclo, double promedio) {
        this.codigo = codigo;
        this.apellidos = apellidos;
        this.nombre = nombre;
        this.carrera = carrera;
        this.ciclo = ciclo;
        this.promedio = promedio;
    }

    public String getCodigo() {
        return codigo;
    }

    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }

    public String getApellidos() {
        return apellidos;
    }

    public void setApellidos(String apellidos) {
        this.apellidos = apellidos;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getCarrera() {
        return carrera;
    }

    public void setCarrera(String carrera) {
        this.carrera = carrera;
    }

    public String getCiclo() {
        return ciclo;
    }

    public void setCiclo(String ciclo) {
        this.ciclo = ciclo;
    }

    public double getPromedio() {
        return promedio;
    }

    public void setPromedio(double promedio) {
        this.promedio = promedio;
    }
    
    public String toString(){
        return "CODIGO "+codigo+"\nAPELLIDOS "+apellidos+"\nNOMBRES "+nombre
                +"\nCARRERA "+carrera+"\nCICLO "+ciclo+"\nPROMEDIO "+promedio;
    }
    
}


PRICIPAL

package proyectoAlumno;

import java.util.Scanner;
public class ProyectoAlumno {
    Alumno alumno;
   VectorAlumno vectorAlumno;
    static Scanner sc=new Scanner(System.in);
String codigo;
String apellidos;
String nombre;
String carrera;
String ciclo;
double promedio;
int indice;

   public void agregarAlumno(){
        System.out.println("CODIGO ");
        codigo=sc.next();
        System.out.println("APELLIDOS ");
        apellidos=sc.next();
        System.out.println("NOMBRES ");
        nombre=sc.next();
        System.out.println("CARRERA ");
        carrera=sc.next();
        System.out.println("CICLO ");
        ciclo=sc.next();
        System.out.println("PROMEDIO ");
        promedio=sc.nextDouble();
        alumno=new Alumno(codigo, apellidos, nombre, carrera, ciclo, promedio);
        vectorAlumno.agregar(alumno);
               
    }  
   public void eliminarAlumno(){
       System.out.println("CODIGO DEL ALUMNO A ELIMINAR ");
       codigo=sc.next();
       indice=vectorAlumno.buscar(codigo);
       if(indice!=-1){
           alumno=vectorAlumno.getAlumno(indice);
           vectorAlumno.eliminar(indice);
           System.out.println("Alumno eliminado "+alumno);
       }else {
           System.out.println("Codigo no se encontro en el registro ");
       }
   }
   
   public void mostrarAlumnos(VectorAlumno alumnos){
       for(int i=0;i<alumnos.getTotalELementos();i++){
           alumno=alumnos.getAlumno(i);
           System.out.println(alumno);
           
       }
   }
   public void alumnoAprobado(){
   
       mostrarAlumnos(vectorAlumno.alumnosAprobados());
   }
   public void alumnoDesaprobado(){
     
       mostrarAlumnos(vectorAlumno.alumnosDesaprobados());
   }
   public void mostrarCarrera(){
       System.out.println("Ingrese carrera ");
       carrera=sc.next();
       mostrarAlumnos(vectorAlumno.reporteCarrera(carrera));
   }
   public static  int opcion(){
        System.out.println("MENU PRINCIPAL ");
        System.out.println("1.agregar Alumno");
        System.out.println("2.Eliminar alumno ");
        System.out.println("3.reportar alumno por carrera");
        System.out.println("4.Alumnos aprobados");
        System.out.println("5.Alumnos desaprobados");
        System.out.println("6.Reportar alumnos");
        System.out.println("7.Salir");
        int opcion=sc.nextInt();
        return opcion;
    }
   
    public static void main(String[] args) {
        ProyectoAlumno a=new ProyectoAlumno();
        a.vectorAlumno=new VectorAlumno();
      int opcion; 
      do{
          opcion=opcion();
          switch(opcion){
              case 1:a.agregarAlumno();break;
              case 2:a.eliminarAlumno();break;
              case 3:a.mostrarCarrera();break;
              case 4:a.alumnoAprobado();break;
              case 5:a.alumnoDesaprobado();break;
              case 6:a.mostrarAlumnos(a.vectorAlumno);break;  
          }
      }while(opcion!=7);
    }
  
}
VECTOR ALUMNO



package proyectoAlumno;
public class VectorAlumno {
    private Alumno[]alumno;
    private int totalElementos;

    public VectorAlumno() {
        alumno=new Alumno[5];
        totalElementos=0;
    }

   public VectorAlumno(int limite){
       alumno=new Alumno[limite];
       totalElementos++;
   }
   
    public boolean agregar(Alumno alumnos){
        if(totalElementos<alumno.length){
           alumno[totalElementos]=alumnos;
            totalElementos++;
            return true;
        }else
            return false;
    }
    public int buscar(String codigo){
        for(int i=0;i<totalElementos;i++){
            if(alumno[i].getCodigo().equals(codigo))
                return i;
        }
        return -1;
    }
    
    public boolean eliminar(int indice){
        if(indice>0 && indice<totalElementos){
            for(int i=0;i<totalElementos;i++)
                alumno[i]=alumno[i+1];
                totalElementos=totalElementos-1;
                return true;
        }else
            return false;
    }
   
    public VectorAlumno alumnosAprobados(){
        VectorAlumno aprobado=new VectorAlumno(alumno.length);
       for(int i=0;i<totalElementos;i++){
           if(alumno[i].getPromedio()>=10.5)
               aprobado.agregar(alumno[i]);
       } 
       return aprobado;
    }
    
    
      public VectorAlumno alumnosDesaprobados(){
        VectorAlumno desaprobado=new VectorAlumno(alumno.length);
       for(int i=0;i<totalElementos;i++){
           if(alumno[i].getPromedio()<10.5)
               desaprobado.agregar(alumno[i]);
       } 
       return desaprobado;
    }
      
     
      public VectorAlumno reporteCarrera(String carrera){
          VectorAlumno AlumnoCarrera=new VectorAlumno();
          for(int i=0;i<totalElementos;i++){
              if(alumno[i].getCarrera().equalsIgnoreCase(carrera))
                  AlumnoCarrera.agregar(alumno[i]);
          }
          return AlumnoCarrera;
      }
      
    public Alumno getAlumno(int indice){
        return alumno[indice];
    }
    public int getTotalELementos(){
        return totalElementos;
    }
}
Share:

Ingresar n números en un vector y mostrar luego, primero la lista de los números pares que fueron ingresados y luego la lista de los números negativos.


//clase vectore negativos
package proyectoparesnegativos;
public class VectorEnteros {
 private int vector[];
 private int totalElementos;

 public VectorEnteros(int limite){
 vector = new int[limite];
 totalElementos = 0;
 }

 public int obtenerLimite() {
 return vector.length;
 }

 public boolean agregar(int valor){
 if(totalElementos < vector.length){
 vector[totalElementos] = valor;
 totalElementos++;
 return true;
 }
 else
 return false;
 }

 public double devolverElemento(int indice){
 return vector[indice];
 }
 public int getTotalElementos() {
 return totalElementos;
 }

 public VectorEnteros devolverPares(){
 VectorEnteros pares = new VectorEnteros(vector.length);
 for(int i = 0; i < totalElementos; i++){
 if(vector[i] % 2 == 0)
 pares.agregar(vector[i]);
 }
 return pares;
 }

 ///clase principal
 public VectorEnteros devolverNegativos(){
     VectorEnteros negativos = new VectorEnteros(vector.length);
 for(int i = 0; i < totalElementos; i++){
 if(vector[i] < 0)
 negativos.agregar(vector[i]);
 }
 return negativos;
 }

}
///proyectonegativos
package proyectoparesnegativos;
import java.util.Scanner;
public class ProyectoParesNegativos {

 public static void main(String[] args) {
 VectorEnteros vectorEnteros = crearVectorEnteros();
 ingresarVector(vectorEnteros);
 VectorEnteros vectorPares = vectorEnteros.devolverPares();
 System.out.println("Numeros Pares ");
 imprimirVector(vectorPares);
 VectorEnteros vectorNegativos = vectorEnteros.devolverNegativos();
 System.out.println("Numeros Negativos ");
 imprimirVector(vectorNegativos);
 }
 public static void imprimirVector(VectorEnteros vectorEnteros) {
 for(int i = 0; i < vectorEnteros.getTotalElementos(); i++)
 System.out.println(vectorEnteros.devolverElemento(i));
 }
 public static void ingresarVector(VectorEnteros vectorEnteros) {
 int valor;
 Scanner entrada = new Scanner(System.in);
 for(int i = 0; i < vectorEnteros.obtenerLimite(); i++){
 System.out.print("VectorEnteros[ " + (i+1) + " ] = ");
 valor = entrada.nextInt();
 vectorEnteros.agregar(valor);
 }
 }
 public static VectorEnteros crearVectorEnteros() {
 Scanner entrada = new Scanner(System.in);
 System.out.print("Numero de elementos del Vector: ");

 int limite = entrada.nextInt();
 return new VectorEnteros(limite);
 }

}
Share:

Crear un Vector de números reales y un método para calcular el producto escalar de ellos

package proyectoproductoescalar;
public class VectorReales {
 private double numeros[];
 private int totalElementos;

 public VectorReales(){
 numeros = new double[10];
 totalElementos = 0;
 }

 public int obtenerLimite(){
 return numeros.length;
 }

 public boolean agregar(double valor){
 if(totalElementos < numeros.length){
 numeros[totalElementos] = valor;
 totalElementos++;
 return true;
 }
 else
 return false;
 }

 public double calcularProductoEscalar(VectorReales vector){
 int i;
 double productoEscalar = 0;
 for(i = 0; i < totalElementos; i++)
 productoEscalar += numeros[i] * vector.numeros[i];
 return productoEscalar;
 }

}
package proyectoproductoescalar;
import java.util.Scanner;
public class ProyectoProductoEscalar {
 public static void main(String[] args) {
 System.out.println("Primer Vector");
 VectorReales vector1 = crearVector();
 System.out.println("Segundo Vector");
 VectorReales vector2 = crearVector();
 double productoEscalar = vector1.calcularProductoEscalar(vector2);
 System.out.println("El producto escalar es: " + productoEscalar);
 }
 public static VectorReales crearVector() {
 double valor;
 Scanner entrada = new Scanner(System.in);
 VectorReales vectorReales = new VectorReales();
 for(int i = 0; i < vectorReales.obtenerLimite(); i++){
 System.out.print("numero" + (i+1) + ": ");
 valor = entrada.nextDouble();
 vectorReales.agregar(valor);
 }
 return vectorReales;
 }

}
Share:

Crear clase VectorNumeros que tenga como atributos un arreglo unidimensional de números reales y el número de elementos ingresados.

package proyectovectornumeros;
public class VectorNumeros {
 private double vector[];
 private int totalElementos;

 public VectorNumeros(){
 vector = new double[10];
 totalElementos = 0;
 }

 public VectorNumeros(int limite){
 vector = new double[limite];
 totalElementos = 0;
 }

 public int obtenerLimite() {
 return vector.length;
 }

 public boolean agregar(double valor){
 if(totalElementos < vector.length){
 vector[totalElementos] = valor;
 totalElementos++;
 return true;
 }
 else
 return false;
 }

 public double obtenerMayor() {
 int i;
 double mayor;
 mayor = vector[0];
 for(i = 0; i < totalElementos; i++)
 if(vector[i] > mayor)
 mayor = vector[i];
 return mayor;
 }
 public double obtenerMenor() {
 int i;
 double menor;
 menor = vector[0];
 for(i = 0; i < totalElementos; i++)
 if(vector[i] < menor)
 menor = vector[i];
 return menor;
 }
 public double calcularPromedio() {
 int i;
 double suma = 0;
 for(i = 0; i < totalElementos; i++)
 suma += vector[i];
 return suma / totalElementos;
 }

 public double desviacionEstandar() {
 int i;
 double promedio, suma;
 promedio = calcularPromedio();
 suma = 0;
 for(i = 0; i < totalElementos; i++)
 suma += Math.pow(vector[i] - promedio, 2);
 return Math.sqrt(suma / (totalElementos - 1));
 }
}
package proyectovectornumeros;
import java.util.Scanner;
public class ProyectoVectorNumeros {
 public static void main(String[] args) {
 VectorNumeros vectorNumeros = crearVectorNumeros();
 ingresarVector(vectorNumeros);
 imprimirVector(vectorNumeros);
 }
 public static void imprimirVector(VectorNumeros vectorNumeros) {
 System.out.println("El mayor es: " + vectorNumeros.obtenerMayor());
 System.out.println("El menor es: " + vectorNumeros.obtenerMenor());
 System.out.println("El promedio es: " + vectorNumeros.calcularPromedio());
 System.out.println("La desviación estandar es: " + vectorNumeros.desviacionEstandar());
 }
 public static void ingresarVector(VectorNumeros vectorNumeros) {
 double valor;
 int i;
 Scanner entrada = new Scanner(System.in);
 for(i = 0; i < vectorNumeros.obtenerLimite(); i++){
 System.out.print("VectorNumeros[ " + (i+1) + " ] = ");
 valor = entrada.nextDouble();
 vectorNumeros.agregar(valor);
 }
 }
 public static VectorNumeros crearVectorNumeros() {
 int totalElementos;
 Scanner entrada = new Scanner(System.in);
 System.out.print("Numero de elementos: ");
 totalElementos = entrada.nextInt();
 return new VectorNumeros(totalElementos);
 }

}

Share:

Crear la clase VectorReales que tenga como atributos un arreglo unidimensional y el número de elementos que se ingresan

  package proyectovectorreales;
public class VectorReales {
 private double vector[];
 private int totalElementos;

 public VectorReales(){
 vector = new double[10];
 totalElementos = 0;

 }

 public VectorReales(int limite){
 vector = new double[limite];
 totalElementos = 0;
 }

 public boolean agregar(double valor){
 if(totalElementos < vector.length){
 vector[totalElementos] = valor;
 totalElementos++;
 return true;
 }
 else
 return false;
 }

 public int buscar(double valor){
 int i;
 for(i = 0; i < totalElementos; i++){
 if(vector[i] == valor)
 return i;
 }
 return -1;
 }

 public boolean modificar(int indice, double nuevo){
 if(indice >= 0 && indice < totalElementos){
 vector[indice] = nuevo;
 return true;
 }
 else
 return false;
 }

 public boolean eliminar(int indice){
 if(indice >= 0 && indice < totalElementos){
 int i;
 for(i = indice; i < totalElementos-1; i++)
 vector[i] = vector[i+1];
 totalElementos--;
 return true;
 }
 else
 return false;
 }

 public boolean insertar(int indice, double valor){
 if(totalElementos < vector.length && indice >= 0 && indice <= totalElementos){
 int i;
 for(i = totalElementos-1; i >= indice; i--)
 vector[i+1] = vector[i];
 vector[indice] = valor;
 totalElementos++;
 return true;
 }
 else
 return false;
 }

 public void ordenAscendente(){
 int i, j;
 double temp;
 for(i = 0; i < totalElementos-1; i++)
 for(j = i+1; j < totalElementos; j++)
 if(vector[i] > vector[j]){
 temp = vector[i];
 vector[i] = vector[j];
 vector[j] = temp;
 }
 }

 public void ordenDescendente(){
 int i, j;
 double temp;
 for(i = 0 ; i < totalElementos-1; i++)
 for(j = i+1; j < totalElementos; j++)
 if(vector[i] < vector[j]){
 temp = vector[i];
 vector[i] = vector[j];
 vector[j] = temp;
 }
 }

 public double devolverElemento(int indice){
 return vector[indice];
 }

 public int getTotalElementos(){
 return totalElementos;
 }


}

package proyectovectorreales;
import java.util.Scanner;
public class ProyectoVectorReales {

 public static void main(String[] args) {
 menuVectorReales();
 }

 public static void menuVectorReales() {
 VectorReales vectorReales = new VectorReales();
 int opcion;
 do {
 opcion = pedirOpcion();
 switch(opcion){
 case 1:
 agregarValor(vectorReales);
 break;
 case 2:
 buscarValor(vectorReales);
 break;
 case 3:
 modificarValor(vectorReales);
 break;
 case 4:
 eliminarValor(vectorReales);
 break;
 case 5:
 insertarValor(vectorReales);
 break;
 case 6:
 mostrarValores(vectorReales);
 break;
 case 7:
 vectorReales.ordenAscendente();
 break;
 case 8:
 vectorReales.ordenDescendente();
 break;
 }
 } while(opcion != 9);
 }

 public static void mostrarValores(VectorReales vectorReales) {
 System.out.println("Elementos del vector");
 for(int i = 0; i < vectorReales.getTotalElementos(); i++)
 System.out.println(vectorReales.devolverElemento(i));
 }
 public static void insertarValor(VectorReales vectorReales) {
 double valor;
 int indice;
 Scanner entrada = new Scanner(System.in);
 System.out.print("Valor a insertar: ");
 valor = entrada.nextDouble();
 System.out.print("Posicion donde desea insertar: ");
 indice = entrada.nextInt();
 if(vectorReales.insertar(indice, valor))
 System.out.println("Dato insertado");
 else
 System.out.println("No se puede insertar");
 }
 public static void eliminarValor(VectorReales vectorReales) {
 double valor;
 int indice;
 Scanner entrada = new Scanner(System.in);
 System.out.print("Valor a eliminar: ");
 valor = entrada.nextDouble();
 indice = vectorReales.buscar(valor);
 if(indice != -1){
 vectorReales.eliminar(indice);
 System.out.println("Dato eliminado");
 }
 else
 System.out.println("Dato no se encuentra");
 }
 public static void modificarValor(VectorReales vectorReales) {
 double valor;
 int indice;
 Scanner entrada = new Scanner(System.in);
 System.out.print("Valor a modificar: ");
 valor = entrada.nextDouble();
 indice = vectorReales.buscar(valor);
 if(indice != -1){
 System.out.print("Nuevo elemento ");
 vectorReales.modificar(indice, entrada.nextDouble());

 }
 else
 System.out.println("Dato no se encuentra");
 }
 public static void buscarValor(VectorReales vectorReales) {
 double valor;
 int indice;
 Scanner entrada = new Scanner(System.in);
 System.out.print("Valor a buscar: ");
 valor = entrada.nextDouble();
 indice = vectorReales.buscar(valor);
 if(indice != -1)
 System.out.println("Dato se encuentra en posicion " + indice);
 else
 System.out.println("Dato no se encuentra");
 }
 public static void agregarValor(VectorReales vectorReales) {
 double valor;
 Scanner entrada = new Scanner(System.in);
 System.out.print("Ingrese valor: ");
 valor = entrada.nextDouble();
 if( !vectorReales.agregar(valor) )
 System.out.println("El arreglo esta lleno");
 }
 public static int pedirOpcion() {
 int opcion;
 Scanner entrada = new Scanner(System.in);
 System.out.println("Vector de Reales");
 System.out.println("[1] Agregar");
 System.out.println("[2] buscar");
 System.out.println("[3] modificar elemento");
 System.out.println("[4] Eliminar elemento");
 System.out.println("[5] Insertar Elemento");
 System.out.println("[6] Mostrar elementos");
 System.out.println("[7] Ordenar Ascendentemente");
 System.out.println("[8] Ordenar Descendentemente");
 System.out.println("[9] Salir");
 System.out.print("Ingrese opcion (1-5): ");
 opcion = entrada.nextInt();
 return opcion;
 }

}
Share:

Crear un vector para trabajadores don pueda agregar mostrar por el sueldo y ordenads por el nombre

package proyectrabajador3;

import java.util.Scanner;

public class ProyectoTrabajador3 {

    VectorTrabajador vectorTrabajador;
    static ProyectoTrabajador3 proyectoTrabajador = new ProyectoTrabajador3();
    static Scanner entrada = new Scanner(System.in);

    public static void menuPrincipal() {
        int op;
        do {
            System.out.println("MENU PRINCIPAL");
            System.out.println("1: Agregar trabajadores");
            System.out.println("2: Ingresar un codigo y mostrar todos sus datos");
            System.out.println("3: Mostrar los trabajadores ordenados por nombre");
            System.out.println("4: Mostrar los trabajadores por sueldo");
            System.out.println("5: Salir");
            System.out.println("Ingrese opcion");
            op = entrada.nextInt();
            switch (op) {
                case 1:
                    proyectoTrabajador.ingresoDeDatos();
                    break;
                case 2:
                    proyectoTrabajador.buscarTrabajador();
                    break;
                case 3:
                    proyectoTrabajador.vectorTrabajador.ordenarNombre();
                    System.out.println("Datos por orden de alfabetico:");
                    proyectoTrabajador.mostrarVector();
                    break;
                case 4:
                    proyectoTrabajador.vectorTrabajador.ordenarSueldo();
                    System.out.println("Datos por orden de sueldo:");
                    proyectoTrabajador.mostrarVector();
                    break;
                default:
                    System.out.println("Saliendo del programa");
            }

        } while (op != 5);
    }

    public static void main(String[] args) {

        menuPrincipal();
    }

    public void ingresoDeDatos() {
        int limite;
        String codigo;
        String nombre;
        double valorHora;
        int horasTraba;

        System.out.println(" Numero De trabajadores:");
        limite = entrada.nextInt();
        vectorTrabajador = new VectorTrabajador(limite);
        for (int i = 0; i < limite; i++) {
            System.out.println("Alumno " + (i + 1));
            System.out.println("igrese codigo:");
            codigo = entrada.next();
            System.out.print("Nombre: ");
            nombre = entrada.next();
            System.out.print("valor por Hora: ");
            valorHora = entrada.nextDouble();
            System.out.println(" horas trabajadas:");
            horasTraba = entrada.nextInt();
            Trabajador trabajador = new Trabajador(codigo, nombre, valorHora, horasTraba);
            vectorTrabajador.agregar(trabajador);
        }
    }

    public void buscarTrabajador() {
        String codigo;
        int indice;
        Trabajador j;
        System.out.println(" ingrese codigo del trabajador a buscar:");
        codigo = entrada.next();
        indice = vectorTrabajador.buscarCodigo(codigo);
        if (indice != -1) {
            j = vectorTrabajador.getTrabajador(indice);
            System.out.println(j);
        } else {
            System.out.println("codigo no encontrado");
        }
    }

    public void mostrarVector() {
        Trabajador trabajador;
        for (int i = 0; i < vectorTrabajador.getTotalELementos(); i++) {
            trabajador = vectorTrabajador.getTrabajador(i);
            System.out.println(trabajador.getNombre() + "," + trabajador.getSueldo());
        }
    }
}

CLASE

package proyectrabajador3;


public class Trabajador {
    private String codigo;
    private String nombre;
    private double valorHora;
    private int horasTraba;

    public Trabajador() {
    }

    public Trabajador(String codigo, String nombre, double valorHora, int horasTraba) {
        this.codigo = codigo;
        this.nombre = nombre;
        this.valorHora = valorHora;
        this.horasTraba = horasTraba;
    }
    
    public void setCodigo(String codigo){
        this.codigo=codigo;
    }
    public String getCodigo(){
        return codigo;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public double getValorHora() {
        return valorHora;
    }

    public void setValorHora(double valorHora) {
        this.valorHora = valorHora;
    }

    public int getHorasTraba() {
        return horasTraba;
    }

    public void setHorasTraba(int horasTraba) {
        this.horasTraba = horasTraba;
    }
    public double sueldo(){
        return horasTraba*valorHora;
    }
    public double getSueldo(){
        return sueldo();
    }

    public String toString(){
        return "NOMBRE "+nombre+"CODIGO "+codigo+"SUELDO "+sueldo();
    }
    
}
VECTOR

package proyectrabajador3;

public class VectorTrabajador {
     private Trabajador []trabajadors;
    private int totalElementos;
public VectorTrabajador(int limite){
    trabajadors=new Trabajador[limite];
    totalElementos=0;
}
   public Trabajador getTrabajador(int valor){
        return trabajadors[valor];
    }
    public int getTotalELementos(){
        return totalElementos;
    }
    
    public boolean agregar(Trabajador producto){
        if(totalElementos<trabajadors.length){
          trabajadors[totalElementos]=producto;
            totalElementos++;
            return true;
        }else
            return false;
    }
    public int buscarCodigo(String codigo){
        for(int i=0;i<totalElementos;i++){
            if(trabajadors[i].getCodigo().equals(codigo))
                return i;
        }
        return -1;
    }
    
    public void ordenarNombre(){
        Trabajador ordenar;
        int i,j;
        for(i=0;i<totalElementos-1;i++ ){
            for(j=i+1;j<totalElementos;j++){
                if(trabajadors[i].getNombre().compareTo(trabajadors[j].getNombre())>0)
                {
                    ordenar =trabajadors[i];
                trabajadors[i]=trabajadors[j];
               trabajadors[j]=ordenar;
            }}
            }
        
    }
    public void ordenarSueldo(){
  Trabajador ordenar;
 double mayo=trabajadors[0].sueldo();
        int i,j;
        for(i=0;i<totalElementos-1;i++ ){
            for(j=i+1;j<totalElementos;j++){
                if(trabajadors[i].getSueldo()<trabajadors[j].getSueldo())
                {
                    ordenar =trabajadors[i];
                trabajadors[i]=trabajadors[j];
               trabajadors[j]=ordenar;
            }}
            }
        
}
    
    }

Share:

Degradados , transiciones, efectos dinamicos

nos sirve para los degrados de la etiqueta
#principal{
width: 500px;
height: 40px;
//background-color: aqua;
text-align: center;
margin: 15px auto;
padding-top: 20px;
border: 3px solid #EC042F;
border-radius: 5px;
box-shadow: blue 10px 5px 10px ;
background:-webkit-linear-gradient(top, #00F, #3FF);
background:-moz-linear-gradient(top, #00F, #3FF);
background:-ms-linear-gradient(top, #00F, #3FF);
background:-o-linear-gradient(top, #00F, #3FF);
}


siempre distinguiendo en los diferences navegadores que se tenga

nos servira para manipular lo de un span
#titulo{
font: bold 36px normal;
text-shadow: yellow 3px 4px 2px
}


PARA HACER UNA ETIQUETA CIRCULAR DE COLORES
background: -webkit-radial-gradient(center, circle, #00F,#3FF)





para hacer un coloreador de tipo elipce

nos sirve para hacer opacidad con la etiqueta
color: rgba(0,12,15,0.5);
para dar bordes fuera de la etiqueta
outline: 2px dashed #01B994;
outline-offset: 15px;


para rotar un etiqueta
-webkit-transform:rotate(30deg)
cambiar la perspectiva de la etiqeuta

-webkit-transform:skew(30deg)

son seudoclases
permite dar un moviemiento al pasar el raton por ensima de la etiqueta seleccionada
#principal:hover{
-webkit-transform:skew(30deg);
}

permite tener una mejor vista al momento de posicionar el mouse en la etiqueta deacuerdo a los parametros que se le de
-webkit-transition:-webkit-transform 1s ease 0.5s;
-webkit-transition:-webkit-transform 0.3s ease-in-out 0.3s

para dar color al texto
color:white


escale es cuando pasas el mause por ensiam y la imagen se mueve hacia adelante
figure img:hover{
-webkit-transform:scale(1.2);
}


Share:

CSS

body{
background-color:aqua
}
 para poner color a fondo de pantalla todo
#selecttorWeb{
background-color:red;
display_inline;
}
file:///C:/Users/USUARIO/Desktop/SEGUNODpAGINA.html

p[ name="misEstilo]{
color:Red
}
lo que nos permite sar un formato a una cierta etiqueta y no utilizando el selector

name^="mis"] nos permite descir que todos las etiquetas que comiencen con mis se le aplicacara los cambios
name$="mis" son los nombres de las etiquetas que terminar en mis

name*="ele" aplica a todos las etiquetas que tengas el nombre incio medio o fin


p:nth-child(2){
color: blueviolet;
}nos permite poner color en una una familia de p y que este dentro del numero 2

p:nth-child(odd){
color: blueviolet;
}odd es para los pares que se vayan coloreando
p:nth-child(even){
color: blueviolet;
}


p:first-child{
color: brown
} para los primeros hijos que se encuentre

p:only-child{
color: aqua
}al unico hijo de las etiquetas
Share:

NAV

dentro de NAV
<ol>
<li> </li>
</ol> nos ir para poner en orden la navegacion y tmabien funciona ul

Share:

ETIQUETAS

ETIQUETAS NUEVAS DE HTML5

<figcaption> nos sirve para hacer una descripcion de la figura insertada

<em> </em> nos sirve para enfatizar el texto esea en cursiva

<strong> </strong > esta etiqueta sirve para poner en negrita las palabras

<mark></mark> nos sirve para resaltar la palabra ya sea en colores completos

<small> </small> sirve para los comentarios para dar otra vista a lo que se esta comentadando y tambien para reservado

<cite></cite> nos permite hacer referencia de que se esta hablando de una pelicula d eun cuento o de algo importante

<address></address> para las dirrecciones de la persona , correo, telefono,o algo referenciado

<time datetime="12-12-2017" pubdate>noticia publicada el dia 12-12-2017</time>




Share:

Blogroll

BTemplates.com

Buscar este blog

Blog Archive

Con tecnología de Blogger.