Java ArrayList. Estructura dinámica de datos DECLARACIÓN Y CREACIÓN DE UN ARRAYLIST De forma general un ArrayList en Java se crea de la siguiente forma: ArrayList nombreArray = new ArrayList(); Esta instrucción crea el ArrayList nombreArray vacío. Un arrayList declarado así puede contener objetos de cualquier tipo. Por ejemplo: ArrayList a = new ArrayList(); a.add("Lenguaje"); a.add(3); a.add('a'); a.add(23.5); Los elementos del arrayList a son: “Lenguaje” 2 ‘a’ 23.5 Es decir, un ArrayList puede contener objetos de tipos distintos. En este ejemplo, el primer objeto que se añade es el String “Lenguaje”. El resto no son objetos. Son datos de tipos básicos pero el compilador los convierte automáticamente en objetos de su clase envolvente(clase contenedora o wrapper) antes de añadirlos al array. Un array al que se le pueden asignar elementos de distinto puede tener alguna complicación a la hora de trabajar con él. Por eso, una alternativa a esta declaración es indicar el tipo de objetos que contiene. En este caso, el array solo podrá contener objetos de ese tipo. De forma general: ArrayList<tipo> nombreArray = new ArrayList<tipo>(); tipo debe ser una clase. Indica el tipo de objetos que contendrá el array.
Transcript
Java ArrayList. Estructura dinámica de datosDECLARACIÓN Y CREACIÓN DE UN ARRAYLIST
De forma general un ArrayList en Java se crea de la siguiente forma:
ArrayList nombreArray = new ArrayList();
Esta instrucción crea el ArrayList nombreArray vacío.
Un arrayList declarado así puede contener objetos de cualquier tipo.
Por ejemplo:
ArrayList a = new ArrayList();
a.add("Lenguaje");a.add(3);a.add('a');a.add(23.5);Los elementos del arrayList a son: “Lenguaje” 2 ‘a’ 23.5
Es decir, un ArrayList puede contener objetos de tipos distintos.
En este ejemplo, el primer objeto que se añade es el String “Lenguaje”. El resto no son objetos. Son datos de tipos básicos pero el compilador los convierte automáticamente en objetos de su clase envolvente(clase contenedora o wrapper) antes de añadirlos al array.
Un array al que se le pueden asignar elementos de distinto puede tener alguna complicación a la hora de trabajar con él. Por eso, una alternativa a esta declaración es indicar el tipo de objetos que contiene. En este caso, el array solo podrá contener objetos de ese tipo.De forma general:
ArrayList<tipo> nombreArray = new ArrayList<tipo>();
tipo debe ser una clase. Indica el tipo de objetos que contendrá el array.No se pueden usar tipos primitivos. Para un tipo primitivo se debe utilizar su clase envolvente.Por ejemplo:ArrayList<Integer> numeros = new ArrayList<Integer>();Crea el array numeros de enteros.MÉTODOS DE ARRAYLIST
Algunos métodos que proporciona ArrayList son:
MÉTODO DESCRIPCIÓN
size() Devuelve el número de elementos (int)
add(X) Añade el objeto X al final. Devuelve true.
add(posición, X) Inserta el objeto X en la posición indicada.
get(posicion) Devuelve el elemento que está en la posición indicada.
remove(posicion) Elimina el elemento que se encuentra en la posición indicada. Devuelve el elemento eliminado.
remove(X) Elimina la primera ocurrencia del objeto X. Devuelve true si el elemento está en la lista.
clear() Elimina todos los elementos.
set(posición, X) Sustituye el elemento que se encuentra en la posición indicada por el objeto X. Devuelve el elemento sustituido.
contains(X) Comprueba si la colección contiene al objeto X. Devuelve true o false.
indexOf(X) Devuelve la posición del objeto X. Si no existe devuelve -1
Utilizando un objeto Iterator.http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.htmlLa ventaja de utilizar un Iterador es que no necesitamos indicar el tipo de objetos que contiene el array.Iterator tiene como métodos:
hasNext: devuelve true si hay más elementos en el array.next: devuelve el siguiente objeto contenido en el array.Ejemplo:
ArrayList<Integer> numeros = new ArrayList<Integer>();…..//se insertan elementos.....Iterator it = numeros.iterator(); //se crea el iterador it para el array numeroswhile(it.hasNext()) //mientras queden elementos System.out.println(it.next()); //se obtienen y se muestran
Ejemplo 2: Escribe un programa que lea números enteros y los guarde en un ArrayList hasta que se lea un 0 y muestra los números leídos, su suma y su media.import java.util.*;
public class ArrayList2 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); ArrayList<Integer> numeros = new ArrayList<Integer>(); int n; do { System.out.println("Introduce números enteros. 0 para acabar: "); System.out.println("Numero: "); n = sc.nextInt();
if (n != 0) numeros.add(n); }while (n != 0); System.out.println("Ha introducido: " + numeros.size() + " números:"); //mostrar el arrayList completo System.out.println(numeros); //recorrido usando un iterador para mostrar un elemento por línea Iterator it = numeros.iterator(); while(it.hasNext()) System.out.println(it.next()); //recorrido usando foreach para sumar los elementos double suma = 0; for(Integer i: numeros){ suma = suma + i; } System.out.println("Suma: " + suma); System.out.println("Media: " + suma/numeros.size()); }}
COPIAR UN ARRAYLIST
El nombre de un ArrayList contiene la referencia al ArrayList, es decir, la dirección de memoria donde se encuentra el ArrayList, igual que sucede con los arrays estáticos.Si disponemos de un ArrayList de enteros llamado ventas:La instrucción:ArrayList<Integer> ventas1 = ventas;No copia el array ventas en el nuevo array ventas1 sino que crea un alias:
De esta forma tenemos dos formas de acceder al mismo ArrayList: mediante la referencia ventas y mediante la referencia ventas1.Para hacer una copia podemos hacerlo de forma manual elemento a elemento o se puede pasar la referencia del ArrayList original al constructor del nuevo:ArrayList<Integer> ventas1 = new ArrayList<Integer>(ventas);
ARRAYLIST COMO PARÁMETRO DE UN MÉTODO
Un ArrayList puede ser usado como parámetro de un método. Además un método puede devolver un ArrayList mediante la sentencia return.Ejemplo: Método que recibe un ArrayList de String y lo modifica invirtiendo su contenido:import java.util.*;
public static ArrayList<String> invertir(ArrayList<String> nombres) { // Crea una lista para el resultado del método ArrayList<String> resultado = new ArrayList<String>(); // Recorre la lista de nombres en orden inverso for (int i = nombres.size() - 1; i >= 0; i--) { // Añade cada nombre al resultado resultado.add(nombres.get(i)); } return resultado; }}
ARRAYS BIDIMENSIONALES UTILIZANDO ARRAYLIST
Un ArrayList es un array unidimensional, pero con ellos podemos simular arrays de dos o más dimensiones anidando ArrayLists.Para crear una matriz lo que creamos es un ArrayList cuyos elementos son a su vez ArrayList. Esto se puede extender sucesivamente y obtener arrays de más dimensiones.Ejemplo:Programa que lee las notas de 10 alumnos y las guarda en un ArrayList Bidimensional. Cada alumno tiene un número indeterminado de notas. La lectura de notas de cada alumno acaba cuando se introduce un número negativo. Finalmente se muestran todas las notas de todos los alumnos.
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
final int numAlumnos = 10; //número de alumnos int i, j, nota, cont = 1; //crear un ArrayList bidimensional de enteros vacío //Realmente se crea un ArrayList de ArrayLists de enteros ArrayList<ArrayList<Integer>> array = new ArrayList<ArrayList<Integer>>(); //Se leen las notas de cada alumno. System.out.println("Introduzca notas. <0 para acabar"); for(i=0;i<numAlumnos;i++){ cont = 1; System.out.println("Alumno " + (i+1) + ": "); System.out.print("Nota " + cont + ": "); nota = sc.nextInt();
//para cada alumno se añade una nueva fila vacía //esto es necesario porque el arrayList se crea vacío array.add(new ArrayList<Integer>());
while(nota>=0){ array.get(i).add(nota); //en la fila i se añade un nueva nota cont++; System.out.print("Nota " + cont + ": "); nota = sc.nextInt(); } } //Mostrar todas las notas System.out.println("Notas de alumnos"); for(i=0;i<array.size();i++){ //para cada alumno (para cada fila) System.out.print("Alumno " + i + ": "); for(j=0;j<array.get(i).size();j++){ //se recorre todas la columnas de la fila System.out.print(array.get(i).get(j) + " "); //se obtiene el elemento i,j } System.out.println(); } }
Un ARREGLO es un conjunto de datos, los cuales pueden ser accedidos mediante índices.
Si queremos almacenar 20 notas de estudiantes, tendríamos q declararnos 20 variables
La ventaja es q nos dan los arreglos, es que, un lugar de declarar 20 variables solamente voy a declarar UNA y voy a acceder a ella mediante sus índices.
Forma de declararlo:
Declararlos desde el inicio: INT []CALIFICACIONES= NEW INT[23,34,5,66,54,34,121,12,34,34];
Declararlos DESPUES: INT []CALIFICACIONES= NEW INT[20];
Declarar un arreglo con arreglos ya establecidos, ahora debemos Inicializarlos
Como es un objeto se pone new
DECLARARLOS DESPUES:
Java Ejercicios Básicos de Arrays Resueltos 1Relación Nº 1: Ejercicios 1 y 2
1. Calcular la media de una serie de números que se leen por teclado.
Programa Java que lea por teclado 10 números enteros y los guarde en un array. A continuación calcula y muestra por separado la media de los valores positivos y la de los valores negativos.
/* * Programa que lea por teclado 10 números enteros * y los guarde en un array. * A continuación calcula y muestra la media de los * valores positivos y la de los valores negativos. */
import java.util.*;public class Media1 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int i; int pos = 0, neg = 0; //contadores de los números positivos y negativos int[] numeros = new int[10]; //array que contendrá los números leídos por teclado double sumaPos = 0, sumaNeg = 0; //acumuladores para las sumas de positivos y negativos //lectura de datos y llenar el array System.out.println("Lectura de los elementos del array: "); for (i = 0; i < 10; i++) { System.out.print("numeros[" + i + "]= "); numeros[i]=sc.nextInt(); }
//recorrer el array para sumar por separado los números positivos
// y los negativos for (i = 0; i < 10; i++) { if (numeros[i] > 0){ //sumar positivos sumaPos += numeros[i]; pos++; } else if (numeros[i] < 0){ //sumar negativos sumaNeg += numeros[i]; neg++; } }
//Calcular y mostrar las medias if (pos != 0) { System.out.println("Media de los valores positivos: " + sumaPos / pos); } else { System.out.println("No ha introducido numeros positivos"); } if (neg != 0) { System.out.println("Media de los valores negativos: " + sumaNeg / neg); } else { System.out.println("No ha introducido numeros negativos"); } }}
2. Programa Java que lea 10 números enteros por teclado y los guarde en un array. Calcula y muestra la media de los números que estén en las posiciones pares del array.
Considera la primera posición del array (posición 0) como par.
/* * Leer 10 números enteros y guardarlos * en un array. Calcular la media de los * que estén en las posiciones pares. */import java.util.*;
public class Arrays1_2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); int i; int[] numeros = new int[10]; double media = 0;
//lectura de datos y llenar el array System.out.println("Lectura de los elementos del array: "); for (i = 0; i < 10; i++) { System.out.print("numeros[" + i + "]= "); numeros[i] = sc.nextInt(); } //Recorrer el array y calcular la media for (i = 0; i < 10; i++) { if (i % 2 == 0){ //si la posición actual es par media = media + numeros[i]; //se suma el valor de esa posición } } //Calcular y mostrar la media System.out.println("Media de los valores que se encuentran en posiciones pares: "+ media/5); }}
Relación Nº 2: Ejercicios 3 y 4
3. Programa que lee por teclado la nota de los alumnos de una clase y calcula la nota media del grupo. También muestra los alumnos con notas superiores a la media. El número de alumnos se lee por teclado.
Este programa utiliza un array de elementos de tipo double que contendrá las notas de los alumnos.
El tamaño del array será el número de alumnos de la clase, por lo tanto primero se pedirá por teclado el número de alumnos y a continuación se creará el array.
Se realizan 3 recorridos sobre el array, el primero para asignar a cada elemento las notas introducidas por teclado, el segundo para
sumarlas y calcular la media y el tercero para mostrar los alumnos con notas superiores a la media.
import java.util.*;public class MediaDeLaClase { public static void main(String[] args) {
Scanner sc = new Scanner(System.in); int numAlum, i; double suma = 0, media;
//Lectura del número de alumnos. Debe ser un valor positivo do { System.out.print("Número de alumnos de la clase: "); numAlum = sc.nextInt(); } while (numAlum <= 0);
//se crea un array llamado notas de numAlumn elementos de tipo double double[] notas = new double[numAlum]; // Entrada de datos. Se lee la nota de cada alummo y se guarda // en cada elemento del array for (i = 0; i < notas.length; i++) { System.out.print("Alumno " + (i + 1) + " Nota final: "); notas[i] = sc.nextDouble(); }
// Sumar todas las notas for (i = 0; i < notas.length; i++) { suma = suma + notas[i]; }
// Calcular la media media = suma / notas.length;
// Mostrar la media System.out.printf("Nota media del curso: %.2f %n", media);
// Mostrar los valores superiores a la media System.out.println("Listado de notas superiores a la media: "); for (i = 0; i < notas.length; i++) { if (notas[i] > media) { System.out.println("Alumno numero " + (i + 1)+ " Nota final: " + notas[i]);
} } }}
4. Programa que crea un array de 20 elementos llamado Pares y guarde los 20 primeros números pares. Mostrar por pantalla el contenido del array creado.
/* * Programa que crea un array de 20 elementos * llamado Pares y guarde los 20 primeros * números pares. * Mostrar por pantalla el contenido * del array creado */import java.util.*;public class ArrayPares {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); int i, cont = 2;
int[] pares = new int[20];
//Llenamos el array con números pares. Utilizamos un contador //con valor inicial 2 y le sumamos dos en cada iteración. for (i = 0; i < pares.length; i++) { pares[i] = cont; cont += 2; } //Mostrar el array for (i = 0; i < pares.length; i++) { System.out.println(pares[i]); } }}
1.Ricardo 11 de febrero de 2014, 21:42 //creo que seria mejor de esta formapublic class Ejemplo4 {
public static void main(String[] args) {int[] arrayPares = new int[20];int index = 0;int i = 1;do {if (i % 2 == 0) {arrayPares[index] = i;index++;i++;}else{i++;}} while (index<20);for (int j = 0; j < arrayPares.length; j++) {System.out.print(arrayPares[j]+",");}}}
5. Programa Java que guarda en un array 10 números enteros que se leen por teclado. A continuación se recorre el array y calcula cuántos números son positivos, cuántos negativos y cuántos ceros.
// Contar el número de elementos positivos, negativos y ceros de un array de 10 elementos.import java.util.*;public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int[] numeros = new int[10]; int pos = 0, neg = 0, cero = 0; //contadores int i; //Leemos los valores por teclado y los guardamos en el array System.out.println("Lectura de los elementos del array: "); for (i = 0; i < numeros.length; i++) { System.out.print("numeros[" + i + "]= "); numeros[i] = sc.nextInt(); } //se recorre el array para contar positivos, negativos y ceros for (i = 0; i < numeros.length; i++) { if (numeros[i] > 0) { pos++; } else if (numeros[i] < 0) { neg++; } else { cero++; } } //mostrar resultados System.out.println("Positivos: " + pos); System.out.println("Negativos: " + neg); System.out.println("Ceros: " + cero); }}
6. Programa Java que llene un array con 10 números enteros que se leen por teclado. A continuación calcula y muestra la media de los valores positivos y la de los valores negativos del array.
/* * Leer 10 números enteros y mostrar la media de los valores positivos y la de los valores negativos. */import java.util.*;public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int[] numeros = new int[10]; int pos = 0, neg = 0; //contadores para positivos y negativos int i; double sumaPos = 0, sumaNeg = 0; //suma de positivos y negativos //Leemos los valores por teclado y los guardamos en el array System.out.println("Lectura de los elementos del array: "); for (i = 0; i < numeros.length; i++) { System.out.print("numeros[" + i + "]= "); numeros[i]=sc.nextInt(); } //se recorre el array para sumar positivos y negativos for (i = 0; i < numeros.length; i++) { if (numeros[i] > 0){ //sumar positivos sumaPos += numeros[i]; pos++; } else if (numeros[i] < 0){ //sumar negativos sumaNeg += numeros[i]; neg++; } } //mostrar resultados if (pos != 0) { System.out.println("Media de los valores positivos: " + sumaPos / pos); } else { System.out.println("No ha introducido números positivos"); } if (neg != 0) { System.out.println("Media de los valores negativos: " + sumaNeg / neg); } else { System.out.println("No ha introducido números negativos"); } }}
7. Programa Java para leer la altura de N personas y calcular la altura media. Calcular cuántas personas tienen una altura superior a la media y cuántas tienen una altura inferior a la media. El valor de N se pide por teclado y debe ser entero positivo.
/* * Leer la altura de N personas y calcular la altura media * Mostra cuántos hay superiores a la media. */import java.util.*;public class Main {
public static void main(String[] args) { Scanner sc = new Scanner(System.in); int i, N; int contMas = 0, contMenos = 0; double media = 0; //Leer el número de personas do{ System.out.print("Número de personas: "); N = sc.nextInt(); }while(N<=0); //Se crea el array de tamaño N double[] alto = new double[N]; //Leer alturas System.out.println("Lectura de la altura de las personas: "); for (i = 0; i < N; i++) { System.out.print("persona " + (i+1) + " = "); alto[i] = sc.nextDouble(); media = media + alto[i]; //se suma la estatura leída para calcular la media } //Calcular la media media = media / N; //recorremos el array para ver cuantos hay más altos //que la media y cuantos más bajos for (i = 0; i < alto.length; i++) { if (alto[i] > media){ //si la estatura es mayor que la media contMas++; } else if (alto[i] < media){ //si es menor contMenos++; } } //Mostrar resultados System.out.println("Estatura media: " + media); System.out.println("Personas con estatura superior a la media: " + contMas); System.out.println("Personas con estatura inferior a la media: " + contMenos); }}
Ejercicios Arrays Java. Leer nombre y sueldo de 20 empleados y mostrar el que más ganaPrograma Java que lea el nombre y el sueldo de 20 empleados y muestre el nombre y el sueldo del empleado que más gana.
Para hacerlo utilizaremos dos arrays:Un array de String para los nombres de los empleadosUn array de tipo double para los sueldos de cada empleado.
Al mismo tiempo que leemos los datos de los empleados iremos comprobando cuál es el que tiene el mayor sueldo. Para ello tomamos el sueldo del primer empleado que se lee como mayor sueldo y después vamos comprobando el resto de sueldos. Cuando encontramos alguno mayor que el mayor actual este sueldo se convierte en el nuevo mayor.
En general para calcular el mayor de una serie de números tomamos el primero como mayor y después comparamos el resto de números.
//programa que muestra el nombre y el sueldo del empleado que más ganaimport java.util.*;public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); //creamos los arrays String[] empleados = new String[20]; double[] sueldos = new double[20];
//variables donde guardar el nombre y sueldo del empleado que más gana String nombreMayor; double mayorSueldo;
int i = 0;
//se lee el primer empleado System.out.println("Lectura de nombres y sueldos de empleados: "); System.out.print("Empleado " + (i + 1) + ": "); empleados[i] = sc.nextLine(); System.out.print("Sueldo: "); sueldos[i] = sc.nextDouble();
//se toma el primero como mayor mayorSueldo = sueldos[i]; nombreMayor = empleados[i];
//se leen el resto de empleados for (i = 1; i < empleados.length; i++) { sc.nextLine(); //limpiar el buffer System.out.print("Empleado " + (i + 1) + ": "); empleados[i] = sc.nextLine(); System.out.print("Sueldo: "); sueldos[i] = sc.nextDouble(); //se compara el sueldo leído con el mayor if (sueldos[i] > mayorSueldo) { mayorSueldo = sueldos[i]; nombreMayor = empleados[i]; } }
//mostrar resultados System.out.println("Empleado con mayor sueldo: " + nombreMayor ); System.out.println("Sueldo: " + mayorSueldo); }}
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
1.Ricardo 12 de febrero de 2014, 16:28 import java.util.Scanner;public class Ejemplo8 {public static void main(String[]args){System.out.println("Introduce nombre y sueldo del empleado");Scanner scanner=new Scanner(System.in);System.out.println("Numero de employees");int n=scanner.nextInt();
for (int i = 0; i < n; i++) {System.out.print("arrayNombres["+i+"]=");arrayNombres[i]=scanner.next();}System.out.println("");for (int i = 0; i < n; i++) {System.out.print("arraySalarios["+i+"]=");arraySalarios[i]=scanner.nextInt();}System.out.println("**************************************");for (int i = 0; i < n; i++) {System.out.println("Nombre:"+arrayNombres[i]+" salario="+arraySalarios[i]);}//ordemanos menor a mayorfor (int i = 0; i < n-1; i++) {double aux;String aux2;for (int j = i+1; j arraySalarios[j]) {aux=arraySalarios[i];arraySalarios[i]=arraySalarios[j];arraySalarios[j]=aux;
aux2=arrayNombres[i];arrayNombres[i]=arrayNombres[j];arrayNombres[j]=aux2;}}}System.out.println("**************************************");System.out.println("Mayor salrio: Nombre "+arrayNombres[n-1]+" Salario="+arraySalarios[n-1]);}}Responder
Javier Muñoz Tous 27 de diciembre de 2014, 15:26 Este comentario ha sido eliminado por el autor.Responder
3.Dani lopez cabrera 21 de enero de 2015, 23:46 import java.util.Random;import java.util.Arrays;import java.util.Scanner;public class Act4{public static void main (String []args){Scanner lector = new Scanner (System.in);Random rnd = new Random ();String [] nombre = new String [10];int [] sueldos = new int [10];int sueldomax = 0;int pos = 0;System.out.println("Dame los nombre de los empleados");for (int i = 0;i sueldomax){sueldomax = sueldos[i];pos = i;}}for (int i = 0;i<nombre.length;i++){if (pos == i){System.out.println("Este es el nombre del empleado que mas cobra " + nombre[i] + " y esto es lo que cobra " + sueldomax);break;}}System.out.println("Esta es la lista de sueldos");System.out.println(Arrays.toString(sueldos));System.out.println("Esta es la lista de empleados");System.out.println(Arrays.toString(nombre));}}
1.Anónimo2 de marzo de 2015, 21:11import static java. lang. System. out;import java. util. Scanner;import java. util. *;class ejercicio3{public static void main (String[] arguments){float comparador=0;//asumir que el menor sueldo es ceroString nombre; // gusrdar el nombre del trabajador que se va entrandoint rec=0; // posición en el array del trabajador que mas cobraint i;Scanner miScanner= new Scanner(System. in);out.println("Cuantos trabajadores va a introducir en la base de datos");int total= miScanner.nextInt();String[]nombres=new String [total];
float []salario = new float [total];for (i=0; i< total; i++ ){ // llenar los arrayout.println("Entre el nombre de trabajador");nombre = miScanner.next();nombres[i] =nombre; // asignando el trabajador a una posición en el arrayout.println("Entre el salarios de :" +nombre);float sal= miScanner.nextInt(); salario[i]= sal; // asignando el salario a una posición en el arrayif(comparador <= sal){ // comparar los salarios comparador= sal; // guardar el mayor salariorec = i; // guardar posición del salrio mayor }}out.println("El mayor salario de la empresa lo tiene:"+nombres[rec] +" " );out.println("con:"+comparador+" "+ "euros" );}}
ArrayList de Objetos en JavaEn esta entrada vamos a escribir un programa Java que crea un ArrayList de Objetos de tipo Coche. El programa pide por teclado los datos de los coches y los guarda en el array. A continuación utilizará el ArrayList para mostrar por pantalla lo siguiente:
- Todos los coches introducidos.
- Todos los coches de una marca determinada.
- Todos los coches con menos de un número determinado de Kilómetros.
- El coche con mayor número de Kilómetros.
- Todos los coches ordenados por número de kilómetros de menor a mayor.
Primero creamos la clase Coche:
//Clase Coche
public class Coche {
private String matricula;
private String marca;
private String modelo;
private int Km;
public int getKm() {
return Km;
}
public void setKm(int Km) {
this.Km = Km;
}
public String getMarca() {
return marca;
}
public void setMarca(String marca) {
this.marca = marca;
}
public String getMatricula() {
return matricula;
}
public void setMatricula(String matricula) {
this.matricula = matricula;
}
public String getModelo() {
return modelo;
}
public void setModelo(String modelo) {
this.modelo = modelo;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("\nMatrícula: ");
sb.append(matricula);
sb.append("\nMarca: ");
sb.append(marca);
sb.append("\nModelo: ");
sb.append(modelo);
sb.append("\nKm: ");
sb.append(Km);
return sb.toString();
}
}
A continuación creamos la clase principal del proyecto:
//clase principal
public class Basico1 {
//Se crea un ArrayList para guardar objetos de tipo Coche.
static ArrayList<Coche> coches = new ArrayList<Coche>();
static Scanner sc = new Scanner(System.in);
//método main
public static void main(String[] args) {
leerCoches();
System.out.println("\nCoches introducidos:");
mostrarCoches();
mostrarPorMarca();
mostrarPorKm();
System.out.println("\nCoche con mayor número de Km: " + mostrarMayorKm());
System.out.println("\nCoches ordenados de menor a mayor número de Km");
mostrarOrdenadosPorKm();
} //fin método main
//Método para leer coches e introducirlos en el array
public static void leerCoches(){
//Declaración de variables para leer los datos de los coches
String matricula;
String marca;
String modelo;
int Km;
//Variable auxiliar que contendrá la referencia a cada coche nuevo.
Coche aux;
int i, N;
//se pide por teclado el número de coches a leer
do {
System.out.print("Número de coches? ");
N = sc.nextInt();
} while (N < 0);
sc.nextLine(); //limpiar el intro
//lectura de N coches
for (i = 1; i <= N; i++) {
//leer datos de cada coche
System.out.println("Coche " + i);
System.out.print("Matrícula: ");
matricula = sc.nextLine();
System.out.print("Marca: ");
marca = sc.nextLine();
System.out.print("Modelo: ");
modelo = sc.nextLine();
System.out.print("Número de Kilómetros: ");
Km = sc.nextInt();
sc.nextLine(); //limpiar el intro
aux = new Coche(); //Se crea un objeto Coche y se asigna su referencia a aux
//se asignan valores a los atributos del nuevo objeto
aux.setMatricula(matricula);
aux.setMarca(marca);
aux.setModelo(modelo);
aux.setKm(Km);
//se añade el objeto al final del array
coches.add(aux);
}
} //fin método leerCoches()
Podemos representar de forma gráfica el contenido del ArrayList según se van introduciendo los objetos:
//Método para mostrar todos los coches public static void mostrarCoches(){
for(int i = 0; i< coches.size(); i++)
System.out.println(coches.get(i)); //se invoca el método toString de la clase Coche
}
//Método para mostrar todos los coches de una marca que se pide por teclado
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
26 comentarios:
1.
evastos26 de julio de 2013, 22:59
Al transcribir las lineas de este código me aparecen muchas alertas que no logro arreglar. He desarrollado todos los ejercicios hasta aquí y ninguno me ha arrojado tantas inconsistencias de código. No se si es la instalación de NetBeans o no he importado las librerías correctas. Requiero una respuesta por favor.
evastos, el código esta completo, lo que llamas inconsistencias es por la falta de las librerías adecuadas, pon algo de tu parte, conchudo
Responder
2.
Javier Cambero3 de agosto de 2013, 19:46
Hola, me encuentro con el mismo problema que evastos, supongo que es cosa de mis pocos conocimientos de JAVA. por ahora he ido entendiendo todos los ejercicios y realizándolos yo mismo, pero en este me he quedado encallado.Me gustaria a ver si alguien puede darnos un poco de ayuda. cada clase, ha de estar en un archivo diferente? o pueden estar en el mismo?
Responder
Respuestas
1.
Enrique5 de agosto de 2013, 11:49Hola, creo que a los dos os deben estar dando los mismos tipos de error. Las dos clases tal y como están escritas aquí son public y deben estar en archivos diferentes. La clase Coche en un archivo Coche.java y la principal en otro archivo Basico1.java. Si las habeis escrito en el mismo archivo, dentro de un
archivo .java solo puede haber una clase pública que es la que da nombre al archivo por lo tanto podeis corregir el error quitando public en la clase Coche.Además teneis que añadir los import. En el ejemplo no aparecen. Si pinchais sobre cada error netBeans os indicará el import que falta y lo podeis añadir.
2.
Javier Cambero7 de agosto de 2013, 22:14
Gracias, ya me funciona :)
Responder
3.
Anónimo27 de agosto de 2013, 22:14
Una pregunta:
cual es la diferencia entre:
public void setModelo(String modelo) {this.modelo = modelo;}
y
public void setModelo(String modelo) {modelo = modelo;}
public void setModelo(String modelo) {this.modelo = modelo;}el THIS hace referencia a un atributo de la clase que tiene como nombre "modelo" y al cual se le esta asignando un valor que recibe en un atributo del método setModelo que tiene el mismo nombre al atributo de la clase. entonces para que al compilar se reconozca cual es el atributo de la clase y cual el que recibe se le pone el this
public void setModelo(String modelo) {modelo = modelo;}en este caso el atributo que se recibe se esta asignando a el mismo, nunca he visto trabajar un metodo asi.
2.
ERICK RAMIREZ23 de septiembre de 2013, 6:46
public void setModelo(String modelo) {this.modelo = modelo;}el THIS hace referencia a un atributo de la clase que tiene como nombre "modelo" y al cual se le esta asignando un valor que recibe en un atributo del método setModelo que tiene el mismo nombre al atributo de la clase. entonces para que al compilar se reconozca cual es el atributo de la clase y cual el que recibe se le pone el this
public void setModelo(String modelo) {modelo = modelo;}en este caso el atributo que se recibe se esta asignando a el mismo, nunca he visto trabajar un metodo asi.
Llenar un array con números aleatoriosEn esta entrada vamos a escribir un método Java que llene un array de enteros con números aleatorios.
Los números aleatorios deberán estar comprendidos entre dos límites (desde, hasta) ambos incluidos.El método recibe como parámetros los valores desde, hasta y el tamaño del array.El método devuelve mediante return el array de enteros creado.Para obtener números enteros aleatorios usaremos el método nextInt() de la clase Random.Para que los números aleatorios obtenidos estén dentro de los limites utilizaremos el método nextInt() de la siguiente fórma: nextInt(hasta - desde + 1) + desde
public static int [] llenarArrayAleatorio(int desde, int hasta, int tam){ int[] numeros = new int[tam]; Random rnd = new Random(); for (int i = 0; i < numeros.length; i++) { numeros[i] = rnd.nextInt(hasta - desde + 1) + desde; } return numeros;}
Si los números no se pueden repetir debemos complicar un poco más el código. En este caso cada vez que se obtiene un número aleatorio se debe comprobar si ya está en el array. Para hacer este trabajo vamos a escribir un método llamado comprobarSiContiene. A este método se le envía el array, la posición del elemento actual y el número aleatorio a insertar y devuelve true si el número ya existe en el array. En ese caso se vuelve a sacar otro número aleatorio.
public static int[] llenarArrayAleatorio(int desde, int hasta, int tam) { int[] numeros = new int[tam]; Random rnd = new Random(); int n; for (int i = 0; i < numeros.length; i++) { do { n = rnd.nextInt(hasta - desde + 1) + desde; } while (comprobarSiContiene(numeros, i, n)); numeros[i] = n; } return numeros;}
public static boolean comprobarSiContiene(int[] numeros, int indice, int valor) { for (int i = 0; i < indice; i++) { if (numeros[i] == valor) { return true; } } return false;}
Esta sería la solución para aquellos que están empezando a programar. Pero en este caso nos podemos ahorrar trabajo utilizando la API de Java. En concreto utilizando un ArrayList y el método shuffle de Collections.
La idea es llenar un ArrayList con todos los números comprendidos entre los límites desde/hasta. A continuación se llama al método shuffle para desordenarlos y después
se pasan al array de enteros lostam primeros elementos, donde tam es el tamaño del array a devolver.
El método utilizando el ArrayList y Collections.shuffle quedaría así:
private static int[] llenarArrayAleatorio(int desde, int hasta, int tam) { ArrayList<Integer> array = new ArrayList<Integer>(); for (int i = desde; i <= hasta; i++) { array.add(i); } Collections.shuffle(array); int [] numeros = new int[tam]; for(int i = 0; i<numeros.length; i++){ numeros[i]=array.get(i); } return numeros;}
Matrices en JavaUn array en Java puede tener más de una dimensión. El caso más general son los arrays bidimensionales también llamados matrices o tablas.La dimensión de un array la determina el número de índices necesarios para acceder a sus elementos.Los vectores que hemos visto en otra entrada anterior son arrays unidimensionales porque solo utilizan un índice para acceder a cada elemento.Una matriz necesita dos índices para acceder a sus elementos. Gráficamente podemos representar una matriz como una tabla de n filas y m columnas cuyos elementos son todos del mismo tipo.La siguiente figura representa un array M de 3 filas y 5 columnas:
Pero en realidad una matriz en Java es un array de arrays.
Gráficamente podemos representar la disposición real en memoria del array anterior así:
La longitud del array M (M.length) es 3.La longitud de cada fila del array (M[i].length) es 5.Para acceder a cada elemento de la matriz se utilizan dos índices. El primero indica la fila y el segundo la columna.CREAR MATRICES EN JAVA
Se crean de forma similar a los arrays unidimensionales, añadiendo un índice.Por ejemplo:matriz de datos de tipo int llamado ventas de 4 filas y 6 columnas:int [][] ventas = new int[4][6]; matriz de datos double llamado temperaturas de 3 filas y 4 columnas:double [][] temperaturas = new double[3][4];
En Java se pueden crear arrays irregulares en los que el número de elementos de cada fila es variable. Solo es obligatorio indicar el número de filas.Por ejemplo:int [][] m = new int[3][];crea una matriz m de 3 filas.A cada fila se le puede asignar un número distinto de columnas:m[0] = new int[3];m[1] = new int[5];m[2] = new int[2];Gráficamente podemos representar la disposición real en memoria del array anterior así:
INICIALIZAR MATRICES
Un array es un objeto, por lo tanto, cuando se crea, a sus elementos se les asigna automáticamente un valor inicial:
- 0 para arrays numéricos- '\u0000' (carácter nulo) para arrays de caracteres- false para arrays booleanos- null para arrays de String y de referencias a objetos.
También podemos dar otros valores iniciales al array cuando se crea.Los valores iniciales se escriben entre llaves separados por comas.Los valores que se le asignen a cada fila aparecerán a su vez entre llaves separados por comas.El número de valores determina el tamaño de la matriz.Por ejemplo:int [][] numeros = {{6,7,5}, {3, 8, 4}, {1,0,2}, {9,5,2}};se crea la matriz numeros de tipo int, de 4 filas y 3 columnas, y se le asignan esos valores iniciales.Asignando valores iniciales se pueden crear también matrices irregulares.int [][] a = {{6,7,5,0,4}, {3, 8, 4}, {1,0,2,7}, {9,5}};Crea una matriz irregular de 4 filas. La primera de 5 columnas, la segunda de 3, la tercera de 4 y la cuarta de 2.
RECORRER MATRICES
Para recorrer una matriz se anidan dos bucles for. En general para recorrer un array multidimensional se anidan tantas instrucciones for como dimensiones tenga el array.Ejemplo de recorrido de una matriz en Java:
Programa que lee por teclado números enteros y los guarda en una matriz de 5 filas y 4 columnas. A continuación muestra los valores leídos, el mayor y el menor y las posiciones que ocupan.
import java.util.*;
public class Bidimensional2 {
public static void main(String[] args) { final int FILAS = 5, COLUMNAS = 4; Scanner sc = new Scanner(System.in); int i, j, mayor, menor; int filaMayor, filaMenor, colMayor, colMenor; int[][] A = new int[FILAS][COLUMNAS]; System.out.println("Lectura de elementos de la matriz: "); for (i = 0; i < FILAS; i++) { for (j = 0; j < COLUMNAS; j++) { System.out.print("A[" + i + "][" + j + "]= "); A[i][j] = sc.nextInt(); } } System.out.println("valores introducidos:"); for (i = 0; i < A.length; i++) { for (j = 0; j < A[i].length; j++) { System.out.print(A[i][j] + " "); } System.out.println(); } mayor = menor = A[0][0];//se toma el primero como mayor y menor filaMayor = filaMenor = colMayor = colMenor = 0;
for (i = 0; i < A.length; i++) { // for (j = 0; j < A[i].length; j++) { if (A[i][j] > mayor) { mayor = A[i][j]; filaMayor = i; colMayor = j; } else if (A[i][j] < menor) { menor = A[i][j]; filaMenor = i; colMenor = j; } } }
En este ejemplo se han utilizado dos formas distintas para recorrer la matriz:- utilizando en el for el número de filas y columnas- utilizando en el for el atributo length
Para recorrer arrays irregulares como el siguiente:int [][] a = {{6,7,5,0,4}, {3, 8, 4}, {1,0,2,7}, {9,5}};
Usaremos siempre length para obtener el número de columnas que tiene cada fila:
for (i = 0; i < a.length; i++) { //número de filas for (j = 0; j < a[i].length; j++) { //número de columnas de cada fila System.out.print(a[i][j] + " "); } System.out.println();}
Algoritmos de ordenación. Metodo de la BurbujaEl algoritmo de la burbuja es uno de los métodos de ordenación más conocidos y uno de los primeros que aprenden los programadores.
Consiste en comparar pares de elementos adyacentes en un array y si están desordenanos intercambiarlos hasta que estén todos ordenados.
Si A es el array a ordenar, se realizan A.length-1 pasadas. Si la variable i es la que cuenta el número de pasadas, en cada pasada i se comprueban los elementos adyacentes desde el primero hasta A.length-i-1 ya que el resto hasta el final del array están ya ordenados. Si los elementos adyacentes están desordenados se intercambian.
El método de ordenación de la burbuja en java para ordenar un array A es el siguiente:
public static void burbuja(int [] A){ int i, j, aux; for(i=0;i<A.length-1;i++) for(j=0;j<A.length-i-1;j++) if(A[j+1]<A[j]){ aux=A[j+1]; A[j+1]=A[j]; A[j]=aux; }}
Ejemplo de ejecución:
Ya están ordenados, pero los dos bucles for seguirán ejecutándose hasta el final.El tiempo de ejecución del algoritmo de la burbuja es del orden O(n2)Es uno de los peores algoritmos de ordenación en cuanto a tiempo de ejecución, solamente es recomendable su uso para ordenar listas con un número pequeño de elementos.
PLISS QUISIERA SABER COMO PUEDE RESOLVER ESTE EJERCICIO ME FALTA LA ULTIMA PARTEpackage MisAplicaciones;
/** APP QUE PERMITA REGISTRAR LA EDAD* DE 5 PERSONAS Y MUESTRE UNA LISTADO* DE EDADES EN ORDEN DESCEBDENTE(EMPLEAR VECTOR)*/import java.util.Vector;import java.util.Scanner;public class PruevaVector {public static void main(String[] xx){ //CREA OBJETO VECTORScanner sc= new Scanner(System .in);Vector vec1= new Vector();vec1.addElement(17);vec1.addElement(15); vec1.addElement(18); vec1.addElement(25); vec1.addElement(45); System.out.println("LAS EDADES INGRESADAS SON:");for(int x=0;x<vec1.size();x++)
En este codigo pide que 5 usuarios ingresen su edad y esta imprime las 5 edades de mayor a menor, este le puede servir al amigo Anónimo que preguntaba por uno donde se pueda agregar valores.
package javaapplication11;import java.util.Scanner;public class JavaApplication11 {public static void main(String[] args) {int arr[]=new int [5];Scanner sc=new Scanner(System.in);for(int i=0;i<arr.length;i++){System.out.println("ingrese numero "+ i);arr[i]=sc.nextInt();} for(int i = 0; i < arr.length - 1; i++){ for(int j = 0; j < arr.length - 1; j++) {if (arr[j] < arr[j + 1]) { int tmp = arr[j+1]; arr[j+1] = arr[j];arr[j] = tmp;}}}for (int i = 0; i < arr.length; i++) {if (i==0) {System.out.println("El mayor es: "+arr[i]);
}else if (i==4) {System.out.println("Y el Menor es: " +arr[i]);}elseSystem.out.println("El siguiente es: "+arr[i]);}}
}
/////a qui les dejo uno chequenlo
import javax.swing.*;
public class burbuja{
static int arre[];int n;int aux ;public burbuja(){
n=Integer.parseInt(JOptionPane.showInputDialog("dame el tamaño de el arreglo"));arre=new int [n] ;
System.out.println ("elemento del vector "+k+" "+ arre[k]);
}}public static void main (String[] args) {
burbuja prueva=new burbuja();prueva.captura();
prueva.ordenar ();prueva.imprimir();
}}
Contar el número de palabras de una frase en JavaPrograma Java para contar el número de palabras que contiene una frase.
El programa lee un texto por teclado y lo guarda en un String. A continuación mostrará el número de palabras que contiene.
La forma más sencilla de resolverlo es utilizando la clase StringTokenizer. Esta clase sirve para dividir un String en partes, según unos delimitadores. Uno de estos delimitadores es el espacio en blanco, por lo tanto podemos aplicar StringTokenizer al texto ya que las palabras en un texto están separadas por espacios en blanco. El método countTokens() nos dirá cuantos elementos se han obtenido o lo que es lo mismo, cuantas palabras contiene el texto.
//Programa que cuenta el número de palabras de un texto.
import java.util.Scanner;
import java.util.StringTokenizer;
public class ContarPalabras {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String frase;
System.out.print("Introduce una frase: ");
frase = sc.nextLine();
StringTokenizer st = new StringTokenizer(frase);
System.out.println("Número de palabras: " + st.countTokens());
}
}
Como alternativa a utilizar la clase StringTokenizer, podemos resolverlo utilizando solo los métodos de la clase String. En este caso se tratará de buscar los espacios en blanco dentro de la cadena y contarlos.
Supondremos que las palabras están separadas entre ellas por un solo espacio en blanco. Para encontrar los espacios en blanco podemos usar el método indexOf(caracter) que devuelve la posición donde se ha encontrado el carácter dentro de la cadena. Si el carácter no se encuentra devuelve -1. También se puede usar indexOf (carácter, p) en este caso busca el carácter a partir de una posición p.
//Método que recibe un String y devuelve el número de palabras que contiene
public static int contarPalabras(String s) {
int contador = 1, pos;
s = s.trim(); //eliminar los posibles espacios en blanco al principio y al final
if (s.isEmpty()) { //si la cadena está vacía
contador = 0;
} else {
pos = s.indexOf(" "); //se busca el primer espacio en blanco
while (pos != -1) { //mientras que se encuentre un espacio en blanco
contador++; //se cuenta una palabra
pos = s.indexOf(" ", pos + 1); //se busca el siguiente espacio en blanco
} //a continuación del actual
}
return contador;
}
Eliminar la última palabra de un String en JavaMÉTODO JAVA PARA QUITAR LA ÚLTIMA PALABRA DE UN STRING.
Vamos a escribir un método que reciba un String que contiene una frase. El método eliminará la última palabra y devuelve un String con la frase modificada.
La forma de resolverlo es la siguiente: se busca el último espacio en blanco del texto mediante el método lastIndexOf. Este método devuelve la posición del último espacio en blanco. Si lastIndexOf devuelve -1 significa que no lo ha encontrado lo que quiere decir que la frase solo tiene una palabra o está vacía. En ese caso se devuelve una cadena vacía.
Si se encuentra el último espacio en blanco, se obtiene un nuevo String mediante el método substring desde la primera posición del texto hasta donde se encuentra el último espacio.
Para que esto funcione correctamente debemos asegurarnos de que el texto no contiene espacios en blanco al final ya que si fuese así no encontraríamos la última palabra con este método. Para eso se utiliza el método trim() que elimina posibles espacios en blanco al principio y al final del String.
public static String eliminarUltimaPalabra(String s) {
int pos;
s = s.trim();
pos = s.lastIndexOf(" ");
if (pos != -1) {
s = s.substring(0, pos);
} else {
s = "";
}
return s;
}
Un método main para probarlo podría ser este:
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String texto;
do {
System.out.println("Introduce texto: ");
texto = sc.nextLine();
} while (texto.isEmpty());
texto = eliminarUltimaPalabra(texto);
System.out.println(texto);
}
Se pide por teclado un texto, mediante el método isEmpty() se obliga a que el texto no esté vacío aunque esto no es necesario. Después se envía el String que contiene el texto al método para que elimine la última palabra y finalmete se muestra el String modificado.
Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest
aqui busco la posicion del ultimo espacio y creo la nueva frase hasta la posicion del espacio vacio... este es un metodo mas sencillo segun mi parecer....public class ExampleThree {public static void main(String[] args) {Scanner sc = new Scanner(System.in);
String Frase;int pos = 0;String Palabra="";
System.out.println("INGRESE LA FRASE:");Frase=sc.nextLine();Frase=Frase.trim();
for (int i = 0; i < Frase.length(); i++) {if(Frase.substring(i, i+1).equals(" ")){pos=i;}}if(pos>0){for (int i = 0; i < pos; i++) {Palabra = Palabra + Frase.substring(i, i+1);}System.out.println("LA FRASE NUEVA ES: ");System.out.println(Palabra);}else{System.out.println("LA FRASE ESTA VACIA");}}}
