1
2
3
4
5

//Si es de tipo String
 String arreglo[] = new String [Aqui se coloca el tamaño con un valor numerico];
 String arreglo[] = new String [2];
 //Si es de tipo entero
 int arreglo[] = new int [2];

y de la misma manera se hace para todos los tipos de datos, una ves que se tiene el arreglo creado, con su tamaño respectivo, lo que sigue es llenarlo con su respectivo tipo de dato. Hay muchas formas de llenar el arreglo aqui mostrare como llenarlo manualmente y despues pidiendolo al usuario:

1
2
3
4

//Manualmente seria ingresar por default en el codigo lo que se agregara
 String arreglo[] = new String [2];
 arreglo[0] = "Manzana";
 arreglo[1] = "Pera";

Cabe mencionar que los arreglos comienzan a llenarse desde el 0 y terminan antes del tamaño del arreglo en este caso como lo puse de tamaño 2, pues este termina en 1. Para llenarlo pidiendolo al usuario, se puede hacer desde consola o en modo grafico, ya sea con algun frame o con algun JOptionPane. Lo aremos con un JOptionPane y un ciclo for.

1
2
3
4
5

//De esta manera lo llenamos pidiendo con JOptionPane al usuario
 String arreglo[] = new String [2];
 for(int = 0; i<arreglo.length();i++){
 arreglo[i] = JOptionPane.showInputDialog("Ingresa Valor al arreglo en la posicion "+i)
 }

?Ahora para imprimir, de la misma manera se puede hacer manual pero eso ya quedo comprendido hasta ahora y es muy poco eficaz y poco robusto, asi que mejor lo haremos con un ciclo, seria de la siguiente manera (concatearemos los valores de el arreglo en una string para poder imprimir en un JOptionPane):

1
2
3
4
5
6

String cadena = "";
 for(int = 0; i<arreglo.length();i++){
 cadena = cadena + arreglo[i];
 }
 
JOptionPane.showMessageDialog(null, "Este es mi arreglo:  "+cadena);

Ahora todo el codigo junto para que funcione de una manera correcta:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import javax:swing.*;
 public class tutorial3{
 public void main(String [] args){
 String arreglo = new String[2];
 
//con esto se hace el llenado
 for(int i=0; i<arreglo.length();i++){
 arreglo[i] = JOptionPane.showInputDialog("Ingrese llenado de arreglo");
 }
 //con esto se imprime
 String cadena=""
 for(int i=0; i<arreglo.length();i++){
 cadena = cadena + arreglo[i];
 }
 
JOptionPane.showMessageDialog(null, "Este es mi arreglo:  "+cadena);
 
}
 }

Aqui dejo los videotutoriales saludos.

Parte1:

[youtube]http://www.youtube.com/watch?v=MWdMVkNB9do[/youtube]

Parte2:

[youtube]http://www.youtube.com/watch?v=8ANOhYPOZ04[/youtube]

Ahora vamos un paso más allá y vamos a ver como podemos invertir el orden de las palabras de una frase. Para ellos nos apoyaremos en una estructura de tipo pila. Puedes ver más información de qué es una pila en Crear una pila en Java.

La idea inicial es quedarnos con las palabras. Para poder acometer este primer paso tenemos que desmontar la frase en palabras. Para ellos nos vamos a apoyar en la clase StringTokenizer. La cual, mediante la simple instanciación de la misma, nos convierte la frase en un array de palabras.

1
2

String sTexto = "En un lugar de la mancha de cuyo nombre no quiero acordarme";
 StringTokenizer frase = new StringTokenizer(sTexto);

Ahora creamos nuestra pila…

1

Stack<String> pila = new Stack<String>();

E iremos insertando cada uno de los elementos del StringTokenizer.

1
2
3

while (frase.hasMoreTokens()) {
 pila.push(frase.nextToken());
 }

Nos apoyamos el el método .hasMoreTokens() de la clase StringTokenizer, para ver si hemos extraído todos los elementos de la misma. La extracción de elementos de la clase StringTokenizer lo haremos mediante .nextToken(), el cual extrae y pasa al siguiente elemento.

Para insertar los elementos en la pila nos apoyamos en el método push().

Una vez cargada la pila, procederemos a la extracción de los elementos de la misma. El hecho de que la pila sea una estructura LIFO (Last In First Out) hace que lo insertado quede en orden inverso. Es por ello que tendremos la frase invertida de una forma muy sencilla.

1
2

while (!pila.empty())
 System.out.print(pila.pop() + " ");

Cada elemento de la pila se extrae con el método .pop(). Un ejemplo muy útil de para qué utilizar una pila.

Lo primero es tener una cadena. Esto es sencillo:

1

String sCadena = "MixInformatico";

La idea es muy simple. Iremos recorriendo la cadena, carácter a carácter, desde el último carácter hasta el primero. Para ello nos apoyamos en un bucle for.

1
2

for (int x=sCadena.length()-1;x>=0;x--)
		sCadenaInvertida = sCadenaInvertida + sCadena.charAt(x);

Para obtener el último carácter lo haremos mediante el método .length()  que nos da el tamaño de la cadena y restandole uno. Esto es así ya que los caracteres de la cadena están numerados del 0 al tamaño de la cadena menos uno.

Ahora solo tendremos que volcar a consola la cadena invertida:

1

System.out.println(sCadenaInvertida);

Descargar el código

• apilar, añade un elemento a la lista.
• desapilar, retira un elemento de la lista
• ¿está vacía?, comprueba si la lista está vacía

En el lenguaje Java contamos con la clase Stack en la librería java.util. Es importante saber que la pila hereda de la pila (aka Vector). Y que por lo tanto podemos utilizar los elementos del Vector sobre la pila.

En nuestro ejemplo vamos a insertar 10 elementos, que serán números, y los recuperaremos en su orden inverso.

Lo primero será definir la pila, es decir, instanciar la clase Stack.

1

Stack<String> pila = new Stack<String>();

Como vemos el tipo de elementos que insertaremos en la pila serán String -cadenas-.

Una vez instanciada vamos a ir creando los elementos e insertándolos en la pila. El método que inserta elementos en la pila es .push(). Este método recibirá como parámetro el elemento a insertar.

1
2

for (int x=1;x<=10;x++)
 pila.push(Integer.toString(x));

Hemos creado un bucle que nos vaya creando los números y nos hemos apoyado en la clase Integer y su método .toString() para convertir los números en cadena.

Una vez que tenemos todos los elementos, procedemos al vaciado de la pila. Tendremos que interactuar sobre la pila hasta que esta esté vacía, cosa que nos dice el método .empty(). En cada una de las iteraciones extraeremos un elemento de la pila mediante el método .pop()

1
2

while (!pila.empty())
 System.out.println(pila.pop());

]]> http://www.mixinformatico.com/2010/03/30/como-crear-una-pila-en-java/feed/ 0 http://www.mixinformatico.com/2010/03/26/metodo-split-en-java/ http://www.mixinformatico.com/2010/03/26/metodo-split-en-java/#comments Fri, 26 Mar 2010 03:38:14 +0000 dementexmaster http://www.mixinformatico.com/?p=9012 Bueno el metodo .split() es muy facil de utilizar, lo que hace este metodo es separa en un arreglo una cadena la cual se delimita por otra subcadena contenida en la misma, pero para una mejor comprencion les dejare este ejemplo de cortar una cadena que contiene algunos lenguajes de programación:

1
2

String cadena = "1 Java-2 Php-3 C++-4 Perl";
 String arr[] = cadena.split("-");

La salida seria de esta forma

1
2
3
4

 1 Java
 2 Php
 3 C++
 4 Perl

Para una mejor comprecion les mostrare el codigo completo de como funciona con impreción:

1
2
3
4
5
6
7
8
9

public class Main{
 public static void main(String[] args) {
 String cadena = "Manzana, Pera, Piña, Durazno";
 String arr[] = cadena.split(", ");
 for(int c=0;c<arr.length;c++){
 System.out.println(arr[c]);
 }
 }
}

1
2
3
4
5
6
7
8
9

static  public void tablasdemultiplicar(int contador){
 int arr[] = {1,2,3,4,5,6,7,8,9,10};
 System.out.println("\nTabla del "+contador);
 for(int c=0;c<arr.length;c++){
 System.out.println(contador+" x "+arr[c]+" = "+(contador*arr[c]));
 }
 if(contador!=10)
 tablasdemultiplicar(contador+1);
 }

Explico como funciona, teniendo un simple arreglo de 10 numeros  y llamando al metodo con un parametro igual a uno lo que esto hara es cada vez que el metodo se llama asi mismo aumenta el parametro y ese parametro se multiplica por los 10 numeros  y esto se hace recursivamente hasta que el parametro es igual a 10 el codigo final seria asi:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Main{
 public static void main(String[] args) {
 tablasdemultiplicar(1);
 }
 
 static  public void minimaexpresion(int contador){
 int arr[] = {1,2,3,4,5,6,7,8,9,10};
 System.out.println("\nTabla del "+contador);
 for(int c=0;c<arr.length;c++){
 System.out.println(contador+" x "+arr[c]+" = "+(contador*arr[c]));
 }
 if(contador!=10)
 tablasdemultiplicar(contador+1);
 }
}

Y la salida seria algo asi:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

Tabla del 1
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5
1 x 6 = 6
1 x 7 = 7
1 x 8 = 8
1 x 9 = 9
1 x 10 = 10
 
Tabla del 2
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18
2 x 10 = 20
 
Tabla del 3
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15
3 x 6 = 18
3 x 7 = 21
3 x 8 = 24
3 x 9 = 27
3 x 10 = 30
 
etc.............................................................

1

int iNumeroPotencias = 10;

Despues utilizaremos un bucle que llame tantas veces al método como potencias queremos mostrar:

1

for (int x=0;x<=iNumeroPotencias;x++) {...}

El método .pow() tiene dos parámetros, el primero es la base de la potencia y el segundo es el número al que queremos elevar la base. En nuestro caso la base será fija, el 2 y la potencia será el valor del bucle. El código que nos queda es el siguiente:

1
2

for (int x=0;x<=iNumeroPotencias;x++)
 System.out.println("2 elevado a " + x + " igual a " + (int)Math.pow(2,x));

Pero vamos por partes. Lo primero será tener una palabra/frase que sea un palíndromo, e instanciarla en un String.

1

String sPalabra = "comete al oso la etemoc";

Preparamos un poco la palabra/frase, quitándola los espacios en blanco. Para ello utilizamos el método replace.

1

sPalabraSinEspacios = sPalabra.replace(" ", "");

Ahora cargaremos el string buffer y le aplicamos el método .reverse, quedándonos la palabra/frase dada la vuelta.

1
2

      StringBuffer sb = new StringBuffer(sPalabraSinEspacios);
      sb = sb.reverse();

Ya solo nos quedará el comparar la palabra original con la palabra dada la vuelta mediante el método reverse. En caso de que coincidan será que la palabra es un palíndromo.

1
2
3
4

if (sPalabraSinEspacios.equalsIgnoreCase(sb.toString()))
 System.out.println(sPalabra + " es un PALINDROMO");
 else
 System.out.println(sPalabra + " NO es un palindromo");

El método .codePointAt() devuelve el código ASCII de un carácter en concreto. El carácter será el que coincida con el índice que se pasa como parámetro al método.

Empezamos definiendo la cadena:

1

String sCadena = "Esto es una cadena de texto";

Ahora empezamos recorriendo la cadena, para ello nos apoyamos en un bucle for y en el método .length(), el cual nos ayuda a conocer el tamaño de la cadena. En el interior del bucle, y apoyándonos en el elemento de interacción vamos obteniendo el código ASCII de los caracteres con el método .codePointAt()

1
2

for (int x=0;x<sCadena.length();x++)
System.out.println(sCadena.charAt(x) + " = " + sCadena.codePointAt(x));

Vemos que utilizamos el método .charAt() para sacar el carácter asociado al código ASCII.

1
2
3
4
5
6
7
8
9
10

public class Nodo {
 Nodo nodoDer;
 int  dato;
 
public  Nodo(int dato) {
 this.dato = dato;
 this.nodoDer = null;
 }
 
}

Nesesitaremos un nodo para agregar a la lista este metodo ira agregando todo al final de la misma:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public  ListaS addLast(int dato) {
 if(siVacio()) {
 Nodo nuevo = new Nodo(dato);
 primero = nuevo;
 ultimo = nuevo;
 nuevo.nodoDer =  nuevo;
 }
 else {
 Nodo nuevo = new Nodo(dato);
 nuevo.nodoDer =  null;
 ultimo.nodoDer =  nuevo;
 ultimo = nuevo;
 }
 this.tamano++;
 return  this;
 }

De igual forma se nesesita un metodo para borrar datos de la lista:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public  Nodo deleteLast() {
 Nodo eliminar = null;
 if(siVacio()) {
JOptionPane.showMessageDialog(null, "La lista se encuentra vacia");
 return  null;
 }
 if(primero == ultimo) {
 primero = null;
 ultimo = null;
 }
 else {
 Nodo actual = primero;
 while(actual.nodoDer !=  ultimo) {
 actual = actual.nodoDer;
 }
 eliminar = actual.nodoDer;
 actual.nodoDer =  null;
 
ultimo = actual;
 }
 this.tamano--;
 return  eliminar;
 }

Nuestro codigo completo quedaria de la siguiente manera:

Classe principal:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

import javax.swing.JOptionPane;
 
public class ListaS {
    private Nodo primero;
    private Nodo ultimo;
    private int tamano;
 
    public ListaS() {
        this.primero = null;
        this.ultimo = null;
        this.tamano = 0;
    }
 
//Metodo utilizado para denotar que la lista se encuentra vacia.
    public boolean siVacio() {
        return (this.primero == null);
    }
 
//Metodo para agregar al final de la lista.
    public ListaS addLast(int dato) {
        if(siVacio()) {
            Nodo nuevo = new Nodo(dato);
            primero = nuevo;
            ultimo = nuevo;
            nuevo.nodoDer = nuevo;
        }
        else {
            Nodo nuevo = new Nodo(dato);
            nuevo.nodoDer = null;
            ultimo.nodoDer = nuevo;
            ultimo = nuevo;
        }
        this.tamano++;
        return this;
    }
 
//Metodo para borrar al final de la lista.
    public Nodo deleteLast() {
        Nodo eliminar = null;
        if(siVacio()) {
            JOptionPane.showMessageDialog(null, "La lista se encuentra vacia");
            return null;
        }
        if(primero == ultimo) {
            primero = null;
            ultimo = null;
        }
        else {
            Nodo actual = primero;
            while(actual.nodoDer != ultimo) {
                actual = actual.nodoDer;
            }
            eliminar = actual.nodoDer;
            actual.nodoDer = null;
 
            ultimo = actual;
        }
        this.tamano--;
        return eliminar;
    }
 
//Metodo que imprime el tamaño de la lista.
    public void tamano() {
        JOptionPane.showMessageDialog(null, "El tamaño es:\n " + this.tamano);
    }
 
//Metodo que imprime la lista y los valores ingresados.
    public void imprimir() {
        if(tamano != 0) {
            Nodo temp = primero;
            String str = "";
            for(int i = 0; i < this.tamano; i++) {
                str = str + temp.dato + "\n";
                temp = temp.nodoDer;
            }
            JOptionPane.showMessageDialog(null, str);
        }
    }
}

Clase Nodo:

1
2
3
4
5
6
7
8
9
10

public class Nodo {
 Nodo nodoDer;
 int  dato;
 
public  Nodo(int dato) {
 this.dato = dato;
 this.nodoDer = null;
 }
 
}