Glosario de funciones en java

Mostrar por pantalla

System.out.print(st): Muestra la cadena st por pantalla sin saltar de línea

System.out.print("Hola");

System.out.println(st): Muestra la cadena st por pantalla y salta de línea

Manejo de datos

int max=Integer.MIN_VALUE; El valor mínimo de un entero.

int min=Integer.MAX_VALUE; El valor máximo de un entero.

Introducción de datos (import java.util.Scanner;)

Scanner sc = new Scanner(System.in): Crea un puerto de entrada de datos

String st=sc.nextLine(): Pide por pantalla un string

Scanner sc = new Scanner(System.in);
System.out.println("Introduce tu nombre");
String nombre=sc.nextLine();

String st=sc.next(): Pide por pantalla un string

Scanner sc = new Scanner(System.in);
System.out.println("Introduce tu nombre");
String nombre=sc.next();

int numero = sc.nextInt(): Pide por pantalla un int

Scanner sc = new Scanner(System.in);
System.out.println("Introduce un caracter ASCII");
int numero = sc.nextInt();

double r=sc.nextDouble(): Pide por pantalla un double

Scanner sc = new Scanner(System.in);
System.out.println("Introduce un radio");

double radio=sc.nextDouble();

char caracter = sc.next().charAt(0): Pide un carácter por pantalla.

Scanner sc = new Scanner(System.in);
System.out.println("Introduce un carácter ASCII");
char caracter = sc.next().charAt(0);

Caracteres

boolean isDigit(char c): indica si el carácter c es un dígito

char c1 = '8', c2 = 'p’;
boolean b;
b = Character.isDigit(c1); //b vale true, ya que '8' es un dígito
b = Character.isDigit(c2); //b es false, 'p' no es un dígito

boolean isLetter(char c): determina si el carácter pasado como parámetro es una letra (minúscula o mayúscula).

Character.isLetter('8'); //false: el carácter '8' no es una letra
Character.isLetter('e'); //true: el carácter 'e' sí es una letra

boolean isLetterOrDigit(char c): indica si el carácter es una letra o un dígito. El conjunto de estos caracteres se conoce como caracteres alfanuméricos.

boolean b;
b = Character.isLetterOrDigit('%'); //false: '%' no es alfanumérico

boolean isLowerCase(char c): especifica si c es una letra y, además, está en minúscula.

char c1 = 'q', c2 = 'Q’;
Character.isLowerCase('*'); //false: ni siquiera es una letra
Character.isLowerCase(c1); //true: es una letra en minúscula

boolean isUpperCase(char c): determina si el carácter es una letra mayúscula.

Character.isUpperCase('t'); //false
Character.isUpperCase('T'); //true

boolean isSpaceChar(char c): devolverá true si el carácter utilizado como parámetro es el espacio (‘ ‘).

Character.isSpaceChar(' '); //devuelve true
Character.isSpaceChar('a'); //false: No es un espacio

boolean isWhitespace(char c): determina si el carácter pasado es cualquier carácter blanco. Los caracteres que hacen que el método devuelva true son:

– Espacio en blanco (‘␣’): se teclea mediante la barra espaciadora.

– Retorno de carro (‘\r’): dependiendo del sistema operativo, este carácter tendrá distinto comportamiento al imprimirse.

– Nueva línea (‘\n’): es el carácter que se consigue al pulsar la tecla Intro.

– Tabulador (‘\t’): equivale a varios espacios en blanco. Se genera con la tecla Tab.

char c = '\t';Character.isWhiteSpace(c); //true: tabulador

char toLowerCase(char c): si el carácter pasado es una letra, lo devuelve con-vertido a minúscula. En otro caso, devuelve el mismo.

char c1 = 'A', c2;
c2 = Character.toLowerCase(c1); //la variable c2 toma el valor 'a’
c2 = Character.toLowerCase('3'); //al no ser una letra, devuelve el  mismo valor pasado: ‘3’

char toUpperCase(char c): similar al anterior método, pero convierte el carácter, si es una letra, a mayúscula. En otro caso devuelve el mismo carácter.

char c1 = 'g’;
char c2 = Character.toUpperCase(c1); //a c2 se le asigna el valor 'G’

Strings

String cad = String.valueOf(tipo valor): recibe por parámetro un valor de cualquier tipo y lo devuelve como cadena.

String cad;
cad = String.valueOf(1234); //cad = "1234“
cad = String.valueOf(-12.34); //cad = "-12.34“
cad = String.valueOf('C'); //cad = "C“
cad = String.valueOf(false); //cad = "false“

boolean = cad1.equals(cad2):  compara cad1 con cad2 y si son iguales devuelve true.

String cad1 = "Hola mundo";
String cad2 = "Hola mundo";
String cad3 = "Hola, buenos días“

boolean iguales;
iguales = cad1.equals(cad2); //iguales vale true
iguales = cad1.equals(cad3); //iguales vale false

boolean = cad1.equalsIgnoreCase(cad2):  compara cad1 con cad2 ignorando las mayúsculas y minúsculas.

String cad1 = "Hola mundo";
String cad2 = "HOLA Mundo";

boolean iguales;
iguales = cad1.equals(cad2); //false, no son iguales
iguales = cad1.equalsIgnoreCase(cad2); //true, 

boolean = cad1.regionMatches(int inicio, String cad2,int inicioCad2, int longitud): compara dos fragmentos de cadenas, cad1 desde inicio y cad2 desde inicioCad2. Comparan la cantidad de caracteres ‘longitud’

String cad = "Mi␣perro␣ladra␣mucho";
String otra = "Un␣bonito␣perro␣blanco";
boolean b = cad.regionMatches(3, otra, 10, 5) //cierto 

boolean regionMatches(boolean ignora, int ini, String otraCad, int iniOtra, int longitud): compara dos fragmentos de cadenas, como ‘regionMatches’. El primer parámetro define si ignora mayúsculas y minúsculas

String cad = "Mi␣perro␣ladra␣mucho";
String otra = "Un␣bonito␣perro␣blanco";
boolean b = cad.regionMatches(3, otra, 10, 5) //cierto 

int = cad1compareTo(cad2): compara alfabéticamente la cadena cad1 con cad2

– 0: si las cadenas comparadas son exactamente iguales.

– negativo: si la cadena llamante es menor alfabéticamente que la cadena pasada como parámetro, es decir, va antes por orden alfabético.

– positivo: si la cadena llamante es mayor alfabéticamente que la cadena pasada, es decir, va después.

   String a="casa";
   String b="caso";
   System.out.println(a.compareTo(b)); //-14
   System.out.println(b.compareTo(a)); // 14

int compareToIgnoreCase(String cadena): realiza una comparación alfabética sin distinguir entre letras mayúsculas ni minúsculas

char = cad1.charAt(int posicion): devuelve el carácter que ocupa el índice posicionen la cadena cad1 que invoca el método

String frase = "Nació con el don de la risa";
System.out.println(frase.charAt(4)); //muestra el carácter 'ó’
char c = frase.charAt(30); //¡error! No existe la posición 30 

String = cad1.substring(int inicio): devuelve la subcadena formada desde la posición inicio hasta el final de la cadena.

String cad1 = "Una mañana, al despertar de un sueño intranquilo";
String cad2 = cad1.substring(28); //cad2 vale "un sueño intranquilo“

String = cad1.substring(int inicio, int fin): devuelve un fragmento de cad1 comprendido entre los índices inicio y el anterior a fin.

String cad1 = "Una␣mañana,␣al␣despertar␣de␣un␣sueño␣intranquilo";
String cad2 = cad1.substring(15, 36); //cad2 = "despertar de un sueño" 

String= cad1.strip(): devuelve una copia de la cadena eliminando los caracteres blancos del principio y del final.

String cad1 = "␣␣␣Mi␣perro␣se␣llama␣Perico␣␣";
String cad2 = cad1.strip(); //cad2 vale "Mi perro se llama Perico“

StringstripLeading(): solo elimina los espacios en blanco del principio.

 String a="  casa  ";
 System.out.println(a.stripLeading());

StringstripTrailing(): solo elimina los espacios en blanco del final.

 String b="  casa  ";
 System.out.println(b.stripTrailing());

int = st.length(): Devuelve la longitud de una cadena

Scanner sc = new Scanner(System.in);
String cad2 = sc.nextLine();
l = cad2.length();
System.out.println("Longitud:" + l);

int = cad1.indexOf(char c): busca la primera ocurrencia del carácter c en la cadena cad1 empezando por el principio. Si lo encuentra, devuelve su índice, o −1 en   caso contrario.

int pos;
String cad = "Mi␣perro␣se␣llama␣Perico";
pos = cad.indexOf('j'); //pos vale -1, no encontramos 'j' en cad
pos = cad.indexOf('e'); //pos vale 4, el índice de la primera ‘e’

int = cad1.indexOf(String cadena): sirve para buscar la primera ocurrencia de una cadena.

pos = cad.indexOf("hola"); //pos vale -1, no se encuentra "hola“
pos = cad.indexOf("perro"); //pos vale 3

int = cad1.indexOf(char c, int inicio): busca la primera ocurrencia del carácter c, pero en lugar de comenzar a buscar en la posición 0, lo hace desde la posición inicio en adelante.

int pos;
String cad = "Mi␣perro␣pequines␣se␣llama␣perico";
pos = cad.indexOf('s'); //devuelve 16
pos = cad.indexOf('s', 25); //devuelve -1, a partir de la posición 25 no se encuentra ‘s’

int = cad1.indexOf(String cadena, int inicio): busca la primera ocurrencia de cadena a partir de la posición inicio.

int pos;
String cad = "Mi␣perro␣pequines␣se␣llama␣perico";
pos = cad.indexOf("pe"); //devuelve 3
pos = cad.indexOf("pe", 4); //devuelve 9, la posición del primer //"pe" a partir del índice 4

int= cad1.lastIndexOf(char c): devuelve el índice de la última ocurrencia de c, o −1 en el caso de que no se encuentre.

String cad = "su␣perro␣pequines␣se␣llama␣perico";
int pos = cad.lastIndexOf('s'); //devuelve 18. Busca 's' desde el final

int = cad1.lastIndexOf(String cadena): devuelve el índice de la última aparición de cadena o -1 si no lo encuentra.

pos = cad.lastIndexOf("pe"); //devuelve 27

int= cad1.lastIndexOf(char c, int inicio): la búsqueda se realiza desde el final al inicio de la cadena, comenzando en la posición inicio.

int= cad1.lastIndexOf(String cadena, int inicio): devuelve la posición de cad1 en la cadena, comenzando en el índice inicio y buscando desde el final hacia el principio. En caso de no encontrar nada, devuelve −1.

boolean = cad1. isEmpty(): indica si la cadena está vacía

String cad1 = "", cad2 = "Hola...";
cad1.isEmpty(); //true
cad2.isEmpty(); //false

boolean = cad1.contains(cad2): devuelve true si en la cad2 está contenida en cad1.

String frase = "En un lugar de la Mancha";
String palabra = "lugar";
System.out.println(frase.contains(palabra)); //muestra true
System.out.println(frase.contains("silla")); //muestra false

boolean = cad1.startsWith(String prefijo): comprueba si la cad1 comienza con la cadena prefijo que se pasa como parámetro.

String frase = "Hola mundo...";
boolean empieza = frase.startsWith("Hol"); //true, frase comienza por "Hol“
empieza = frase.startsWith("mun"); //false, frase no comienza por "mun“

boolean = cad1.startsWith(String prefijo, int inicio):  comprueba si el prefijo está en cad1 desde la posición de inicio.

String frase = "Hola mundo...", prefijo1 = "Hol", prefijo2 = "mun";
empieza = frase.startsWith(prefijo1, 5);//false // 
empieza = frase.startsWith(prefijo2, 5);//true // 

boolean= cad1.endsWith(String sufijo):  indica si la cadena termina con el sufijo que le pasamos como parámetro.

String frase = "Hola mundo";
b = frase.endsWith("De"); //falso, evidentemente frase no termina en "De“
b = frase.endsWith("undo"); //cierto, frase finaliza con "undo" 

String= cad1.toLowerCase(): devuelve una copia de la cadena donde se han convertido todas las letras a minúsculas.

String frase = "Mi PeRrO: sE lLaMa PeRiCo23.";
String copia;
copia = frase.toLowerCase(); //"mi perro: se llama perico23.“

String= cad1.toUpperCase(): Convierte todas las letras a mayúsculas. 

String frase = "Mi PeRrO: sE lLaMa PeRiCo23.";
String copia;
copia = frase.toUpperCase(); //"MI PERRO: SE LLAMA PERICO23." 

st2=st1.replace(c1, c2): Cambia el carácter c1 por el carácter c2 dentro de la cadena.

String cad="Casa";
System.out.println("Cadena:"+cad);
cad=cad.replace('a', 'e');
System.out.println("Cadena:"+cad);

st2=st1.replace(cad1, cad2): Cambia la cadena cad1 por la cadena cad2 dentro de la cadena st1.

String[] = cad1.split(String separador): devuelve las subcadenas resultantes de dividir la cad1 con el separador pasado como parámetro en un array de String.

String frase = "En␣un␣lugar␣de␣La␣Mancha";
String[] palabras = frase.split("␣"); //separador: espacio en blanco
//palabras = ["En", "un", "lugar", "de", "La", "Mancha"]

char[] = cad1.toCharArray(): crea y devuelve una tabla de caracteres con el contenido de la cadena desde la que se invoca, a razón de un carácter en cada elemento.

String frase = "Hola␣mundo";
char letras[];
letras = frase.toCharArray();
//la tabla letras contiene ['H','o','l','a','␣','m','u','n','d','o’]

String = String.valueOf(char[] tabla): devuelve un String con el contenido de la tabla de caracteres.

String cad;
char c[] = {'H', 'o', 'l', 'a’};
cad = String.valueOf(c); //cad vale "Hola“

static String valueOf(char[] t, int inicio, int cuantos):  devuelve un String con el contenido de la tabla de caracteres desde el índice inicio, tantos elementos como indica la variable cuantos

String cad;char c[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g’};
cad = String.valueOf(c, 2, 4}; //cad vale "cdef“

Arrays (import java.util.Arrays;)

.length: Devuelve la longitud de un array.

int notas[] = new int [10];
System.out.println("Longitud de la tabla notas: " + notas.length);

Arrays.fill (t[], valor): Inicializa la tabla indicada con el valor del segundo parámetro.

Arrays.fill(sueldos, 1234.56); //inicializa todos los elementos de la tabla sueldos con 1234,56

Arrays.fill (t[], desde, hasta, valor): Inicializa la tabla indicada desde la posición «desde» hasta la posición anterior a «hasta», con el valor indicado en el último parámetro.

Arrays.fill(sueldos, 3, 7, 1234.56); //inicializa el elemento 3,4,5,6

for (variable : t[]): Recorre una tabla de principio a fin, cargando en variable cada elemento

double sumaSueldos = 0;
for (double sueldo : sueldos) { //sueldo tomará todos los valores de la tabla suma
   sumaSueldos += sueldo;
}

Arrays.toString(t[]): Transforma un array en una cadena

int t[] = {8, 41, 37, 22, 19};
System.out.println(Arrays.toString(t));

//Muestra los valores de la tabla entre corchetes: [8, 41, 37, 22, 19].

Arrays.sort(t[]): Ordena los elementos de una tabla de forma creciente

int edad[] = {85, 19, 3, 23, 7}; //tabla desordenada
Arrays.sort(edad); //ordena la tabla. 
System.out.print(Arrays.toString(edad));
 //Ahora edad = [3, 7, 19, 23, 85];

Arrays.binarySearch(t[], valor): Búsqueda en tabla ordenada. Busca el valor dentro de la tabla t[]. Devuelve el índice donde se encuentra el valor o un valor negativo que indica en que posición debería insertarse restándole 1. Posición donde debe estar: (-pos – 1)

int t[] = {1, 3, 4,8}; 
System.out.print(Arrays.toString(t));
int p = Arrays.binarySearch(t, 5); 
if (p >= 0)  System.out.println("Encontrado en el índice: " + p); 
else 	     System.out.println("Debe estar en el índice: " + (-p-1));
//se muestra: Debe estar en el índice: 3

Arrays.binarySearch(t[], desde, hasta, valor): Búsqueda en una tabla ordenada entre el índice desde hasta el índice hasta-1

o[]=Arrays.copyOf(t[],n): Copia los primeros n elementos de la tabla t[] a la tabla o[]

int t[] = {1, 3, 4,8}; 
int o[];
o=Arrays.copyOf(t, t.length);
System.out.println (Arrays.toString(o));

o[]=Arrays.copyOfRange(t[], desde, hasta): Copia desde la tabla t[] a la tabla o[] los elementos desde la posición desde hasta la posición hasta-1

int t[] = {1, 3, 4, 8}; 
int o[];
o=Arrays.copyOfRange(t, 1, 4);
System.out.println (Arrays.toString(o));
//Muestra [3, 4, 8]

System.arraycopy(t[], posOrigen, o[], posDestino,n): Copia n caracteres de la tabla t[] desde la posición posOrigen en la posición posDestino de la tabla o[]. La tabla destino tiene que estar inicializada

int t[] = {1, 3, 4, 8}; 
int o[] = {9, 9, 9, 9};
System.arraycopy(t, 1, o, 2, 2);
System.out.println (Arrays.toString(o));
//Muestra [9, 9, 3, 4]