Cuántas letras hay en Java

plant.length() cuenta las letras que plant ya guarda. String plant = "leaf"; sigue guardando leaf, y System.out.println(plant.length()) escribe 4. Las letras siguen siendo leaf. No se vuelven el número. El punto después del nombre es la pregunta, y la línea de escritura muestra la respuesta.

El punto pregunta cuántas letras

Abre Mint.java. El nombre del archivo sigue siendo Mint.java, porque public class Mint sigue siendo el nombre del archivo. Esta página no cambia el nombre del archivo y no cambia public class Mint. La página anterior guardaba String plant = "leaf"; y una línea de escritura que mostraba leaf. Esta página guarda esa línea de guardado. Borra una línea int si todavía está, de la página anterior a las comillas. Borra cualquier línea de import, cualquier línea de reader y cualquier línea de nextLine. El archivo que guardas no tiene import, ni Scanner, ni nextLine. Un import sin uso no hace fallar a javac por sí solo, y tampoco escribe la cuenta. La cuenta la escribe solo la línea de escritura que hace la pregunta.

Dentro de main, la línea de guardado sigue siendo String plant = "leaf";. String es la palabra del tipo. plant es el nombre, y empieza con una p minúscula. Las comillas guardan l, e, a, f, todas pequeñas, y nada más entre ellas. Esa línea guarda las letras. No hace una pregunta y no escribe la pantalla. La pregunta es el trabajo siguiente, después de guardar las letras. Después del nombre escribes un punto, luego la palabra de la pregunta length, luego un par de paréntesis sin nada dentro. La pregunta entera es plant.length(). El punto ata la pregunta al nombre. length es la palabra de la pregunta para la cuenta. Los paréntesis vacíos dicen que esta pregunta no necesita una palabra extra dentro. Aquí no hay un número de lugar. En el archivo que guardas, esa pregunta está dentro de la segunda línea de escritura. No es una línea sola. Preguntar no es guardar. Las letras del nombre siguen siendo leaf. La pregunta no quita las comillas y no mete el número 4 dentro del nombre plant.

El archivo que guardas escribe primero las letras y luego hace la pregunta. La primera línea de escritura es el nombre solo: System.out.println(plant);. Sin comillas y sin punto. Escribe leaf y termina la línea, igual que la página anterior. La segunda línea de escritura es la pregunta: System.out.println(plant.length());. Sin comillas alrededor de length. Java lee el nombre plant, cuenta las letras que ese nombre guarda, escribe esa cuenta y termina la línea. Para el archivo que guardas, la cuenta es 4. Las comillas no están en la pantalla. La palabra length no está en la pantalla. Los paréntesis no están en la pantalla. Las letras del propio nombre, p, l, a, n, t, no están en la pantalla. Guarda el archivo.

El archivo que guardas

Guarda esto como Mint.java. Es el archivo que esta página guarda. Una línea de guardado, String plant = "leaf";. Una línea de escritura para las letras. Una línea de escritura para la cuenta. La línea de la cuenta es plant.length() dentro de println. Nada más.

Léelo desde arriba. public class Mint nombra el archivo. No escribe la pantalla. public static void main(String[] args) es donde Java empieza. La palabra String en esa línea de main sigue sin ser una línea de guardado. La línea de guardado es la siguiente, String plant = "leaf";. Guarda cuatro letras. No escribe nada. System.out.println(plant); escribe leaf y termina la línea. System.out.println(plant.length()); escribe 4 y termina la línea. Dos líneas en la pantalla. La primera línea son las letras. La segunda línea es la cuenta. Las comillas se quedan en el archivo, alrededor de leaf, y no están en ninguna de las dos líneas de la pantalla.

Qué muestra la pantalla

En la carpeta que contiene este Mint.java, escribe javac Mint.java. Cuando el archivo está bien, ese comando no escribe ninguna línea. Una pregunta después del punto no hace que javac escriba una línea por sí sola, ni hace que javac falle. Luego escribe java Mint. No escribas .java después de java. Son los mismos dos comandos que escribes en Windows y en macOS. Esta página no cita el aviso del shell. El programa escribe leaf y luego 4 en la línea siguiente. No espera a que escribas. Las letras ya estaban en el archivo, y la cuenta se responde con esas letras. Si java Mint espera, nextLine sigue en el archivo. Borra esa línea y deja la línea de guardado y las dos líneas de escritura. El programa termina después de la segunda línea de escritura.

La pantalla muestra leaf y luego 4. Cuatro letras pequeñas, luego la cuenta, sin comillas en ninguna de las dos líneas. Si la pantalla muestra plant, una línea de escritura tiene comillas alrededor del nombre: System.out.println("plant");. Esas comillas marcan las letras p, l, a, n, t, así que el leaf guardado no se escribe y la pregunta no se hace. Si la pantalla muestra solo leaf, falta la segunda línea de escritura. El archivo que guardas tiene las dos líneas, primero las letras y luego la cuenta. Si la pantalla muestra solo 4, falta la primera línea de escritura. Las letras pueden seguir en el archivo, pero la prueba de esta página es la pantalla: leaf y luego 4. Si la pantalla muestra 4 y luego leaf, las dos líneas de escritura están cambiadas. Pon println(plant) encima de println(plant.length()). Si la pantalla muestra 5, la cuenta está mal para estas letras. Las comillas no son letras que el nombre guarde, así que no forman parte del 4. Una quinta letra tendría que estar entre las comillas. El archivo que guardas tiene solo l, e, a, f. Si la pantalla muestra mint, sigues en un archivo más viejo. Si la pantalla muestra leaf y luego leaf otra vez, la segunda línea de escritura es otro println(plant), no la pregunta. No vuelves a instalar Java porque la pantalla muestre la línea equivocada.

Una letra grande entre las comillas cuenta como una letra, igual que una pequeña. String plant = "Leaf"; hace que plant.length() escriba 4 igual. La línea de escritura de las letras muestra Leaf, con una L grande. El archivo que guardas no usa eso. Usa cuatro letras pequeñas, y la línea de la cuenta escribe 4. Juzga la cuenta por las letras que de verdad están entre las comillas.

Puedes guardar la cuenta bajo un segundo nombre. int count = plant.length(); toma la respuesta, y la palabra del tipo es int, porque la respuesta es un número entero. Luego System.out.println(count); escribe 4. Eso está permitido. No es el archivo que guardas. El archivo guardado escribe la pregunta directamente, así que la pantalla es leaf y luego 4, y no necesitas un segundo nombre para ver la cuenta. El número 4 es la respuesta. No sustituye a las letras dentro de plant.

Un espacio cuenta como uno

Las letras entre las comillas pueden cambiar, y la cuenta sigue a esas letras. Debajo de la primera pregunta, guarda un conjunto nuevo de letras en el mismo nombre y vuelve a hacer la pregunta. La nueva línea de guardado es plant = "leaf stem";. No empieza con String. plant ya existe, así que esta línea solo cambia las letras que el nombre guarda. Entre las comillas hay nueve lugares: l, e, a, f, un espacio, s, t, e, m. El espacio es uno de ellos. length lo cuenta. Las dos palabras siguen siendo un valor guardado, no dos nombres. Este segundo archivo no escribe las letras. Escribe solo las dos cuentas, para que la pantalla no se confunda con las letras mismas.

Este es el segundo archivo. No es el archivo que guardas. El archivo que guardas tiene una línea de guardado, las letras leaf, ningún espacio, y una pantalla leaf y luego 4. Guarda este segundo archivo como Mint.java cuando quieras ver el espacio contado, y luego vuelve a dejar el archivo guardado.

Escribe javac Mint.java. El archivo está bien, así que javac no escribe ninguna línea. La segunda línea de guardado puede no escribir String, y esa ausencia no hace fallar a javac. Luego escribe java Mint. La pantalla muestra 4, y la línea siguiente es 9. Dos líneas. Sin comillas. Las letras leaf no están en la pantalla. Las letras leaf stem tampoco están en la pantalla. Solo están las cuentas. La primera cuenta sale de las letras que el nombre guardaba en ese momento. La segunda cuenta sale de las letras que el nombre guarda después de plant = "leaf stem";. Si la segunda línea es 8, falta el espacio entre las comillas, y las letras guardadas son leafstem. Si las dos líneas son 4, falta la segunda línea de guardado o todavía dice "leaf". Si las dos líneas son 9, la primera línea de guardado ya dice "leaf stem". La pantalla sigue el orden de las líneas del archivo, y sigue las letras entre las comillas, espacio incluido.

No escribas String una segunda vez para el mismo nombre. String plant = "leaf stem";, puesto bajo una línea que ya creó plant, es un error distinto. Esa línea intenta crear plant otra vez. javac escribe un error y no se queda callado. No necesitas las palabras exactas de ese error. Todavía no escribas java Mint. Borra el segundo String y deja plant = "leaf stem";. El nombre se crea una vez. Las líneas de después solo cambian las letras que guarda, o hacen una pregunta sobre esas letras. En el archivo que guardas no hay una segunda línea de guardado. Después de ver 4 y luego 9, vuelve a dejar ese archivo: String plant = "leaf";, println(plant) y println(plant.length()).

Qué letra está en un lugar

length pregunta cuántas. Otra pregunta pregunta qué letra está en un lugar. La palabra de la pregunta es charAt. El lugar va dentro de los paréntesis, porque esta pregunta necesita esa palabra extra. El primer lugar es 0, no 1. En leaf, el lugar 0 tiene l, el lugar 1 tiene e, el lugar 2 tiene a y el lugar 3 tiene f. plant.charAt(0) responde con la letra sola l. plant.charAt(1) responde con la letra sola e. La respuesta es una letra, no la palabra leaf entera, y no el número del lugar. Las letras guardadas en plant siguen siendo leaf. Preguntar por un lugar no borra los otros.

Este es el tercer archivo. No es el archivo que guardas. El archivo que guardas pregunta length, y su pantalla es leaf y luego 4. Guarda este tercer archivo como Mint.java cuando quieras ver los lugares, y luego vuelve a dejar el archivo guardado.

Escribe javac Mint.java. El archivo está bien, así que javac no escribe ninguna línea. Un número de lugar dentro de los paréntesis no hace fallar a javac cuando ese lugar es una de las letras. Luego escribe java Mint. La pantalla muestra l, y la línea siguiente es e. Dos líneas. Sin comillas. La palabra leaf no está en la pantalla. Los números 0 y 1 no están en la pantalla. Si la primera línea es e, la primera pregunta pidió el lugar 1, que es la segunda letra. La primera letra es el lugar 0. Si la primera línea es leaf, la línea de escritura es println(plant), no charAt. Si la primera línea es 0, la línea de escritura escribió el número del lugar y no preguntó charAt. Si las dos líneas son l, las dos preguntas dicen charAt(0). El lugar 2 escribe a. El lugar 3 escribe f. Esos dos lugares existen en leaf. Este tercer archivo no los pregunta. Pregunta 0 y luego 1, para que veas que la cuenta empieza en 0.

Un lugar donde no hay letra

El lugar 4 no es una de las letras de leaf. La cuenta es 4, y los lugares que existen son 0, 1, 2 y 3. Cambia la primera pregunta a plant.charAt(4) y deja el resto del tercer archivo. Escribe javac Mint.java. javac no escribe ninguna línea. La línea es una pregunta permitida, así que una letra que falta no es un fallo de javac. Luego escribe java Mint. El programa escribe un error. No escribe una quinta letra, y no escribe 4. No necesitas las palabras exactas de ese error. El hecho útil es que el fallo ocurre cuando el programa se ejecuta, no cuando javac lee el archivo. Vuelve a poner charAt(0) y charAt(1) si todavía quieres esas dos líneas, y luego vuelve a dejar el archivo guardado. No dejes charAt(4) en el archivo que guardas.

Un par vacío tiene la cuenta 0. String plant = ""; no guarda ninguna letra. System.out.println(plant.length()); escribe 0. javac no escribe ninguna línea, porque un par vacío está permitido. java Mint escribe 0 y termina. No espera. Una línea en blanco era lo que println(plant) escribía en la página anterior. La pregunta es distinta: la pantalla muestra el dígito 0, que es la cuenta, no una línea en blanco. plant.charAt(0) en ese par vacío es un lugar donde no hay letra. javac sigue sin escribir ninguna línea. java Mint escribe un error, porque el lugar 0 necesita una letra y la cuenta es 0. Después de ver 0, haz que la línea de guardado vuelva a ser String plant = "leaf";.

Los paréntesis forman parte de la pregunta. System.out.println(plant.length); tiene el punto y la palabra length, y no tiene paréntesis. javac escribe un error. No se queda callado. No hay pantalla que leer, porque no escribes java Mint mientras javac escribe un error. No necesitas las palabras exactas. Vuelve a poner el par de paréntesis vacío, para que la línea sea System.out.println(plant.length());. charAt no puede estar vacío. System.out.println(plant.charAt()); escribe un error en javac, porque esa pregunta necesita el lugar. Pon un lugar que exista dentro de los paréntesis, por ejemplo 0, cuando estés en el tercer archivo. El archivo que guardas usa length(), y entre los paréntesis no hay nada.

La pregunta se escribe después del nombre. System.out.println(length()); trata length como un nombre que este archivo no tiene. javac escribe un error. La palabra de la pregunta va después de plant y un punto. System.out.println(plantlength()); también es un nombre, plantlength, y este archivo no lo tiene. El punto es lo que separa el nombre de la pregunta. El nombre tiene que existir antes de la línea que lo usa. Si System.out.println(plant.length()); está escrito encima de String plant = "leaf";, javac escribe un error. La pregunta nombra plant antes de que plant exista. Mueve la línea de guardado por encima de las líneas de escritura. Es el mismo orden que ya usaste para count y para reader.

La pregunta es para letras, no para un número entero que guardaste con int. int count = 4; y System.out.println(count.length()); le pregunta a un número entero cuántas letras guarda. javac escribe un error. Un número entero no tiene pregunta length. El arreglo en esta página no es solo añadir paréntesis. El arreglo es hacer la pregunta al nombre que guarda letras: plant.length(). La página anterior a las comillas guardaba int y guardaba 4, sin pregunta. La página anterior guardaba String y guardaba "leaf". Esta página guarda String, guarda "leaf" y pregunta length.

Ahora puedes preguntar cuántas letras guarda ya un nombre, y qué letra está en un lugar que empieza en 0. String plant = "leaf"; sigue guardando leaf. System.out.println(plant); escribe leaf. System.out.println(plant.length()); escribe 4, y las letras siguen siendo leaf. Un plant = "leaf stem"; más adelante hace que la cuenta siguiente sea 9, porque el espacio cuenta como uno. plant.charAt(0) escribe l, y plant.charAt(1) escribe e. Un lugar donde no hay letra, como 4 para leaf, deja a javac callado y hace que java Mint escriba un error. length sin paréntesis hace que javac escriba un error. La página siguiente deja estas preguntas. Se queda con un número entero como el 4 que escribió esta cuenta, y ese número lo escribes tú otra vez en el archivo.

La pantalla muestra la respuesta y las letras se quedan

El archivo que guardas escribe leaf y luego 4. El nombre en la primera línea de escritura es plant, y plant no está en la pantalla. length está en el archivo, después del punto, y no está en la pantalla. Las comillas se quedan alrededor de leaf. No se cuentan, y no están en la pantalla. Un espacio entre las comillas sí se cuenta. El primer lugar es 0.