2025-02-03-Programacion | Mediateca de EducaMadrid

Bueno, y repito un segundillo, estaba comentando fuera de grabación que el día del examen, el día 12, os citaremos quizás un pelín antes para poder disponer de todo el tiempo del examen escribiendo ya en él. 00:00:00

Entonces, pues como 10-15 minutos antes, quien por tema de trabajo llegue apurado a la hora justa de iniciar el examen, pues no pasa nada, se incorpora en ese momento. 00:00:14

Y el examen lo tenemos el día 12, entonces la semana que viene, como la tenéis con exámenes, no sé si ya el día 10 tenéis alguno, no recuerdo muy bien el calendario, pero sea como fuere, toda esta semana han suspendido las tutorías. 00:00:22

Con lo cual la semana que viene, el 10, no nos vemos. Si tenéis alguna consulta que me queráis hacer respecto a lo que es el temario o respecto al examen o lo que sea, pues me lo podéis hacer por los foros, pero ya hasta el día del examen, una vez acabemos la tutoría y no nos volvemos a ver o no volvemos a hablar así en tutoría. 00:00:37

y nada, pues esto, comentaros esto 00:00:58

por otro lado, bueno, pues nada, vamos a abrir un poco 00:01:02

para ponernos a trabajar ya hoy en la tutoría, no sé si tenéis alguna consulta 00:01:07

que queréis hacerme en particular, el examen justo hasta los contenidos 00:01:11

que hemos visto en el tema 6 y no sé si tenéis 00:01:15

alguna consulta que me queréis hacer 00:01:19

antes de arrancar a hablar de diferentes cosas 00:01:20

Sí, sí. Había pensado justo arrancar comentando estas dos cositas. Estos dos debates que se han abierto ahora en el foro. 00:01:25

Entonces, si te parece, ahora abrimos Eclipse y nos ponemos a trabajar un poco sobre ello. Y si sobre la marcha sigue habiendo dudas, pues me preguntas y vemos cómo las aclaramos. 00:02:10

bueno pues venga pues mira vamos a arrancar si van surgiendo cosas nuevas me va a ir diciendo 00:02:20

y si no vamos a arrancar justo a hacer cosas aquí con Eclipse ya voy a crear un nuevo proyecto 00:02:29

digamos es reg de expresiones regulares por si luego una vez aclaremos esta un poquillo estar 00:02:37

dos dudas que teníamos seguimos con expresiones regulares y si no bueno pues da igual el nombre 00:02:44

el proyecto para trabajar cualquier cosa. Vamos a crear el proyecto. 00:02:51

Creamos una clase por aquí. Podemos llamar es Reg también. 00:02:55

Bueno, aquí vamos a meter el 00:03:05

main de inicio del programa. Y bueno, hemos tenido 00:03:10

este fin de semana un par de dudas 00:03:21

abiertas, un par de debates ahí en el foro. Uno de ellas tenía que ver 00:03:26

con, bueno, pues sabemos que tenemos los arrays que nos sirven para 00:03:30

definir variables, un conjunto de variables 00:03:34

del mismo tipo. Vamos a crear aquí dentro del proyecto 00:03:36

una clase persona, un momento 00:03:39

para ir apoyándonos en ella también en las explicaciones 00:03:43

sin tampoco mucho detalle 00:03:46

de métodos y atributos, vamos a ponerle 00:03:50

que tenga un nombre, por ejemplo, de momento, si luego necesitamos 00:03:53

más cosas ya la vamos haciendo. Cuando nosotros definimos 00:03:56

una variable primitiva, pues decimos 00:04:00

int i y decimos que la variable primitiva 00:04:03

directamente hacen ya una reserva de memoria RAM para trabajar con ellas. 00:04:07

Si nosotros ponemos aquí otro int i, pues como en este ámbito está definida ya una variable que se llama i 00:04:11

y tenemos aquí otra, pues básicamente, bueno, directamente no nos deja, no hay que hacer muchas más suposiciones, 00:04:20

no permite que dos variables se llamen de la misma forma, pero un poquito por buscar una lógica, 00:04:26

Si dijésemos que i vale 3 y tuviésemos dos variables, dos espacios de memoria que se han reservado para una variable que se llama i, pues no sabría qué espacio de memoria reservarlo. Imaginaros que esta, al ser primitiva, no ha sido necesario un new, pero el sistema operativo le ha dado a la máquina virtual de Java, a la ejecución del programa, la posición 20.000 para guardar en un tamaño de un entero un valor. 00:04:31

y en esta la 30.000. Pues si decimos aquí int i igual a 3, pues diría 00:04:55

¿dónde lo guardo? ¿En la 20.000 o en la 30.000? Una discrepancia, ambigüedad 00:04:59

no me gusta. Si aquí en lugar de 00:05:03

considerar dos variables int i 00:05:07

dijésemos que una es un float y la llamásemos 00:05:11

i, pues seguiría pasándonos lo mismo. En este caso 00:05:15

se nos intentaría hacer una reserva para el tamaño de un float 00:05:19

pero nos reservaría 00:05:22

una posición diferente, vamos a suponer la 40.000 00:05:27

si decimos i igual a 3 00:05:29

pues diría, ¿dónde lo guardo? 00:05:32

para el entero o para el float, en la posición 20.000 o en la 40.000 00:05:34

este i, ¿a qué estará refiriéndose? 00:05:38

pues nada, directamente no me compila en la segunda vez 00:05:41

que lo intento, y si yo cojo 00:05:44

y en lugar de una variable primitiva digo 00:05:47

Persona i, pues vuelvo a estar en las mismas, coge y dice aquí estás definiendo un puntero, un dedito que intenta señalar a una persona y me has dicho que se llama i. 00:05:50

como hay una duplicidad de nombre de variables, pues ya no me gusta 00:06:07

entonces, si aquí cogemos y definimos 00:06:11

un array de personas, de enteros 00:06:16

por ejemplo, o de personas, persona, mi per 00:06:19

vamos a ir con los 00:06:23

se mezclan un poquito las dos cuestiones que se han abierto, pero vamos 00:06:30

a ir hablando un poquito de esto, fijaros, si yo pongo 00:06:35

persona miper, esto lo que hará será hacer una reserva de memoria RAM para miper, vamos a suponer 00:06:39

la 40.000 y ¿para qué estará reservando espacio en memoria en la 40.000? Pues estará reservando 00:06:49

espacio para algo que terminará apuntando a un conjunto de referencias a personas. Vamos a suponer 00:06:55

que mi per apunta a la posición 00:07:05

que deciros. Bueno, 40.000 hemos dicho 00:07:08

aquí. O sea, la 40.000. Si yo ahora cojo 00:07:13

y digo mi per igual a new 00:07:23

persona, pongo aquí 5, lo que estoy 00:07:27

haciendo es que a partir del 40.000 tengo 5 referencias 00:07:39

a personas. No 5 personas, 5 referencias a personas. 00:07:44

igual la primera referencia a una persona está en la posición 0 00:07:47

y precisamente utiliza la posición 40.000, a lo mejor, ¿vale? 00:07:54

Para la posición 1 apunta a la 40.050, por ejemplo. 00:08:06

Vamos a poner aquí 3 para no escribir tanto. 00:08:12

Y a lo mejor la posición 40.002 apunta a la posición 100. 00:08:19

no quiere decir que entre este 00:08:24

40.000 y 40.050 00:08:27

esté 00:08:29

el nombre que tiene una persona 00:08:30

no, esto es, será 00:08:33

bueno, de hecho 00:08:34

de forma inicial 00:08:37

sería null 00:08:39

posiblemente, no apuntarían a ninguna persona 00:08:40

estos son, digamos 00:08:43

punteros donde puede haber 00:08:44

personas 00:08:46

y luego si yo pongo aquí mi per 00:08:47

0, igual 00:08:50

esto en realidad empezaría apuntando a null, a ninguna persona en particular 00:08:54

y cuando cojo y hago mi per new 00:09:06

persona, aquí lo que haría el sistema operativo sería reservar espacio 00:09:17

de memoria para una determinada persona, para una persona 00:09:24

fijaros, esto es una persona en su conjunto 00:09:28

los arrays se pueden poner los asteriscos aquí o aquí 00:09:30

entonces fijaros, esto, si marcamos todo esto 00:09:35

y leemos hacia la izquierda, esto es un array de personas 00:09:39

y esto es una persona. 00:09:43

Fijaros, hacia la izquierda me ha quedado persona solo. 00:09:46

Entonces, si hacemos un new a esto, 00:09:48

esto sí que me haría una reserva de memoria. 00:09:50

Por ejemplo, en el 50.000 00:09:52

y a partir de esta posición de memoria 00:09:54

es donde podríamos poner el nombre de esta persona. 00:10:00

A ver si lo explico. 00:10:07

Un array, esto, sin hacer un new al array, 00:10:10

es algo que va a terminar apuntando. 00:10:14

imaginaos que es un puntero, con un dedito que señalamos algo, es algo 00:10:16

que va a estar apuntando a una raíz de personas, pero no lo hemos hecho 00:10:21

el new, para dimensionarlo, pues será algo que apuntará 00:10:24

a una raíz de personas, cuando hacemos el new, lo que hacemos es 00:10:29

definir, en este caso, tres variables 00:10:32

de persona, pero no hemos hecho la reserva para su espacio de memoria, es como si pusiéramos aquí 00:10:36

persona, miper, pero no le hiciéramos el new 00:10:42

miper2 y no le hiciéramos el new. Esto como no hemos hecho el new 00:10:47

no tenemos espacio donde guardarle el nombre de esta persona 00:10:51

miper2 pero en cambio tenemos un dedito que va a ser capaz 00:10:55

de apuntar a un sitio donde finalmente va a haber una persona 00:10:59

y cuando pongo miper2 igual a new 00:11:02

persona estoy haciendo una reserva 00:11:06

para un objeto de la clase persona que por ejemplo sea la posición 00:11:11

60.000 y este punterito que antes todavía no habíamos asignado un valor y probablemente 00:11:15

directamente valía nul empieza a valer 60.000 que es el punto donde va a empezar datos para 00:11:23

una persona para la cual sí que hemos reservado espacio de memoria si me dicen por aquí que 00:11:29

quieren participar a ver dime si no no no no no no no no no no no no no no la misma persona 00:11:39

aquí hay un grupo de personas mira aquí estamos definiendo una variable pues si yo cojo y pongo 00:12:24

int aquí no tienes un entero aquí lo que tiene son 10 enteros esto es un entero estos son 10 enteros 00:12:33

esto voy a juntar las dos esto es una persona estos son punteros a tres personas para que sea 00:12:52

equivalente este a este, si quitamos el new, 00:13:14

esto es un puntero a una sola persona, igual que esto 00:13:20

es una variable de un entero, esto son 00:13:23

tres punteros a tres personas distintas, a José, Ana, 00:13:27

Laura, igual que esto son diez variables enteras, diferentes 00:13:31

cada una. Lo que pasa es que cuando trabajamos con un array, lo que compartimos 00:13:35

es un nombre, digamos que pudiéramos para estas 00:13:40

10 personas, hacer un grupo. 00:13:43

Entonces, y a 00:13:46

todas esas 10 personas las llamamos 00:13:48

con un nombre en común. Pues este sería el nombre en común 00:13:49

de esas 10 personas, pero esto 00:13:52

no sería una persona con 3 atributos. 00:13:53

Serían 3 personas 00:13:56

y cada persona, cada una de esas 3 personas 00:13:57

tendrán todos estos atributos. 00:13:59

Los que estén definidos en la clase persona. 00:14:02

No, no, pero... 00:14:10

Sí. 00:14:13

Dices... Me he quedado antes 00:14:56

con lo que ha dicho. Afectos prácticos 00:14:58

miper trabajas como un grupo de personas, pero no es que sea 00:15:00

a efectos prácticos, o sea, que a efectos prácticos lógicamente 00:15:04

trabajas así, es que es lo que es, un grupo de personas 00:15:07

o sea, en ningún momento miper aquí es una persona 00:15:10

es un array, un conjunto de personas 00:15:13

bueno, es que 00:15:16

perdona, un momentito, por si a lo mejor 00:15:27

los matices, bueno, perdona por decir tu nombre que estamos con la grabación 00:15:31

sí, sí, que 00:15:35

es que mi per no es un objeto, mi per, mira, tú lee de aquí 00:15:37

para ver lo que es mi per, vamos a leer hacia la izquierda, mi per es 00:15:43

un array de personas, un array 00:15:46

de objetos, mi per no es un objeto, es un array de objetos 00:15:50

y un determinado valor de mi per 00:15:54

o sea, si ponemos aquí mi per 0 00:15:58

fíjate, considerando los corchetes 00:16:02

leemos lo que aquí leemos de izquierda a derecha, vamos a leerlo 00:16:06

aquí de derecha a izquierda, miper con el array, esto 00:16:10

si es un objeto de una persona. Bueno, un objeto cuando 00:16:13

le hagamos el new, de momento es una referencia a una persona. 00:16:16

Pero miper no es un objeto de una persona, miper es 00:16:19

un array de personas, un conjunto de personas. 00:16:22

De hecho, tú no puedes poner, 00:16:26

mira, si fuera una persona, miper, 00:16:28

lo pudiéramos considerar esto como una persona, nos aceptaría 00:16:31

aquí el id, poner mi per punto, porque si es una persona, llegar a los 00:16:34

atributos de una persona. Nos permitiría poner mi per punto 00:16:38

ese nombre, pero esto no existe. ¿Por qué? Porque 00:16:42

un array de personas no es una 00:16:45

persona. En cambio, si cogemos y decimos mi per 00:16:50

mira, añado los corchetes, que si hacemos la lectura de aquí 00:16:53

derecha e izquierda, fíjate como a la izquierda ya se me queda que esto es una persona 00:16:58

y pongo punto, ese nombre 00:17:02

sí que está. ¿Por qué? Porque mi per 00:17:04

entre corchetes con un índice 00:17:06

eso sí que es una persona en particular. 00:17:08

Eso es. Bueno, 00:17:16

sí, eso es. Un grupo de personas 00:17:18

con un matiz 00:17:19

que es lo otro que os he intentado 00:17:21

contar, no sé si mejor o peor 00:17:24

en el foro. 00:17:26

Lo que estás creando 00:17:28

aquí es un grupo 00:17:30

nos olvidamos de esto por un 00:17:32

momento, estás creando un grupo 00:17:34

de referencias 00:17:36

de deditos que apuntan 00:17:37

a personas. Para 00:17:40

llevárnoslo a un caso simple, si pones aquí mi 00:17:41

per persona 00:17:43

p 00:17:44

y pones punto y coma y no 00:17:47

haces el new, ¿p qué es? 00:17:49

p va a ser algo 00:17:52

que va a terminar apuntando en memoria RAM 00:17:53

a donde vaya a existir en un futuro una persona 00:17:55

pero como no hemos hecho el new, no lo hemos 00:17:57

pedido al sistema operativo espacio 00:17:59

para esa persona. Entonces esto inicialmente 00:18:01

es como que no apunta a ningún sitio 00:18:04

todavía. 00:18:06

Cuando yo haga p igual a new persona, ponga el new y llame al constructor, en ese momento, que normalmente está ahí esta línea, la ponemos en una solo, en este momento es cuando hacemos reserva en memoria RAM. 00:18:07

Imagínate que nos dice la posición 60.000, este empieza ya a apuntar a la posición 60.000 y terminamos llamando a un constructor para que haga las inicializaciones que tengamos programadas. 00:18:25

pues esto que todavía no es una persona que apunta null 00:18:34

es un dedito que terminará apuntando una persona cuando tengamos espacio de memoria 00:18:39

después de hacer el new, pues lo que estamos haciendo aquí es 00:18:43

con esta instrucción, lo que estamos haciendo con esta 00:18:47

expresión es crear, igual que aquí creamos 00:19:01

con este new, creamos una persona a la cual 00:19:05

apuntar algo que hasta este momento era 00:19:09

era un dedito, aquí lo que estamos creando son tres deditos 00:19:13

que apuntarán a tres personas, pero los tres apuntan 00:19:18

a nulo. En este momento, mi per 00:19:26

y entre corchetes cero es como si hubiéramos hecho esto con una variable normal. 00:19:30

Mi per entre corchetes uno es como si hubiéramos hecho esto con una variable 00:19:34

normal y mi per dos igualmente. Son tres 00:19:38

punteros, pero para ninguna de esas tres personas hemos hecho una reserva de memoria. 00:19:42

Hemos hecho aquí para un grupo de tres personas el equivalente a esto para una sola variable. 00:19:46

Por eso, cuando haces un array, como no tienes reservado espacio, fíjate que aquí no hemos llamado a ningún constructor de la clase persona, por mucho que aparezca aquí un new. 00:19:53

¿Ves? El constructor va entre paréntesis y aquí lo que hemos hecho ha sido entre corchetes dimensionar el array. 00:20:03

Es igual que aquí, hemos dimensionado la raíz con 10 enteros, hemos tenido que hacer los new para j0, j1, j2, no, ¿por qué? Porque estas son variables primitivas y para las variables primitivas no es necesario hacer el new, por eso aquí no hacemos el new para cada uno de los enteros, pero de la misma forma que aquí, para algo que es una variable referenciada, si tenemos que hacer su new, identificamos el punterito que la va a señalar y luego hacemos el new llamando al constructor, 00:20:09

aquí, lo que hemos hecho ha sido un grupito 00:20:37

de 10, en este caso de 3, porque hemos dado 00:20:40

dimensión de 3, de 3 punteros que van a apuntar 00:20:43

a 3 personas distintas, el equivalente a esto 00:20:46

¿cuándo lo tendremos que hacer? Pues si queremos 00:20:49

para cada una de estas 3 personas sabemos que vamos a poder acceder 00:20:51

a ellas a través de un nombre común 00:20:55

la primera con el índice 0 00:20:57

esto es un dedito que apunta a una persona igual que lo es 00:21:00

fíjate como si leemos de izquierda a derecha y nos venimos a la definición 00:21:04

de derecha a izquierda, eso ya es un punterito 00:21:09

de una persona, entonces si hacemos aquí el new persona 00:21:12

y ahora aquí sí que fíjate ponemos constructor, esto 00:21:16

es esto, estamos reservando 00:21:20

espacio de memoria para esta persona, igual que aquí 00:21:25

lo hicimos para esta, hasta que no hemos hecho el new 00:21:28

con el constructor de la clase persona, 00:21:31

no hemos tenido espacio para poder trabajar con esa persona. 00:21:36

Aquí, para la referencia p con una variable normal, 00:21:39

aquí, para la referencia mi per cero, 00:21:42

acordándonos que es una referencia a una persona. 00:21:46

Este es el momento en el que ya tenemos para esta persona 00:21:48

espacio de memoria reservada. 00:21:51

Mira. 00:21:53

Sí, dime. 00:21:56

Ah, ajá. 00:21:59

Claro, es que, claro, claro, ¿qué es lo que sucede? Mira, digamos que retomando cosas que hemos hablado en otros momentos y dejando un momentito los arrays a un lado, aunque luego terminemos en ellos, ¿qué hacíamos cuando definíamos una variable de tipo entero? 00:22:15

Pues esta es una variable de tipo, una variable primitiva y para variables primitivas no es necesario hacer new, ¿verdad? 00:23:04

Cogíamos y decíamos persona, mi per 30 vamos a poner aquí, new persona. 00:23:13

Para una variable que es referenciada, pues una variable de un objeto de una clase que hemos desarrollado nosotros en nuestro programa 00:23:23

o que hemos incorporado desde las librerías, sí que necesitamos nosotros 00:23:31

hacer el new obligatorio. Y luego había un caso intermedio, que son 00:23:35

los strings, acordaros. Los strings son variables 00:23:39

referenciadas, pero que tienen características, algunas de las características 00:23:42

de las primitivas. En sí, si hay que decir que sí son una 00:23:47

cosa u otra, son referenciadas, es cierto. De hecho, si tú defines un 00:23:51

string, pues te permite incluso hacerle un new y 00:23:55

compila, ¿ves? Y te permite 00:24:05

también trabajar con ella sin hacerle 00:24:07

el new, porque está un poco a medio 00:24:09

camino entre las primitivas, 00:24:11

como los enteros, y las referenciadas. 00:24:13

Entonces, con tu array 00:24:16

de strings, ¿qué es lo que ha pasado? 00:24:17

Lo que ha pasado es que, igual 00:24:19

que si haces un array de enteros, 00:24:21

te funciona 00:24:24

directamente sin hacer new, porque 00:24:25

cada una de todas 00:24:27

las referencias de este 00:24:29

entero de jotas, no es 00:24:31

necesario hacerle, bueno, 00:24:33

Sí que le tienes que dimensionar con esto, pero fíjate que no estamos llamando a un constructor de enteros. 00:24:35

Lo que estamos dando es un tamaño, igual que le estamos dando un tamaño aquí, a los punteros referenciador de persona. 00:24:40

Pero no hacemos un new para cada uno de los enteros. ¿Por qué? Porque para las variables ya no lo necesitamos. 00:24:47

Esto es un conjunto de tres enteros y como los enteros son primitivos, para cada entero no es necesario hacer un j0 igual a new int. 00:24:52

Esto, de hecho, ni nos deja. 00:25:08

¿Por qué? Porque es primitiva y lo hace él solo. 00:25:10

Para los strings, como están a medio camino entre las referenciadas y las primitivas, 00:25:13

acuérdate que no es necesario hacerle un new. 00:25:18

Entonces, como no es necesario hacerle un new, 00:25:20

si tú coges y pones aquí string b igual a new string 2, por ejemplo, 00:25:22

pues esto serían dos referencias a personas, 00:25:33

pero para esas dos referencias, igual que para una variable normal de string no es necesario hacerle un new, pues para esas dos referencias, que son en total dos strings que comparten el cierto nombre aquí, en cuanto a nombre de grupo, no es necesario hacerle el string. 00:25:37

Por eso, con el string te funciona, porque el new lo hace directamente la máquina virtual de Java cuando se pone a ejecutar. 00:25:52

Pero, para un objeto de la clase persona, que es un referenciado puro y sí que necesitamos el new, 00:25:59

obligatoriamente tienes que hacer un new para cada uno de todos los objetos con los que trabajes. 00:26:04

Bueno, es que, a ver, seguramente tú consigues un programa que te dé el resultado a través de strings. 00:26:45

Pero en realidad tenemos que buscar hacer el enfoque del ejercicio a nivel funcional y luego trasladarlo al programa. Entonces, ¿tú en verdad qué es lo que tienes? ¿Tienes en tu programa general, en tu main, tienes un array de nombres de frigoríficos o de nombres de personas? 00:26:55

No, tú lo que tienes es un grupo de personas. 00:27:20

Tú imagínate que estuviéramos haciendo un ejercicio para aquí, para clase, ¿no? 00:27:23

Entonces, ¿cómo organizarías tú esto? 00:27:28

Un poco olvidándonos de que vamos a programarlo en Java, pues dirías, 00:27:30

pues mira, en el aula yo tengo un conjunto de personas. 00:27:35

Ese conjunto de personas, ¿qué es lo que tienen? 00:27:39

Tienen un nombre y un número de matrícula. 00:27:41

¿El nombre de cada una de las personas a ti te parece que es coherente definirlo en el conjunto del aula o el nombre lo identificamos en cada una de las personas? 00:27:43

El nombre es de cada una de las personas, no es del aula. El nombre de las personas no es del aula, el nombre de las personas es de las personas. 00:27:58

Lo que hay es una serie de personas, alumnos, que eso sí que pueden pertenecer a un determinado aula. No sé si me explico. 00:28:05

O sea, por diseño. Está claro que si tú estabas teniendo el problema este de hacer el new para las personas o para las cocinas o para los frigoríficos, para los frigoríficos en este caso, como estamos ahí a medio caballo entre dos aplicaciones. 00:28:11

bueno, como estabas teniendo ese problema y no eras capaz 00:28:26

de resolverlo, pues me parece 00:28:29

que practicando, pues me parece 00:28:31

bien que hagas el intento de decir 00:28:33

pues mira, el color de la placa o el color 00:28:34

de frigorífico, la marca, bueno, como 00:28:37

venga a ser, pues me lo llevo a una 00:28:38

instancia más mayor, pero 00:28:41

la marca de una placa 00:28:42

pertenece a una placa, no 00:28:44

pertenece a la cocina 00:28:46

la cocina tiene las placas 00:28:48

y las placas tienen su marca 00:28:50

¿sabes? 00:28:52

entonces 00:28:54

Claro, es lo que otras veces, por ejemplo, os he intentado también contar. Imagínate que tienes aquí, en la clase persona, organizar las cosas, luego las llevamos en programa Java, bien, pero vamos a intentar darle una lógica de razonarlo como humanos, digamos, ¿vale? 00:28:56

tú tienes un aula donde hay personas, las personas tienen unas características 00:29:17

y hacen una serie de cosas que son sus métodos, igual que está eso pues habrá 00:29:21

un proyector, el proyector tendrá sus características y tendrá sus métodos 00:29:25

entonces yo digo en el aula hay alumnos, defino alumnos 00:29:29

en el aula hay un profesor, defino un profesor, en el aula hay un proyector, defino un proyector 00:29:34

todos esos elementos pertenecen al aula, sí 00:29:38

el proyector, los alumnos y el profesor, ahora el nombre de un 00:29:41

alumno pertenece al aula para definirlo en una instancia mayor que es el aula? Pues no, el nombre 00:29:45

del alumno pertenece a cada alumno. Entonces, si hemos definido un objeto alumno dentro de los 00:29:52

alumnos, vamos a identificar esos alumnos. Mira, otra cosa que ayuda además a, que es simplemente 00:29:56

un poco por pura lógica, pero otra cosa que ayuda además a pensar que esto es lo correcto, pues tú 00:30:03

piensa que estás haciendo un programa en el cual participa una persona que tiene un nombre y luego 00:30:10

de repente dices, pues mira, esta clase de persona 00:30:15

que la he probado en este proyecto me parece 00:30:17

muy interesante cómo está trabajado 00:30:19

y resulta que tengo que hacer otro proyecto 00:30:21

este era de, yo qué sé qué decirte, de un 00:30:23

campo de fútbol y ahora vas a hacer uno de tiendas 00:30:25

pero dices, justo la 00:30:27

definición de la clase de persona me viene muy 00:30:29

bien para la clase de tiendas 00:30:31

entonces si tú te vas a llevar 00:30:33

todas las características 00:30:34

de esa clase de persona de un proyecto a otro 00:30:37

pues que te llevan la clase de persona 00:30:39

que es la que está recogiendo las características 00:30:41

y las acciones que hacen las personas 00:30:43

Si lo haces de la otra forma y los nombres de las personas te las has llevado a la clase en sí, aula, pues si te llevas la clase personal se va a esa persona sin nombre. 00:30:44

Sí, no sé. Sí, sí, bueno. Mira, dentro de la clase persona vamos a poner, por ejemplo, un poquito insistiendo en que por diseño, aunque es verdad que Java va a ser capaz de tragarse ejecuciones que sean diferentes, pero bueno, para insistir un poco más en cosas que os digo a veces. 00:30:55

imaginaros que tienes aquí un método que es public void saludar y yo conjo y tengo aquí un 00:31:26

system punto out punto println y pongo aquí hola más imagínate que tengo aquí una variable ese 00:31:38

saludo 2 entonces está ahora mismo no me compila porque esta variable no existe esta variable para 00:31:52

que me compile, yo puedo definirla aquí, ya me compila, o puedo 00:32:05

definirla aquí, en el ámbito local de esta clase, o la puedo 00:32:11

definir como una variable de clase. ¿Dónde está más correcto 00:32:20

definir esta variable? ¿Saludo2 es un atributo que caracterice 00:32:24

a las personas o es una variable que parece que necesitamos 00:32:30

de forma local para construir nuestro programa Java dentro 00:32:34

el método saludar. Pues a mí me pega más que pertenece a esto, ¿no? 00:32:37

Pues entonces, esta variable, donde hay que definirla, es aquí, porque aquí 00:32:41

puedo tener otro método, que sea el método despedir, 00:32:45

donde no tiene ningún sentido que exista una variable 00:32:56

que sea saludo2. Esta variable es para un uso particular 00:32:59

en un momento dado dentro del método saludar. Imagínate que aquí cogiésemos 00:33:03

a través de un escáner el saludo que en verdad se va a sacar por 00:33:08

pantalla. Esto no es una característica de las personas. 00:33:11

Si tú pones esto aquí, el programa Java te compila 00:33:16

un poquito algo parecido a lo que has necesitado hacer tú para resolver este 00:33:19

problema que tenías. Pero aquí, por diseño, ¿está bien 00:33:23

definida esta variable? No. Esta variable está bien definida aquí. Igual que el nombre, pues si 00:33:27

parece correcto que esté aquí, porque sí que es algo que caracteriza a las personas. 00:33:31

¿Sí? Bueno. Vale. Genial. Nada, nada. 00:33:40

Y luego, bueno, acabo con esto de los array que os estaba contando para justificar que tenemos que hacer un new a cada uno de ellos. 00:33:43

fijaros, aquí para comprobar de verdad 00:33:58

que lo que hemos hecho ha sido en esta definición del array 00:34:03

que fijaros, insisto, algo que nos puede mostrar que en verdad no hemos hecho reserva 00:34:07

para el espacio de memoria RAM de las diferentes personas 00:34:11

fijaros que aquí hay corchetes, en realidad no hay 00:34:14

el constructor, no estamos llamados al constructor que es el que acompañamos a new cuando creamos 00:34:17

espacio de memoria RAM para una determinada persona, aquí lo que estamos 00:34:23

es con el new dimensionando el array, que es un array en este caso de punteros 00:34:26

a personas. Entonces fijaros aquí 00:34:31

para la persona 0 justo, una de las tres que se definen, al tener 00:34:36

tamaño 3, estará mi per 0, mi per 1 y mi per 2 00:34:40

para este sí que estamos haciendo una reserva de memoria RAM para esa persona en particular 00:34:43

Entonces fijaros, si yo hago aquí un system.out.println 00:34:48

de mi per 0, ese nombre 00:34:52

es previsible que este no falle 00:34:55

y es previsible que este falle. ¿Por qué? 00:35:02

Porque para mi per 0 he hecho una reserva de memoria 00:35:07

para esa persona aquí y para mi per 1 no la he hecho. Es verdad que existe esa 00:35:10

referencia dada de alta en el array, pero no he hecho 00:35:15

un new para esa persona en particular. Entonces fijaros 00:35:19

como si ejecutamos esto, ¿veis? El programa 00:35:23

me ha sacado un posición 0, dos puntos, es decir, ha ejecutado 00:35:27

esta instrucción, me ha dicho que es null porque 00:35:35

a esta variable no le hemos dado ningún valor, vamos a darle aquí un valor al constructor 00:35:44

en el constructor, por ejemplo, vamos a decir 00:35:49

public persona, vamos a hacer que todas las personas 00:35:52

inicialmente tengan en este string algo que ponga sin nombre 00:36:04

cuando llegamos al constructor damos al ese nombre 00:36:08

un sin nombre para todo objeto que llame este constructor, que será lo que estará 00:36:17

pasando aquí, entonces si hacemos esa ejecución 00:36:23

fijaros como esta primera línea si funciona 00:36:25

es capaz de mostrarme el nombre que es sin nombre porque no se lo hemos asignado 00:36:29

tiene este valor porque se lo ha asignado aquí en el constructor 00:36:35

pero cuando intentamos hacer este otro acceso 00:36:38

en este en particular me pega un error, dice 00:36:42

no puedo leer ese nombre porque 00:36:47

mi per 1 es 00:36:49

null. ¿Y por qué es null? Pues porque 00:36:52

no le hemos hecho un new. 00:36:54

¿Existe algo que apunta 00:36:58

mi per 1 a lo que 00:37:00

futuro será una persona? Sí, porque esto es 00:37:02

un conjunto de 00:37:04

punteros a personas. 00:37:06

¿Pero existe la persona esa 00:37:09

en particular? No, porque no le hemos hecho el new 00:37:10

para ese puntero. Entonces, si yo 00:37:12

cojo y pongo mi per 1 00:37:14

new persona, 00:37:16

ahora ya, 00:37:18

Me funcionan los dos porque le he hecho el new. 00:37:19

Y mirad, para insistir un poquillo más en lo que son esto de los punteros y lo que no son los punteros, 00:37:26

fijaros, podemos coger y hacer miper.eseNombre, vamos a decirle, vamos a darle un valor. 00:37:39

Vamos a decirle que se llame no. 00:37:48

Aquí lo tenemos completo, bien. 00:37:51

Si yo ahora cojo y digo persona miper2, punto y coma, esto apuntará a null. 00:37:53

igual que en la raíz si no hacemos el new, ¿por qué? porque no le he hecho un new 00:38:03

es un puntero algo que será capaz de apuntar a una persona pero no hacerle el new 00:38:07

no le ha asignado el sistema operativo una zona de memoria 00:38:11

con lo cual en principio es null, si yo cojo y digo 00:38:15

mi per 2 igual a mi per 00:38:21

sin necesidad de hacerle el new 00:38:25

mi per 2 ¿qué pasará a valer? pues pasará a valer 00:38:29

lo mismo que vale miper1, dejará de valer null, porque miper2 aquí está valiendo null, y pasará a valer la misma zona de memoria donde esté apuntando miper1. 00:38:33

Aquí, al hacer el new miper1, como siempre haciendo una suposición, vamos a suponer que el sistema operativo le ha dicho que reserva un trocito de memoria RAM 00:38:44

a partir de la zona del número 55.000. 00:38:53

Mi per vale 55.000, que es el trocito a partir de donde van a guardar sus atributos. 00:38:57

Aquí lo que estoy haciendo es mi per 2, que aquí valía nul, 00:39:03

y el sistema operativo no le ha dado ningún espacio de memoria 00:39:07

porque no le hemos hecho un new, le decimos que valga lo mismo que vale mi per. 00:39:09

Entonces si yo cojo y hago eso, va a resultar que mi per 2 va a pasar a valer 00:39:14

posición de memoria 55.000, donde sí que hay un trocito de memoria RAM 00:39:18

reservado con datos de una persona, porque le hemos 00:39:23

hecho este new, y en particular 00:39:26

utilizando la referencia miper 00:39:28

le hemos dado a su nombre noa, con lo cual a partir de 00:39:31

55.000 habrá un trocito de memoria para el nombre, ese nombre 00:39:35

que tendrá noa, y justo este mismo 55.000 00:39:38

está compartido ahora por miper2, entonces si yo pongo 00:39:41

aquí un system.out.println 00:39:44

de miper2.ese 00:39:47

nombre, el único 00:39:53

system out es está referenciado a través de mi perdón yo cojo de aquí y me dice que es no aunque 00:39:56

en realidad sólo habíamos aplicado a través de mi per pero como mi per apunta al mismo sitio que mi 00:40:05

perdón o mi perdón se apunta al mismo que mi per pues ya funciona si yo cojo y comentó esto aquí 00:40:09

mi perdón que es lo que vale bueno de hecho ni siquiera ya me deja aquí fijaros dice inicializa 00:40:18

la variable. Vamos a inicializarla a nul. Como apunta 00:40:24

a nul, no hemos hecho un new para que tenga su propio espacio de memoria y hemos 00:40:31

quitado esta asignación, pues esto ahora me va a dar un error. 00:40:35

¿Entiendo? ¿Veis? Me da una excepción, un null pointer excepción. 00:40:39

Excepción de acceso a un puntero nulo. 00:40:44

Porque mi per2 es nul, lo mismo que nos pasaba antes con los arrays. 00:40:46

¿Alguna aclaración más con esto? ¿Necesitáis alguien por ahí? 00:40:56

Vale, pues mirad, la otra cosa que comentábamos en los foros tenía que ver con intentar asignar a variables, crear variables cuyo nombre se asignan a partir de una variable. 00:40:59

La verdad es que es algo en la que siempre, si fuese posible, uno empieza a pensar muchas alternativas. 00:41:22

Entonces había algo como, se hacía algo así como string ese nombre de la variable. 00:41:31

Y entonces la idea era hacer algo como con un array for, si no recuerdo mal, int igual a cero, 00:41:47

mientras y sea menor, por ejemplo, de tres 00:41:53

y más más. 00:41:57

Es decir, vamos a crear tres variables diferentes, 00:42:01

algo que nos diera una funcionalidad del estilo de un array, 00:42:05

un conjunto de variables, pero vamos a intentar 00:42:09

automatizarlo con un bucle y que cada una de las variables tenga un nombre 00:42:13

distinto. Entonces, 00:42:17

lo que hacía por aquí era decir por ejemplo ese 00:42:19

nombre var que sea igual 00:42:23

al nombre más 00:42:27

entonces como en cada una de las 00:42:33

vueltas fijaros si ponemos aquí un system.out.println 00:42:41

esta variable vamos a sacarlo por pantalla 00:42:47

la ejecución del programa, fijaros que vale 00:42:54

nombre 0, nombre 1, nombre 2, nombre siempre 00:42:57

porque lo tengo aquí de forma literal puesto y luego 00:43:00

en la iteración del bucle desde 0 hasta 2 00:43:03

porque iteramos hasta que 00:43:06

mientras i sea menor de 3 00:43:09

pues me saca las tres alternativas, entonces 00:43:12

lo que a alguien se le ocurría era decir 00:43:15

pues mira, vamos a intentar darle estos nombres a través 00:43:18

de un bucle y creo un grupo de personas 00:43:21

entonces era poner algo aquí como persona 00:43:23

e intentar darle el nombre de la variable 00:43:28

que sabemos que está variando su valor 00:43:32

¿qué es lo que sucede con esto? que cuando definimos una 00:43:36

variable en el programa no me permite que ese nombre 00:43:39

sea variable, tiene que ser un nombre constante, es igual que si 00:43:44

sea para la clase persona o sea para un tipo primitivo 00:43:49

para lo que sea. Si pongo int y esto, pues tampoco me deja. ¿Y qué es lo que está sucediendo en el fondo? Pues lo que está sucediendo es que si esto 00:43:52

no lo va a considerar de partida como una variable para coger cada uno de estos tres valores y está pensando que el nombre que le quiero dar al objeto 00:44:05

de la clase persona es ese nombre par, lo que me está 00:44:13

diciendo es, mira, ese nombre par, ese nombre var 00:44:17

lo tienes definido en este ámbito aquí, o lo tienes definido 00:44:20

en este ámbito aquí, en el mismo ámbito tienes definidas dos variables 00:44:26

con el mismo nombre, que es igual que si intento hacer aquí int i 00:44:31

y long i, pues me dice no, mira 00:44:34

ya si tú asignas aquí un valor a i, no sé si 00:44:38

se lo estás asignando a esta o a esta 00:44:43

con lo cual directamente no dejo que compiles 00:44:45

dos variables no se pueden llamar igual 00:44:46

se llaman diferente y así me deja 00:44:48

pues aquí al final lo que estamos haciendo es eso 00:44:50

estamos dando 00:44:53

a una variable 00:44:54

de tipo string el nombre es en onBar 00:44:55

y estamos dando a una variable de tipo 00:44:58

persona, un objeto de la clase persona 00:45:00

un mismo nombre 00:45:03

entonces dice pues esto no me gusta 00:45:05

y ya está 00:45:06

que era otra de las alternativas que 00:45:08

aparecían por ahí 00:45:12

¿Cómo vamos a trabajar con conjuntos de variables? Pues vamos a trabajar con estructuras dinámicas de datos y con estructuras estáticas. Las estructuras estáticas son los arrays, que ya los estamos conociendo. 00:45:13

Y las dinámicas que también nos sirven para manejar conjuntos de variables, digamos, que pueden ser bien variables primitivas o bien variables referenciadas con las colecciones. 00:45:30

Cada una con sus características particulares. Muy chulas las colecciones para hacer cosas interesantes. Lo vemos en futuros temas ya hasta final de curso. 00:45:45

trabajaremos con las colecciones, ya veréis 00:45:56

que nos dejan hacer cosas interesantes 00:45:58

lo único que bueno 00:46:00

pues los Arrays tienen como ventaja 00:46:02

que proporcionan 00:46:04

programas más eficientes 00:46:06

si la solución se puede 00:46:08

adaptar al Array que las colecciones 00:46:10

pero bueno, conociendo las dos 00:46:12

pues en cada caso utilizaremos una diferente 00:46:14

según nos interese en cada momento 00:46:16

bueno, esta era más o menos la segunda pregunta 00:46:18

yo creo que teníamos por ahí 00:46:23

pero 00:46:24

Pero por poco tiempo, los mapas son colecciones. Hace referencia a esto que os estaba... creo que se me ha quedado pillado la máquina virtual, igual la voy a tener que cerrar y abrir de nuevo. Los mapas son colecciones y las colecciones las vamos a ver en uno de estos temas. 00:47:16

Os estaba diciendo hace un minuto, justo al hilo de esto, que... bueno, bien hecho el apunte. Os estaba diciendo, para trabajar con grupos tenemos o bien los arrays o bien las colecciones, que son chulas y permiten hacer cosas muy interesantes. 00:47:30

Cada uno tiene su ámbito de trabajo, los Arrays, ya os digo, si nos permiten trabajar con Arrays un programa, esos son más eficientes que las colecciones, que llevan más algoritmia para dar las respuestas, pero las colecciones permiten hacer cosas interesantes y trabajando no tanto como haciendo parte del algoritmo por nosotros. 00:47:46

Hay colecciones que te permiten almacenar información, por ejemplo, de objetos de personas ordenadas bajo un determinado criterio o sin que estén ordenadas o que cuando tú vas añadiendo a ese grupo de personas definir qué característica hace dos personas iguales, por ejemplo, que tengan un mismo DNI o que se llamen igual. 00:48:10

En cada programa podría ser un criterio diferente y según eliges una colección u otra, pues te permite el que haya duplicados, o sea, haya entradas duplicadas o no las haya. Yo que sé, imaginaros que, para poneros un pelín en contexto de lo que os cuento, aunque sin entrar en detalles, porque ya tocará en su momento, imaginaros que tienes en el enunciado un programa en el cual estás dando de alta personas en un club de petanca. 00:48:31

Pues si una persona ya añades al grupo ese de personas trabajando mediante una colección que son librerías de Java, ya os digo que ya la veremos, añades a una determinada persona, si quieres añadir esa misma persona de nuevo al club de socios, pues lo normal es que tuvieses que hacer por tu programa unas comprobaciones de que esa persona no se haya asocia, porque no va a ser asocia dos veces. 00:48:58

Entonces, eso lo puedes hacer tú 00:49:21

Tú puedes crear tu estructura en un array de los socios 00:49:25

Pero para hacer esa comprobación en un array 00:49:29

Tendrías que recorrer los socios 00:49:32

Y comprobar que ya no está de alta 00:49:34

En cambio, utilizando una colección 00:49:36

Tú llamas a un método de un objeto de esa colección 00:49:38

Y si estás utilizando la colección correcta 00:49:40

Que no permite duplicados 00:49:43

Pues directamente solo lo añades si no existe ya 00:49:44

Ese código que hay en las librerías 00:49:46

Hará esa comprobación 00:49:49

Pues lo tiene que hacer 00:49:50

Sí, lo tiene que hacer sí o sí, ¿no? Pero lo hace por nosotros simplemente con una llamada a un método. En cambio, imagínate el otro programa en el cual, oye, lo que estoy comprobando no es dar de alta en un club de petanca, sino las visitas que hay a un determinado centro comercial. 00:49:51

Y yo puede ser que vaya por la mañana y vuelva por la tarde. Entonces, igual en este otro enunciado, digamos, el algoritmo que queremos resolver en este caso, si nos interesa, pues crear un grupo, que en este caso será el grupo de personas que han ido a comprar ahí al centro comercial, pero si es duplicados, igual me interesa recogerlo justo en este contexto. 00:50:08

¿Por qué? Porque si hay una misma persona dos veces, quiero que eso se quede registrado. 00:50:27

Pues entonces lo que se haría sería utilizar una colección diferente de todas las que tengo a mi disposición, que en este caso sí aceptaría duplicados. 00:50:31

Igual que con la gestión de duplicados o no duplicados, pues hay colecciones que están ordenadas, que no están ordenadas, según un criterio u otro. 00:50:40

Ya os digo, hay un tema en el que trabajaremos con esto. 00:50:48

entonces para trabajar con grupos de objetos tenemos los arrays o las colecciones y esto que 00:50:50

has visto de los mapas está colgando de las de la funcionalidad de colecciones así que lo veremos 00:50:57

ya voy a cerrar la máquina virtual que si me deja cerrar eclipse no se ha quedado pillada voy a 00:51:05

cerrar la máquina virtual y la arrancó de nuevo entonces pues bueno pues es una solución que sí 00:51:12

que se podría resolver el programa por esa línea, pero ya lo veremos. A ver si arranca bien, ahora 00:51:18

¿dónde puedo cerrar yo la máquina? Uy, se ha quedado, no me da la opción, se ha quedado guardada, no me 00:51:31

da la opción de apagarla por aquí y aquí está pillada. Bueno y vamos a comentar un poquito si 00:52:09

os parece, si podemos dar por cerrado más o menos 00:52:42

estas dos consultas que teníamos abiertas 00:52:44

vamos a hablar un poquito de expresiones regulares 00:52:48

que es algo totalmente nuevo 00:52:50

que sí que aparece en este tema. Mira, las expresiones regulares 00:52:53

no son una cosa exclusiva 00:53:04

ni mucho menos de Java y lo que nos permite 00:53:08

es manejar cadenas 00:53:10

normalmente de caracteres 00:53:13

pero bajo patrones, es decir, ponemos un patrón que hace que se cumpla o no se cumpla, me identifica si se cumple o no se cumple. 00:53:15

Se utiliza mucho, por ejemplo, en las validaciones de campos cuando trabajamos con formularios, todavía no hemos trabajado con formularios, 00:53:26

ya lo haréis, si metes en un campo información de un correo electrónico, pues los correos electrónicos tienen unas determinadas características, 00:53:33

Pues tienen un arroba y antes tienen una parte anterior al arroba, una parte posterior. Entonces, si yo intento en un campo que me dice que meto un correo electrónico, pongo José Manuel solo, pues en el momento de intentar validar esto, pues me comprobará que esta estructura no corresponde a la estructura, no tanto José Manuel o lo que sea, sino que no corresponde a la estructura típica de un correo electrónico. 00:53:44

En cambio, si yo pongo aquí arroba gmail.com, pues me dirá, mira, esta estructura desde la expresión regular, no sé si este correo ha estado de alta en Gmail, pero la estructura sí que sería válida porque tiene un texto por aquí delante, luego tiene aquí un arroba y luego tiene algo que típicamente aquí suele ser un dominio posible de correo. 00:54:08

Entonces coge y le vale. Para comprobar las estructuras, las expresiones regulares, está indicado en el aula virtual. Hay una página que la verdad es que es bastante cómoda para practicar un poco. 00:54:35

a ver si la localizo por aquí, entre los papeles que tengo 00:54:56

para iros contando, bueno, aquí en esta página 00:55:01

pues se pueden poner la estructura regular que quieres comprobar, a ver cómo funciona 00:55:22

y aquí ir poniendo textos para ir 00:55:26

validándolo, mirad, por ejemplo 00:55:30

cuando estamos trabajando con la sintaxis de las estructuras regulares 00:55:33

pues hay un carácter, hay algo que te indica cualquier tipo de carácter 00:55:38

que es el punto, entonces si yo pongo aquí ahora un texto 00:55:42

pues fijaros como me está diciendo que la A 00:55:46

lo cumple, que la B lo cumple, la C lo cumple, realmente 00:55:50

un punto viene a significar cualquier cosa 00:55:54

como cada una de las que lo cumplen pues me lo va poniendo en un color un poquito 00:55:57

diferente, veis aquí azul más clarito, azul más oscuro, de nuevo va alternando 00:56:02

azul claro y azul oscuro, cada uno de estos cumple este bloque 00:56:06

de un punto. Si yo le pongo, por ejemplo, aquí el sombrerito este, a ver, el sombrerito, lo que estoy diciendo es, el sombrerito significa el inicio de la expresión regular. 00:56:10

Entonces aquí decimos, quiero algo que empiece por el sombrerito y que tenga cualquier cosa. Entonces ya en este caso no me vale cualquiera, fijaros, ya solamente me vale este, 00:56:30

porque hemos metido una condición más a la expresión regular que es 00:56:42

que tenga el inicio y tenga un carácter 00:56:46

antes, como no era el inicio, decía, pues mira, me vale cualquiera 00:56:51

de todas ellas, en cambio si cojo y le digo 00:56:55

el inicio, pues ya solamente me vale esta, ¿por qué? porque la B 00:56:57

ya no cumple esa expresión regular, la expresión regular 00:57:03

o la C o la D, la E o el 4, es, cumple la condición 00:57:07

de que es un punto pero no de que se encuentra al principio si lo que quiero es identificar el 00:57:11

inicio y el final el inicio se pone con el sombrerito este que es un carácter que tenemos 00:57:19

justo a la derecha de la p y el final para el final se utiliza en la expresión regular el 00:57:25

dólar entonces ahora lo que estamos diciendo es que quiero que me compruebe lo que hay aquí a 00:57:32

A ver si cumple esta expresión regular, que empiece, o sea, inicio, se encuentre un carácter, el que sea, y termine. 00:57:39

Y esta expresión regular no cumple eso, porque tiene muchas cosas entre el inicio y el final. 00:57:48

Esta es cierto que empieza, tiene un carácter cualquiera, pero no termina, que sería el dólar. 00:57:53

Esta no cumple ni el inicio ni el final, y el 4 lo que no cumple es el inicio. 00:57:59

Al inicio, el 4 no empieza, porque tiene todo esto por delante. 00:58:04

Así que es cierto que es el último. 00:58:08

Si lo dejamos aquí en uno, fijaros como ya sí que lo cumple. 00:58:10

Tiene inicio, cualquier cosa y el final. 00:58:14

Hay algunos caracteres que nos permiten ir manejándolo. 00:58:24

Fijaros aquí a la derecha, por cierto, la aplicación nos va echando una mano de lo que intenta expresar la expresión regular que tenemos aquí puesta. 00:58:32

Hay tres caracteres clave que son la interrogante, una interrogante lo que significa es que lo que le precede puede aparecer cero o una vez, entonces si tenemos aquí el 4 aparece una vez y si lo tuviéramos así pues aparecería cero, también lo cumpliría pero bueno en realidad pues como no tenemos texto por aquí ahora lo comprobamos después. 00:58:42

no podemos ver es que lo que le antecede en este caso el punto es decir cualquier tipo de carácter aparezca cero o una vez si ponemos un más significa que aparezca uno o n veces siendo n hasta infinito vale entonces si ahora cojo y pongo ya aquí a b c fijaros como se sigue cumpliendo todo el rato la expresión regular porque pues porque cualquier cosa puede aparecer o una o n veces 00:59:17

N veces, pues es cualquier número. 00:59:47

Entonces fijaros como ya todo el rato la expresión regular se cumple. 00:59:49

La interrogante era 0, 1, el más es 1, n, y el asterisco es 0, o n. 00:59:58

Ahora metemos alguna cosilla más para ver bien la diferencia. 01:00:05

0, o n veces. 01:00:10

En la expresión regular también podemos poner valores en particular. 01:00:16

Imaginaros que quiero una palabra que empiece siempre por una mayúscula, entonces podemos poner la expresión regular, algo que empiece por A, fijaros, que empiece por A mayúscula y luego tenga cualquier carácter que se puede repetir o cero o n veces, como hemos dicho con el asterisco. 01:00:20

Entonces fijaros, si ahora pongo aquí una A mayúscula, ya se cumple, ¿veis? 01:00:44

Y como es o 0 o n veces, si yo quito todas, como es el asterisco, se sigue cumpliendo. 01:00:48

0 o n veces. 01:00:54

En este caso estaríamos con 0, en este caso estaríamos con 1, 01:00:56

y en este caso con n hasta donde quisiéramos llegar. 01:00:59

Fijaros, el espacio también le vale. 01:01:03

Si yo pongo aquí, en lugar del asterisco, un más, 01:01:08

el más hemos dicho que significa que a lo que antecede que es el punto 01:01:12

aparezca una o n veces, entonces tenemos 01:01:17

cierto que empieza por una A mayúscula, como indica aquí, si pusiéramos una A minúscula 01:01:20

dejaría de cumplirse, ya no me la indica 01:01:25

que es correcta, y luego como es uno o n veces 01:01:29

con el más, estos son n, le vale 01:01:33

esto es la A y uno, que le vale para el más 01:01:36

Pero si le quito este, ya no se cumple, ¿veis? Porque el más es una o n veces, está dejando de cumplir la expresión regular. Tenemos a y tendría que aparecer algo una o n veces al utilizar el más, pues ya no le gusta. 01:01:42

Si ponemos un carácter, ya le vuelve a valer. 01:02:00

Y la interrogante que decíamos antes, hemos dicho que era cero o n veces. 01:02:04

Entonces, tenemos la a y cualquier carácter que es el punto, una vez, cero veces también, porque tenemos la interrogante, 01:02:09

pero si ponemos ya dos, pues ya no le vale. 01:02:18

Tendríamos que manejarlo a través del más o del asterisco según nos interesase. 01:02:22

Respecto al manejo de las repeticiones, tenemos también la posibilidad de poner entre llaves un número de repeticiones. 01:02:32

Entonces, si ponemos aquí tres, un número en particular, lo que le estaríamos diciendo es que en este caso que aparezca una A y cualquier carácter tres veces. 01:02:43

Y tres caracteres. Y cualquier carácter tres veces. 01:02:54

Entonces, fijaros, tenemos un A ahora mismo y un carácter cualquiera dos veces, si ponemos un A, ya lo cumple. Si le metemos otra más, ya no lo cumple. ¿Por qué? Porque son tres veces fijas, según lo hemos puesto ahí. 01:02:58

si ponemos esta expresión regular 01:03:15

lo que estamos diciendo es 01:03:30

una A 01:03:31

y en este caso es cualquier carácter 01:03:32

entre 3 y 5 veces 01:03:36

entonces tenemos la A 01:03:38

y 1, 2, 3, 4 01:03:40

pues bueno, está en el arranque ese que hemos dicho 01:03:42

un quinto carácter también le valdría 01:03:44

si metemos un sexto, ya no cumple la expresión 01:03:46

3 todavía le vale 01:03:48

fijaros la A 01:03:51

1, 2, 3 01:03:52

si quitamos otro más, ya no cumple la expresión 01:03:54

si aquí quitamos el inicio y el final 01:03:57

y mantenemos la expresión regular 01:04:03

fijaros, esto le vale una A y tres caracteres 01:04:05

una A y cuatro caracteres también le valdría 01:04:10

y si ponemos algo aquí de antemano 01:04:13

anterior, todos estos no lo cumplen 01:04:16

pero como hemos quitado la condición de que fuese 01:04:19

desde el principio, este bloque le sigue valiendo 01:04:22

porque se encuentra en un momento dado una A y tres caracteres, lo que dice la expresión regular. 01:04:26

Si yo pongo aquí, fijaros más, se cumple hasta que tiene una A y uno, dos, tres, cuatro y cinco, 01:04:32

que es la propia expresión regular. 01:04:39

Y si yo ahora pongo aquí una A y otra vez cinco caracteres, pues me dice se vuelve a cumplir. 01:04:41

Es decir, poner el inicio o el final nos marca que sea una expresión regular 01:04:46

que cumple por completo la expresión regular, si indicamos 01:04:52

principio y final, si ponemos solo principio, garantizar que 01:04:56

la expresión regular empieza, el texto empieza por esa expresión regular 01:04:59

y si ponemos el dólar, garantizamos que el texto finaliza 01:05:04

con esa expresión regular. Si quitamos inicio y final, pues nos 01:05:08

localiza todas las partes en el texto donde 01:05:12

tenemos la expresión regular recogida. Mira, más cosas. 01:05:14

imaginaos que tenemos que deciros 01:05:25

que, por ejemplo, que queremos 01:05:30

localizar la palabra 01:05:33

que queremos localizar, alumno, en un texto 01:05:37

simplemente poniendo como expresión regular 01:05:42

un texto, esta clase 01:05:49

hay muchos alumnos 01:05:52

Ya veis que diferencia entre mayúsculas y minúsculas, alumnos y alumnas. 01:06:02

Pues nada, fijaros que me ha localizado alumnos, pero no me ha localizado alumnas. 01:06:14

¿Por qué? Porque es lo que he puesto aquí en la expresión regular. 01:06:20

Pero podríamos querer, lógicamente, en este contexto, pues nos interesa tanto los chicos como las chicas, para que nos aparezca. 01:06:22

Entonces la posibilidad de que una de las palabras puede ser una combinación, uno entre varios, lo podemos identificar con corchetes. Entonces en la apertura y cierre de los corchetes ponemos todos aquellos caracteres que nos resulten válidos en ese trozo. 01:06:29

Entonces aquí decimos, tiene que poner alumn, n y una a, una o para que sea alumna o alumno 01:06:50

y luego, bueno, por la s porque estamos hablando de mayúsculas. 01:06:58

Entonces al poner la a y la o, fijaros como ya nos identifica a los dos. 01:07:02

Podemos ponerlo de esta manera, con comas también. 01:07:07

Imaginaos que tenemos alumnus también. 01:07:16

Bueno, pues si tenemos varios lo podemos separar ahí por comas y sin comas también. 01:07:25

Si lo que queremos es un bloque de información, por ejemplo, imaginaos que lo que queremos localizar es aquello que aparezca el número entre 1 y 3 aquí, o entre 5 y 7. 01:07:33

entonces lo que podemos poner es un rango entre 5 y 8 01:07:53

de esta forma, queda un poco raro poner aquí un número 01:07:57

pero si ponemos un 6, fijaros, ponemos aquí un 8 01:08:00

ponemos aquí un 5, de esta forma 01:08:04

podemos identificar un rango, para no poner todos los valores 01:08:09

individualmente que forman ese rango, si tenemos 20 caracteres 01:08:12

y todos van consecutivos uno detrás de otro, pues podríamos 01:08:17

poner desde la A a la P y no tener que poner A, B, C, D, 01:08:21

F, G, H, I, J, K aquí todos. Mira, si ponemos aquí 01:08:25

desde la A a la P, pues me valdría alumnas 01:08:29

alumnus, que también está 01:08:35

por ahí. No, alumno no está, está después de la P. 01:08:38

OP, la O sí. Y en cambio, por ejemplo, la Z 01:08:45

pues no le valdría. ¿Por qué? Porque no está en este rango. Más cosas por ahí 01:08:48

de las expresiones regulares el inicio al final las llaves cualquier carácter el punto si lo que 01:08:59

queremos es identificar algo dentro un corchete pero no decir que es que aparezca uno de esos 01:09:12

caracteres en esa posición sino al contrario decir mira lo que no quiero es que aparezcan 01:09:20

estos caracteres justo dentro del corchete podemos volver a utilizar el sombrerito el 01:09:25

el mismo sombrerito que hemos puesto aquí para representar el inicio 01:09:31

de la expresión regular, lo podemos poner aquí. Entonces, para hacer eso, 01:09:35

si lo ponemos aquí, a ver, ahí lo tenemos el sombrerito. 01:09:40

Ahora lo que hemos hecho ha sido invertir los caracteres que teníamos aquí. 01:09:45

Es decir, lo que le estamos diciendo con el sombrerito es que estos caracteres 01:09:49

justo no sean los que aparecen. Entonces, una vez que hemos puesto esto, 01:09:53

fijaros como ya la A de alumnas 01:09:57

que estaba dentro del bloque este que sí considerábamos válido 01:10:00

ya no nos vale, la O tampoco 01:10:03

porque lo estamos negando aquí y en cambio la Z 01:10:05

que no pertenece a este rango ahora ya sí que le gusta 01:10:08

entonces nos está marcando que la expresión regular se cumple 01:10:12

para alum y con la Z 01:10:15

pero ya no se cumple para alumnos y alumnas 01:10:17

si lo que queremos es tener dos bloques 01:10:21

para un determinado carácter, imaginaos que nos vale 01:10:27

que ponga alumnas, alumnos con este rango 01:10:31

de variables, pero queremos que pueda ser en mayúsculas o minúsculas 01:10:35

pues un primer rango lo identificamos así y a continuación podemos poner aquí en mayúsculas 01:10:39

un segundo rango, entonces ahora si aquí pongo 01:10:44

aluv, la b mayúscula 01:10:49

nb, a ver, pues también le vale 01:10:53

¿Por qué? Estos dos le valen gracias a este rango y puede ser cualquiera de todos los caracteres que identifiquemos aquí, pues este otro rango es el que me está admitiendo que ponga aquí una D. 01:10:59

Mira, por ejemplo, los números binarios. Los números binarios están recogidos con ceros y unos, ¿verdad? En binario aquí en informática, pues esto sería un número binario, cualquier combinación que esté formado con ceros y unos. 01:11:22

Pues si queremos validar que una determinada variable tiene un número binario, 01:11:39

pues podríamos decir que desde el principio y hasta el final todos sus valores sean 0 o 1. 01:11:44

Pero claro, esto me está diciendo que un carácter sea 0 o 1. 01:11:59

Si yo cojo y hago así, me dice que bien, pero en cuanto tengo más, ya no. 01:12:02

entonces, para considerar un número binario 01:12:09

lo quiero considerar que 01:12:12

tenga un número que no tenga ningún 01:12:14

o sea, que no tenga ningún cero o ningún uno, lo consideramos como binario 01:12:18

pues si que lo fuera así, podríamos poner aquí un asterisco 01:12:22

entonces diríamos, esto lo considero 01:12:24

el número binario vacío 01:12:27

si tiene un solo carácter le vale, el asterisco recordad que era 01:12:29

de cero a n 01:12:33

entonces, todo ese le vale 01:12:36

y si el vacío no lo quiero considerar como un número binario 01:12:37

porque es como que no lo has incluido a la hora de valorar la expresión regular 01:12:42

le puedo poner una más 01:12:45

entonces en cuanto tenga un 0 o un 1 ya le vale 01:12:46

fijaros como el 0 aquí aunque esté vacío 01:12:50

me marca aquí que está cumpliendo la expresión regular 01:12:52

lo veis aquí en el rosita 01:12:55

pero si le pongo el más 01:12:56

ya no está cumpliendo la expresión regular 01:12:59

porque tiene que tener al menos una vez el 0 o el 1 01:13:00

entonces yo pongo aquí ya cualquier número y ya le vale 01:13:04

Y si cojo y pongo un número que no sea el 0 y el 1, como no está recogido aquí, pues nada, no le valdría. 01:13:07

Imaginaos que en la expresión regular quiero asegurarme que sea un número en sí. 01:13:19

Pues yo puedo coger y poner aquí. 01:13:25

Podría poner que vaya entre 0 y 9, ese número. 01:13:28

Entonces, cualquier combinación de números le vale. 01:13:33

Cuanto meto una letra, pues ya no le gusta. 01:13:37

esto tiene un atajo si son todos los números que es poner barra de de minúscula veis y ya pues le 01:13:39

gustó es igual que poner de 0 a 9 si ahora ponemos aquí unas letras pues ya no lo cumple y la de 01:13:49

mayúscula lo que hace es indicar que al contrario que lo que tienes ahí dentro no sea un número 01:13:59

cualquier cosa excepto un número entonces como esto tiene números le vale pero si ahora yo pongo 01:14:06

aquí ya empieza a cumplirlo incluso espacios caracteres lo que sea mientras en el momento 01:14:11

que mete un número la barra de mayúscula deja de ser válida y bueno pues podéis poner en mil 01:14:16

situaciones no vamos a pues que para validar ir jugando con las diferentes combinaciones que 01:14:29

tenemos en la sintaxis estoy contando algunas en creo que en el aula virtual bueno pues aparecen 01:14:35

alguna más. Con la W 01:14:40

lo que te 01:14:42

dice es que 01:14:45

ahí, W 01:14:46

minúscula. 01:14:48

Lo que te dice es que, barra W, 01:14:50

perdón, lo que te dice es que este carácter 01:14:53

puede ser 01:14:55

o bien un dígito numérico o una 01:14:56

letra, pero no un símbolo. 01:14:58

Entonces, si yo pongo aquí, si es lo que quiero 01:15:00

valorar, ¿veis? A esto le gusta, 01:15:02

minúsculas también. Ahora, si 01:15:05

pongo algo que 01:15:06

no sea una letra o un número, el dólar por ejemplo, pues ya no le gusta, un espacio 01:15:08

tampoco, el punto tampoco, y si utiliza 01:15:12

la W mayúscula, pues lo que hace es 01:15:16

a ver, voy a poner una mayúscula, ahí está, lo que hace es igual que la D 01:15:21

eran los números y la D mayúscula era lo contrario a los números 01:15:26

la W mayúscula pues lo invierte, entonces le vale la expresión regular 01:15:29

cualquier cosa, siempre y cuando no sean ni números 01:15:34

ni caracteres alfanuméricos 01:15:38

en general. Entonces, a este no le gusta, fijaros 01:15:42

si pongo solo números, tampoco 01:15:46

aún poniendo solo letras, tampoco, pero si pongo solamente 01:15:49

caracteres que no sean alfanuméricos, perdón, he puesto números ahora 01:15:53

pues ya sí le gusta. ¿Por qué? Porque hemos puesto en la expresión regular la W. 01:15:57

Imaginaos que queremos tener 01:16:07

un número 01:16:09

que permita tener decimales 01:16:12

o no decimales. Entonces podríamos 01:16:14

decir números decimales 01:16:16

que tenga al menos un dígito 01:16:21

y después de este bloque, que sea 01:16:23

números decimales que tenga un dígito, 01:16:25

podemos decir que si hay 01:16:27

decimales, solamente 01:16:29

aparezca el punto que 01:16:34

separa la parte entera de la parte decimal 01:16:36

en caso de que haya decimales, pero podemos 01:16:38

poner números que no tengan decimales. 01:16:40

Entonces podríamos poner 01:16:42

para todo el bloque de los decimales, ponemos aquí algo 01:16:43

vamos a poner entre paréntesis 01:16:47

y decirle que esto que pongamos aquí dentro 01:16:51

ahora lo rellenamos, puede aparecer o no. Entonces 01:16:56

si no aparece, bien, y si aparece, lo primero que se encontrará será un punto 01:16:59

pero si ponemos un punto es cualquier cosa. Para utilizar el punto 01:17:04

en sí tenemos que escaparlo. Decimos que sea un punto 01:17:08

verdad, esto era el carácter de cualquier cosa 01:17:11

esto 01:17:13

el punto 01:17:14

y luego si aparece el punto 01:17:16

sí que vamos a necesitar que aparezca 01:17:19

al menos un dígito 01:17:21

entonces le podemos poner aquí 01:17:23

entre corchetes que aparezca un dígito 01:17:24

y vamos a decir por ejemplo 01:17:27

que solo tenga hasta tres decimales 01:17:29

como mucho, que vaya entre uno 01:17:31

y tres 01:17:35

vamos a probar a ver si nos funciona 01:17:37

ponemos cero 01:17:40

punto, bueno, 0 le gusta, es decir, todo este bloque 01:17:42

como esto puede aparecer o no aparecer, en este caso no está apareciendo y ya le gusta 01:17:46

si pongo 0 y un punto, todavía no le gusta, ¿por qué? porque ha aparecido 01:17:52

este punto, es cierto, pero aquí le estoy diciendo que aparezca 01:17:56

entre 1 y 3 decimales, le digo 0,3 01:18:00

2,4, vale, pues ahí está, y si pongo otro más, ya no le gusta 01:18:03

pues vamos a pasar al código, para 01:18:08

hacer y os enseño cómo integrarlo dentro de Java 01:18:19

hasta donde nos dé tiempo. No sé si nos va a dar tiempo del todo. 01:18:23

Bueno, aquí según la síntesis de las expresiones regulares 01:18:28

se pueden validar un montón de cosas. Os cuento un poco ahí 01:18:31

en la teoría. Si tenéis dudas, abrid un hilo 01:18:35

y vamos comentándolo en el aula virtual. Voy a pasar al otro lado para que nos dé tiempo 01:18:39

a ver cómo las expresiones regulares las podemos incorporar al código. 01:18:43

Entonces, nos venimos por aquí. 01:18:49

Y, bueno, en el código hay unas clases que, bueno, os aparecen también en la teoría que nos permite manejarlo y luego ahí, bueno, pues se pueden utilizar en algunas de las funciones que ya conocéis incluso. 01:18:51

fijaros, o que estáis incluso viendo este tema 01:19:11

antes de ir a las propias 01:19:14

librerías que están para las expresiones regulares 01:19:18

vamos a definir una variable aquí 01:19:20

y vamos a meterle aquí un 01:19:23

contenido, por ejemplo vamos a poner 01:19:29

1 y vamos a utilizar 01:19:31

las zetas para luego meterlo en las expresiones regulares 01:19:36

vamos a poner 1, zeta, zeta, aquí dos zetas 01:19:38

2, vamos a poner una zeta mayúscula 01:19:40

vamos a poner varias zetas, este texto, imaginaos que tenemos 01:19:43

en una variable un texto de este tipo, y luego 01:19:53

podemos utilizar en algunos de los métodos que tenemos disponibles en Java 01:19:56

ya directamente, cuando en Eclipse busquéis las opciones 01:20:01

de métodos que os proporcionan, veréis que algunos de los métodos permiten 01:20:05

recibir como parámetro expresiones regulares, una de ellas 01:20:08

en la siguiente, fijaros, imaginaos que tenemos aquí, definimos un string 01:20:13

vamos a poner sres, lo podemos llamar 01:20:17

que lo queremos cargar con información de ese info 01:20:21

si pusiéramos ese info, pues nos cargaría 01:20:25

en sres esto, pero queremos esto, pero modificado 01:20:28

bajo ciertas características, y vamos para ello a definir una expresión 01:20:32

regular, entonces podemos utilizar el método replace 01:20:37

replace all, por ejemplo, y fijaros como aquí el replace all 01:20:40

me ofrece una expresión regular como primer parámetro. 01:20:45

Replace first, replace all 01:20:50

sustituirá todas las ocurrencias de la expresión regular por el texto 01:20:52

que pongamos aquí. Replace first, pues sustituirá la primera 01:20:57

aparición de algo del texto de la expresión regular por lo que 01:21:01

pongamos aquí. Vamos a utilizar un replace all. Entonces, decimos 01:21:05

aquí era donde me indicaba, me pedía la expresión regular, entonces aquí podemos poner 01:21:09

como expresión regular, por ejemplo, podemos decir 01:21:15

aquí, que me sustituya la Z 01:21:23

o la Z, si aparece una o más veces 01:21:27

por el texto 01:21:35

cambio. ¿Qué es lo previsible? Pues que a esta información 01:21:38

va a aplicarle esta expresión regular y donde la encuentre va a sustituir 01:21:54

ese texto por cambio. ¿Aquí qué es lo que estamos diciendo? El carácter Z o Z mayúscula, me da igual cualquiera de los dos, 01:21:58

si aparece una o más veces, ¿y dónde lo tenemos? Pues fijaros, tenemos aquí una o más veces la Z minúscula, 01:22:09

aquí tenemos la Z mayúscula y aquí tenemos varias veces la Z minúscula, vamos a poner una de ellas mayúscula. 01:22:16

Entonces es previsible que esto me lo sustituya por la palabra cambio, que esto me lo sustituya por la palabra cambio 01:22:23

y que esto me lo sustituya por la palabra cambio y lo cargue aquí. 01:22:30

Si hacemos esta ejecución, vamos a ver si de verdad lo hace. 01:22:34

Mirad, lo veis aquí. Me ha efectuado el cambio. 01:22:38

¿Qué es lo que ha cambiado? Pues lo que hemos puesto aquí en una expresión regular. 01:22:41

¿Qué expresión regular nos podemos poner aquí? Pues todas las que estábamos viendo 01:22:45

en el documento. 01:22:48

En el documento, en la web, está en la reges 101. 01:22:52

¿Lo ha cambiado todas? Mira. 01:23:04

dices, si aparece dos veces Z 01:23:06

que pusiera dos veces cambio 01:23:09

no, porque he puesto aquí esto 01:23:11

si quito el más 01:23:17

mira, si quito el más 01:23:19

me aparece cambio, cambio dos veces, porque aquí lo que le estoy 01:23:20

diciendo es que cuando aparezca una Z 01:23:26

una Z mayúscula, que me lo ponga por cambio 01:23:28

pero si le pongo esto, lo que le estoy diciendo 01:23:30

en la expresión regular es que 01:23:32

cuando aparezca esto, una o 01:23:33

n veces, que aplique el cambio 01:23:36

entonces, me aplica esto 01:23:38

mira 01:23:40

A ver, si en lugar de replaceAll pongo un replaceFirst, bueno, pues tenemos la misma jugada de antes, pero con este otro método lo que hace es reemplazar la primera aparición de la expresión regular y no replaceAll. 01:23:42

Bueno, pero esto es para una cosa muy particular de hacerlo aquí, con el método pattern y el matcher, pues te permite hacer una gestión más, de hacer más cosas, esto es simplemente para el replace first, o sea, para hacer un reemplazo, las expresiones regulares aparecen en muchas partes, como parámetros, pues este te lo ofrece y a nivel general para trabajar sobre, si tú lo que quieres, imagínate que es validar un parámetro, 01:24:15

un campo, pues entonces utilizas el dato del pattern matcher 01:24:51

este, que ahora a ver si nos da tiempo a desarrollarlo un poquito 01:24:55

pues para hacer la comprobación de si está y validar si 01:24:59

se ha ido correcto o no ha ido correcto, o sea, si el dato 01:25:03

que estás validando responde a la expresión regular 01:25:06

este método, el replace all de la clase 01:25:10

string, bueno, pues nos ofrece esta posibilidad también 01:25:15

pero no sustituye a la otra necesariamente 01:25:18

sí 01:25:21

pues 01:25:24

claro 01:25:43

bueno, que solamente 01:25:44

sea dos 01:25:53

ah bueno, si solo es una 01:25:54

lo que puedes hacer aquí es poner la expresión regular 01:26:03

de esta forma 01:26:05

decir que la expresión regular 01:26:07

a ver 01:26:09

mira, lo que quieres decir tú 01:26:10

yo creo que es esto, cuando aparezca dos 01:26:13

coma 01:26:15

yo creo que asterisco o sin nada, me parece que sin nada 01:26:16

esto lo que quiere decir es que cuando aparezca dos veces o todas las que sean 01:26:21

quiero que me lo cambies por una Z, lo único que aquí es cierto que te va a cambiar 01:26:25

la mayúscula y la minúscula, ¿vale? por una Z, entonces decimos 01:26:30

ejecutamos aquí, ¿ves? y ahora ya 01:26:35

me deja aquí una Z, esta no la toca, porque está una Z 01:26:39

solo, ¿ves? he puesto que sustituya por una Z minúscula 01:26:44

Entonces estas dos zetas minúsculas me las ha cambiado aquí por una zeta. Esta zeta mayúscula me la ha mantenido y estas dos zetas minúsculas, una mayúscula y una minúscula, me la ha vuelto a sustituir por una zeta. Entonces en ese caso la expresión regular sería esta. 01:26:47

Sí. Vale, mirad, las clases estas que hacéis referencia para el manejo que tenemos en librerías de Java, para el manejo de expresiones regulares, son la pattern y la matcher. 01:27:02

Entonces vamos a ver si nos da tiempo a hacer un pequeño ejercicio para verlo hasta donde lleguemos y si es necesario, si luego seguís con dudas, pues lo mantenemos ahí en el aula virtual con algún hilo. 01:27:18

Vamos a definir una primera variable de tipo string con la expresión regular con la que queremos trabajar. Por ejemplo, vamos a identificar hola con la primera letra que aparezca, mayúsculas, minúsculas, hola, por ahí ponemos. 01:27:34

si queremos considerar un punto 01:27:55

en el hola, si pusiéramos esto, esto significaría 01:28:08

cualquier carácter, entonces hay que escapar esto, en el aula virtual 01:28:12

en la página web que hemos visto antes, hemos puesto este carácter 01:28:16

pero si ponemos un solo carácter, se nos queja a la hora de escaparlo 01:28:19

entonces aquí en Java tenemos que poner dos caracteres, esto lo que estamos diciendo es que 01:28:24

esto lo considere como un punto, que si lo dejamos 01:28:28

así, por tratarse de una expresión regular, va a considerar cualquier palabra. 01:28:32

Si lo mantenemos así, pues expresiones que serían válidas serían 01:28:36

hola z, ¿por qué? Porque la z lo considera un punto. 01:28:39

También valdría hola porque hemos dicho que considere 01:28:44

esto la h mayúscula y minúscula 01:28:48

j, valdría también. Si lo que queremos es 01:28:51

considerar que sea un punto, tenemos que escaparlo. Como Java no lo deja, 01:28:55

lo escapamos dos veces, esto es una cuestión de Java del doble escape 01:28:59

en la página web pusimos un escape solo 01:29:02

entonces estas expresiones ahora ya no serían válidas porque serían válidas esta 01:29:06

y sería válida esta, entonces vamos a utilizar 01:29:12

la expresión regular para hacer ahí varias pruebas en las cuales 01:29:19

ponga hola y acabe con un punto y vamos a decir que el punto 01:29:23

sea opcional para que también me valga hola y hola 01:29:27

¿Vale? Eso en cuanto a la expresión. Y ahora vamos a definir aquí 01:29:33

un string, ese cadena. Esta es la que vamos a ir validando. 01:29:37

Vamos a poner, por ejemplo, hola de inicio aquí. ¿Cómo construimos 01:29:44

una validación con las clases pattern 01:29:50

y matcher, que son dos clases que tenemos disponibles en la librería de Java para trabajar 01:29:55

con las expresiones regulares? Pues primero definimos 01:29:59

un objeto de la clase pattern. Y hacemos uso 01:30:03

de un método estático que tiene, que es, y como es estático, fijaros, 01:30:07

que ponemos pattern punto algo, y lo que hacemos es compilar la expresión. 01:30:13

Y aquí, digamos que estamos definiendo el patrón que vamos a utilizar 01:30:23

como expresión regular, que la tenemos identificada en este string. 01:30:29

Ahí lo tenemos. Fijaros cómo Eclipse me ha incluido de la librería Java 01:30:34

Bautil-Reyes, la clase Pattern. A partir de aquí definimos 01:30:38

un objeto de la clase Matcher 01:30:45

y este objeto en lugar de hacerle un new lo que hacemos 01:30:47

es obtener la referencia del objeto 01:30:56

M desde el patrón 01:31:00

punto, llamamos al método Matcher que tiene y aquí 01:31:06

lo que le pasamos al Matcher es la cadena 01:31:11

que queremos validar. Al pattern con el método compiler le pasamos 01:31:15

la expresión regular. Al matcher, a través de este método del pattern, 01:31:19

le pasamos la que queremos 01:31:25

utilizar. Aquí, matcher con una T solo. 01:31:27

Y ahora, esto lo que tiene son diferentes 01:31:39

métodos. El matcher que nos dice 01:31:42

si aparecen o no aparecen. Si cumple, si 01:31:45

esta cadena cumple esta expresión regular. 01:31:50

Entonces, si utilizamos con un if 01:31:54

el m, que es el objeto de la clase 01:31:57

matcher, el método matches, bueno, ya veis 01:32:04

tiene diferentes métodos por aquí, hasMath 01:32:08

matches, hasMath devuelve un boolean, fine, bueno, tiene muchos, ¿no? 01:32:12

Lo más habitual es el matches, con el método 01:32:16

matches nos devuelve un boolean que será verdadero si cumple si os si cumple por 01:32:20

completo la cadena la expresión regular eso lo que implica el hecho utilizar matches es 01:32:27

que considera el sombrerito el dólar no es aparece en algún sitio en la cadena la 01:32:34

expresión regular no es cumple por completo sería como en el otro sitio poner esto 01:32:45

mirad aquí no me está dejando sería como poner esto en el otro sitio en una expresión regular 01:32:50

el hecho de utilizar matches es lo cumple por completo la expresión regular está recogida en 01:32:57

la palabra en su conjunto en lugar de ponerlo ahí utilizamos el método matches vamos a poner 01:33:03

aquí un system.out.println vamos a poner un cumple luego si nos da tiempo adornamos más el programa 01:33:11

else no cumple 01:33:24

en este caso cumple, fijaros, hola está cumpliendo con esta 01:33:36

expresión regular de principio a fin, pues parece que sí, porque tenemos 01:33:41

la h, la o, la 01:33:45

luego sería un punto, pero ese punto puede aparecer o no aparecer 01:33:48

entonces si damos aquí a ejecutar, me dice que cumple, como es la 01:33:52

expresión regular en su conjunto, si ponemos aquí una a, pues ya no 01:34:01

cumpliría, porque estamos utilizando el método machis. 01:34:05

Entonces dice ya que no cumple, ¿veis? 01:34:07

También hemos dicho que podría aparecer 01:34:11

el punto no aparecer 01:34:12

con este trocito de la expresión 01:34:14

regular. 01:34:16

Sin él, hemos visto que nos dice que cumple 01:34:18

y con el punto 01:34:20

pues también la debería cumplir 01:34:22

porque estamos diciendo que podría aparecer un punto 01:34:24

o no aparecer. 01:34:26

Pues también cumple. 01:34:29

Si ponemos dos puntos 01:34:31

pues ya no cumple. 01:34:32

Si ponemos aquí un más 01:34:37

a ver si localizo el más aquí, pues ahora diríamos 01:34:38

que el punto tiene que aparecer una o n veces, no cero o una 01:34:45

entonces le damos aquí y ahora ya dice que cumple a pesar de que tiene dos puntos 01:34:49

pero como es una o n, si quito esto, ahora ya me dice que no cumple 01:34:53

¿por qué? porque no tiene ningún punto, si pongo aquí un asterisco, cero puntos me valdría 01:34:58

pues sí me valdría, ¿veis? ya sigue cumpliendo 01:35:02

bueno, pues en función de la cadena 01:35:06

que queramos validar, que la pondremos aquí en el matcher 01:35:10

y de la expresión regular con la que queremos validar 01:35:14

esa cadena, que la pondríamos aquí en el compile 01:35:18

a través de una estructura de selección con un if 01:35:22

y el método matches, somos capaces de 01:35:26

aquí hacer lo que toque cuando cumple y aquí probablemente sería 01:35:30

mostrar un mensaje diciendo no cumples el correo electrónico que has puesto aquí 01:35:34

que has recogido aquí no cumple con la expresión regular de los correos electrónicos. 01:35:38

En definitiva, aquí te muestro un mensaje o te dejo en un bucle hasta que pongas bien el correo 01:35:44

o ya veremos a ver lo que hacemos. 01:35:48

El objeto de la clase Matcher nos permite comprobar la expresión regular de principio a fin, 01:35:53

pero luego tiene más métodos. 01:36:01

Entonces, si en lugar de Matches ponemos aquí, utilizamos el método Lookinat, 01:36:02

Esto lo que hace es mirar a ver si aparece en algún sitio 01:36:10

No a ver si lo cumple o no lo cumple 01:36:21

Entonces, esta expresión 01:36:24

Cumple, vamos a poner aquí para saber los dos mensajes 01:36:26

Cumple looking, no cumple looking 01:36:30

Entonces, cumple looking, cumple de normal 01:36:35

Si lo cumple estrictamente, lógicamente lo va a cumplir en el looking 01:36:40

Pero si yo pongo aquí una A aquí ahora 01:36:45

A ver, ¿qué es lo que he hecho por aquí mal? Ah, vale, bien. ¿Por qué me dice que no cumple el looking? A ver, vale, sí, perdón que lo estaba diciendo mal. El looking at no lo busca en cualquier sitio de la cadena, sino que lo busca al principio, si lo cumple al principio. 01:36:47

A ver, exactamente, perdonad, os lo había dicho mal. El método matches mira que toda la expresión, que toda la cadena cumpla la expresión. Entonces, en este caso, como tiene hola, pero luego tiene esto, pues no cumple el matching. 01:37:30

en cambio el looking at lo que hace es comprobar a ver si lo cumple al principio es como si 01:37:52

tuviéramos simplemente el sombrerito pero no tuviéramos el dólar aquí entonces dice que 01:37:58

cumple el looking para localizarlo en cualquier sitio tenemos el método find que sería no 01:38:01

considerar ni el sombrerito ni el dólar al final entonces si hacemos que cumple de forma estricta 01:38:18

Ahora vamos modificando. 01:38:42

Mirad, el fine no le vale encontrarlo, no lo considera. 01:38:55

Como tienes el looking at, entiendo que te lo localiza al principio. 01:38:58

Con el fine, si te lo cumple desde el principio, dice que no cumple. 01:39:03

Fijaros. 01:39:07

¿Veis? No cumple fine cuando cumple looking at. 01:39:09

Cumple el normal y el looking at. 01:39:12

Pero si dejamos aquí un espacio, algo anterior, no cumple la cadena normal, 01:39:14

no cumple el looking porque no está al principio, pero cumple el fine. 01:39:21

Es decir, la primera, el find, no te considera la primera de las veces 01:39:30

si se encuentra al principio, porque dice, bueno, ya lo validarás 01:39:34

con el lookinat, entiendo. 01:39:38

Yo, con el find, te voy a dar la solución para cuando no puedas utilizar 01:39:40

el lookinat al principio. 01:39:45

Mira, si ponemos aquí cualquier cosa, este no cumplirá la expresión regular, 01:39:48

no cumple el 01:39:54

ah, no, un momentito 01:39:56

que no es 01:40:02

creo, a ver, un segundín 01:40:04

mira, voy a poner esto 01:40:05

pero voy a comentar porque yo creo 01:40:08

que no va a ser exactamente ese el motivo 01:40:10

vamos a comentar el lookinat, un momentito 01:40:12

fijaros, he vuelto 01:40:14

aquí al principio, veis, sin dejar 01:40:29

el espacio ese en la parte 01:40:31

de adelante, vale, y ahora ya dice que cumple el fine 01:40:33

vale, os cuento 01:40:35

que es lo que estaba pasando, antes 01:40:36

os he dicho, os estaba comentando, pues parece que el find 01:40:38

como ya el servicio encontrado al principio lo tiene el looking at, pues el find 01:40:42

te encuentra las siguientes, por eso esta nos decía 01:40:46

el find que no cumple cuando si había cumplido el looking 01:40:51

up, pero en realidad no es eso, en realidad lo que sucede 01:40:55

es que estos métodos, el looking at y el find, lo que 01:40:59

hace es localizarlo y va avanzando digamos un cursor, que es lo 01:41:03

que ha hecho aquí? Bueno, el machis no avanzó un cursor, dice si cumple o no cumple 01:41:10

y luego se ha encontrado un lookinat, entonces ha dicho 01:41:14

¿lo he encontrado? Sí, hola, pues digo que lo cumplo. 01:41:17

Y como ya lo he encontrado este, lo que hago es avanzar el cursor y lo pongo por aquí 01:41:21

o por aquí, no sé exactamente dónde, después de la expresión. Y dice 01:41:25

¿cumple el find después? Y dice ya, como he avanzado 01:41:29

el cursor por aquí, ya no lo encuentro, entonces me dice que no cumple. 01:41:33

En cambio, si no hago el lookinat inicial, el cursor cuando llega al find, ¿dónde está? En el inicio de la expresión regular. Entonces, a pesar de que no tiene nada adelante, al no haber hecho un lookinat y haber avanzado el cursor de búsqueda, ya me dice que cumple el find. 01:41:37

Esto lo podemos gestionar con uno y con otro, a ver, haciendo un reset, creo. 01:41:58

A ver, reset, sí. 01:42:07

El método reset del matcher lo que hace es, si he avanzado con el cursor, 01:42:09

porque ya he ido encontrándolo y lo que espero es encontrar nuevas ocurrencias de la expresión regular, 01:42:15

con un reset lo que hago es volver a traer el cursor aquí al principio. 01:42:20

Entonces, si yo ahora cojo y ejecuto aquí, ¿veis? 01:42:24

Ya me dice que no cumple el matcher, lógicamente no lo cumple porque tengo este texto por aquí, pero cumple el looking at, ¿por qué? Porque lo encuentro al principio, el looking at en realidad habrá avanzado el cursor hasta por aquí probablemente, hasta aquí, si no tuviéramos este reset el find buscaría partir de aquí y diría que no cumple, pero como hemos hecho un reset lo que conseguimos es que el cursor se me vuelva aquí al principio, con lo cual el find también me lo encuentra. 01:42:27

Y si yo pongo aquí otro hola, fijaros, el matcher no me lo cumplirá, el looking at me lo cumplirá porque lo encuentra aquí y el find me lo encontrará una vez y dos veces. 01:42:54

Entonces vamos a, en lugar de poner un for, un if aquí, vamos a poner aquí un while. 01:43:13

Mientras lo vaya encontrando, sácame que cumple el find. 01:43:24

fijaros que este bucle, aunque no tengamos ningún avance en particular 01:43:29

por código, en realidad sí que está avanzando porque cada find 01:43:34

va avanzando el cursor, entonces encontrará aquí un find, luego dirá 01:43:37

que encuentra aquí otro, y cuando haya encontrado este llegará aquí 01:43:42

y dirá pues ya no lo he encontrado más veces, con lo cual es previsible 01:43:46

que con esto, con el find me salga dos veces, veis 01:43:50

me dice no cumple el matcher, cumple el looking 01:43:55

es verdad que habrá avanzado el cursor, pero como hacemos un reset, nos lo traemos al principio 01:43:59

de nuevo y cumple dos veces el find, ¿veis? que es 01:44:04

una este y otra este 01:44:07

y ya para terminar, por lo menos por aquí 01:44:11

mostraros que cuando hacemos 01:44:16

de este cursor del que os estoy hablando y cuando lo va encontrando 01:44:21

pues tenemos a ver un mstart, que es donde 01:44:25

empieza cuando lo ha encontrado la aparición 01:44:29

de la expresión regular dentro del texto 01:44:33

y un stop, y un end 01:44:37

entonces si ejecutamos esto, fijaros 01:44:47

que dice, no cumple, efectivamente como hemos dicho antes 01:45:02

cumple el looking at, está al principio, y el 01:45:05

find lo encuentra dos veces, una y dos, y dice 01:45:09

que aparece la expresión regular 01:45:14

en el texto entre el carácter 0 con una longitud de 4 01:45:18

desde el carácter 0, 1, 2, 3 y 4 01:45:21

y luego dice que en el 10, del 10 al 14 01:45:24

entonces, 1, 2, 3, 4, 5, 6, 7 01:45:28

8, 9, 10 y el 11, 12, 13 y 14 01:45:34

de esta forma podemos localizar donde aparece 01:45:37

A través de esto podríamos hacer un replace en esta cadena, pues podríamos, lo único que ahora tendríamos que hacer un replace no con la expresión regular, sino que ir haciendo replace desde estas posiciones para cambiarla por el texto que nos gustase, por ejemplo. 01:45:41

Digamos, el pattern y el matcher son dos clases disponibles en las librerías de Java que nos permiten trabajar con expresiones regulares, localizando las expresiones regulares dentro de textos para luego aquí tener la posibilidad de hacer lo que nosotros queramos. 01:46:02

escribieron una base de datos, no sé qué nombre, apareció tres veces. 01:46:19

He sustituido esto por esto. 01:46:23

Al final, no un texto por otro, sino una expresión regular 01:46:25

por el texto que sea o lo que toque hacer. 01:46:29

Pero nos da la posibilidad de gestionar expresiones regulares 01:46:32

para hacer búsquedas de esos patrones dentro de cadenas de caracteres 01:46:35

y los otros métodos, como el que os he enseñado antes, 01:46:39

era una cosa más particular, que no viene de Perlas, 01:46:42

pero para hacer un replays o un replays all 01:46:46

como en un stream 01:46:48

bueno, me hubiera gustado hacer algunos ejercicios más 01:46:49

por aquí, cosas tenía apuntadas 01:46:56

no sé si fuera de 01:46:58

este primer examen, pues podemos 01:47:00

algún día en la siguiente tutoría 01:47:02

repasamos un poco más alguna cosita 01:47:04

pero hoy ya no nos da más tiempo 01:47:06

desafortunadamente 01:47:08

así que 01:47:10

no sé, sí, dime 01:47:12

alguien me pregunta por Google 01:47:13

sí, sí, sí 01:47:15

hasta este tema incluido 01:47:20

si necesitáis desarrollar algo más de este tema 01:47:22

como no os he dado tiempo a muchas tutorías, pues preguntadme por ahí 01:47:26

por los foros, ya sabéis que intento andar pendiente 01:47:28

y poca cosa más, esta clase os la subo ahora al aula 01:47:31

bueno, ahora o a lo largo del día porque siempre 01:47:36

tardo un rato en subir y bueno 01:47:39

pues os veo la semana que viene a los que os animéis a hacer el examen 01:47:42

a ver que tal os va 01:47:44

¿alguna preguntilla queréis antes de cerrar? 01:47:45

no, pues venga, por aquí lo dejamos ya 01:47:56

Venga, hasta la semana que viene. Hasta luego. 01:47:58

2025-02-03-Programacion - Contenido educativo

Del mismo autor…

Talleres de los sentidos

Adrián

Martina

CIRCLASSICA

CALANTHA_Elfos en el CEIP Luis De Góngora de Madrid

ELENTAN e ISILDUR_Elfos en el CEIP Luis De Góngora de Madrid

MELIA y ALBRUM_Exposición de Elfos en el CEIP Luis De Góngora de Madrid