Foro de elhacker.net

Muy buenas, estoy aquí de nuevo con más dudas :/

Tengo este código :

public static void main(String[] args) {
 
		ArrayList<Empleado> empleados = new ArrayList<Empleado>();
 
		String resp;
		Scanner S = new Scanner(System.in);
 
		do{
			char respuesta = 'S';
			System.out.print("Introduce el nombre del empleado: ");
			String nombre = S.nextLine();
			System.out.println();
 
			System.out.print("Introduce su sueldo: ");
			int sueldo = S.nextInt();
			System.out.println();
 
			empleados.add(Empleado(nombre, sueldo));
 
			System.out.println("¿Quieres añadir algún empleado más? (S/N)");
			resp = S.nextLine();
			resp = resp.toUpperCase();
			respuesta = (char)resp.charAt(0);
 
		}while(respuesta=='S');
 
		for(Empleado empl : empleados){
			empleados.get(empl);
		}

Tengo una clase llamada Empleado con este constructor :

private String nombre;
	private int sueldo;
 
	public Empleado(String nombre, int sueldo){
		this.nombre = nombre;
		this.sueldo = sueldo;
	}

Y me da error en :

empleados.add(Empleado(nombre, sueldo));

También en el while, no entiendo por que :/

Y otro más en el método .get de la lista empleados (en el for).

La verdad es que llevo rato mirando el código y no tengo ni la más remota idea de porque esos errores :/

Gracias de antemano y un abrazo.

empleados.add(Empleado(nombre, sueldo));

en esta linea te esta faltando poner new ya que cada vez que agregas objeto Empleado tiene que ser uno nuevo

empleados.add(new Empleado(nombre, sueldo));

ademeas el for el metodo get pide un indice entero y tu le estas pasando un objeto lo mas correcto seria hacer un for desde 0 hasta empleados.size

espero solucione tus problemas saludos...

codigo

public class Testeo {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
        ArrayList<Empleado> empleados = new ArrayList<Empleado>();
 
        String resp;
        Scanner S = new Scanner(System.in);
        char respuesta = 'S';
 
        do{
 
            System.out.print("Introduce el nombre del empleado: ");
            String nombre = S.nextLine();
            System.out.println();
 
            System.out.print("Introduce su sueldo: ");
            int sueldo = S.nextInt();
            S.nextLine();//despues de usar el S.nextInt(); al teclear enter el valor se que da en el limbo
            //por lo cual es recomendable hacer un S.nextline(); antes del siguiente S.nextline();
            System.out.println();
 
            empleados.add(new Empleado(nombre, sueldo));//tienes que añadir un nuevo objeto cada vez que agreges
            //un empleado a la lista
 
            System.out.println("¿Quieres añadir algún empleado más? (S/N)");
            resp = S.nextLine();
            resp = resp.toUpperCase();
            respuesta = (char)resp.charAt(0);
 
            }while(respuesta=='S');
 
 
        for(int i=0;i<empleados.size();i++){
            System.out.println(empleados.get(i).toString());//el empleados get pide un entero no un objeto caso como lo tenias antes
        }
 
 
    }
 
}
 

Para no ser repetitivo, he modificado un poco tu código. El código cumple la misma finalidad, solo que esta implementado de otra manera, te recomiendo que lo veas xD:

import java.util.ArrayList;
import java.util.Scanner;
 
public class Clase1 {
 
    public static void main(String[] args) {
        ArrayList<Empleado> empleados = new ArrayList<Empleado>();
 
        Scanner s = new Scanner(System.in);
 
        while(true) {
            System.out.print("Introduce el nombre del empleado: ");
            String nombre = s.next();
            System.out.println();
 
            System.out.print("Introduce su sueldo: ");
            int sueldo = s.nextInt();
            System.out.println();
 
            empleados.add(new Empleado(nombre, sueldo));
 
            System.out.println("¿Quieres añadir algún empleado más? (S/N)");
            String respuesta = s.next();
            if(respuesta.equalsIgnoreCase("n")) {
                break;
            }
        }
 
        for(int i = 0; i < empleados.size(); i++){
        	empleados.get(i).get();
        }
    }
}
 
 

Y esta es la clase Empleado, mira que he creado mi método get.

class Empleado {
    private String nombre;
    private int sueldo;
 
    public Empleado(String nombre, int sueldo){
            this.nombre = nombre;
            this.sueldo = sueldo;
    }
 
    public void get() {
        if(sueldo > 1) {
            System.out.println("Este empleado se llama "+this.nombre+" y su sueldo es de "+this.sueldo+" dolares por mes");
        }
        else if(sueldo >0) {
            System.out.println("Este empleado se llama "+this.nombre+" y su sueldo es de "+this.sueldo+" dolar por mes");
        }
        else{
            System.out.println("Este empleado se llama "+this.nombre+" y no tiene sueldo");
        }
    }
}
 
 

Salu2.

Joder, que empanao que estoy :/ no darme cuenta del new...  :-[

He estado viendo tu código, y no se, ¿Es mejor hacerlo con un while, que con un do/while?
Lo que si voy a cambiar es lo de la condición, así es más simple sin pasarlo a char y tal :P

Respecto a lo del get, todavía no entiendo bien esa función, (si que la entiendo como la tienes hecha tú, lo que no entiendo es lo que hace si no la escribes tú mismo en la clase del objeto...) Pero, se me ha olvidado comentar que lo que tengo que mostrar son los empleados que no tengan ningún dato igual que otro, osea, si uno tiene de sueldo 1000, y otro también tiene 1000, que sólo muestre uno, aunque se llamen diferente.  O sea, que no muestre datos repetidos.

No se por donde cogerlo :/

Ah y se me olvidaba, gracias por las respuestas :)

Pocas veces he tenido que recurrir al do/while, desde mi punto de vista, veo bastante mas sencillo hacerlo con el while, es como mas entendible.

Pues esa función get que dices, es propia de la clase ArrayList y lo que hace es devolver un objeto dentro del ArrayList, por ejemplo:

ArrayList array = new ArrayList();

Si yo quisiera obtener algo del array lo haría así:

array.get(0);

Ahí estaría obteniendo un objeto que esta en la posicion 1, funciona igual que con los Arrays tradicionales, tu metes y sacas los valores.

En cuanto a lo de:

Acá tienes que usar un poco mas de lógica, yo lo hice de la siguiente manera,
Seria bueno que le heches un ojo y lo intentes hacer de nuevo basándote en este código:

import java.util.ArrayList;
import java.util.Scanner;
 
public class Clase1 {
 
    public static void main(String[] args) {
        ArrayList<Empleado> empleados = new ArrayList<Empleado>();
 
        Scanner s = new Scanner(System.in);
 
        while(true) {
            System.out.print("Introduce el nombre del empleado: ");
            String nombre = s.next();
            System.out.println();
 
            System.out.print("Introduce su sueldo: ");
            int sueldo = s.nextInt();
            System.out.println();
 
            empleados.add(new Empleado(nombre, sueldo));
 
            System.out.println("¿Quieres añadir algún empleado más? (S/N)");
            String respuesta = s.next();
            if(respuesta.equalsIgnoreCase("n")) {
                break;
            }
        }
 
        int[] valores = new int[empleados.size()];//En este array vamos guardando todos los valores de los empleados a medida que lo mostramos
 
        for(int i = 0; i < empleados.size(); i++){//Recorremos todos los empleados agregados
            boolean mostrarEmpleadoActual = true;//Inidicamos si mostramos el usuario actual o no
 
            //Este ciclo se fija si el empleado actual tiene el mismo sueldo que otro empleado, si es asi cambia el valor de la variable
            //mostrarEmpleadoActual por false
            for (int i2 = 0; i2 < valores.length; i2++) {
                if(empleados.get(i).getSueldo() == valores[i2]) {
                    mostrarEmpleadoActual = false;
                    break;
                }
            }
 
            //Se fija el valor de la variable mostrarEmpleadoActual, si es verdadero mostramos el empleado
            if(mostrarEmpleadoActual) {
                valores[i] = empleados.get(i).getSueldo();
                empleados.get(i).get();
            }
        }
    }
}
 
 
 

Lo único que he hecho acá fue cambiar agregar un array de int y modificar totalmente el ciclo for del final.

public int getSueldo() {
        return this.sueldo;
    }
 

Este metodo deberás agregarlo a la clase Empleado.

Si no entiendes algo, comenta la duda.

Salu2  ;)

Pero, si lo que te muestra es un objeto por ejemplo, Empleado, como el que tengo creado, ¿que te muestra exactamente? ¿todos sus atributos? ¿o el nombre del objeto creado?

Y respecto al código, he tenido que mirarmelo varias veces, me cuesta entenderlo haha :/ pero, tampoco se pueden repetir los nombres, no sólo el sueldo... ¿tendría que hacer dos arrays y dos blucles for más? :/

Cuando yo estoy haciendo esto:

empleados.get(i).get();

Estoy haciendo referencia al objeto en la posición X del ArrayList con el metodo get y pasandole como parámetro el objeto que quiero hacer referencia, fíjate esto:

Empleado empleado1 = new Empleado("Baal_30", 4000);
empleado1.get();

Acá estoy creando un objeto y abajo estoy haciendo referencia al objeto creado y llamando a su metodo.


Pero quieres que no se puedan crear 2 empleados con el mismo nombre o que no se repitan cuando los imprimo??.

Cuando tu guardas objetos en un ArrayList y quieres llamar a un método de algún objeto o cambiarle algún atributo, primero tienes que referenciarte a dicho objeto y luego llamar a los métodos o atributos del mismo.

El clase ArrayList tiene un metodo get que te devuelve la referencia al objeto para poder manipularlo y cambiarle los atributos del objeto, como dije anteriormente es lo mismo que hacerlo asi:

Empleado empleado1 = new Empleado("Baal_30", 4000);
empleado1.get();

y asi se haria con un arrayList:

ArrayList array = new ArrayList();
array.add(new Empleado("Baal_30", 4000));
array.get(0).get();
 

creo que este codigo resuelve tus dudas no repite ni sueldos ni nombre
o si no vuelve a plantear tu pregunta

import java.util.ArrayList;
import java.util.Scanner;
 
/**
 *
 * @author bdwong
 */
 
 
 
public class Testeo {
 
 
   public static boolean repetido(ArrayList<Empleado> data,String nombre, int sueldo){
 
       for(int i=0;i<data.size();i++){
            if((data.get(i).getNombre().equals(nombre)) || (data.get(i).getSueldo()==sueldo)){
                return true;
            }
 
       }
 
       return false;
  }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
       ArrayList<Empleado> empleados = new ArrayList<Empleado>();
 
       Scanner s = new Scanner(System.in);
 
       while(true) {
           System.out.println("Introduce el nombre del empleado: ");
           String nombre = s.nextLine();
 
 
 
           System.out.println("Introduce su sueldo: ");
           int sueldo = s.nextInt();
           s.nextLine();
 
 
 
 
           if(!repetido(empleados, nombre, sueldo)){
                empleados.add(new Empleado(nombre, sueldo));
           }
 
 
 
           System.out.println("¿Quieres añadir algún empleado más? (S/N)");
           String respuesta = s.next();
           s.nextLine();
           if(respuesta.equalsIgnoreCase("n")) {
               break;
           }
       }
 
       for(int i=0;i<empleados.size();i++){
 
           System.out.println("Empleado "+empleados.get(i).getNombre()+" sueldo "+empleados.get(i).getSueldo());
       }
 
 
    }
 
}
 

public class Empleado {
 
 
    private String nombre;
    private int sueldo;
 
    public String getNombre() {
        return nombre;
    }
 
 
 
    public int getSueldo() {
        return sueldo;
    }
 
 
 
    public Empleado(String nombre, int sueldo){
           this.nombre = nombre;
           this.sueldo = sueldo;
    }
 
}

Pablopbl genial explicado ;) El método get del ArrayList te dice que objeto está en esa posición, pero no te muestra nada por sí mismo, sólo la referencia al objeto como tal ¿no?

Y el método de "repetido" de crack81 creo que funcionaría bien, pero no veo cuando llamas a ese método para mostrar los que no se repiten en el for del main :/

^^ exactamente es así como dices xD

En cuanto al método repetido, si que lo llama para hacer comprobaciones con el if:

if(!repetido(empleados, nombre, sueldo)){
                empleados.add(new Empleado(nombre, sueldo));
           }

Ya que ese método devuelve un boolean y sirve para validar.

Salu2.

Aaah vale, lo usa para crear o no el nuevo Empleado. Yo a lo que me refería es que no muestre los que se repitan algun dato, pero que si los pueda crear. Supongo que poniendo el if ese dentro del for del main, y en vez de llamar al constructor, que imprima lo que imprime el for, conseguiría el resultado que busco, ¿no?

Y tendrías que hacer algo parecido a lo que hice con el sueldo, si entendiste el código no debería ser un problema.

Cualquier duda me dices.

Voy a probar! okey cualquier duda te comento ;)

Muchas gracias :D

No me aclaro :/

He modificado así el código del for para imprimir:

for(int i=0;i<empleados.size();i++){
			  if(repetido(empleados, empleados.get(i).getNombre(), empleados.get(i).getSueldo())){
				  System.out.println("Empleado "+empleados.get(i).getNombre()+" sueldo "+empleados.get(i).getSueldo());
	           }
		}

Y el método lo he dejado así :

public static boolean repetido(ArrayList<Empleado> empleados, String nombre, int sueldo){
 
	       for(int i=0;i<empleados.size();i++){
	            if((empleados.get(i).getNombre().equals(nombre)) || (empleados.get(i).getSueldo()==sueldo)){
	                return false;
	            }
	       }
 
	       return true;
	  }

Y pruebo creando 3 objetos, y dos de ellos con el mismo nombre, y no me imprime ninguno :/ y si cambio los returns( el false por el true y viceversa) me imprime los 3 aunque se repitan :/

Mira este Código:


Clase 1:

import java.util.ArrayList;
import java.util.Scanner;
 
public class Clase1 {
 
    public static void main(String[] args) {
        ArrayList<Empleado> empleados = new ArrayList<Empleado>();
 
        Scanner s = new Scanner(System.in);
 
        while(true) {
            System.out.print("Introduce el nombre del empleado: ");
            String nombre = s.next();
            System.out.println();
 
            System.out.print("Introduce su sueldo: ");
            int sueldo = s.nextInt();
            System.out.println();
 
            empleados.add(new Empleado(nombre, sueldo));
 
            System.out.println("¿Quieres añadir algún empleado más? (S/N)");
            String respuesta = s.next();
            if(respuesta.equalsIgnoreCase("n")) {
                break;
            }
        }
 
        int[] valores = new int[empleados.size()];//En este array vamos guardando todos los valores de los empleados a medida que lo mostramos
        String[] empleadosImprimidos = new String[empleados.size()];
 
        for(int i = 0; i < empleados.size(); i++){//Recorremos todos los empleados agregados
            boolean mostrarEmpleadoActual = true;//Inidicamos si mostramos el usuario actual o no
 
            //Este ciclo se fija si el empleado actual tiene el mismo sueldo que otro empleado, si es asi cambia el valor de la variable
            //mostrarEmpleadoActual por false
            for (int i2 = 0; i2 < valores.length; i2++) {
                if(empleados.get(i).getSueldo() == valores[i2]) {
                    mostrarEmpleadoActual = false;
                    break;
                }
            }
 
            if(mostrarEmpleadoActual == true) {
                for(int i3 = 0; i3 < empleadosImprimidos.length; i3++) {
                    if(empleados.get(i).getNombre().equals(empleadosImprimidos[i3])) {
                        mostrarEmpleadoActual = false;
                        break;
                    }
                }
            }
 
            //Se fija el valor de la variable mostrarEmpleadoActual, si es verdadero mostramos el empleado
            if(mostrarEmpleadoActual) {
                valores[i] = empleados.get(i).getSueldo();
                empleadosImprimidos[i] = empleados.get(i).getNombre();
                empleados.get(i).get();
            }
        }
    }
}
 

Clase Empleado:

 
class Empleado {
    private String nombre;
    private int sueldo;
 
    public Empleado(String nombre, int sueldo){
            this.nombre = nombre;
            this.sueldo = sueldo;
    }
 
    public void get() {
        if(sueldo > 1) {
            System.out.println("Este empleado se llama "+this.nombre+" y su sueldo es de "+this.sueldo+" dolares por mes");
        }
        else if(sueldo >0) {
            System.out.println("Este empleado se llama "+this.nombre+" y su sueldo es de "+this.sueldo+" dolar por mes");
        }
        else{
            System.out.println("Este empleado se llama "+this.nombre+" y no tiene sueldo");
        }
    }
 
    public int getSueldo() {
        return this.sueldo;
    }
 
    public String getNombre() {
        return this.nombre;
    }
}
 
 

Este Código hace todo lo que quieres, tan solo tuve que modificar el for y agregar un array de String y problema solucionado.

Prueba haber que tal.

Salu2.

Te he enviado un MP  ;).

Hasta donde tengo entendido sobre lo que deseas hacer, lo haría así:

package com.company.app.model.entities;
 
public class Employee {
	private Short id;
	private String names;
	private String surnames;
	private Double salary;
 
	public Employee() {}
 
	public Employee(Short id, String names, String surnames, Double salary) {
		super();
		this.id = id;
		this.names = names;
		this.surnames = surnames;
		this.salary = salary;
	}
 
	public Short getId() {
		return id;
	}
 
	public void setId(Short id) {
		this.id = id;
	}
 
	public String getNames() {
		return names;
	}
 
	public void setNames(String names) {
		this.names = names;
	}
 
	public String getSurnames() {
		return surnames;
	}
 
	public void setSurnames(String surnames) {
		this.surnames = surnames;
	}
 
	public Double getSalary() {
		return salary;
	}
 
	public void setSalary(Double salary) {
		this.salary = salary;
	}
 
 
}

package com.company.app.model.entities;
 
import java.util.ArrayList;
 
public class EmployeeList extends ArrayList<Employee> {
	private static final long serialVersionUID = 2924861284507271931L;
 
	public EmployeeList() {
		super();
	}
 
	public boolean hasRepeatProperties(Employee employee) {
		boolean hasRepeat = false;
		for(Employee e : this) {
			if(e.equals(employee))
				continue;
			if(compareProperties(e.getId(), employee.getId())) {
				hasRepeat = true;
				break;
			}
			else if(compareProperties(e.getNames(), employee.getNames())) {
				hasRepeat = true;
				break;
			}
			else if(compareProperties(e.getSurnames(), employee.getSurnames())) {
				hasRepeat = true;
				break;
			}
			else if(compareProperties(e.getSalary(), employee.getSalary())) {
				hasRepeat = true;
				break;
			}
		}
 
		return hasRepeat;
	}
 
	private boolean compareProperties(Object first, Object second) {
		boolean hasRepeat = false;
		if(first instanceof String) {
			hasRepeat = first.equals(second);
		}
		else if (first instanceof Short){
			hasRepeat = ((Short) first).shortValue() == ((Short) second).shortValue();
		}
		else if (first instanceof Double) {
			hasRepeat = ((Double) first).doubleValue() == ((Double) second).doubleValue();
		}
 
		return hasRepeat;
	}
 
}

package com.company.app;
 
import java.util.Scanner;
 
import com.company.app.model.entities.Employee;
import com.company.app.model.entities.EmployeeList;
 
public class Main {
 
	public static void main(String[] args) {
		EmployeeList employeeList = new EmployeeList();
		Scanner reader = new Scanner(System.in);
		String option = "S";
 
		do {
			Employee employee = new Employee();
			System.out.println("Ingrese el ID del nuevo empleado");
			employee.setId(Short.valueOf(reader.nextLine()));
			System.out.println("\nIngrese sus nombres:");
			employee.setNames(reader.nextLine());
			System.out.println("\nIngrese sus apellidos");
			employee.setSurnames(reader.nextLine());
			System.out.println("Ingrese su salario");
			employee.setSalary(Double.valueOf(reader.nextLine()));
			employeeList.add(employee);
			System.out.println("\n¿Desea seguir agregando empleados? S/N");
			option = reader.nextLine();
		}
		while(option.equalsIgnoreCase("s"));
		reader.close();
 
		for(Employee employee : employeeList) {
			if(employeeList.hasRepeatProperties(employee))
				continue;
			System.out.println("ID del empleado: "+employee.getId());
			System.out.println("Nombres: "+employee.getNames());
			System.out.println("Apellidos: "+employee.getSurnames());
			System.out.println("Salario: "+employee.getSalary());
		}
 
	}
 
}

Claro que está demás decir que tienes que manejar las excepciones que pueden ocurrir (NumberFormatException, InputMismatchException).

Hola Gus, estuve viendo un poco tu código y vi una parte en la que obtenías los datos desde la clase Scanner:

System.out.println("Ingrese el ID del nuevo empleado");
			employee.setId(Short.valueOf(reader.nextLine()));
			System.out.println("\nIngrese sus nombres:");
			employee.setNames(reader.nextLine());
			System.out.println("\nIngrese sus apellidos");
			employee.setSurnames(reader.nextLine());
			System.out.println("Ingrese su salario");
			employee.setSalary(Double.valueOf(reader.nextLine()));
			employeeList.add(employee);
			System.out.println("\n¿Desea seguir agregando empleados? S/N");
			option = reader.nextLine();

y la pregunta es, ¿La clase Scanner solo puede obtener un tipo de dato en particular?

¿Esto estaría mal?

Scanner scanner = new Scanner(System.in);
String nombre = sca.nextLine();
int edad = sca.nextInt();
 

Y ¿Esto estaría bien?

Scanner scanner = new Scanner(System.in);
String nombre = sca.nextLine();
int edad = Integer.parseInt(sca.nextLine());
 

La duda surge, por que estaba haciendo un par de cosas con esta clase y pues obtenía datos diferentes y me daba error, pero no si era por eso.

Ambas formas son válidas. La razón por la que uso el nextLine es por preferencia personal.

Por ejemplo, cuando lees un entero, Scannet te devuelve lo ingresado pero el enter que das se guarda en el input por lo que si seguidamente llamas a nextLine, éste método leerá lo que ha quedado en el input y el resultado es la percepción que se ha dado un enter automáticamente. Para evitar ésto debes de llamar al método nextLine solo para que lea el enter dejado por el nextInt y a continuación puedes seguir guardando Strings.

Usando solo nextLine me evito ésto y solo tendría que poner un catch para NumberFormatException.

Saludos.

Osea en vez de hacer esto:

Scanner scaner = new Scanner(System.in);
int edad = scaner.nextInt();
String nombre = scaner.nextLine();
 

Si no me equivoco debería hacer esto  ;D

Scanner scaner = new Scanner(System.in);
        int edad = scaner.nextInt();
        scaner.nextLine();
        String nombre = scaner.nextLine();
 

Pero me gusta mas todo con nextLine y de ahí convierto todo a sus respectivos tipos.

Salu2 crack!!

Sí, es así como comentas. También me gusta de ese modo, se tiene un poco más de control.

Saludos ^^.

Muchas gracias a los dos :D este ejercicio ya era más complejo :/

Lo del scanner me di cuenta al probar el código jaja :P pero hice lo de otro nextLine y solucionado ;)

Gracias a los dos :)