Saltar navegación

Manejo de String - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 1 de octubre de 2024 por Stefano C.

48 visualizaciones

Más información Transcripción

Descargar la transcripción

voy a grabar esta clase por lo tanto si habláis y hacéis preguntas me autoriza jce a que vuestra 00:00:00
voz sea grabada vale lo que vamos a ver hoy son algunas pinceladas sobre dos tipos que hemos visto 00:00:05
pero que hemos dejado un poquito así en la niebla que son por un lado string y por otro lado char 00:00:16
Entonces, empezamos por string 00:00:22
Nosotros hemos visto que Java tiene varios tipos primitivos 00:00:25
Que son todos los que cuando se escriben aquí salen en azul 00:00:33
Tipo int, char, float, doble, etc 00:00:37
Todo esto se llaman tipos primitivos 00:00:46
Son tipos que Java define 00:00:49
Hay tipos numéricos, hay tipos de letras, hay tipos booleanos 00:00:52
Hay varios tipos que tenemos 00:00:57
De los tipos que hemos utilizado nosotros y que utilizamos normalmente 00:00:59
Y que hacemos variables, que por ahora son estos 00:01:03
Más uno, que es una pizca distinto 00:01:06
Porque cuando yo pongo string 00:01:09
No sale como palabra reservada 00:01:11
String no es un tipo primitivo 00:01:14
String es algo distinto 00:01:17
Si os fijáis, funciona 00:01:20
Funciona como una variable, puedo crearla así 00:01:23
Pero esta cosa de aquí 00:01:25
No es un tipo primitivo, es una cosa distinta 00:01:27
Algo parecido 00:01:29
Lo hemos visto con Scanner 00:01:32
Hemos visto que 00:01:35
Aquí también estamos creando una cosa 00:01:44
Que desde una perspectiva 00:01:47
Sintáctica 00:01:49
es una variable, porque hay un algo 00:01:51
un nombre igual y un valor 00:01:55
punto y coma, es la misma sintaxis de las variables 00:01:58
entonces podemos asumir que esta es una variable 00:02:03
pero no tiene, esto es un pogonar 00:02:07
duda 00:02:11
Entonces, la razón es que estos señores de aquí no son tipos primitivos, son objetos. 00:02:26
Estos señores de aquí son clases 00:02:45
Y de estas clases yo creo un objeto 00:02:50
Cosa que nosotros no sabemos porque todavía no hemos visto programación de objetos y cosas por el estilo 00:02:55
Pero string, por ejemplo, es un objeto tan cómodo, tan útil, tan normalmente utilizado 00:03:00
que hasta el mismo Java lo usa en una forma un poquito distinta 00:03:11
con respecto a como se usan normalmente los objetos 00:03:17
los objetos se usan así normalmente 00:03:20
declaro una variable que se llama scan 00:03:23
un lugar de memoria donde dentro creo algo que es un objeto de tipo scanner 00:03:27
y para crear este objeto tengo que utilizar el new 00:03:34
El new es una operación que me dice 00:03:39
Crear un nuevo objeto 00:03:42
De este tipo 00:03:43
Si os fijáis aquí no lo estoy haciendo 00:03:45
¿Vale? 00:03:47
String es talmente tan utilizada 00:03:49
Se puede hacer, si se puede hacer 00:03:51
Yo puedo hacer new string 00:03:53
De hola 00:03:56
Esto funciona 00:03:57
Esto se parece mucho más a este de aquí 00:03:58
¿Si? Pero como string es tan 00:04:01
Utilizado, estamos constantemente haciendo 00:04:04
Palabras para escribirla por pantalla 00:04:05
para guardarla, para meter un fichero, cosas por el estilo 00:04:07
las tiras de caracteres, las secuencias de caracteres 00:04:10
son algo que se utiliza muchísimo en Java 00:04:13
pues entonces Java ha evolucionado hasta un cierto momento 00:04:15
diciendo, vale, sí, es verdad, esto es un tipo 00:04:19
pero lo voy a hacer un poquito más fácil de utilizar 00:04:21
para que como lo tienes que utilizar muchas veces 00:04:26
pues te doy una sintaxis alternativa 00:04:29
que igualmente yo voy a entender 00:04:32
y cuando me encuentro esta cosa de aquí 00:04:34
en automático por debajo, estaré haciendo esto 00:04:36
esto hace que string sea un poco distinto 00:04:40
de los otros objetos y de cómo se utiliza string 00:04:46
es más, string se utiliza talmente tanto 00:04:50
así de mucho 00:04:53
que además tiene sus propias particularidades de cómo funciona 00:04:56
en memoria, o sea, todo lo que veremos de los objetos 00:05:02
y de cómo se guardan los objetos y de cómo se crean los objetos 00:05:06
para string no vale exactamente 00:05:10
string es un objeto especial 00:05:14
veremos cuando veremos los objetos y los utilizaremos 00:05:16
que de hecho cuando quiero probar algo que funciona con objetos 00:05:20
probarlo con string siempre es peligroso 00:05:23
porque a veces string funciona de una forma distinta 00:05:27
con respecto a otros objetos para optimizar 00:05:30
Para que sea más rápido y más fácil de utilizar 00:05:34
Pero esta cosa aquí a veces comporta características y comportamientos de string 00:05:39
Que no son muy, muy, muy, muy, muy algo 00:05:45
¿Vale? 00:05:51
Entonces, lo que vamos a hacer es ahora olvidarnos que es un objeto 00:05:54
Olvidarnos que es más o menos 00:06:01
Esta parte no nos interesa 00:06:04
Endagar sobre eso 00:06:06
Pero ya que nos proporciona 00:06:07
Algunas cosas interesantes 00:06:10
Pues vamos a decirla o vamos a utilizar 00:06:11
Y vamos a ver que pasa 00:06:13
Entonces esto nos lo olvidamos 00:06:15
Estamos utilizando objetos 00:06:18
Estamos haciendo todo orientado a objetos 00:06:19
Ejemplos 00:06:21
String 00:06:24
Es igual 00:06:25
A new 00:06:29
Estoy haciendo un objeto 00:06:30
De esta clase 00:06:38
Pero vosotros no lo sabéis hacer 00:06:40
Lo veremos en un futuro 00:06:42
Vamos a hacer pruebas 00:06:44
Con string a ver que pasa 00:06:49
¿Vale? 00:06:51
Ok, empezamos 00:06:53
Tengo un string que se llama hola 00:06:54
¿Si? Fenomenal 00:06:57
Pregunta 00:06:59
Si yo digo escribe 00:07:00
X es igual a ola 00:07:03
¿Qué me escribe? 00:07:07
¿Qué es este operador de aquí? 00:07:15
¿Y qué tipo de operador es? 00:07:20
Entonces el resultado de esta expresión será un 00:07:22
True o False 00:07:25
¿Estamos de acuerdo con esto? 00:07:27
50% de probabilidad 00:07:28
¿Esto me da True o False? 00:07:31
True 00:07:33
Fenomenal 00:07:38
String 00:07:40
es igual a hola 00:07:43
x igual a igual a y 00:07:49
true o false 00:07:52
string k 00:07:55
es igual a 00:08:03
k es igual 00:08:05
a lo que hay en k 00:08:09
más la 00:08:11
que hay ahora mismo 00:08:12
dentro k 00:08:15
hola 00:08:16
x igual a igual a k 00:08:21
ah claro 00:08:29
No, claro no, claro nada 00:08:39
Porque me esperaría que fuera true 00:08:42
Tiene dentro lo mismo 00:08:45
¿No estáis convencidos que dentro tiene lo mismo? 00:08:47
Si, so, x, si, so, k 00:08:49
¿Veis que es lo mismo? 00:08:57
¿Por qué pasa esto? 00:09:07
¿Vale? 00:09:09
Y esto es relativamente complejo 00:09:10
Vamos a pintar 00:09:11
Ahora, cuando tú creas un tipo primitivo, una variable de tipo primitivo, un int, lo que pasa en la memoria, esta es la memoria, es que por ejemplo int x es igual a 3 o int a es igual a 3, me crea un trocito de memoria referenciado con el nombre a que tiene dentro enteros y como valor dentro. 00:09:14
Tiene un 3 00:09:53
¿Estamos de acuerdo? 00:09:54
Vale 00:09:58
¿Cuándo creo un objeto? 00:09:59
Esto vale para todos los tipos primitivos 00:10:01
¿Sí? 00:10:04
¿Cuándo creo un objeto? 00:10:06
Como scanner, como cosa por estilo 00:10:09
La cosa es un poquito distinta 00:10:11
Pensamos en un scanner, por ejemplo 00:10:13
Cuando yo hago scanner, scan es igual a new scanner, bla bla bla 00:10:14
Lo que se está haciendo es creando un trocito de memoria 00:10:18
referenciado con el nombre scan 00:10:21
que tiene dentro un objeto scanner 00:10:25
y hasta aquí es igual 00:10:30
pero la operación new no sé qué 00:10:34
lo que está haciendo es crearme el objeto 00:10:37
en otro lado del mundo 00:10:40
en una zona que se llama el heap 00:10:42
montón en español 00:10:45
un montón de cosas que están allí 00:10:51
y luego aquí dentro 00:10:55
no se pone el objeto 00:10:58
aquí dentro se pone una referencia 00:11:00
a donde se coloca el objeto 00:11:03
ahora, si yo creo otro objeto scanner 00:11:06
que se llama S2 00:11:17
siempre tipo scanner 00:11:23
lo que se hará es crear otro objeto por aquí 00:11:25
y que esto referencia a esto 00:11:29
Cuando hago scan es igual igual a S2 00:11:33
No estoy comparando si estos dos objetos son iguales 00:11:38
Mas estoy comparando si esta referencia es igual 00:11:43
Entonces en este caso daría false 00:11:47
Si yo esto hago que apunte aquí 00:11:54
Sería true 00:11:59
Es decir que el igual igual entre objetos 00:12:01
solo es true 00:12:05
si los dos objetos son el mismo objeto 00:12:08
no que sean parecidos 00:12:12
mas sean el mismo objeto en memoria 00:12:16
vamos a hablar de esto en términos de string 00:12:19
pensamos esto en string 00:12:24
y hemos dicho que string es un objeto 00:12:34
por lo tanto como debería funcionar string 00:12:36
debería funcionar que si yo pongo aquí un objeto que es string 00:12:39
que se llama x 00:12:43
Y creo un objeto hola 00:12:45
Por algún lado se creará el objeto hola 00:12:47
Y aquí hay un puntero a este objeto hola 00:12:50
Y que cuando me creo un objeto K 00:13:00
Que es un objeto 00:13:04
Que apunta a un objeto O 00:13:07
Y luego lo modifico 00:13:10
Añadiendo la aquí 00:13:18
Que es lo que he hecho 00:13:19
Ignorad por ahora esta parte de aquí 00:13:24
¿Vale? He creado un objeto hola, este aquí, y luego he dicho, crea un objeto K con dentro solo HO, y luego después le pegas detrás la. 00:13:28
¿Vale? Entonces lo que he hecho es crear este objeto K con solo dentro HO, y luego le he pegado el HO aquí. 00:13:43
Estos son dos objetos distintos. Entonces, si yo hago x es igual a y, el resultado es falso. 00:13:51
Acá. Está escrito acá, ¿no lo veis? Ahí, acá. 00:14:04
El resultado será falso porque lo que está escrito aquí, que es como una dirección de memoria, imaginámonos así, es distinto de lo que está escrito aquí. 00:14:11
Pero dentro tiene la misma cosa 00:14:22
Tiene hola a los dos, sí 00:14:24
Pero cuando lo hago con igual 00:14:25
Igual 00:14:28
No estoy comparando lo que contiene 00:14:29
Estoy comparando 00:14:32
Este dato de aquí 00:14:34
Y como apunta a dos objetos distintos 00:14:36
Es distinto 00:14:39
Y esta es la razón de por qué aparece 00:14:41
Este falso 00:14:45
Y dice, ignorad esta parte 00:14:46
¿La has ignorado? 00:15:00
No, me has dicho una pregunta sobre esta parte 00:15:02
No lo estás ignorando suficientemente 00:15:04
Ignóralo más 00:15:06
¿Vale? 00:15:07
Cuando hemos entendido cómo debería funcionar 00:15:09
Explicamos por qué no funciona aquí 00:15:12
¿Sí? 00:15:14
Que aclaro esto 00:15:16
¿Sí? 00:15:17
Si yo hago B siempre entero 00:15:28
Con 3 00:15:30
Cuando luego hago el igual igual 00:15:32
Voy a comparar este 3 con este 3 00:15:34
No es una referencia 00:15:37
Es un valor allí dentro 00:15:38
Mientras que cuando trabajo con objetos 00:15:40
dentro de la variable no me encuentro el objeto, me encuentro una 00:15:42
referencia donde está el objeto 00:15:46
ahí está la jala, es lo que luego 00:15:48
veremos que en un futuro cuando utilizamos los métodos 00:15:54
y le tenemos que pasar parámetros a estos métodos, habrá pasos por 00:15:58
valor o pasos por referencia 00:16:02
lo veremos y volveremos sobre esto, por ahora me interesa 00:16:06
solo a nivel de string, de entender 00:16:10
por qué string funciona un poquito raro. 00:16:12
¿Sí? Y por qué no 00:16:15
puedo comparar dos 00:16:16
string utilizando 00:16:18
igual, igual. Entonces, ¿cómo 00:16:20
comparo dos string? 00:16:24
Pues string, no. 00:16:28
Porque, cuidado, 00:16:31
si yo comparo 00:16:33
la referencia, estoy comparando si son 00:16:34
el mismo objeto. Pero yo 00:16:36
no quiero preguntarme si son el mismo objeto. 00:16:38
Yo quiero preguntarme si tienen o la dentro igual. 00:16:40
¿Sí? Que sería 00:16:43
esto, que sería, no el valor de la diferencia, porque el valor de la diferencia 00:16:44
de esto podría ser 37, vete a la posición 37, y esto 45 00:16:47
que es, vete a la posición 45 de la memoria y encontrarás el objeto 00:16:52
y estos son dos números distintos, y yo quiero comprobar si 00:16:56
lo interior, el valor, lo que contiene este objeto es igual al valor 00:16:59
de este objeto de aquí, o sea, si al fin y al cabo 00:17:04
hay una H en los dos, hay una O en las dos, hay una L en las dos, hay una O en las dos 00:17:07
Si eso es así, pues son iguales 00:17:11
Si no, no 00:17:14
Pero no lo puedo hacer con el igual-igual 00:17:14
El igual-igual me va a mirar este valor y este valor 00:17:17
Descubrirá que son distintos y me dirá que son distintos 00:17:21
Pero yo no es lo que me estaba preguntando 00:17:23
El igual-igual entre objetos no te pregunta si son iguales 00:17:26
Te pregunta si son el mismo objeto 00:17:30
Charra es un primitivo 00:17:32
Cómo se hace no nos interesa 00:17:42
Vale, por ahora, lo haremos 00:17:48
En cada clase y objeto que tú crearás, el objeto alumno, tú definirás cuando dos alumnos son iguales 00:17:50
Los alumnos iguales cuando son iguales, mejor cuando corresponde el nombre 00:18:00
Y si dos alumnos se llaman igual, pues entonces cuando se corresponde el DNI, pues ya está 00:18:04
Lo decides tú, pero ahora lo veremos 00:18:08
La idea es que si yo uso el igual igual, compruebo el primer nivel 00:18:10
Entonces si yo lo estoy usando entre variables de tipo primitivo 00:18:16
Esto me funciona muy bien porque encuentro el valor directamente allí 00:18:20
Y comparo los valores 00:18:24
Pero si lo utilizo en objetos o en variables que no son de tipo primitivo 00:18:25
No estoy comparando el valor real de este objeto 00:18:31
Si no estoy comparando la referencia de ese objeto 00:18:35
La posición, no es exactamente así 00:18:39
Pero la posición de memoria en la que están 00:18:40
Entonces si la posición de memoria es la misma 00:18:43
Apuntarán al mismo objeto y son lo mismo 00:18:46
Muy bien 00:18:49
Pero si la posición no es la misma 00:18:50
Estará apuntando a dos objetos distintos 00:18:53
Que pero podrían contener lo mismo 00:18:56
Ola y ola 00:19:00
Entonces podrían ser iguales 00:19:01
Desde mi definición de igualdad 00:19:03
Es que con los tipos primitivos no hay problemas 00:19:09
Con los tipos objeto, los tipos no primitivos 00:19:16
Yo puedo preguntarme dos cosas 00:19:19
Puedo preguntarme si son el mismo objeto o si el objeto vale lo mismo 00:19:22
Y son dos cosas distintas 00:19:26
Aquí no son el mismo objeto, pero el objeto vale lo mismo 00:19:28
En una situación en la que creo Y 00:19:32
No, Y no lo he usado ya 00:19:36
Que creo W 00:19:40
Que tiene la misma 00:19:41
Cosa 00:19:44
Aquí se corresponden 00:19:48
Esto 00:19:50
Y se corresponde también en valor 00:19:51
¿Lo veis la diferencia? 00:19:55
¿Cómo lo hago esto en código? 00:19:57
En código sería una cosa así 00:19:59
String 00:20:00
Es igual a X 00:20:09
Esto en un cierto sentido me está creando 00:20:10
Una nueva variable 00:20:22
Y está copiando esta cosa de aquí a aquí 00:20:23
Entonces apuntan al mismo objeto 00:20:27
No son dos objetos distintos 00:20:30
¿Dudas? 00:20:31
Vamos hasta aquí 00:20:36
Todo esto para deciros que 00:20:37
No se puede comparar dos strings con igual a igual 00:20:40
Si queréis saber si 00:20:43
Este es un nombre que te ha dado el usuario 00:20:45
Y queréis saber si el nombre que te ha dado el usuario es Estefano 00:20:47
No lo podéis comparar con igual a igual 00:20:50
Lo tenéis que comparar de otra forma 00:20:52
¿Cómo? Nuestro amigo String es una clase 00:20:56
Si vosotros buscáis String API Java, os viene por algún lado la documentación de Java 00:21:03
Donde os sale, por ejemplo, la clase String 00:21:10
Ahora, si os acordáis cuando vimos y hablamos del concepto de programar por objetos 00:21:15
De programación orientada a objetos 00:21:22
La idea era pillar un concepto y juntarlo con las características de este objeto y todo lo que puede hacer este objeto. 00:21:24
Hacer un package, un paquete, en el que dentro pongo lo que es este objeto, sus características, sus valores relacionados, 00:21:34
por ejemplo, las caracteres que tiene dentro si es un string, 00:21:44
y además le añado un montón de funciones, de métodos, que yo puedo utilizar sobre este string, sobre este objeto. 00:21:48
En particular, la clase string me proporciona todos estos métodos que veis aquí para poder trabajar sobre string. 00:21:58
Entre todos estos métodos, del que alguno veremos, está el método equals 00:22:11
Que me permite hacer un igual entre un objeto y otro 00:22:26
Entre un string y otro string 00:22:35
Es decir que cuando quiero comprobar si estos dos señores son iguales 00:22:37
Porque son iguales 00:22:46
no le voy a decir x es igual o igual a k, porque no son el mismo objeto y me diría falso, 00:22:49
porque son dos referencias distintas, sino que le voy a decir x.equals, 00:23:00
.equals, llamo un método de la clase string sobre el objeto x. 00:23:17
Lo veremos en un futuro, por ahora lo asimiláis como podáis. 00:23:32
Cuando quiero hacer esto entre dos strings, en vez de utilizar el .igual, tengo que escribir .equals. 00:23:36
Sí. 00:23:45
Lo veremos en un futuro. 00:23:53
Sí. 00:23:55
No, y no lo hemos visto todavía. 00:24:00
Lo veremos en la segunda evaluación 00:24:02
Por lo tanto, por ahora 00:24:06
No lo sé, lo veremos en la segunda evaluación 00:24:07
Sé solo que sobre string puedo utilizar 00:24:14
Magia 00:24:19
Y la magia se invoca con un punto 00:24:20
Algunos 00:24:22
Veremos 00:24:31
¿Vale? 00:24:32
Entonces, este de aquí, ¿ahora qué me da? 00:24:34
False 00:24:43
¿Es esto? 00:24:44
Si queréis lo ponga aquí 00:24:46
Igual, igual 00:24:47
Y .equals 00:24:49
El igual igual 00:25:17
Me da false 00:25:34
El .equals me da true 00:25:35
¿Lo veis? 00:25:38
¿Si? 00:25:41
Entonces os he puesto 00:25:45
Pinceladas de programación a objetos 00:25:50
Por favor, olvidáosla por ahora 00:25:52
¿Vale? Os estoy explicando por qué pasa esto 00:25:54
Por si estáis interesados 00:25:56
Pero sobre esto 00:25:58
Volveremos otras veces y volveremos 00:25:59
Más en detalle cuando veremos los objetos 00:26:02
Ahora, el resumen de esto 00:26:04
Es que no comparéis string con igual igual 00:26:06
Cada vez que queréis preguntaros 00:26:09
Si una string que habéis leído 00:26:12
O que tenéis por ahí es igual a otra string 00:26:13
Lo comparáis con .equals 00:26:15
¿Sí? 00:26:17
¿Lo das? 00:26:21
Vale 00:26:22
Siempre de cara a... 00:26:23
¿Por qué entonces esto sí funciona? 00:26:26
¿Vale? 00:26:34
Porque si os fijáis 00:26:35
Este de aquí 00:26:36
Hasta este 00:26:38
¿Por qué este funciona? 00:26:41
Este tampoco debería funcionar 00:26:44
Este y este 00:26:46
No deberían funcionar 00:26:47
Por como hemos dicho que funcionan las cosas 00:26:50
Y explico por qué no deberían funcionar 00:26:53
Según lo que hemos entendido 00:26:56
Cuando yo hago 00:26:59
Esta primera cosa aquí 00:27:01
Lo que estoy haciendo es crear 00:27:07
crear un objeto x 00:27:09
que tiene una referencia a un objeto real 00:27:14
donde está escrito hola 00:27:19
cuando hago esto, x es igual a hola 00:27:20
esta cosa de aquí no es este objeto x 00:27:26
debería ser otro valor por algún lado que pone hola 00:27:29
referenciado no sé cómo 00:27:35
porque no tengo una variable para referenciarla 00:27:37
Y estaría comprobando esto con esto 00:27:40
Pero como esto no es esto 00:27:43
Porque es este de aquí 00:27:45
Me debería dar falso 00:27:47
El problema 00:27:48
Es que como se usan 00:27:50
Muchas 00:27:53
Muchas 00:27:54
Strings 00:27:56
Y como los strings se usan mucho 00:27:57
Y como Java quiere ser eficiente 00:28:00
Con los strings 00:28:03
Y solo con los strings 00:28:05
Pero en particular con los strings 00:28:06
Cuando yo hago esta cosa de aquí, en realidad el objeto hola que se crea es un objeto especial que se queda allí 00:28:08
Y cuando yo lo reutilizo otra vez, él va a utilizar el mismo objeto, no va a crear uno nuevo 00:28:19
Es como si en vez de crear un nuevo objeto cada vez que lo uso 00:28:27
Él se hiciera un índice 00:28:31
Un vocabulario, un diccionario, no sé cómo llamarlo 00:28:35
En que dice, vale, aquí me creo hola 00:28:41
Y ahora todas las veces que usas el string hola, pues usa esto 00:28:43
¿Por qué? Porque es más fácil 00:28:46
No tengo que crear 50 veces hola 00:28:49
Lo tengo aquí, es hola, ya está 00:28:51
Y entonces cuando uso esto o cuando uso esto 00:28:53
En realidad está utilizando el mismo objeto 00:29:00
Y cuando hago Y, en realidad me dice 00:29:04
Uy, hola, ya existe mi índice 00:29:07
Y por lo tanto en vez de crear un nuevo hola y gastar memoria 00:29:10
Voy a pillar y hacerte referenciar el mismo objeto que antes 00:29:15
Por eso cuando hago son iguales 00:29:20
Sí, porque son la misma referencia 00:29:22
Para que me dé false 00:29:26
Si os fijáis, yo voy a crear una cosa distinta 00:29:29
Cuando le digo esto 00:29:32
Entonces él no puede decir 00:29:34
Oye, mira acá, va aquí 00:29:36
Porque HO no es lo mismo que hola 00:29:37
Está forzado a crearme otro objeto HO 00:29:40
Que luego yo lo modifique, le añade el A detrás 00:29:43
Pues no me lo hace igual a esto 00:29:51
no se da cuenta que son lo mismo 00:29:53
al final 00:29:57
y entonces ahora tengo dos objetos 00:29:57
y entonces cuando intento hacer x igual a k 00:30:00
me dice no 00:30:02
porque son dos objetos reales 00:30:03
aún así 00:30:07
¿os interesa saberlo, haberlo entendido? 00:30:08
no, ¿qué os interesa? 00:30:10
para comprobar 00:30:19
dos strings 00:30:21
se usa el punto equals 00:30:22
siempre, cada vez que yo tenga 00:30:24
que hacer comparaciones entre dos strings 00:30:27
haré string1.equals 00:30:29
y entre paréntesis pongo la string2 00:30:32
se acabó, eso es lo que tengo que hacer 00:30:34
sí, sí, espérate, espérate, no te vayas adelante 00:30:37
¿has entendido esto? sí, pues ahora 00:30:43
déjame tiempo 00:30:45
que sí, que sí, que voy a dar más 00:30:47
pero, equals, equals 00:30:50
¿sí? ¿se ha entendido? vale 00:30:53
Otros metoditos mágicos 00:30:57
Ya que estamos aquí 00:31:00
Que son muy útiles de string 00:31:01
Uno lo hemos visto 00:31:04
Ayer 00:31:06
Charat 00:31:08
Imaginaos que tengo un string 00:31:12
String S es igual a 00:31:15
A, B, C, D, E, F, G 00:31:18
Lo que puedo hacer 00:31:21
Es pillar uno solo de estos caracteres 00:31:26
Por ejemplo, haciendo que char 00:31:29
Es igual, o le llamo c0 00:31:33
Es igual a s 00:31:36
Pillo la string 00:31:40
Le aplico magia 00:31:42
Char at 00:31:44
Y la posición del carácter que quiero 00:31:46
Tened en cuenta que los índices de los carácteres empiezan de 0 00:31:49
Este es el carácter 0 00:31:54
4, 5, 6 00:32:02
entonces si ahora hago, si hizo 00:32:06
c0, que me escribirá 00:32:12
y si en vez de c0 pillo c3 00:32:16
0, 1, 2 00:32:32
3, que me pilla 00:32:41
d, se entiende, esto es 00:32:45
De este string 00:32:56
Pilla el carácter 00:32:58
En la posición 00:33:00
Esta 00:33:02
Acordaos que empieza por 0 00:33:04
¿Dónde está el primitivo? 00:33:05
Yo estoy usando un método sobre que 00:33:18
¿Y ese qué es? 00:33:19
El primitivo es el resultado de esto 00:33:28
Pero yo el método 00:33:32
Lo estoy usando sobre un 00:33:33
Char 00:33:35
No es un objeto, no tiene métodos 00:33:39
S es un string 00:33:42
Si tiene método, tiene el método equals 00:33:44
Tiene el método charAt 00:33:46
Pero siempre lo estoy usando sobre algo 00:33:48
Que es un string 00:33:56
Todos los métodos que vamos a ver 00:33:57
En este momento se están utilizando 00:34:00
Sobre un objeto 00:34:02
Que no es de tipo primitivo 00:34:04
No puede hacer 00:34:05
C0 punto 00:34:07
Nada 00:34:10
Fijaos que si yo hago ese punto 00:34:12
me dice, uy, puedes hacer todas estas cosas 00:34:16
de aquí, que fíjate tú 00:34:18
son 00:34:22
estas cosas de aquí 00:34:23
sin embargo, si hago 00:34:27
que no es un objeto 00:34:32
punto, no hay nada 00:34:34
porque no es un objeto, no tiene asociado 00:34:38
métodos 00:34:41
solo ese, punto 00:34:42
solo lo metido scan 00:34:44
le borramos 00:34:47
scanner 00:34:47
scan es igual a new 00:34:50
scanner de 00:34:52
system.int 00:34:53
que es el otro objeto que nosotros estamos 00:34:56
manejando, vale 00:34:58
scan. 00:35:00
Y esto es todo lo que puede hacer con scan. 00:35:02
Incluido 00:35:05
next 00:35:05
int, por ejemplo. 00:35:07
Que es el que uso yo. 00:35:10
Porque cuando yo he usado scan.next 00:35:12
int nadie me ha dicho nada. 00:35:14
Nadie se ha bajurado. ¿Qué es eso del punto? 00:35:18
Pero estabais usando un objeto 00:35:20
O estabais usando un objeto 00:35:22
Y estabais usando un método 00:35:24
Pues misma cosa, estoy usando un objeto 00:35:26
Y estoy usando un método 00:35:29
Estoy usando un objeto 00:35:31
Y estoy usando un método 00:35:33
Y es lo que decíamos al principio 00:35:34
¿Estamos usando nosotros 00:35:37
Programación estructurada básica? 00:35:39
No, estamos usando programación de un objeto 00:35:41
Solo que no lo sabéis 00:35:43
Lo que podéis hacer es pillar 00:35:44
Al fin y al cabo, lo que es un string 00:35:59
es un objeto que representa una secuencia 00:36:01
de char, en vez de utilizar carácter 00:36:04
por carácter, tú podrías no usar 00:36:06
los string, nunca, y trabajar 00:36:08
todo con char, pero sería un infierno 00:36:10
para escribir hola, necesitas 4 char 00:36:12
entonces, aquí hemos 00:36:16
visto equals 00:36:28
aquí hemos visto charat 00:36:29
¿están de acuerdo? 00:36:33
tercer método 00:36:38
que nos mola 00:36:39
de string 00:36:41
lengt 00:36:42
¿Qué hará LENGTH? 00:36:44
Me dice cuántos caracteres hay en este string 00:37:03
Por ejemplo, pillo este de aquí 00:37:07
Le digo SISO S.LENGTH 00:37:11
Me contestará 7 00:37:16
¿Por qué? ¿Cuántos caracteres hay aquí? 00:37:21
Cuidado 00:37:32
Siete caracteres 00:37:33
Que van de la posición cero a la posición seis 00:37:37
¿Sí? 00:37:41
No, son siete 00:37:46
ABCDEFG, contala, son siete 00:37:47
Pero el problema es que van de cero a seis 00:37:51
La posición es uno menos 00:37:53
No obstante sean siete caracteres 00:37:58
Nunca habrá un charat de siete 00:38:02
No existe el charat de siete 00:38:04
Porque va de cero a seis 00:38:07
Si tengo una string de 52 00:38:08
Irá de 0 a 51 00:38:12
Nunca habrá el carácter en posición 52 00:38:13
¿Se entiende? 00:38:16
¿Dudas? 00:38:20
¿Preguntas? 00:38:22
Y pregunta para vosotros 00:38:23
¿Qué pasa si aquí yo le pongo 00:38:24
Su... 00:38:27
Error 00:38:36
String index 00:38:37
Out of bounds 00:38:42
Exception 00:38:43
Índice del string 00:38:44
fuera de los límites, índice de los 00:38:47
string, fuera de los límites, de 0 a 6 00:38:51
¿se entiende? y ¿qué pasa si le digo, jaja, yo soy listo 00:38:55
le pongo menos 3, o menos 2 00:39:02
error, mismo error, ¿vale? es el mismo, siempre 00:39:05
fuera de los límites, los límites son de 0 a 6, de 0 00:39:10
a length menos 1, ¿ok? de 0 00:39:14
que es el primero 00:39:23
a length 00:39:25
menos uno 00:39:27
length sería siete, menos uno es seis 00:39:28
estos tres señores 00:39:31
equals, charat 00:39:37
y length se usan mucho 00:39:39
son de los tres 00:39:41
métodos de string 00:39:44
que más se usan 00:39:45
para programar 00:39:47
está programado muchas veces 00:39:51
lo veréis 00:39:54
son cosas que se utilizan 00:39:56
por ejemplo, con esto 00:39:58
ahora ya podéis 00:40:01
darme un char solo 00:40:03
es un string y luego pillas el primer carácter 00:40:05
y ya está 00:40:08
luego veremos para qué sirve en un futuro 00:40:08
fijaos también que 00:40:11
equals 00:40:12
pilla como parámetro 00:40:13
entre paréntesis 00:40:16
otro string 00:40:17
x es un string 00:40:19
punto equals 00:40:21
k que es el otro string 00:40:22
porque tiene que comparar dos 00:40:24
compara el objeto x 00:40:26
Que estás llamando el equals 00:40:29
Con el objeto k 00:40:31
Que es el otro objeto que voy a comparar 00:40:33
Comparo estos dos 00:40:35
Charat 00:40:36
Recibe como parámetro 00:40:39
Cual es la posición 00:40:40
Vale, tú dame un string 00:40:42
Te voy a sacar un carácter en una determinada posición 00:40:45
Pero me tienes que decir 00:40:49
Que posición es 00:40:51
¿Entiende? 00:40:52
Y finalmente length en vez 00:40:55
No necesita ningún parámetro 00:40:57
No depende de un parámetro decir cuánto es la larga de una cadena 00:40:59
Cuántos carácter contiene un string 00:41:05
No necesita ningún parámetro 00:41:09
Necesita solo el string sobre el que lo llamo 00:41:11
Entonces, acordaos que esto recibe otro string 00:41:14
Esto recibe un entero 00:41:22
Que tiene que estar entre 0 00:41:23
Entre 0 y 00:41:26
Length 00:41:30
Menos 1 00:41:31
Si no explota 00:41:34
Y este de aquí 00:41:36
No recibe ningún parámetro 00:41:38
Tú das 00:41:42
Sobre esto 00:41:47
Y esto es un poquito de manejo de string 00:41:49
Porque no le sirve 00:41:54
¿Qué parámetro le vas a dar? 00:42:01
Yo tengo esta palabra aquí 00:42:04
Speaker 00:42:06
¿Vale? Y tengo esta 00:42:07
¿Qué te sirve más para contar cuántas letras hay? 00:42:09
Pues te sirven solo speakers 00:42:14
Ahora, si yo te digo, píllame una letra 00:42:15
De speaker píllame una letra en una cierta posición 00:42:17
¿Necesitas algo más de parámetro? 00:42:20
Sí, necesitas saber qué posición 00:42:23
Si no, ¿cómo te pillo esa cosa ahí? 00:42:25
Pues entonces te lo doy aquí 00:42:27
Y yo te digo, ahora compárame speaker con otra cosa 00:42:28
¿Necesitarás otro parámetro? ¿Qué es el otro parámetro? 00:42:31
La otra cosa 00:42:35
¿Vale? 00:42:35
Con esta cosa aquí, speaker con esta 00:42:37
Posición de memoria, speaker con esta cosa 00:42:40
Que leo de teclado, pero necesito 00:42:42
Otra cosa para poder comparar 00:42:44
Por eso le paso los parámetros 00:42:46
¿Sí? Ahora, esto 00:42:47
Con calma 00:42:49
Hay que 00:42:52
Asimilarlo 00:42:53
¿Vale? Es un pasito porque 00:42:56
Usa métodos, vosotros estáis 00:42:58
Usando métodos desde el primer 00:43:00
Programa que habéis hecho 00:43:01
Porque esto sabéis vosotros que es 00:43:03
Y esto que será 00:43:06
Este es un objeto 00:43:08
System.out será un objeto 00:43:18
De tipo printwriter 00:43:23
Creo 00:43:26
Que si vosotros lo buscáis aquí 00:43:26
En esta cosa aquí 00:43:29
Encontráis un objeto printwriter 00:43:32
Que tiene la posibilidad de hacer 00:43:34
El método println 00:43:36
Este 00:43:38
Y lo habéis estado utilizando sin problemas 00:43:39
Desde el primer día 00:43:42
Habéis utilizado el escáner 00:43:43
cuántas veces os ha dado la gana desde el primer día 00:43:46
ahora 00:43:48
hemos entendido un poquito más 00:43:49
de cómo van las cosas 00:43:51
y hemos entendido que string 00:43:52
no es un carácter primitivo 00:43:55
un tipo primitivo 00:43:57
es un tipo avanzado 00:43:59
porque en realidad 00:44:02
es una clase 00:44:04
alguien ha hecho public class string 00:44:05
ha abierto paréntesis 00:44:08
y ha escrito todos los métodos 00:44:09
que vemos aquí en esta cosa aquí 00:44:12
y los ha implementado 00:44:13
y ahora yo los puedo usar 00:44:15
entre todos estos hay tres 00:44:17
que son equals, charAt y length 00:44:20
esto aquí, y ahora os pongo 00:44:24
aquí hay, para que practiquéis estos conceptos 00:44:36
hay una tanda de ejercicios sobre string 00:44:40
que sustancialmente os hace utilizar estos métodos 00:44:45
como por ejemplo, compararás dos cadenas 00:44:49
Y te dice, utiliza el método equals, ¿vale? 00:44:51
O no, o no, para ver si son iguales o no. 00:44:55
¿Sí? Y te dice de hacer este ejercicio. 00:44:58
Luego te dice, convertir mayúsculas a minúsculas. 00:45:00
Entonces, hay un método de string que tú le das una cadena en minúsculas, 00:45:04
le dices, haz tu magia y se transforma en mayúsculas. 00:45:10
Como por ejemplo el toUpperCase. 00:45:14
Y hay otro método que me da una cadena y te transforma todas las letras en minúsculas, que es toLowerCase. 00:45:16
Y esto ya está hecho, es solo utilizarlo. 00:45:27
Entonces, te dice, entrada está de aquí, la salida esperada que te ponga o todo en minúsculas, si has usado el toLowerCase, o todo mayúsculas si has usado el toUpperCase. 00:45:31
obtener la longitud de una cadena 00:45:42
pues aquí tendrás que utilizar el método length 00:45:46
concatenar dos cadenas 00:45:48
el operador más 00:45:51
y existe también otra forma 00:45:52
que es el método concat 00:45:54
¿vale? hace lo mismo 00:45:55
extraer subcadenas 00:45:58
pues entonces está el método substring 00:46:00
reemplazar cadenas 00:46:02
el método replace 00:46:06
Comprobar si una cadena empieza o termina con una cadena 00:46:07
Starts with o ends with 00:46:15
Etcétera, etcétera, etcétera 00:46:17
¿Vale? 00:46:20
Sí 00:46:28
Es lo mismo que el más 00:46:28
Pero a lo mejor en ciertos casos necesitas este método 00:46:30
Sí 00:46:35
Entonces, la idea es que luego pilléis estas cosas de aquí 00:46:36
Intentáis hacerla y utilizarla 00:46:40
Veréis que algunos de estos métodos necesitan poner valores y algunos no 00:46:42
Por ejemplo, el método toUpperCase 00:46:49
¿Creéis que va a pillar algún parámetro o no? 00:46:58
No, tienes una cadena, hazla en mayúscula 00:47:03
Ya está, no necesito nada más 00:47:06
Ahora, el método cambia 00:47:07
que lo que hace es pillar 00:47:12
por ejemplo 00:47:15
reemplazar las aporo 00:47:17
tendré que decirle 00:47:21
cuántos parámetros, al menos dos 00:47:23
lo que quiero reemplazar 00:47:29
y a qué 00:47:31
quiero reemplazar 00:47:33
dímelo tú 00:47:39
y si vosotros 00:47:41
buscáis el string 00:47:43
aquí os viene más información 00:47:45
vais al método replace 00:47:47
replace 00:47:49
y te dice que 00:47:53
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
48
Fecha:
1 de octubre de 2024 - 12:47
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
47′ 55″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
158.19 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid