NOMBRAR 10 PALABRAS RESERVADAS EN JAVA 


    PALABRAS RESERVADAS DE JAVA

    Las palabras reservadas son identificadores predefinidos que tienen un significado para el compilador y por tanto no pueden usarse como identificadores creados por el usuario en los programas.

    Las palabras reservadas en Java ordenadas alfabéticamente son las siguientes:



    Resultado de imagen para PALABRAS RESERVADAS EN JAVA


    abstract: Se utilizan para implementar una abstracción en Java. Un método sin definición debe declararse como abstracto y la clase que lo contiene debe declararse como abstracto. Las clases abstractas no pueden ser instanciadas. Los métodos abstractos deben ser implementados en las subclases. La palabra clave abstract no se puede utilizar con variables o constructores. Tenga en cuenta que no se requiere que una clase abstracta tenga un método abstracto en absoluto.
    assert: Assert describe un predicado (una declaración de verdadero / falso) colocado en un programa Java para indicar que el desarrollador piensa que el predicado siempre es verdadero en ese lugar. Si una aserción se evalúa como falsa en tiempo de ejecución, se produce un error de aserción, que normalmente hace que la ejecución se anule. Opcionalmente habilitar por el método ClassLoader.
    boolean: Define una variable booleana para los valores "true" o "false" solamente. Por defecto, el valor del tipo primitivo booleano es falso. Esta palabra clave también se usa para declarar que un método devuelve un valor del tipo primitivo booleano.
    break: Se utiliza para finalizar la ejecución en el cuerpo del bucle actual.
    byte: La palabra clave byte se utiliza para declarar un campo que puede contener un entero de complemento de dos con signo de 8 bits. Esta palabra clave también se utiliza para declarar que un método devuelve un valor del byte tipo primitivo.
    case: Una declaración en el bloque de conmutación se puede etiquetar con una o más etiquetas de case. La instrucción switch evalúa su expresión, luego ejecuta todas las declaraciones que siguen la etiqueta de caso correspondiente.
    catch: Se usa junto con un bloque de prueba y un bloque finalmente opcional. Las declaraciones en el bloque catch especifican qué hacer si el bloque try lanza un tipo específico de excepción.
    char: Define una variable de carácter capaz de contener cualquier carácter del conjunto de caracteres del archivo fuente Java.
    class: Un tipo que define la implementación de un tipo particular de objeto. Una definición de clase define los campos de instancia y clase, los métodos y las clases internas, además de especificar las interfaces que implementa la clase y la superclase inmediata de la clase. Si la superclase no se especifica explícitamente, la superclase es implícitamente Object. La palabra clave de clase también se puede utilizar en el formulario Class.class para obtener un objeto Class sin necesidad de una instancia de esa clase. Por ejemplo, String.class se puede usar en lugar de hacer una nueva String (). GetClass ().
    continue: Se utiliza para reanudar la ejecución del programa al final del cuerpo del bucle actual. Si le sigue una etiqueta, continúe con la ejecución de reanudación al final del cuerpo del bucle etiquetado adjunto.
    default: La palabra clave default se puede usar opcionalmente en una instrucción de cambio para etiquetar un bloque de instrucciones que se ejecutarán si ningún caso coincide con el valor especificado; ver interruptor. Alternativamente, la palabra clave predeterminada también se puede utilizar para declarar valores predeterminados en una anotación de Java. Desde Java 8 en adelante, la palabra clave predeterminada se puede usar para permitir que una interfaz proporcione una implementación de un método.
    do: La palabra clave do se usa junto con while para crear un bucle do-while, que ejecuta un bloque de sentencias asociadas con el bucle y luego prueba una expresión booleana asociada con while. Si la expresión se evalúa como verdadera, el bloque se ejecuta de nuevo; esto continúa hasta que la expresión se evalúa como falsa.


    ¿QUE ES UN IDENTIFICADOR EN JAVA?

    DENTIFICADORES JAVA

    Conoce cuales son las reglas para definir identificadores y qué son las palabras reservadas en Java, así como ejemplos de identificadores validos.
    En los lenguajes de programación, los identificadores (como su nombre lo indica) se utilizan con fines de identificación. En Java, un identificador puede ser un nombre de clase, un nombre de método o un nombre de variable. Por ejemplo:
    En el código java anterior, tenemos 5 identificadores, a saber:
    • Test: nombre de clase.
    • main: nombre del método.
    • String: nombre de clase predefinido.
    • args: nombre de la variable.
    • a: nombre de la variable.

    1. Reglas para definir identificadores de Java

    Existen ciertas reglas para definir un identificador java válido. Estas reglas deben seguirse, de lo contrario obtenemos un error en tiempo de compilación. Estas reglas también son válidas para otros lenguajes como C, C++.
    • Los únicos caracteres permitidos para los identificadores son todos los caracteres alfanuméricos ([AZ], [az], [0-9]), “$” (signo de dólar) y ‘_’ (guión bajo). Por ejemplo, “java@” no es un identificador de Java válido ya que contiene “@” – carácter especial.
    • Los identificadores no deben comenzar con dígitos ([0-9]). Por ejemplo, “123java” no es un identificador de Java válido.
    • Los identificadores de Java distinguen entre mayúsculas y minúsculas.
    • No hay límite en la longitud del identificador, pero es aconsejable usar solamente una longitud óptima de 4 a 15 caracteres.
    • Las palabras reservadas no se pueden usar como un identificador. Por ejemplo, int while = 28; es una declaración inválida ya que while es una palabra reservada. Hay 53 palabras reservadas en Java.

    2. Ejemplos de identificadores válidos

    MyVariable
    MYVARIABLE
    myvariable
    x
    i
    x1
    i1
    _myvariable
    $myvariable
    sum_of_array
    javadesdecero

    3. Ejemplos de identificadores inválidos

    My Variable // Contiene un espacio
    123java // Comienza con un dígito
    a+c // El signo más (+) no es un carácter alfanumérico
    variable-2 // El guión (-) no es un carácter alfanumérico
    sum_&_difference // ampersand (&) no es un carácter válido

    4. Palabras reservadas en Java


    Cualquier lenguaje de programación reserva algunas palabras para representar funcionalidades definidas por ese lenguaje. Estas palabras se llaman palabras reservadas. Estas pueden ser categorizadas brevemente en dos partes: palabras clave/keywords (50) y literales (3).



    TIPOS DE DATOS EN JAVA 

    Tipos de datos primitivos en Java

    Java cuenta con un pequeño conjunto de tipos de datos primitivos. Podríamos considerarlos fundamentales, ya que la mayor parte de los demás tipos, los tipos estructurados o complejos, son composiciones a partir de estos más básicos. Estos tipos de datos primitivos sirven para gestionar los tipos de información más básicos, como números de diversas clases o datos de tipo verdadero/falso (también conocidos como "valores booleanos" o simplemente "booleanos").
    De estos tipos primitivos, ocho en total, seis de ellos están destinados a facilitar el trabajo con números. Podemos agruparlos en dos categorías: tipos numéricos enteros y tipos numéricos en punto flotante. Los primeros permiten operar exclusivamente con números enteros, sin parte decimal, mientras que el segundo grupo contempla también números racionales o con parte decimal.

    Tipos numéricos enteros

    En Java existen cuatro tipos destinados a almacenar números enteros. La única diferencia entre ellos es el número de bytes usados para su almacenamiento y, en consecuencia, el rango de valores que es posible representar con ellos. Todos ellos emplean una representación que permite el almacenamiento de números negativos y positivos. El nombre y características de estos tipos son los siguientes:
    • byte: como su propio nombre denota, emplea un solo byte (8 bits) de almacenamiento. Esto permite almacenar valores en el rango [-128, 127].
    • short: usa el doble de almacenamiento que el anterior, lo cual hace posible representar cualquier valor en el rango [-32.768, 32.767].
    • int: emplea 4 bytes de almacenamiento y es el tipo de dato entero más empleado. El rango de valores que puede representar va de -231 a 231-1.
    • long: es el tipo entero de mayor tamaño, 8 bytes (64 bits), con un rango de valores desde -263 a 263-1.

    Tipos numéricos en punto flotante

    Los tipos numéricos en punto flotante permiten representar números tanto muy grandes como muy pequeños además de números decimales. Java dispone de 2 tipos concretos en esta categoría:
    • float: conocido como tipo de precisión simple, emplea un total de 32 bits. Con este tipo de datos es posible representar números en el rango de 1.4x10-45 a 3.4028235x1038.
    • double: sigue un esquema de almacenamiento similar al anterior, pero usando 64 bits en lugar de 32. Esto le permite representar valores en el rango de 4.9x10-324 a 1.7976931348623157x10308.

    Booleanos y caracteres

    Aparte de los 6 tipos de datos que acabamos de ver, destinados a trabajar con números en distintos rangos, Java define otros dos tipos primitivos más:
    • boolean: tiene la finalidad de facilitar el trabajo con valores "verdadero/falso" (booleanos), resultantes por regla general de evaluar expresiones. Los dos valores posibles de este tipo son truefalse.
    • char: se utiliza para almacenar caracteres individuales (letras, para entendernos). En realidad está considerado también un tipo numérico, si bien su representación habitual es la del carácter cuyo código almacena. Utiliza 16 bits y se usa la codificación UTF-16 de Unicode.

    Tipos de datos estructurados

    Los tipos de datos primitivos que acabamos de ver se caracterizan por poder almacenar un único valor. Salvo este reducido conjunto de tipos de datos primitivos, que facilitan el trabajo con números, caracteres y valores booleanos, todos los demás tipos de Java son objetos, también llamados tipos estructurados o "Clases".
    Los tipos de datos estructurados se denominan así porque en su mayor parte están destinados a contener múltiples valores de tipos más simples, primitivos. También se les llama muchas veces "tipos objeto" porque se usan para representar objetos. Puede que te suene más ese nombre.

    Cadenas de caracteres

    Aunque las cadenas de caracteres no son un tipo simple en Java, sino una instancia de la clase String, el lenguaje otorga un tratamiento bastante especial a este tipo de dato, lo cual provoca que, en ocasiones, nos parezca estar trabajando con un tipo primitivo.
    Aunque cuando declaramos una cadena estamos creando un objeto, su declaración no se diferencia de la de una variable de tipo primitivo de las que acabamos de ver:
    String nombreCurso = "Iniciación a Java";
    
    Y esto puede confundir al principio. Recuerda: Las cadenas en Java son un objeto de la clase String, aunque se declaren de este modo.
    Las cadenas de caracteres se delimitan entre comillas dobles, en lugar de simples como los caracteres individuales. En la declaración, sin embargo, no se indica explícitamente que se quiere crear un nuevo objeto de tipo String, esto es algo que infiere automáticamente el compilador.
    Las cadenas, por tanto, son objetos que disponen de métodos que permiten operar sobre la información almacenada en dicha cadena. Así, encontraremos métodos para buscar una subcadena dentro de la cadena, sustituirla por otra, dividirla en varias cadenas atendiendo a un cierto separador, convertir a mayúsculas o minúsculas, etc.

    Vectores o arrays

    Los vectores son colecciones de datos de un mismo tipo. También son conocidos popularmente como arrays e incluso como "arreglos" (aunque se desaconseja esta última denominación por ser una mala adaptación del inglés).
    Un vector es una estructura de datos en la que a cada elemento le corresponde una posición identificada por uno o más índices numéricos enteros.
    También es habitual llamar matrices a los vectores que trabajan con dos dimensiones.
    Los elementos de un vector o array se empiezan a numerar en el 0, y permiten gestionar desde una sola variable múltiples datos del mismo tipo.
    Por ejemplo, si tenemos que almacenar una lista de 10 números enteros, declararíamos un vector de tamaño 10 y de tipo entero, y no tendríamos que declarar 10 variables separadas de tipo entero, una para cada número.

    Tipos definidos por el usuario

    Además de los tipos estructurados básicos que acabamos de ver (cadenas y vectores) en Java existen infinidad de clases en la plataforma, y de terceros, para realizar casi cualquier operación o tarea que se pueda ocurrir: leer y escribir archivosenviar correos electrónicosejecutar otras aplicaciones o crear cadenas de texto más especializadas, entre un millón de cosas más.
    Todas esas clases son tipos estructurados también.
    Y por supuesto puedes crear tus propias clases para hacer todo tipo de tareas o almacenar información. Serían tipos estructurados definidos por el usuario.

    Tipos envoltorio o wrapper

    Java cuenta con tipos de datos estructurados equivalentes a cada uno de los tipos primitivos que hemos visto.
    Así, por ejemplo, para representar un entero de 32 bits (int) de los que hemos visto al principio, Java define una clase llamada Integer que representa y "envuelve" al mismo dato pero le añade ciertos métodos y propiedades útiles por encima.
    Además, otra de las finalidades de estos tipos "envoltorio" es facilitar el uso de esta clase de valores allí donde se espera un dato por referencia (un objeto) en lugar de un dato por valor (para entender la diferencia entre tipos por valor y tipos por referencia lee este artículo. Aunque está escrito para C#, todo lo explicado es igualmente válido para Java).
    Estos tipos equivalentes a los primitivos pero en forma de objetos son: ByteShortIntegerLongFloatDoubleBoolean y Character (8 igualmente).
    A continuación te dejamos un esquema resumen de todo lo anterior para facilitarte que lo "digieras" viéndolo ya ordenado:
    Esquema de tipos de datos en Java

    LOS MODIFICADORES DE VARIABLES JAVA
     Los modificadores de acceso nos introducen al concepto de encapsulamiento. El encapsulamiento busca de alguna forma controlar el acceso a los datos que conforman un objeto o instancia, de este modo podríamos decir que una clase y por ende sus objetos que hacen uso de modificadores de acceso (especialmente privados) son objetos encapsulados.
    Los modificadores de acceso permiten dar un nivel de seguridad mayor a nuestras aplicaciones restringiendo el acceso a diferentes atributos, métodos, constructores asegurándonos que el usuario deba seguir una "ruta" especificada por nosotros para acceder a la información.
    Es muy posible que nuestras aplicaciones vayan a ser usadas por otros programadores o usuarios con cierto nivel de experiencia; haciendo uso de los modificadores de acceso podremos asegurarnos de que un valor no será modificado incorrectamente por parte de otro programador o usuario. Generalmente el acceso a los atributos se consigue por medio de los métodos get y set, pues es estrictamente necesario que los atributos de una clase sean privados.
    Nota: Siempre se recomienda que los atributos de una clase sean privados y por tanto cada atributo debe tener sus propios métodos get y set para obtener y establecer respectivamente el valor del atributo.
    Nota 2: Siempre que se use una clase de otro paquete, se debe importar usando import. Cuando dos clases se encuentran en el mismo paquete no es necesario hacer el import pero esto no significa que se pueda acceder a sus componentes directamente.
    Veamos un poco en detalle cada uno de los modificadores de acceso

    Modificador de acceso private

    El modificador private en Java es el más restrictivo de todos, básicamente cualquier elemento de una clase que sea privado puede ser accedido únicamente por la misma clase por nada más. Es decir, si por ejemplo, un atributo es privado solo puede ser accedido por lo métodos o constructores de la misma clase. Ninguna otra clase sin importar la relación que tengan podrá tener acceso a ellos.
    package aap.ejemplo1; public class Ejemplo1 { private int atributo1;//Este atributo es privado private int contador = 0; //Contador de registro //Si un atributo es privado podemos crear método get y set ... //... para éste y permitir el acceso a él desde otras instancias public void setAtributo1(int valor) { contador++;//Contador que lleva el registro de ediciones del atributo1 atributo1 = valor;//Establecemos el valor del atributo } public int getAtributo1() { return atributo1;//Retornamos el valor actual del atributo } //Get para el contador public int getContador() { return contador; } //Notar que no ponemos un set, pues no nos interesa que el contador pueda ser cambiado. }
    En el ejemplo anterior vemos lo que mencioné al comiendo, tenemos un atributo privado y permitimos el acceso a él únicamente por medio de los métodos de get y set, notemos que estos métodos son públicos y por tanto cualquiera puede accederlos. Lo realmente interesante con los métodos get y set es que nos permiten realizar cualquier operación como por ejemplo llevar una cuenta de la veces que se estableció el valor para el atributo permitiéndonos mantener nuestro sistema sin problemas. También debemos notar que debido a que los métodos get y set son propios de la clase no tienen problemas con acceder al atributo directamente.

    El modificador por defecto (default)

    Java nos da la opción de no usar un modificador de acceso y al no hacerlo, el elemento tendrá un acceso conocido como defaulto acceso por defecto que permite que tanto la propia clase como las clases del mismo paquete accedan a dichos componentes (de aquí la importancia de declararle siempre un paquete a nuestras clases).
    package aap.ejemplo2; public class Ejemplo2 { private static int atributo1;//Este atributo es privado static int contador = 0; //Contador con acceso por defecto public static void setAtributo1(int valor) { contador++;//Contador que lleva el registro de ediciones del atributo1 atributo1 = valor;//Establecemos el valor del atributo } public static int getAtributo1() { return atributo1;//Retornamos el valor actual del atributo } } package aap.ejemplo2; public class Ejemplo2_1 { public static int getContador() { return Ejemplo2.contador;//Accedemos directamente al contador desde otra clase } }

    Modificador de acceso protected

    El modificador de acceso protected nos permite acceso a los componentes con dicho modificador desde la misma clase, clases del mismo paquete y clases que hereden de ella (incluso en diferentes paquetes). Veamos:
    package aap.ejemplo3; public class Ejemplo3 { protected static int atributo1;//Atributo protected private static int atributo2; //Atributo privado int atributo3;//Atributo por default public static int getAtributo2() { return atributo2; } } package aap.ejemplo3_1; import aap.ejemplo3.Ejemplo3;//Es necesario importar la clase del ejemplo 3 public class Ejemplo3_1 extends Ejemplo3 { public static void main(String[] args) { //La siguientes dos líneas generan error, pues atributo2 es privado y atributo 3 es default //System.out.println(atributo2); //System.out.println(atributo3); System.out.println(atributo1);//Sí tenemos acceso a atributo1 } }

    Modificador public

    El modificador de acceso public es el más permisivo de todos, básicamente public es lo contrario a private en todos los aspectos (lógicamente), esto quiere decir que si un componente de una clase es public, tendremos acceso a él desde cualquier clase o instancia sin importar el paquete o procedencia de ésta.
    package aap.ejemplo4; public class Ejemplo4 { public static int atributo1; //Atributo publico public static void metodo1() { System.out.println("Método publico"); } } package paquete.externo; import aap.ejemplo4.Ejemplo4; //importamos la clase del ejemplo4 public class ClaseExterna { public static void main(String[] args) { System.out.println(Ejemplo4.atributo1); //Tuvimos Acceso directo por ser publico Ejemplo4.metodo1(); //Metodo1 también es publico } }
    A continuación y ya para finalizar, pondré una pequeña tabla que resume el funcionamiento de los modificadores de acceso en Java.
    ModificadorLa misma claseMismo paqueteSubclaseOtro paquete
    privateNoNoNo
    defaultNoNo
    protectedSí/NoNo
    public
    Debo aclarar algo en el caso del modificador de acceso protected y el acceso desde suclases. Es un error común pensar que se puede crear un objeto de la clase madre y luego acceder al atributo con acceso protected sin problemas, sin embargo esto no es cierto, puesto que el modificador protected lo que nos permite es acceder al atributo heredado desde el ámbito de la clase hija y no directamente. Sé que esto es un poco confuso así que te invito a ver el video explicativo al final de esta sección para quedar más claros.
    Eso ha sido todo en esta sección, no te olvides de dejar tus comentarios y de suscribirte a nuestras redes sociales para estar al tanto de las novedades en el sitio.


    TIPOS DE VARIABLES EN JAVA
    Una variable en Java es un identificador que representa una palabra de memoria que contiene información. El tipo de información almacenado en una variable sólo puede ser del tipo con que se declaró esa variable.
    Una variable se declara usando la misma sintaxis de C. Por ejemplo la siguiente tabla indica una declaración, el nombre de la variable introducida y el tipo de información que almacena la variable:
    Declaraciónidentificadortipo
    int i;ientero
    String s;sreferencia a string
    int a[];areferencia a arreglo de enteros
    int[] b;breferencia a arreglo de enteros
    Java posee dos grandes categorías de tipos para las variables:
    Tipos Primitivosreferencias a Objetos
    int, short, byte, longStrings
    char, booleanArreglos
    float, doubleotros objetos
    Las variables de tipos primitivos almacenan directamente un valor que siempre pertenece al rango de ese tipo. Por ejemplo una variable int almacena un valor entero como 1, 2, 0, -1, etc.
    Esto significa que al asignar una variable entera a otra variable entera, se copia el valor de la primera en el espacio que ocupa la segunda variable.
    Las variables de tipo referencia a objetos en cambio almacenan direcciones y no valores directamente. Una referencia a un objeto es la dirección de un área en memoria destinada a representar ese objeto. El área de memoria se solicita con el operador new.
    Al asignar una variable de tipo referencia a objeto a otra variable se asigna la dirección y no el objeto referenciado por esa dirección. Esto significa que ambas variables quedan refenciando el mismo objeto.
    La diferencia entre ambas asignaciones se observa en la siguiente figura:
    Esto tiene implicancias mayores ya que si se modifica el objeto referenciado por r, entonces también se modifica el objeto referenciado por s, puesto que son el mismo objeto.
    En Java una variable no puede almacenar directamente un objeto, como ocurre en C y C++.
    Por lo tanto cuando se dice en Java que una variable es un string, lo que se quiere decir en realidad es que la variable es una referencia a un string.

    Tipos primitivos

    En la siguiente tabla se indica para cada tipo primitivo el número de bits que se emplea en su representación y el rango de valores que se puede almacenar en las variables de estos tipos.
    TipoBitsRangoEjemplos
    int32-2**31 .. 2**31-10, 1, 5, -120, ...
    short16-2**15 .. 2**15-10, 1, 5, -120, ...
    byte8-2**7 .. 2**7-10, 1, 5, -120, ...
    long64-2**63 .. 2**63-10, 1, 5, -120, ...
    boolean1n/afalse, true
    char16n/a'a', 'A', '0', '*', ...
    float32IEEE1.2
    double64IEEE1.2
    Se dice que un tipo A es de mayor rango que un tipo B si A es un superconjunto de B. Esto quiere decir que las variales de tipo B siempre se pueden asignar a variables de tipo A (eventualmente con pérdida de significancia).
    Por ejemplo int es de mayor rango que short, que a su vez es de mayor rango que byte. Float y double son de mayor rango que int. Double es de mayor rango que float.
    Esto se puede resumir en:
    double > float > long > int > short > byte

    Expresiones

    En Java cada expresión tiene un tipo que se determina durante la compilación, es decir es independiente del valor durante la ejecución. Una expresión puede ser:

    • Una constante: 1, 1.0, true, etc.El tipo de esta expresión es el tipo de la constante. En el ejemplo los tipos son int, double y boolean respectivamente.
    • Una variable: i, s, aEl tipo de esta expresión es el tipo con que se declaró aquella variable. En el ejemplo los tipos son entero, referencia a string y referencia a arreglo.
    • El resultado de una operación: i+1, a[1], etc.El tipo se determina en función de los tipos de las expresiones que se indican como argumentos de la operación.
    Java tiene prácticamente los mismos operadores de C y C++. Cada operador acepta una, dos o tres expresiones de diversos tipos. A veces un operador no está definido para argumentos de ciertos tipos. Por ejemplo la resta entre strings no esta definida. Pero la suma de strings esta definida como la concatenación. A continuación veremos los operadores más frecuentes en Java.

    Operadores binarios entre expresiones numéricas

    SímboloOperación
    +Suma
    -Resta
    *Multiplicación
    /División
    %Resto
    Los operandos y el resultado de estos operadores pueden ser:
    DominioRango
    int*intint
    long*longlong
    float*floatfloat
    double*doubledouble
    • Al operar con byte y short, estos se convierten implícitamente a int.
    • Cuando los tipos de los operandos no coinciden, el operando de menor rango se convierte implícitamente al tipo de mayor rango. El resultado de la operación es del tipo de mayor rango.
    Ejemplos:
    <b> int a=1, b=2; int c= a + b; short s= 1; int d= s + c; // s se convierte a int float f= 1.0 + a; // a se convierte a float </b>

    Operadores unarios sobre expresiones numéricas

    SímboloOperaciónArgumento
    + expnadaint | long | float | double
    - expcambio de signoint | long | float | double
    El resultado de estas operaciones es siempre del mismo tipo del operando.
    Si el operando es byte o short entonces se convierte a int, se realiza la operación y el resultado es un int.

    Operadores sobre variables enteras

    SímboloOperaciónArgumento
    ++ varpreincrementoint | short | byte | long
    -- varpredecrementoint | short | byte | long
    var ++postincrementoint | short | byte | long
    var --postdecrementoint | short | byte | long
    El resultado de estas operaciones es siempre del mismo tipo del operando.
    Ejemplos:
    <b> int a=1, b=2; int c= +a; int d= -(c+1); b= a++; // b= 1, a=2 a= --b; // a=b= 0 (a+1)++; // error a+1 no es una variable float f= a; f++; // error f no es entero </b>

    Operadores binarios relacionales

    SímboloOperación
    >mayor
    <menor
    >=mayor igual
    <=menor igual
    ==igual
    !=distinto
    Los operandos y el resultado de estos operadores pueden ser:

    DominioRango
    int*intboolean
    long*longboolean
    float*floatboolean
    double*doubleboolean

    Operadores entre valores booleanos

    OperaciónSignificado
    exp && expy-lógico
    exp || expo-lógico
    ! expnegación
    Los operandos y el resultado de estos operadores son siempre booleanos.
    Los operadores && y || evalúan la expresión del lado derecho sólo si es necesario.
    Ejemplos:
    <b> int a=1, b=2; boolean v= ! a&amp;lt;=b &amp;amp;&amp;amp; a==5 || b!=4; boolean w= ((! a&amp;lt;=b) &amp;amp;&amp;amp; a==5) || b!=4; boolean w2= a&amp;lt;=b &amp;amp;&amp;amp; a; // error a no es boolean </b>

    Conversiones: cast

    • Java realiza conversiones implícitas de menor a mayor rango.
    • Eventualmente hay pérdida de significacia al convertir enteros a punto flotante.
    • Todas las conversiones de mayor a menor rango deben ser explícitas por medio del operador de cast:
      (tipo)expresión
    Ejemplos:
    <b> int i= 1; short s= 2; int j= i+s; s= a; // error short &amp;lt; int s= (short)a; // Ok i= 1.0; // error int &amp;lt; double i= (int)1.0; // Ok f= 1.0; // error float &amp;lt; double f= (float)1.0; // Ok f= 1.0f; // Ok boolean v=(boolean)a; // error no existe conversión </b>

    Precedencia de Operadores


    <b> . () [] unarios: - + (cast) * / % + - &amp;lt; &amp;gt; &amp;lt;= &amp;gt;= == != ! || &amp;amp;&amp;amp;</b>


    ¿QUE ES UN ARRAY?


    Resultado de imagen para ¿QUE ES UN ARRAY?


    5.2)Definición de un Array.
    Un array, es un tipo de dato estructurado que permite almacenar un conjunto de datos homogeneo, es decir, todos ellos del mismo tipo y relacionados. Cada uno de los elementos que componen un vector pueden ser de tipo simple como caracteres, entero o real, o de tipo compuesto o estructurado como son vectores, estructuras, listas...
    A los datos almacenados en un array se les denomina elementos; al número de elementos de un array se les denomina tamaño o rango del vector.
    Para acceder a los elementos individuales de un array se emplea  un índice que será un número entero no negativo que indicará la posición del elemento dentro del array. Para referirse a una posición particular o elemento dentro del array, especificamos el nombre del array y el número de posición del elemento particular dentro del mismo, el índice.
    Los arrays en gran parte se definen como las variables ordinarias, excepto en que cada array debe acompañarse de una especificación de tamaño (número de elementos). Para un array unidimensional, el tamaño se especifica con una expresión entera positiva encerrada entre paréntesis cuadrados. La expresión es normalmente una constante entera positiva.
    En términos generales un array unidimensional puede expresarse como:
     
    tipo-almacenamiento tipo-dato array[expresión];
    donde:
    • "tipo-almacenamiento" se refiere al tipo de almacenamiento del array
    • "tipo-dato" es el tipo de dato
    • "array" es el nombre del array
    • "expresion" una expresión entera positiva que indica el número de elementos del array.
    El tipo-almacenamiento es opcional; los valores por defecto son automáticos para un array definidos dentro de una función o bloque, y externos para arrays definidos fuera de una función.
    Los arrays automáticos a diferencia de las variables automáticas no pueden ser inicializados. Sin embargo las definiciones de los arrays estáticos y externos pueden incluir, si se desea, la asignación de los valores iniciales. Los valores iniciales deben aparecer en el orden en que serán asignados a los elementos individuales del array, encerrados entre llaves y separados por comas.
    La forma general es:
    tipo-almacenamiento tipo-dato array[expresión] = { valor1, valor2,..., valorn};
    donde:
    • "valor1" se refiere al valor del primer elemento del array
    • "valor2" al segundo elemento , y así sucesivamente.
    • La presencia de la "expresión", que indica el número de elementos del array, es opcional cuando los valores iniciales están presentes.


    ¿QUE ES UN RUBY?


    Puede que aún te preguntes ¿Qué es Ruby? a lo que podemos responder que es un lenguaje de scripts para una programación orientada a objetos rápida y sencilla, es un lenguaje de programación interpretado, de muy alto nivel y orientado a objetos, pero tambien puede que te preguntes entonces que es Ruby on RailsRails es un framework para Ruby de la misma manera que Cakephp lo es para Php, basicamente es una utilidad diseñada para facilitar el desarrollo de proyectos en Ruby.
    Ruby es un lenguaje de programación de tan alto nivel que hasta los números y los caracteres literales son objetos, y tienen métodos de su clase, que pueden llamarse normalmente.
    Ruby podrá ser probablemente uno de los lenguajes de programación más faciles de los que vas a ver.
    Es realmente fascinante ver cuanto llega a simplificar la programación por ejemplo si quisieramos hacer una suma sólo necesitariamos una sentecia:
    puts 1+2
    Pero por ejemplo si quisieramos repetir una cadena de texto tres veces no necesitariamos ni siquiera un bucle nos bastaria con:
    puts (“Hola”+” Adios “)*3
    … y si lo quieres complicar aún más y lo que quieres es crear un sudoku prueba con esto.

    Bueno si te ha gustado prueba a buscar más información en estos enlaces:

    ¿Cómo buscar información sobre Ruby?

    Seguramente si alguna vez has intentado programar alguna aplicación en Ruby se te habrán planteado algunas dudas, es cierto que es difícil encontrar información sobre ello.
    Para buscar información os recomiendo Ruby Kitchen Sink, realmente no es más que una adaptación de la búsqueda personalizada de Google pero si utilizas habitualmente este lenguaje te será de gran utilidad.

    Curiosidades

    Hoy mismo he visto esta curiosa imagen en Microsiervos en la cual los programadores de Ruby ocupan una de las plazas más altas de la jerarquia considerandose a sí mismos superiores a todos los demas.






    ¿QUE ES OUTPUT EN JAVA?


    Entrada y salida en Java


    No hay declaraciones estándar en Java para entrada y salida. Todas las entradas y salidas se realizan utilizando métodos en varias clases estándar de Java.   Estas clases se encuentran en varios paquetes de Java, sin embargo, el paquete de Java más común es java.io. Varios paquetes de IO están disponibles, y un programador puede elegir el que contiene las clases requeridas.   El paquete IO más común es el paquete java.io.

    IO Streams


    Una secuencia es una secuencia de caracteres o bytes utilizados para la entrada o salida del programa.   En general, puede haber varios flujos de entrada y flujos de salida.   Java proporciona muchas clases diferentes de flujo de entrada y salida en la API java.io.   Los objetos IO más utilizados son:

    • System.in (flujo de entrada)
    • System.out (flujo de salida para resultados normales)
    • System.err (flujo de salida para mensajes de error)

    Estos objetos se utilizan para introducir datos del usuario en la aplicación y enviar datos al usuario. 
    • En general, System.in está conectado al teclado e ingresa datos de caracteres *, y
    • System.out y System.err están conectados al monitor y a los datos de caracteres de salida.

    * Los datos recopilados por el objeto System.in son datos de caracteres, incluso si se ingresan como dígitos numéricos. Por lo tanto, si la aplicación realiza algún cálculo, los caracteres de entrada, primero debe convertirse al tipo de datos primitivos antes de que se utilice. 


    El flujo de salida estándar: System.out


    Ya hemos usado el flujo de salida estándar, System.out, que se declara en la clase del sistema y está asociado con la ventana de la consola.   Al escribir caracteres en el sistema, el método outout () o println () muestra estos caracteres en su pantalla.   Cualquier carácter, imprimible o no se puede leer o escribir en una secuencia.   Un flujo no tiene un tamaño fijo, ya que escribimos información en un flujo, solo estamos agregando caracteres al final del flujo.   Los métodos de salida de la secuencia hacen un seguimiento del tamaño de la secuencia.

    Ejemplo:
    Por la declaración

    System.out.println ("Edad es" + edad + "\ nNombre es" + nombre);

    La expresión de cadena entre paréntesis se evalúa y los caracteres se agregan a la secuencia de salida estándar.   Durante el proceso de evaluación, los números binarios almacenados en la antigüedad se convierten a una secuencia de caracteres de dígitos decimales.




    Entrada de usuario usando el teclado


    Hay varias formas de aceptar la entrada del usuario.   Veremos tres de ellos,
    1. Lector Buffer
    2. Escáner
    3. JOptionPane

    Lector Buffer (java.io)


    En la clase Sistema, hay objetos que se pueden usar para aceptar y enviar datos al usuario. El objeto, System.in, representa el teclado (a menos que especifique lo contrario) y se usa para leer los datos del usuario (ingresados ​​usando el teclado) en su programa.

    La clase BufferedReader lee datos de una entrada estándar (System.in, el teclado.   Puede parecer confuso, pero lo hace en dos pasos.

    Paso 1: crear un objeto InputStreamReader


    Los objetos InputStreamReader leen caracteres de una secuencia de entrada, en este caso, la secuencia de entrada del teclado, System.in.   El método constructor de la clase InputStreamReader toma el objeto del flujo de entrada como un argumento.   Sin embargo, los objetos de esta clase ofrecen una funcionalidad limitada porque leen un solo carácter a la vez.   Cuando leemos los datos del usuario, no queremos tener que procesar los datos carácter por carácter, queremos leer y procesar los caracteres en su totalidad.   Por eso es necesario el siguiente paso.


    Paso 2: Crea un objeto BufferedReader


    La clase BufferedReader ofrece funcionalidad adicional.   Cuenta con métodos que nos permiten leer caracteres y líneas de datos más fácilmente.   "Envolvemos" nuestro objeto InputStreamReader dentro de un objeto BufferedReader, para agregar funciones adicionales.   El proceso de dos pasos se parece al de abajo:

    InputStreamReader sysIn = new InputStreamReader (System.in);
    BufferedReader input = new BufferedReader (sysIn);

    Paso 3: Obtener la entrada del usuario


    En el siguiente paso, leemos los datos del usuario desde la línea de comandos.   El usuario ingresa los datos, seguido de la tecla de retorno, y el texto que precede (vino antes) puede ser almacenado en nuestro programa.

    Generalmente, como queremos dar alguna instrucción al usuario (es decir, ingresar algo ahora) emitiremos una instrucción, antes de leer los datos de los usuarios. 

    System.out.println ("Hey You, ingresa algo!");
    String userInput = input.readLine ();

    Después de esto, la referencia del objeto String ahora apunta a los datos ingresados ​​por el usuario.   En el ejemplo anterior, el método readLine () es un método que pertenece a la clase BufferedReader, que lee una línea de texto del usuario.

    IMPORTANTE: Los datos recopilados utilizando el método readLine () siempre son datos de CHARACTER.   Por lo tanto, si queremos hacer algunos cálculos con los datos, primero tenemos que convertir los datos a datos numéricos antes de poder procesarlos.

    Paso 4: convertir datos de caracteres a datos numéricos (si es necesario)

    Hablamos de "envoltorios de tipo" antes.   Una envoltura de tipo es una clase que tiene métodos que podemos utilizar para convertir objetos como los objetos 'String' en tipos de datos primitivos, como int o double.

    Para convertir los datos de String en datos int, usamos la clase envoltura Integer (y Double para doble, etc.).   La clase Integer tiene un método, parseInt () que invocamos en un objeto String y que devuelve un resultado int.

    int myData = Integer.parseInt (userInput);

    Ahora somos libres de usar myData en nuestra aplicación.

    Ejemplo: EchoSquare.java


     Excepciones


    Java es un lenguaje de programación que está diseñado para ayudar al programador a lidiar con datos erróneos y fallas de entrada comunes.   Una excepción es una indicación de un problema que ocurre durante la ejecución de un programa.   La excepción de nombre implica que el problema ocurre con poca frecuencia (es decir, una excepción a la regla). Hay muchas situaciones que pueden causar una excepción en una aplicación Java. 

    Cuando se produce una excepción, se crea un objeto de excepción que contiene información sobre lo que salió mal.   El manejo de excepciones permite a los programadores crear aplicaciones que pueden resolver excepciones.   Hay dos formas de lidiar con la excepción; una es escribir código para manejar con elegancia la excepción, en la sección donde puede ocurrir una excepción.   El segundo es eludir la excepción.   Esto se denomina lanzar una excepción y se requiere en los casos en que se pueden producir excepciones.   Cuando está lanzando una excepción, básicamente está reconociendo que puede ocurrir un error, pero que desea omitir el error.   Veremos el manejo de excepciones más adelante en el curso, y por ahora solo lanzaremos excepciones.

    Hay una serie de tipos de excepciones.   Con las operaciones de entrada / salida, cuando una operación falla, la aplicación generará una excepción IOException. Para indicar a la aplicación que omita o lance el error, incluimos el siguiente código en nuestra declaración de método principal.

    public static void main (String [] args) lanza IOException {}

    En la declaración anterior, throws es una palabra clave que indica que deseamos lanzar una excepción.   IOException indica que la excepción generada estará relacionada con las operaciones de entrada / salida.   Sin la instrucción throw, cuando compila su programa, obtendría el siguiente error de tiempo de compilación:

    Error: excepción no reportada java.io.IOException; debe ser atrapado o declarado para ser lanzado

    Escáner

    La clase Scanner es una clase en java.util, que permite al usuario leer valores de varios tipos. La clase Scanner tiene muchos métodos, pero solo usaremos algunos de ellos.   Primero veremos los que nos permiten leer en valores numéricos desde cualquiera de los teclados sin tener que convertirlos de cadenas y determinar si hay más valores para leer.

    Los métodos útiles del escáner se enumeran a continuación:

    Método

    Devoluciones

    nextInt ()
    Siguiente token como un entero
    siguienteDouble ()
    Siguiente token como doble
    siguiente()
    Siguiente token como una cadena
    línea siguiente()
    Devuelve la línea completa (o línea restante) como una cadena.
    El objeto Scanner busca 'tokens' en la entrada.   Un token es un grupo de caracteres que están separados por espacios en blanco (espacio, tabulador, retorno de línea, final del archivo). Un token es una serie de caracteres que termina con lo que Java llama espacios en blanco.    Si leemos una línea que es una serie de números, separados por espacios en blanco, el Escáner ve cada número como un token separado.   Los valores numéricos pueden estar todos en una línea con espacios en blanco entre cada valor o pueden estar en líneas separadas.   Los caracteres de espacio en blanco (espacios en blanco o retornos de carro) actúan como separadores. 

    Ejemplo: ScannerExampleHere.java




    ¿A QUE LLAMAMOS CASE EN JAVA?


    Resultado de imagen para ¿A QUE LLAMAMOS CASE EN JAVA?





























    Switch case es una estructura de control empleada en programación. Se utiliza para agilizar la toma de decisiones múltiples; trabaja de la misma manera que lo harían sucesivos ifif else o until anidados, así como combinaciones propias de determinados lenguajes de programación.
    El switch no es tan popular como el if, pero se utiliza con regularidad en la programación. En principio la funcionalidad de un switch también se puede implementar con múltiples if anidados. En el caso de que haya muchas acciones dependientes de muchos valores iniciales, es recomendable su uso. El switch favorece la Facilidad y rapidez en la programación.
    El switch no solo te ayuda en ciertos casos. Si no que te permite realizar " Opciones " Que en un if no lo pudieras hacer nada".

    La nomenclatura[editar]

    switch( variable ){
      case valor1: accion1; (*)
      case valor2: accion2; (*+++)
      case valor3: accion3; (*)
      ...
      case valorN: accionN; (*)
    
      default: accionD; (**)
    }
    
    • (**) La acción default es usada para los valores que no correspondieron en casos anteriores, y puede aparecer sin "accionD()", e incluso, con el break al final.
    • (*) En estos huecos, al final de las acciones acción1, acción2,... incluso después de la accionD, normalmente se suele usar un break para salir del switch. Su uso, generalizado, permite realizar programas que, por ejemplo, se comportan de diferente modo por cada entrada:
    Switch( número )
    {
      case 0: escribir("No hay elementos.");
      break;
      case 1: escribir("Hay solo un elemento.");
      break;
      default: escribir("Hay " número " elementos"); /* break; */
    }
    
    En este ejemplo,es necesario utilizar la palabra reservada break, excepto en el último (que está entre comentarios y por lo tanto no se ejecutará) para el correcto funcionamiento del programa. Esto lo que hace es, dependiendo si el número que contiene la variable número es 0, 1 u otro cualquiera, escribir que No hay elementos, Hay solo un elemento o Hay numero elementos respectivamente.
    En cambio, el uso del switch puede ser interesante sin recurrir a los break al final de las acciones, por ejemplo, en este otro programa:
    Switch( paso )
    {
      case 1: escribir("Paso 1 (ponerse cómodo) sin finalizar. ");
      case 2: escribir("Paso 2 (regular espejos) sin finalizar. ");
      case 3: escribir("Paso 3 (abrochar cinturón) sin finalizar. ");
      case 4: escribir("Paso 4 (arrancar motor) sin finalizar. ");
    }
    
    Este otro programa muestra por pantalla los pasos que aun faltan por realizar de una tarea pre-programada. Por ejemplo, si estamos en el paso 1, todavía nos quedará terminar ese, el 2, el 3 y el 4, por lo que mostrará desde el 1 en adelante. Pero si estamos en el paso 3, solo mostrará que falta el Paso 3 y el Paso 4.
    Por supuesto, el uso de los break se puede usar en diferentes acciones, sin ser en todas o en ninguna, por ejemplo, añadiendo un paso final al anterior programa:
    Switch( paso ){
      case 1: escribir("Paso 1 (ponerse cómodo) sin finalizar. ");
      case 2: escribir("Paso 2 (regular espejos) sin finalizar. ");
      case 3: escribir("Paso 3 (abrochar cinturón) sin finalizar. ");
      case 4: escribir("Paso 4 (arrancar motor) sin finalizar. ");
      break;
      case 5: escribir("Tarea finalizada.");
    }
    
    De esta forma, el funcionamiento será igual que el anterior, salvo que si el paso es el 5, es decir, que todas los pasos anteriores están finalizados, nos mostrará que "Tarea finalizada."; en cambio, si el paso es anterior al 5, al mostrar el mensaje "(...) Paso 4 (arrancar motor) sin finalizar." realizará el break y no mostrará, lógicamente, el mensaje del Paso 5, que no tendría sentido.

    Funcionamiento

    El programa interpreta el valor de la variable almacenándolo en una zona de memoria temporal (oculta). Después lo compara con el valor seguido de cada case, y si coincide, realiza el flujo de acciones correspondientes, hasta encontrar un break, con el que finalizará el Switch. Es muy importante saber que, en el momento en el que se realiza la accionI (para I < N), se ejecutarán todas las acciones entre I y N mientras no se encuentre la instrucción break.

    Similitud

    Con la nomenclatura anterior, el Switch se puede asemejar a este otro algoritmo basado en if y for:
    for( temporal = variable; true; break){
      if( temporal == valor1 ) {accion1;}
      if( temporal == valor1 or temporal == valor2 ) {accion2;}
      if( cordero == temporal )
      temporal++;
      if( temporal == valor1 or temporal == valor2 or... or temporal == valorN ) {accionN;}
      accionD;
    }



    ¿QUE ES UN STRING?
    Hemos aprendido a diferenciar entre clase y objetos, a acceder desde un objeto a los miembros datos y a las funciones miembro. Vamos a utilizar clases importantes en el lenguaje Java y a crear objetos de dichas clases. Empezaremos por la clase String una de las más importantes del lenguaje Java. Más adelante, volveremos a estudiar otros ejemplos para que el lector se acostumbre a crear sus propias clases.

    Las clases del lenguaje Java

    Como habremos observado, y apreciaremos aún más en la parte correspondiente a la creación de applets, el IDE JBuilder proporciona un sistema de ayuda a medida que vamos escribiendo el código. También, podemos situar el cursor sobre el nombre de una clase, al pulsar el botón derecho del ratón, aparece un menú flotante. Seleccionando el primer elemento del menú, Browse symbol at cursor, aparece la definición de la clase. Los paneles cambian, podemos seleccionar la función miembro que nos interesa en el panel de estructura (inferior izquierda) y ver su código fuente en el panel de contenido (a la derecha).
    En la figura podemos ver la clase String y en el panel de contenido la definición de una de las funciones miembro substring que hemos seleccionado en el panel de estructura. Por encima de la definición aparece la documentación relativa a dicha función.
    Para volver al código fuente de nuestra clase pulsamos en el botón "home" encima del panel de navegación.
    string.gif (17915 bytes)

    La clase String

    disco.gif (1035 bytes)string: StringApp.java
    Dentro de un objeto de la clases String o StringBuffer, Java crea un array de caracteres de una forma similar a como lo hace el lenguaje C++. A este array se accede a través de las funciones miembro de la clase.
    Los strings u objetos de la clase String se pueden crear explícitamente o implícitamente. Para crear un string implícitamente basta poner una cadena de caracteres entre comillas dobles. Por ejemplo, cuando se escribe
    	System.out.println("El primer programa");
    Java crea un objeto de la clase String automáticamente.
    Para crear un string explícitamente escribimos
    	String str=new String("El primer programa");
    También se puede escribir, alternativamente
    	String str="El primer programa";
    Para crear un string nulo se puede hacer de estas dos formas
    	String str="";
    	String str=new String();
    Un string nulo es aquél que no contiene caracteres, pero es un objeto de la clase String. Sin embargo,
    	String str;
    está declarando un objeto str de la clase String, pero aún no se ha creado ningún objeto de esta clase.

    Cómo se obtiene información acerca del string

    Una vez creado un objeto de la clase String podemos obtener información relevante acerca del objeto a través de las funciones miembro.
    Para obtener la longitud, número de caracteres que guarda un string se llama a la función miembro length.
    	String str="El primer programa";
    	int longitud=str.length();
    Podemos conocer si un string comienza con un determinado prefijo, llamando al método startsWith, que devuelve true o false, según que el string comience o no por dicho prefijo
    	String str="El primer programa";
    	boolean resultado=str.startsWith("El");
    En este ejemplo la variable resultado tomará el valor true.
    De modo similar, podemos saber si un string finaliza con un conjunto dado de caracteres, mediante la función miembro endsWith.
    	String str="El primer programa";
    	boolean resultado=str.endsWith("programa");
    Si se quiere obtener la posición de la primera ocurrencia de la letra p, se usa la función indexOf.
    	String str="El primer programa";
    	int pos=str.indexOf('p');
    Para obtener las sucesivas posiciones de la letra p, se llama a otra versión de la misma función
    	pos=str.indexOf('p', pos+1);
    El segundo argumento le dice a la función indexOf que empiece a buscar la primera ocurrencia de la letra p a partir de la posición pos+1.
    Otra versión de indexOf busca la primera ocurrencia de un substring dentro del string.
    	String str="El primer programa";
    	int pos=str.indexOf("pro");
    Vemos que una clase puede definir varias funciones miembro con el mismo nombre pero que tienen distinto número de parámetros o de distinto tipo.

    Comparación de strings

    disco.gif (1035 bytes)equals: EqualsApp.java
    La comparación de strings nos da la oportunidad de distinguir entre el operador lógico == y la función miembro equals de la clase String. En el siguiente código
            String str1="El lenguaje Java";
            String str2=new String("El lenguaje Java");
    	if(str1==str2){
    		System.out.println("Los mismos objetos");
    	}else{
    		System.out.println("Distintos objetos");
    	}
    	if(str1.equals(str2)){
    		System.out.println("El mismo contenido");
    	}else{
    		System.out.println("Distinto contenido");
    	}        
    Esta porción de código devolverá que str1 y str2 son dstintos objetos pero con el mismo contenido. str1 y str2 ocupan posiciones distintas en memoria pero guradan los mismos datos.
    Cambiemos la segunda sentencia y escribamos
            String str1="El lenguaje Java";
            String str2=str1;
    	System.out.prinln("Son el mimso objeto "+(str1==str2);
    Los objetos str1 y str2 guardan la misma referencia al objeto de la clase String creado. La expresión (str1==str2) devolverá true.
    Asñi pues, el método equals compara un string con un objeto cualquiera que puede ser otro string,  y devuelve true cuando dos strings son iguales o falsesi son distintos.
            String str="El lenguaje Java";
    	boolean resultado=str.equals("El lenguaje Java");
    La variable resultado tomará el valor true.
    La función miembro comapareTo devuelve un entero menor que cero si el objeto string es menor (en orden alfabético) que el string dado, cero si son iguales, y mayor que cero si el objeto string es mayor que el string dado.
    	String str="Tomás";
    	int resultado=str.compareTo("Alberto");
    La variable entera resultado tomará un valor mayor que cero, ya que Tomás está después de Alberto en orden alfabético.
    	String str="Alberto";
    	int resultado=str.compareTo("Tomás");
    La variable entera resultado tomará un valor menor que cero, ya que Alberto está antes que Tomás en orden alfabético.

    Extraer un substring de un string

    En muchas ocasiones es necesario extraer una porción o substring de un string dado. Para este propósito hay una función miembro de la clase Stringdenominada substring.
    Para estraer un substring desde una posición determinada hasta el final del string escribimos
            String str="El lenguaje Java";
    	String subStr=str.substring(12);
    Se obtendrá el substring "Java".
    Una segunda versión de la función miembro substring, nos permite extraer un substring especificando la posición de comienzo y la el final.
            String str="El lenguaje Java";
    	String subStr=str.substring(3, 11);
    Se obtendrá el substring "lenguaje". Recuérdese, que las posiciones se empiezan a contar desde cero.

    Convertir un número a string

    Para convertir un número en string se emplea la función miembro estática valueOf (más adelante explicaremos este tipo de funciones).
    	int valor=10;
    	String str=String.valueOf(valor);
    La clase String proporciona versiones de valueOf para convertir los datos primitivos: int, long, float, double.
    Esta función se emplea mucho cuando programamos applets, por ejemplo, cuando queremos mostrar el resultado de un cálculo en el área de trabajo de la ventana o en un control de edición.

    Convertir un string en número

    Cuando introducimos caracteres en un control de edición a veces es inevitable que aparezcan espacios ya sea al comienzo o al final. Para eliminar estos espacios tenemos la función miembro trim
    	String str="  12 ";
    	String str1=str.trim();
    Para convertir un string en número entero, primero quitamos los espacios en blanco al principio y al final y luego, llamamos a la función miembro estática parseInt de la clase Integer (clase envolvente que describe los números enteros)
    	String str="  12 ";
    	int numero=Integer.parseInt(str.trim());
    Para convertir un string en número decimal (double) se requieren dos pasos: convertir el string en un objeto de la clase envolvente Double, mediante la función miembro estática valueOf, y a continuación convertir el objeto de la clase Double en un tipo primitivo double mediante la función doubleValue
    	String str="12.35 ";
    	double numero=Double.valueOf(str).doubleValue();
    Se puede hacer el mismo procedimiento para convertir un string a número entero
    	String str="12";
    	int numero=Integer.valueOf(str).intValue();

    La clase StringBuffer

    En la sección dedicada a los operadores hemos visto que es posible concatenar cadenas de caracteres, es, decir, objetos de la clase String. Ahora bien, los objetos de la clase String son constantes lo cual significa que por defecto, solamente se pueden crear y leer pero no se pueden modificar.
    Imaginemos una función miembro a la cual se le pasa un array de cadenas de caracteres. Los arrays se estudiarán en la siguiente página.
    public class CrearMensaje{
    	public String getMensaje(String[] palabras){
    		String mensaje="";
    		for(int i=0; i<palabras.length; i++){	
    			mensaje+=" "+palabras[i];
    		}
    		return mensaje;
    	}
    //...	
    }
    Cada vez que se añade una nueva palabra, se reserva una nueva porción de memoria y se desecha la vieja porción de memoria que es más pequeña (una palabra menos) para que sea liberada por el recolector de basura (grabage collector). Si el bucle se realiza 1000 veces, habrá 1000 porciones de memoria que el recolector de basura ha de identificar y liberar.
    Para evitar este trabajo extra al recolector de basura, se puede emplear la clase StringBuffer que nos permite crear objetos dinámicos, que pueden modificarse.
    public class CrearMensaje{
    	public String getMensaje(String[] palabras){
    		StringBuffer mensaje=new StringBuffer();
    		for(int i=0; i<palabras.length; i++){	
    			mensaje.append("  ");
    			mensaje.append(palabras[i]);
    		}
    		return mensaje.toString();
    	}
    //...	
    }
    La función append incrementa la memoria reservada para el objeto mensaje con una palabra más sin crear nueva memoria, cada vez que se ejecuta el bucle. La función toString, que veremos más adelante, convierte un objeto en una cadena de caracteres.

    Comentarios

    Entradas populares de este blog