Java ArrayList.

Estructura dinmica de
datos
DECLARACIN Y CREACIN DE UN ARRAYLIST

De forma general un ArrayList en Java se crea de la siguiente forma:

ArrayList nombreArray = new ArrayList();
Esta instruccin crea el ArrayList nombreArray vaco.
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 aade es el String
Lenguaje. El resto no son objetos. Son datos de tipos bsicos pero
el compilador los convierte automticamente en objetos de su clase
envolvente(clase contenedora o wrapper) antes de aadirlos al
array.
Un array al que se le pueden asignar elementos de distinto puede
tener alguna complicacin a la hora de trabajar con l. Por eso, una
alternativa a esta declaracin 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.
MTODOS DE ARRAYLIST

Algunos mtodos que proporciona ArrayList son:

MTODO

DESCRIPCIN

size()

Devuelve el nmero de elementos (int)

add(X)

Aade el objeto X al final. Devuelve true.

add(posicin, X)

Inserta el objeto X en la posicin indicada.

get(posicion)

Devuelve el elemento que est en la posicin indicada.

remove(posicion)

Elimina el elemento que se encuentra en la posicin ind

Devuelve el elemento eliminado.

remove(X)

Elimina la primera ocurrencia del objeto X. Devuelve tru

elemento est en la lista.

clear()

Elimina todos los elementos.

set(posicin, X)

Sustituye el elemento que se encuentra en la posicin in

por el objeto X. Devuelve el elemento sustituido.

contains(X)

Comprueba si la coleccin contiene al objeto X. Devuelv

o false.

indexOf(X)

Devuelve la posicin del objeto X. Si no existe devuelve

Los puedes consultar todos en:

http://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html

RECORRER UN ARRAYLIST

Podemos recorrerlo de forma clsica con un bucle for:

for(int i = 0;i<array.size();i++){
System.out.println(array.get(i));
}
Con un bucle foreach:
Si suponemos el array de enteros llamado numeros:
for(Integer i: numeros){
System.out.println(i);
}
Si el array contiene objetos de tipos distintos o desconocemos el tipo:
for(Object o: nombreArray){
System.out.println(o);
}
Utilizando un objeto Iterator.
http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html

La ventaja de utilizar un Iterador es que no necesitamos indicar el

tipo de objetos que contiene el array.
Iterator tiene como mtodos:
hasNext: devuelve true si hay ms 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
numeros
while(it.hasNext())
//mientras queden elementos
System.out.println(it.next()); //se obtienen y se muestran
EJEMPLOS DE USO DE ARRAYLIST

Ejemplo 1:
ArrayList<String> nombres = new ArrayList<String>();
nombres.add("Ana");
nombres.add("Luisa");
nombres.add("Felipe");
System.out.println(nombres); // [Ana, Luisa, Felipe]
nombres.add(1, "Pablo");
System.out.println(nombres); // [Ana, Pablo, Luisa, Felipe]
nombres.remove(0);
System.out.println(nombres); // [Pablo, Luisa, Felipe]
nombres.set(0,"Alfonso");
System.out.println(nombres); // [Alfonso, Luisa, Felipe]
String s = nombres.get(1);
String ultimo = nombres.get(nombres.size() - 1);
System.out.println(s + " " + ultimo); // Luisa Felipe
Ejemplo 2: Escribe un programa que lea nmeros enteros y los
guarde en un ArrayList hasta que se lea un 0 y muestra los nmeros
ledos, 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 nmeros 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() + "
nmeros:");
//mostrar el arrayList completo
System.out.println(numeros);
//recorrido usando un iterador para mostrar un elemento por
lnea
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 direccin de memoria donde se encuentra el ArrayList, igual que
sucede con los arrays estticos.
Si disponemos de un ArrayList de enteros llamado ventas:
La instruccin:
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 PARMETRO DE UN MTODO

Un ArrayList puede ser usado como parmetro de un mtodo.

Adems un mtodo puede devolver un ArrayList mediante la
sentencia return.
Ejemplo: Mtodo que recibe un ArrayList de String y lo modifica
invirtiendo su contenido:
import java.util.*;
public class ArrayList4 {
public static void main(String[] args) {
ArrayList<String> nombres = new ArrayList<String>();
nombres.add("Ana");
nombres.add("Luisa");
nombres.add("Felipe");
nombres.add("Pablo");
System.out.println(nombres);
nombres = invertir(nombres);
System.out.println(nombres);
}
public static ArrayList<String> invertir(ArrayList<String>
nombres) {
// Crea una lista para el resultado del mtodo
ArrayList<String> resultado = new ArrayList<String>();
// Recorre la lista de nombres en orden inverso
for (int i = nombres.size() - 1; i >= 0; i--) {
// Aade 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 ms 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 ms
dimensiones.
Ejemplo:
Programa que lee las notas de 10 alumnos y las guarda en un ArrayList Bidimensional.
Cada alumno tiene un nmero indeterminado de notas. La lectura de notas de cada
alumno acaba cuando se introduce un nmero 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; //nmero de alumnos
int i, j, nota, cont = 1;
//crear un ArrayList bidimensional de enteros vaco
//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 aade una nueva fila vaca
//esto es necesario porque el arrayList se crea vaco
array.add(new ArrayList<Integer>());

while(nota>=0){
array.get(i).add(nota); //en la fila i se aade 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, tendramos 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 Bsicos de Arrays

Resueltos 1
Relacin N 1: Ejercicios 1 y 2
1. Calcular la media de una serie de nmeros que se leen por teclado.
Programa Java que lea por teclado 10 nmeros enteros y los guarde
en un array. A continuacin calcula y muestra por separado la media
de los valores positivos y la de los valores negativos.
/*
* Programa que lea por teclado 10 nmeros enteros
* y los guarde en un array.
* A continuacin 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 nmeros positivos y

negativos
int[] numeros = new int[10]; //array que contendr los
nmeros ledos 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 nmeros
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 nmeros enteros por teclado y los

guarde en un array. Calcula y muestra la media de los nmeros que
estn en las posiciones pares del array.
Considera la primera posicin del array (posicin 0) como par.
/*
* Leer 10 nmeros enteros y guardarlos
* en un array. Calcular la media de los
* que estn 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 posicin actual es par
media = media + numeros[i]; //se suma el valor de esa
posicin
}
}
//Calcular y mostrar la media
System.out.println("Media de los valores que se encuentran en
posiciones pares: "+ media/5);
}
}

Relacin 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. Tambin muestra los alumnos con
notas superiores a la media. El nmero de alumnos se lee por
teclado.
Este programa utiliza un array de elementos de tipo double que
contendr las notas de los alumnos.
El tamao del array ser el nmero de alumnos de la clase, por lo
tanto primero se pedir por teclado el nmero de alumnos y a
continuacin 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 nmero de alumnos. Debe ser un valor positivo
do {
System.out.print("Nmero 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 nmeros pares. Mostrar por pantalla el
contenido del array creado.
/*
* Programa que crea un array de 20 elementos
* llamado Pares y guarde los 20 primeros
* nmeros 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 nmeros pares. Utilizamos un

contador
//con valor inicial 2 y le sumamos dos en cada iteracin.
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.
Ricardo11 de febrero de 2014, 21:42
//creo que seria mejor de esta forma
public 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 nmeros enteros que se leen por teclado.
A continuacin se recorre el array y calcula cuntos nmeros son positivos, cuntos
negativos y cuntos ceros.

// Contar el nmero 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 nmeros enteros que se leen por teclado.
A continuacin calcula y muestra la media de los valores positivos y la de los valores
negativos del array.
/*
* Leer 10 nmeros 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 nmeros positivos");
}
if (neg != 0) {
System.out.println("Media de los valores negativos: " + sumaNeg / neg);
} else {
System.out.println("No ha introducido nmeros negativos");
}
}

7. Programa Java para leer la altura de N personas y calcular la altura media. Calcular
cuntas personas tienen una altura superior a la media y cuntas 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 cuntos 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 nmero de personas
do{
System.out.print("Nmero de personas: ");
N = sc.nextInt();
}while(N<=0);
//Se crea el array de tamao 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 leda para calcular la media
}
//Calcular la media

media = media / N;
//recorremos el array para ver cuantos hay ms altos
//que la media y cuantos ms 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
ms gana
Programa Java que lea el nombre y el sueldo de 20 empleados y muestre el nombre y
el sueldo del empleado que ms gana.
Para hacerlo utilizaremos dos arrays:
Un array de String para los nombres de los empleados
Un array de tipo double para los sueldos de cada empleado.
Al mismo tiempo que leemos los datos de los empleados iremos comprobando cul es
el que tiene el mayor sueldo. Para ello tomamos el sueldo del primer empleado que se
lee como mayor sueldo y despus 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 nmeros tomamos el primero
como mayor y despus comparamos el resto de nmeros.

//programa que muestra el nombre y el sueldo del empleado que ms gana

import 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 ms 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 ledo 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 electrnicoEscribe un blogCompartir con TwitterCompartir con

FacebookCompartir en Pinterest

7 comentarios:
1.
Ricardo12 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();
String []arrayNombres=new String[n];
double []arraySalarios=new double[n];
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 mayor
for (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
2.
Javier Muoz Tous27 de diciembre de 2014, 15:26

Este comentario ha sido eliminado por el autor.

Responder
3.
Dani lopez cabrera21 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.
Annimo2 de marzo de 2015, 21:11
import 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 cero
String nombre; // gusrdar el nombre del trabajador que se va entrando
int rec=0; // posicin en el array del trabajador que mas cobra
int 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 array
out.println("Entre el nombre de trabajador");
nombre = miScanner.next();
nombres[i] =nombre; // asignando el trabajador a una posicin en el array
out.println("Entre el salarios de :" +nombre);
float sal= miScanner.nextInt();
salario[i]= sal; // asignando el salario a una posicin en el array
if(comparador <= sal){ // comparar los salarios
comparador= sal; // guardar el mayor salario
rec = i; // guardar posicin del salrio mayor
}
}
out.println("El mayor salario de la empresa lo tiene:"+nombres[rec] +" " );
out.println("con:"+comparador+" "+ "euros" );
}}

ArrayList de Objetos en Java

En 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 continuacin 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 nmero determinado de Kilmetros.

El coche con mayor nmero de Kilmetros.

Todos los coches ordenados por nmero de kilmetros 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("\nMatrcula: ");
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 continuacin 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);
//mtodo main
public static void main(String[] args) {
leerCoches();
System.out.println("\nCoches introducidos:");
mostrarCoches();
mostrarPorMarca();
mostrarPorKm();
System.out.println("\nCoche con mayor nmero de Km: " + mostrarMayorKm());
System.out.println("\nCoches ordenados de menor a mayor nmero de Km");
mostrarOrdenadosPorKm();
} //fin mtodo main

//Mtodo para leer coches e introducirlos en el array

public static void leerCoches(){
//Declaracin 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 nmero de coches a leer
do {
System.out.print("Nmero 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("Matrcula: ");
matricula = sc.nextLine();
System.out.print("Marca: ");
marca = sc.nextLine();
System.out.print("Modelo: ");
modelo = sc.nextLine();
System.out.print("Nmero de Kilmetros: ");
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 aade el objeto al final del array

coches.add(aux);
}
} //fin mtodo leerCoches()

Podemos representar de forma grfica el contenido del ArrayList

segn se van introduciendo los objetos:

//Mtodo 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 mtodo toString de la clase

Coche
}

//Mtodo para mostrar todos los coches de una marca que se pide por teclado
public static void mostrarPorMarca(){
String marca;
System.out.print("Introduce marca: ");
marca = sc.nextLine();
System.out.println("Coches de la marca " + marca);
for(int i = 0; i<coches.size(); i++){
if(coches.get(i).getMarca().equalsIgnoreCase(marca))
System.out.println(coches.get(i));
}
}

//Mtodo para mostrar todos los coches con un nmero de Km inferior

//al nmero de Km que se pide por teclado
public static void mostrarPorKm(){
int Km;
System.out.print("Introduce nmero de kilmetros: ");
Km = sc.nextInt();
System.out.println("Coches con menos de " + Km + " Km");
for(int i = 0; i<coches.size(); i++){
if(coches.get(i).getKm() < Km)
System.out.println(coches.get(i));
}
}

//Mtodo que devuelve el Coche con mayor nmero de Km

public static Coche mostrarMayorKm(){
Coche mayor = coches.get(0);
for(int i = 0; i < coches.size(); i++){
if(coches.get(i).getKm() > mayor.getKm())
mayor = coches.get(i);
}
return mayor;
}

//Mtodo que muestra los coches ordenados por nmero de Km de menor a mayor
public static void mostrarOrdenadosPorKm(){
int i, j;
Coche aux;
for(i = 0; i< coches.size()-1; i++)
for(j=0;j<coches.size()-i-1; j++)
if(coches.get(j+1).getKm() < coches.get(j).getKm()){
aux = coches.get(j+1);
coches.set(j+1, coches.get(j));
coches.set(j, aux);
}
mostrarCoches();
}
} //fin de la clase principal

Enviar por correo electrnicoEscribe un blogCompartir con TwitterCompartir con

FacebookCompartir en Pinterest

26 comentarios:
1.
evastos26 de julio de 2013, 22:59
Al transcribir las lineas de este cdigo me aparecen muchas alertas que
no logro arreglar. He desarrollado todos los ejercicios hasta aqu y
ninguno me ha arrojado tantas inconsistencias de cdigo. No se si es la
instalacin de NetBeans o no he importado las libreras correctas.
Requiero una respuesta por favor.
Responder
Respuestas
1.
ivania aguilar23 de octubre de 2013, 7:32
Este comentario ha sido eliminado por el autor.

2.
Annimo6 de mayo de 2014, 18:21
evastos, el cdigo esta completo, lo que llamas inconsistencias es
por la falta de las libreras 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 realizndolos 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:49
Hola, creo que a los dos os deben estar dando los mismos tipos
de error. Las dos clases tal y como estn 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 pblica que es la que da nombre
al archivo por lo tanto podeis corregir el error quitando public en
la clase Coche.
Adems teneis que aadir los import. En el ejemplo no aparecen.
Si pinchais sobre cada error netBeans os indicar el import que
falta y lo podeis aadir.

2.
Javier Cambero7 de agosto de 2013, 22:14
Gracias, ya me funciona :)
Responder
3.
Annimo27 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;
}
Responder
Respuestas
1.

ERICK RAMIREZ23 de septiembre de 2013, 6:45

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 mtodo 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 mtodo 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 nmeros aleatorios

En esta entrada vamos a escribir un mtodo Java que llene un array de enteros con
nmeros aleatorios.
Los nmeros aleatorios debern estar comprendidos entre dos lmites (desde, hasta)
ambos incluidos.
El mtodo recibe como parmetros los valores desde, hasta y el tamao del array.
El mtodo devuelve mediante return el array de enteros creado.
Para obtener nmeros enteros aleatorios usaremos el mtodo nextInt() de la clase
Random.
Para que los nmeros aleatorios obtenidos estn dentro de los limites utilizaremos el
mtodo nextInt() de la siguiente frma: 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 nmeros no se pueden repetir debemos complicar un poco ms el cdigo.
En este caso cada vez que se obtiene un nmero aleatorio se debe comprobar si ya
est en el array.
Para hacer este trabajo vamos a escribir un mtodo llamado comprobarSiContiene. A
este mtodo se le enva el array, la posicin del elemento actual y el nmero aleatorio
a insertar y devuelve true si el nmero ya existe en el array. En ese caso se vuelve a
sacar otro nmero 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 sera la solucin para aquellos que estn empezando a programar. Pero en este
caso nos podemos ahorrar trabajo utilizando la API de Java. En concreto utilizando un
ArrayList y el mtodo shuffle de Collections.
La idea es llenar un ArrayList con todos los nmeros comprendidos entre los lmites
desde/hasta. A continuacin se llama al mtodo shuffle para desordenarlos y despus
se pasan al array de enteros lostam primeros elementos, donde tam es el tamao del
array a devolver.
El mtodo utilizando el ArrayList y Collections.shuffle quedara 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 Java
Un array en Java puede tener ms de una dimensin. El caso ms
general son los arrays bidimensionales tambin
llamados matrices o tablas.
La dimensin de un array la determina el nmero 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.
Grficamente 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.

Grficamente podemos representar la disposicin 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, aadiendo
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 nmero de
elementos de cada fila es variable. Solo es obligatorio indicar el
nmero de filas.
Por ejemplo:
int [][] m = new int[3][];
crea una matriz m de 3 filas.
A cada fila se le puede asignar un nmero distinto de columnas:
m[0] = new int[3];
m[1] = new int[5];
m[2] = new int[2];
Grficamente podemos representar la disposicin 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
automticamente un valor inicial:

0 para arrays numricos

'\u0000' (carcter nulo) para arrays de caracteres

false para arrays booleanos
null para arrays de String y de referencias a objetos.
Tambin 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 aparecern a su vez entre llaves separados
por comas.
El nmero de valores determina el tamao 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 tambin 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 nmeros enteros y los guarda en una
matriz de 5 filas y 4 columnas. A continuacin muestra los valores
ledos, 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;
}
}
}
System.out.print("Elemento mayor: " + mayor);
System.out.println(" Fila: "+ filaMayor + "
Columna: " + colMayor);
System.out.print("Elemento menor: " + menor);
System.out.println(" Fila: "+ filaMenor + "
Columna: " + colMenor);
}
}
-

En este ejemplo se han utilizado dos formas distintas para recorrer la matriz:
utilizando en el for el nmero 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 nmero de columnas que

tiene cada fila:
for (i = 0; i < a.length; i++) { //nmero de filas
for (j = 0; j < a[i].length; j++) { //nmero de columnas de cada
fila
System.out.print(a[i][j] + " ");
}
System.out.println();
}

Algoritmos de ordenacin. Metodo de la

Burbuja
El algoritmo de la burbuja es uno de los mtodos de ordenacin
ms conocidos y uno de los primeros que aprenden los
programadores.
Consiste en comparar pares de elementos adyacentes en un array y
si estn desordenanos intercambiarlos hasta que estn todos
ordenados.
Si A es el array a ordenar, se realizan A.length-1 pasadas. Si la
variable i es la que cuenta el nmero 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 estn ya
ordenados. Si los elementos adyacentes estn desordenados se
intercambian.
El mtodo de ordenacin 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 ejecucin:
Ya estn ordenados, pero los dos bucles for seguirn ejecutndose
hasta el final.
El tiempo de ejecucin del algoritmo de la burbuja es del orden O(n2)
Es uno de los peores algoritmos de ordenacin en cuanto a tiempo de
ejecucin, solamente es recomendable su uso para ordenar listas con
un nmero pequeo de elementos.

PLISS QUISIERA SABER COMO PUEDE RESOLVER ESTE EJERCICIO ME FALTA

LA ULTIMA PARTE
package 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 VECTOR
Scanner 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++)
{
System.out.println("la edad es: "+vec1.elementAt(x));
}
}
}
Annimo27 de agosto de 2013, 17:01
Ms facil e intuitivo:
for (int i = 0; i < nums.length; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (nums[i] > nums[j]) {
aux = nums[i];
nums[i] = nums[j];
nums[j] = aux;

}
}
}
hay les va otro cdigo para lo mismo. tambin muestra las pasadas.
public class Burbuja {

public static void main(String[] args) {

int [] arre={1, 23, 10, 9, 5};
burbuja (arre);
}
public static void burbuja(int [] A){
int j,k, aux;
boolean f=false;
String pasada="";
for (k=0;k<A.length;k++) {
for(j=1;j<A.length;j++) {
if(A[j]<A[j-1]){
aux=A[j];
A[j]=A[j-1];
A[j-1]=aux;
System.out.println("A[j]="+A[j]+" A[j-1]="+A[j-1]+" AUX="+aux);
for(int i=0;i<A.length;i++){
pasada+=" "+Integer.toString(A[i]);
}
System.out.println("Arreglo A={" +pasada+" }");
pasada="";
}
}
}
}
}
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 Annimo 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]);
}else
System.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 tamao de el
arreglo"));
arre=new int [n] ;
}
public void captura (){
int ele;
for (int i=0; i arre[j+1] ){
aux=arre[j];
arre[j]=arre[j+1];
arre[j+1]=aux;
}
}

}
}
public void imprimir(){
System.out.println ("el vector quedadela siguiente forma ");
for(int k=0; k<n;k++){
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 nmero de palabras de una

frase en Java
Programa Java para contar el nmero de palabras que contiene una
frase.
El programa lee un texto por teclado y lo guarda en un String. A
continuacin mostrar el nmero de palabras que contiene.
La forma ms sencilla de resolverlo es utilizando la
clase StringTokenizer. Esta clase sirve para dividir un String en
partes, segn 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 estn separadas por espacios
en blanco. El mtodo countTokens() nos dir cuantos elementos se
han obtenido o lo que es lo mismo, cuantas palabras contiene el
texto.

//Programa que cuenta el nmero 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("Nmero de palabras: " + st.countTokens());
}
}

Como alternativa a utilizar la clase StringTokenizer, podemos

resolverlo utilizando solo los mtodos 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 estn separadas entre ellas por un
solo espacio en blanco. Para encontrar los espacios en blanco
podemos usar el mtodo indexOf(caracter) que devuelve la posicin
donde se ha encontrado el carcter dentro de la cadena. Si el
carcter no se encuentra devuelve -1. Tambin se puede usar indexOf
(carcter, p) en este caso busca el carcter a partir de una posicin p.

//Mtodo que recibe un String y devuelve el nmero 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 vaca
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 continuacin del

actual
}
return contador;
}

Eliminar la ltima palabra de un String en

Java
MTODO JAVA PARA QUITAR LA LTIMA PALABRA DE UN STRING.

Vamos a escribir un mtodo que reciba un String que contiene una

frase. El mtodo 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 mtodo lastIndexOf. Este mtodo
devuelve la posicin 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 vaca. En ese caso se devuelve
una cadena vaca.
Si se encuentra el ltimo espacio en blanco, se obtiene un nuevo
String mediante el mtodo substring desde la primera posicin 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
encontraramos la ltima palabra con este mtodo. Para eso se utiliza
el mtodo 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 mtodo main para probarlo podra 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 mtodo isEmpty() se obliga

a que el texto no est vaco aunque esto no es necesario. Despus se
enva el String que contiene el texto al mtodo para que elimine la
ltima palabra y finalmete se muestra el String modificado.

Enviar por correo electrnicoEscribe un blogCompartir con TwitterCompartir con

FacebookCompartir en Pinterest

3 comentarios:
1.
Annimo1 de marzo de 2015, 3:19
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");
}
}
}