1
00:00:00,370 --> 00:00:14,609
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.

2
00:00:14,869 --> 00:00:22,210
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.

3
00:00:22,210 --> 00:00:37,929
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.

4
00:00:37,929 --> 00:00:58,570
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.

5
00:00:58,570 --> 00:01:02,899
y nada, pues esto, comentaros esto

6
00:01:02,899 --> 00:01:07,159
por otro lado, bueno, pues nada, vamos a abrir un poco

7
00:01:07,159 --> 00:01:11,340
para ponernos a trabajar ya hoy en la tutoría, no sé si tenéis alguna consulta

8
00:01:11,340 --> 00:01:15,120
que queréis hacerme en particular, el examen justo hasta los contenidos

9
00:01:15,120 --> 00:01:19,260
que hemos visto en el tema 6 y no sé si tenéis

10
00:01:19,260 --> 00:01:20,640
alguna consulta que me queréis hacer

11
00:01:20,640 --> 00:01:25,280
antes de arrancar a hablar de diferentes cosas

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

13
00:02:10,379 --> 00:02:20,520
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.

14
00:02:20,520 --> 00:02:29,340
bueno pues venga pues mira vamos a arrancar si van surgiendo cosas nuevas me va a ir diciendo

15
00:02:29,340 --> 00:02:37,620
y si no vamos a arrancar justo a hacer cosas aquí con Eclipse ya voy a crear un nuevo proyecto

16
00:02:37,620 --> 00:02:44,000
digamos es reg de expresiones regulares por si luego una vez aclaremos esta un poquillo estar

17
00:02:44,000 --> 00:02:51,580
dos dudas que teníamos seguimos con expresiones regulares y si no bueno pues da igual el nombre

18
00:02:51,580 --> 00:02:55,599
el proyecto para trabajar cualquier cosa. Vamos a crear el proyecto.

19
00:02:55,759 --> 00:03:03,099
Creamos una clase por aquí. Podemos llamar es Reg también.

20
00:03:05,240 --> 00:03:10,710
Bueno, aquí vamos a meter el

21
00:03:10,710 --> 00:03:21,569
main de inicio del programa. Y bueno, hemos tenido

22
00:03:21,569 --> 00:03:26,469
este fin de semana un par de dudas

23
00:03:26,469 --> 00:03:30,349
abiertas, un par de debates ahí en el foro. Uno de ellas tenía que ver

24
00:03:30,349 --> 00:03:34,069
con, bueno, pues sabemos que tenemos los arrays que nos sirven para

25
00:03:34,069 --> 00:03:36,789
definir variables, un conjunto de variables

26
00:03:36,789 --> 00:03:39,810
del mismo tipo. Vamos a crear aquí dentro del proyecto

27
00:03:39,810 --> 00:03:43,030
una clase persona, un momento

28
00:03:43,030 --> 00:03:46,389
para ir apoyándonos en ella también en las explicaciones

29
00:03:46,389 --> 00:03:50,590
sin tampoco mucho detalle

30
00:03:50,590 --> 00:03:53,710
de métodos y atributos, vamos a ponerle

31
00:03:53,710 --> 00:03:56,750
que tenga un nombre, por ejemplo, de momento, si luego necesitamos

32
00:03:56,750 --> 00:04:00,919
más cosas ya la vamos haciendo. Cuando nosotros definimos

33
00:04:00,919 --> 00:04:03,879
una variable primitiva, pues decimos

34
00:04:03,879 --> 00:04:07,120
int i y decimos que la variable primitiva

35
00:04:07,120 --> 00:04:11,439
directamente hacen ya una reserva de memoria RAM para trabajar con ellas.

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

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

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

39
00:04:31,660 --> 00:04:55,740
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.

40
00:04:55,740 --> 00:04:59,959
y en esta la 30.000. Pues si decimos aquí int i igual a 3, pues diría

41
00:04:59,959 --> 00:05:03,560
¿dónde lo guardo? ¿En la 20.000 o en la 30.000? Una discrepancia, ambigüedad

42
00:05:03,560 --> 00:05:07,439
no me gusta. Si aquí en lugar de

43
00:05:07,439 --> 00:05:11,420
considerar dos variables int i

44
00:05:11,420 --> 00:05:15,860
dijésemos que una es un float y la llamásemos

45
00:05:15,860 --> 00:05:19,019
i, pues seguiría pasándonos lo mismo. En este caso

46
00:05:19,019 --> 00:05:22,459
se nos intentaría hacer una reserva para el tamaño de un float

47
00:05:22,459 --> 00:05:27,180
pero nos reservaría

48
00:05:27,180 --> 00:05:29,339
una posición diferente, vamos a suponer la 40.000

49
00:05:29,339 --> 00:05:32,240
si decimos i igual a 3

50
00:05:32,240 --> 00:05:33,899
pues diría, ¿dónde lo guardo?

51
00:05:34,899 --> 00:05:38,800
para el entero o para el float, en la posición 20.000 o en la 40.000

52
00:05:38,800 --> 00:05:40,879
este i, ¿a qué estará refiriéndose?

53
00:05:41,699 --> 00:05:44,579
pues nada, directamente no me compila en la segunda vez

54
00:05:44,579 --> 00:05:47,439
que lo intento, y si yo cojo

55
00:05:47,439 --> 00:05:50,259
y en lugar de una variable primitiva digo

56
00:05:50,259 --> 00:06:07,680
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.

57
00:06:07,680 --> 00:06:11,259
como hay una duplicidad de nombre de variables, pues ya no me gusta

58
00:06:11,259 --> 00:06:16,000
entonces, si aquí cogemos y definimos

59
00:06:16,000 --> 00:06:19,740
un array de personas, de enteros

60
00:06:19,740 --> 00:06:23,920
por ejemplo, o de personas, persona, mi per

61
00:06:23,920 --> 00:06:30,300
vamos a ir con los

62
00:06:30,300 --> 00:06:35,519
se mezclan un poquito las dos cuestiones que se han abierto, pero vamos

63
00:06:35,519 --> 00:06:39,220
a ir hablando un poquito de esto, fijaros, si yo pongo

64
00:06:39,220 --> 00:06:49,610
persona miper, esto lo que hará será hacer una reserva de memoria RAM para miper, vamos a suponer

65
00:06:49,610 --> 00:06:55,569
la 40.000 y ¿para qué estará reservando espacio en memoria en la 40.000? Pues estará reservando

66
00:06:55,569 --> 00:07:05,250
espacio para algo que terminará apuntando a un conjunto de referencias a personas. Vamos a suponer

67
00:07:05,250 --> 00:07:08,769
que mi per apunta a la posición

68
00:07:08,769 --> 00:07:13,310
que deciros. Bueno, 40.000 hemos dicho

69
00:07:13,310 --> 00:07:23,620
aquí. O sea, la 40.000. Si yo ahora cojo

70
00:07:23,620 --> 00:07:27,319
y digo mi per igual a new

71
00:07:27,319 --> 00:07:39,810
persona, pongo aquí 5, lo que estoy

72
00:07:39,810 --> 00:07:44,189
haciendo es que a partir del 40.000 tengo 5 referencias

73
00:07:44,189 --> 00:07:47,470
a personas. No 5 personas, 5 referencias a personas.

74
00:07:47,470 --> 00:07:54,759
igual la primera referencia a una persona está en la posición 0

75
00:07:54,759 --> 00:07:58,759
y precisamente utiliza la posición 40.000, a lo mejor, ¿vale?

76
00:08:06,189 --> 00:08:10,170
Para la posición 1 apunta a la 40.050, por ejemplo.

77
00:08:12,829 --> 00:08:15,470
Vamos a poner aquí 3 para no escribir tanto.

78
00:08:19,139 --> 00:08:24,019
Y a lo mejor la posición 40.002 apunta a la posición 100.

79
00:08:24,019 --> 00:08:27,000
no quiere decir que entre este

80
00:08:27,000 --> 00:08:29,360
40.000 y 40.050

81
00:08:29,360 --> 00:08:30,519
esté

82
00:08:30,519 --> 00:08:33,120
el nombre que tiene una persona

83
00:08:33,120 --> 00:08:34,799
no, esto es, será

84
00:08:34,799 --> 00:08:37,360
bueno, de hecho

85
00:08:37,360 --> 00:08:39,200
de forma inicial

86
00:08:39,200 --> 00:08:40,340
sería null

87
00:08:40,340 --> 00:08:43,039
posiblemente, no apuntarían a ninguna persona

88
00:08:43,039 --> 00:08:44,779
estos son, digamos

89
00:08:44,779 --> 00:08:46,960
punteros donde puede haber

90
00:08:46,960 --> 00:08:47,639
personas

91
00:08:47,639 --> 00:08:50,639
y luego si yo pongo aquí mi per

92
00:08:50,639 --> 00:08:54,809
0, igual

93
00:08:54,809 --> 00:09:06,190
esto en realidad empezaría apuntando a null, a ninguna persona en particular

94
00:09:06,190 --> 00:09:17,340
y cuando cojo y hago mi per new

95
00:09:17,340 --> 00:09:24,519
persona, aquí lo que haría el sistema operativo sería reservar espacio

96
00:09:24,519 --> 00:09:28,759
de memoria para una determinada persona, para una persona

97
00:09:28,759 --> 00:09:30,620
fijaros, esto es una persona en su conjunto

98
00:09:30,620 --> 00:09:35,259
los arrays se pueden poner los asteriscos aquí o aquí

99
00:09:35,259 --> 00:09:39,980
entonces fijaros, esto, si marcamos todo esto

100
00:09:39,980 --> 00:09:43,759
y leemos hacia la izquierda, esto es un array de personas

101
00:09:43,759 --> 00:09:46,220
y esto es una persona.

102
00:09:46,379 --> 00:09:48,500
Fijaros, hacia la izquierda me ha quedado persona solo.

103
00:09:48,980 --> 00:09:50,340
Entonces, si hacemos un new a esto,

104
00:09:50,860 --> 00:09:52,460
esto sí que me haría una reserva de memoria.

105
00:09:52,960 --> 00:09:54,960
Por ejemplo, en el 50.000

106
00:09:54,960 --> 00:10:00,299
y a partir de esta posición de memoria

107
00:10:00,299 --> 00:10:02,340
es donde podríamos poner el nombre de esta persona.

108
00:10:07,090 --> 00:10:07,850
A ver si lo explico.

109
00:10:10,269 --> 00:10:13,750
Un array, esto, sin hacer un new al array,

110
00:10:14,409 --> 00:10:16,850
es algo que va a terminar apuntando.

111
00:10:16,850 --> 00:10:21,029
imaginaos que es un puntero, con un dedito que señalamos algo, es algo

112
00:10:21,029 --> 00:10:24,950
que va a estar apuntando a una raíz de personas, pero no lo hemos hecho

113
00:10:24,950 --> 00:10:29,269
el new, para dimensionarlo, pues será algo que apuntará

114
00:10:29,269 --> 00:10:32,850
a una raíz de personas, cuando hacemos el new, lo que hacemos es

115
00:10:32,850 --> 00:10:36,110
definir, en este caso, tres variables

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

117
00:10:42,860 --> 00:10:47,179
persona, miper, pero no le hiciéramos el new

118
00:10:47,179 --> 00:10:51,159
miper2 y no le hiciéramos el new. Esto como no hemos hecho el new

119
00:10:51,159 --> 00:10:55,179
no tenemos espacio donde guardarle el nombre de esta persona

120
00:10:55,179 --> 00:10:59,299
miper2 pero en cambio tenemos un dedito que va a ser capaz

121
00:10:59,299 --> 00:11:02,600
de apuntar a un sitio donde finalmente va a haber una persona

122
00:11:02,600 --> 00:11:06,539
y cuando pongo miper2 igual a new

123
00:11:06,539 --> 00:11:11,340
persona estoy haciendo una reserva

124
00:11:11,340 --> 00:11:15,220
para un objeto de la clase persona que por ejemplo sea la posición

125
00:11:15,220 --> 00:11:23,139
60.000 y este punterito que antes todavía no habíamos asignado un valor y probablemente

126
00:11:23,139 --> 00:11:29,279
directamente valía nul empieza a valer 60.000 que es el punto donde va a empezar datos para

127
00:11:29,279 --> 00:11:39,460
una persona para la cual sí que hemos reservado espacio de memoria si me dicen por aquí que

128
00:11:39,460 --> 00:12:24,559
quieren participar a ver dime si no no no no no no no no no no no no no no la misma persona

129
00:12:24,559 --> 00:12:33,200
aquí hay un grupo de personas mira aquí estamos definiendo una variable pues si yo cojo y pongo

130
00:12:33,200 --> 00:12:52,009
int aquí no tienes un entero aquí lo que tiene son 10 enteros esto es un entero estos son 10 enteros

131
00:12:52,009 --> 00:13:14,389
esto voy a juntar las dos esto es una persona estos son punteros a tres personas para que sea

132
00:13:14,389 --> 00:13:17,509
equivalente este a este, si quitamos el new,

133
00:13:20,120 --> 00:13:23,779
esto es un puntero a una sola persona, igual que esto

134
00:13:23,779 --> 00:13:27,659
es una variable de un entero, esto son

135
00:13:27,659 --> 00:13:31,740
tres punteros a tres personas distintas, a José, Ana,

136
00:13:31,840 --> 00:13:35,960
Laura, igual que esto son diez variables enteras, diferentes

137
00:13:35,960 --> 00:13:40,039
cada una. Lo que pasa es que cuando trabajamos con un array, lo que compartimos

138
00:13:40,039 --> 00:13:43,779
es un nombre, digamos que pudiéramos para estas

139
00:13:43,779 --> 00:13:46,019
10 personas, hacer un grupo.

140
00:13:46,639 --> 00:13:48,000
Entonces, y a

141
00:13:48,000 --> 00:13:49,679
todas esas 10 personas las llamamos

142
00:13:49,679 --> 00:13:52,019
con un nombre en común. Pues este sería el nombre en común

143
00:13:52,019 --> 00:13:53,840
de esas 10 personas, pero esto

144
00:13:53,840 --> 00:13:55,940
no sería una persona con 3 atributos.

145
00:13:56,620 --> 00:13:57,700
Serían 3 personas

146
00:13:57,700 --> 00:13:59,960
y cada persona, cada una de esas 3 personas

147
00:13:59,960 --> 00:14:01,940
tendrán todos estos atributos.

148
00:14:02,059 --> 00:14:03,720
Los que estén definidos en la clase persona.

149
00:14:10,080 --> 00:14:13,779
No, no, pero...

150
00:14:13,779 --> 00:14:14,120
Sí.

151
00:14:56,539 --> 00:14:58,220
Dices... Me he quedado antes

152
00:14:58,220 --> 00:15:00,500
con lo que ha dicho. Afectos prácticos

153
00:15:00,500 --> 00:15:04,519
miper trabajas como un grupo de personas, pero no es que sea

154
00:15:04,519 --> 00:15:07,440
a efectos prácticos, o sea, que a efectos prácticos lógicamente

155
00:15:07,440 --> 00:15:10,000
trabajas así, es que es lo que es, un grupo de personas

156
00:15:10,000 --> 00:15:13,799
o sea, en ningún momento miper aquí es una persona

157
00:15:13,799 --> 00:15:16,639
es un array, un conjunto de personas

158
00:15:16,639 --> 00:15:27,820
bueno, es que

159
00:15:27,820 --> 00:15:31,919
perdona, un momentito, por si a lo mejor

160
00:15:31,919 --> 00:15:35,279
los matices, bueno, perdona por decir tu nombre que estamos con la grabación

161
00:15:35,279 --> 00:15:37,480
sí, sí, que

162
00:15:37,480 --> 00:15:43,019
es que mi per no es un objeto, mi per, mira, tú lee de aquí

163
00:15:43,019 --> 00:15:46,960
para ver lo que es mi per, vamos a leer hacia la izquierda, mi per es

164
00:15:46,960 --> 00:15:50,940
un array de personas, un array

165
00:15:50,940 --> 00:15:54,779
de objetos, mi per no es un objeto, es un array de objetos

166
00:15:54,779 --> 00:15:58,860
y un determinado valor de mi per

167
00:15:58,860 --> 00:16:02,360
o sea, si ponemos aquí mi per 0

168
00:16:02,360 --> 00:16:06,899
fíjate, considerando los corchetes

169
00:16:06,899 --> 00:16:10,379
leemos lo que aquí leemos de izquierda a derecha, vamos a leerlo

170
00:16:10,379 --> 00:16:13,399
aquí de derecha a izquierda, miper con el array, esto

171
00:16:13,399 --> 00:16:16,299
si es un objeto de una persona. Bueno, un objeto cuando

172
00:16:16,299 --> 00:16:18,919
le hagamos el new, de momento es una referencia a una persona.

173
00:16:19,740 --> 00:16:22,460
Pero miper no es un objeto de una persona, miper es

174
00:16:22,460 --> 00:16:24,960
un array de personas, un conjunto de personas.

175
00:16:26,259 --> 00:16:28,259
De hecho, tú no puedes poner,

176
00:16:28,480 --> 00:16:30,039
mira, si fuera una persona, miper,

177
00:16:31,059 --> 00:16:34,240
lo pudiéramos considerar esto como una persona, nos aceptaría

178
00:16:34,240 --> 00:16:38,440
aquí el id, poner mi per punto, porque si es una persona, llegar a los

179
00:16:38,440 --> 00:16:42,320
atributos de una persona. Nos permitiría poner mi per punto

180
00:16:42,320 --> 00:16:45,759
ese nombre, pero esto no existe. ¿Por qué? Porque

181
00:16:45,759 --> 00:16:50,500
un array de personas no es una

182
00:16:50,500 --> 00:16:53,100
persona. En cambio, si cogemos y decimos mi per

183
00:16:53,100 --> 00:16:58,460
mira, añado los corchetes, que si hacemos la lectura de aquí

184
00:16:58,460 --> 00:17:02,399
derecha e izquierda, fíjate como a la izquierda ya se me queda que esto es una persona

185
00:17:02,399 --> 00:17:04,180
y pongo punto, ese nombre

186
00:17:04,180 --> 00:17:06,200
sí que está. ¿Por qué? Porque mi per

187
00:17:06,200 --> 00:17:08,440
entre corchetes con un índice

188
00:17:08,440 --> 00:17:10,299
eso sí que es una persona en particular.

189
00:17:16,730 --> 00:17:17,250
Eso es. Bueno,

190
00:17:18,210 --> 00:17:19,750
sí, eso es. Un grupo de personas

191
00:17:19,750 --> 00:17:21,190
con un matiz

192
00:17:21,190 --> 00:17:24,069
que es lo otro que os he intentado

193
00:17:24,069 --> 00:17:26,190
contar, no sé si mejor o peor

194
00:17:26,190 --> 00:17:27,269
en el foro.

195
00:17:28,950 --> 00:17:30,029
Lo que estás creando

196
00:17:30,029 --> 00:17:32,210
aquí es un grupo

197
00:17:32,210 --> 00:17:34,170
nos olvidamos de esto por un

198
00:17:34,170 --> 00:17:36,009
momento, estás creando un grupo

199
00:17:36,009 --> 00:17:37,809
de referencias

200
00:17:37,809 --> 00:17:40,069
de deditos que apuntan

201
00:17:40,069 --> 00:17:41,809
a personas. Para

202
00:17:41,809 --> 00:17:43,769
llevárnoslo a un caso simple, si pones aquí mi

203
00:17:43,769 --> 00:17:44,930
per persona

204
00:17:44,930 --> 00:17:47,890
p

205
00:17:47,890 --> 00:17:49,809
y pones punto y coma y no

206
00:17:49,809 --> 00:17:51,869
haces el new, ¿p qué es?

207
00:17:52,289 --> 00:17:53,750
p va a ser algo

208
00:17:53,750 --> 00:17:55,589
que va a terminar apuntando en memoria RAM

209
00:17:55,589 --> 00:17:57,789
a donde vaya a existir en un futuro una persona

210
00:17:57,789 --> 00:17:59,930
pero como no hemos hecho el new, no lo hemos

211
00:17:59,930 --> 00:18:01,730
pedido al sistema operativo espacio

212
00:18:01,730 --> 00:18:04,069
para esa persona. Entonces esto inicialmente

213
00:18:04,069 --> 00:18:06,109
es como que no apunta a ningún sitio

214
00:18:06,109 --> 00:18:06,750
todavía.

215
00:18:07,809 --> 00:18:24,289
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.

216
00:18:25,109 --> 00:18:34,650
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.

217
00:18:34,650 --> 00:18:39,309
pues esto que todavía no es una persona que apunta null

218
00:18:39,309 --> 00:18:43,170
es un dedito que terminará apuntando una persona cuando tengamos espacio de memoria

219
00:18:43,170 --> 00:18:47,190
después de hacer el new, pues lo que estamos haciendo aquí es

220
00:18:47,190 --> 00:19:01,599
con esta instrucción, lo que estamos haciendo con esta

221
00:19:01,599 --> 00:19:05,019
expresión es crear, igual que aquí creamos

222
00:19:05,019 --> 00:19:09,420
con este new, creamos una persona a la cual

223
00:19:09,420 --> 00:19:13,200
apuntar algo que hasta este momento era

224
00:19:13,200 --> 00:19:18,160
era un dedito, aquí lo que estamos creando son tres deditos

225
00:19:18,160 --> 00:19:26,440
que apuntarán a tres personas, pero los tres apuntan

226
00:19:26,440 --> 00:19:30,200
a nulo. En este momento, mi per

227
00:19:30,200 --> 00:19:34,279
y entre corchetes cero es como si hubiéramos hecho esto con una variable normal.

228
00:19:34,759 --> 00:19:38,440
Mi per entre corchetes uno es como si hubiéramos hecho esto con una variable

229
00:19:38,440 --> 00:19:42,539
normal y mi per dos igualmente. Son tres

230
00:19:42,539 --> 00:19:46,200
punteros, pero para ninguna de esas tres personas hemos hecho una reserva de memoria.

231
00:19:46,200 --> 00:19:52,799
Hemos hecho aquí para un grupo de tres personas el equivalente a esto para una sola variable.

232
00:19:53,640 --> 00:20:03,559
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.

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

234
00:20:09,720 --> 00:20:37,480
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,

235
00:20:37,480 --> 00:20:40,700
aquí, lo que hemos hecho ha sido un grupito

236
00:20:40,700 --> 00:20:43,339
de 10, en este caso de 3, porque hemos dado

237
00:20:43,339 --> 00:20:46,500
dimensión de 3, de 3 punteros que van a apuntar

238
00:20:46,500 --> 00:20:49,660
a 3 personas distintas, el equivalente a esto

239
00:20:49,660 --> 00:20:51,640
¿cuándo lo tendremos que hacer? Pues si queremos

240
00:20:51,640 --> 00:20:55,220
para cada una de estas 3 personas sabemos que vamos a poder acceder

241
00:20:55,220 --> 00:20:57,200
a ellas a través de un nombre común

242
00:20:57,200 --> 00:21:00,359
la primera con el índice 0

243
00:21:00,359 --> 00:21:04,700
esto es un dedito que apunta a una persona igual que lo es

244
00:21:04,700 --> 00:21:09,119
fíjate como si leemos de izquierda a derecha y nos venimos a la definición

245
00:21:09,119 --> 00:21:12,940
de derecha a izquierda, eso ya es un punterito

246
00:21:12,940 --> 00:21:16,880
de una persona, entonces si hacemos aquí el new persona

247
00:21:16,880 --> 00:21:20,680
y ahora aquí sí que fíjate ponemos constructor, esto

248
00:21:20,680 --> 00:21:25,000
es esto, estamos reservando

249
00:21:25,000 --> 00:21:28,880
espacio de memoria para esta persona, igual que aquí

250
00:21:28,880 --> 00:21:31,720
lo hicimos para esta, hasta que no hemos hecho el new

251
00:21:31,720 --> 00:21:35,660
con el constructor de la clase persona,

252
00:21:36,039 --> 00:21:38,740
no hemos tenido espacio para poder trabajar con esa persona.

253
00:21:39,599 --> 00:21:42,000
Aquí, para la referencia p con una variable normal,

254
00:21:42,299 --> 00:21:45,619
aquí, para la referencia mi per cero,

255
00:21:46,420 --> 00:21:48,960
acordándonos que es una referencia a una persona.

256
00:21:48,960 --> 00:21:51,180
Este es el momento en el que ya tenemos para esta persona

257
00:21:51,180 --> 00:21:53,160
espacio de memoria reservada.

258
00:21:53,960 --> 00:21:54,079
Mira.

259
00:21:56,019 --> 00:21:56,980
Sí, dime.

260
00:21:59,000 --> 00:22:15,789
Ah, ajá.

261
00:22:15,789 --> 00:23:04,559
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?

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

263
00:23:13,380 --> 00:23:21,079
Cogíamos y decíamos persona, mi per 30 vamos a poner aquí, new persona.

264
00:23:23,940 --> 00:23:31,579
Para una variable que es referenciada, pues una variable de un objeto de una clase que hemos desarrollado nosotros en nuestro programa

265
00:23:31,579 --> 00:23:35,500
o que hemos incorporado desde las librerías, sí que necesitamos nosotros

266
00:23:35,500 --> 00:23:39,579
hacer el new obligatorio. Y luego había un caso intermedio, que son

267
00:23:39,579 --> 00:23:42,819
los strings, acordaros. Los strings son variables

268
00:23:42,819 --> 00:23:47,259
referenciadas, pero que tienen características, algunas de las características

269
00:23:47,259 --> 00:23:51,500
de las primitivas. En sí, si hay que decir que sí son una

270
00:23:51,500 --> 00:23:55,339
cosa u otra, son referenciadas, es cierto. De hecho, si tú defines un

271
00:23:55,339 --> 00:24:05,519
string, pues te permite incluso hacerle un new y

272
00:24:05,519 --> 00:24:07,539
compila, ¿ves? Y te permite

273
00:24:07,539 --> 00:24:09,539
también trabajar con ella sin hacerle

274
00:24:09,539 --> 00:24:11,299
el new, porque está un poco a medio

275
00:24:11,299 --> 00:24:13,339
camino entre las primitivas,

276
00:24:13,519 --> 00:24:15,900
como los enteros, y las referenciadas.

277
00:24:16,460 --> 00:24:17,660
Entonces, con tu array

278
00:24:17,660 --> 00:24:19,079
de strings, ¿qué es lo que ha pasado?

279
00:24:19,819 --> 00:24:21,420
Lo que ha pasado es que, igual

280
00:24:21,420 --> 00:24:23,339
que si haces un array de enteros,

281
00:24:24,559 --> 00:24:25,700
te funciona

282
00:24:25,700 --> 00:24:27,220
directamente sin hacer new, porque

283
00:24:27,220 --> 00:24:29,500
cada una de todas

284
00:24:29,500 --> 00:24:31,500
las referencias de este

285
00:24:31,500 --> 00:24:33,460
entero de jotas, no es

286
00:24:33,460 --> 00:24:35,200
necesario hacerle, bueno,

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

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

289
00:24:47,940 --> 00:24:52,740
Pero no hacemos un new para cada uno de los enteros. ¿Por qué? Porque para las variables ya no lo necesitamos.

290
00:24:52,740 --> 00:25:08,059
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.

291
00:25:08,779 --> 00:25:10,440
Esto, de hecho, ni nos deja.

292
00:25:10,660 --> 00:25:12,319
¿Por qué? Porque es primitiva y lo hace él solo.

293
00:25:13,859 --> 00:25:18,319
Para los strings, como están a medio camino entre las referenciadas y las primitivas,

294
00:25:18,940 --> 00:25:20,819
acuérdate que no es necesario hacerle un new.

295
00:25:20,940 --> 00:25:22,519
Entonces, como no es necesario hacerle un new,

296
00:25:22,519 --> 00:25:32,359
si tú coges y pones aquí string b igual a new string 2, por ejemplo,

297
00:25:33,900 --> 00:25:37,759
pues esto serían dos referencias a personas,

298
00:25:37,759 --> 00:25:52,380
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.

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

300
00:25:59,079 --> 00:26:03,960
Pero, para un objeto de la clase persona, que es un referenciado puro y sí que necesitamos el new,

301
00:26:04,740 --> 00:26:09,380
obligatoriamente tienes que hacer un new para cada uno de todos los objetos con los que trabajes.

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

303
00:26:55,119 --> 00:27:20,680
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?

304
00:27:20,680 --> 00:27:22,960
No, tú lo que tienes es un grupo de personas.

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

306
00:27:28,420 --> 00:27:30,339
Entonces, ¿cómo organizarías tú esto?

307
00:27:30,859 --> 00:27:34,599
Un poco olvidándonos de que vamos a programarlo en Java, pues dirías,

308
00:27:35,480 --> 00:27:37,839
pues mira, en el aula yo tengo un conjunto de personas.

309
00:27:39,099 --> 00:27:40,900
Ese conjunto de personas, ¿qué es lo que tienen?

310
00:27:41,119 --> 00:27:43,980
Tienen un nombre y un número de matrícula.

311
00:27:43,980 --> 00:27:58,740
¿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?

312
00:27:58,740 --> 00:28:05,039
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.

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

314
00:28:11,059 --> 00:28:26,460
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.

315
00:28:26,460 --> 00:28:29,180
bueno, como estabas teniendo ese problema y no eras capaz

316
00:28:29,180 --> 00:28:31,019
de resolverlo, pues me parece

317
00:28:31,019 --> 00:28:33,240
que practicando, pues me parece

318
00:28:33,240 --> 00:28:34,980
bien que hagas el intento de decir

319
00:28:34,980 --> 00:28:37,119
pues mira, el color de la placa o el color

320
00:28:37,119 --> 00:28:38,880
de frigorífico, la marca, bueno, como

321
00:28:38,880 --> 00:28:41,119
venga a ser, pues me lo llevo a una

322
00:28:41,119 --> 00:28:42,660
instancia más mayor, pero

323
00:28:42,660 --> 00:28:44,500
la marca de una placa

324
00:28:44,500 --> 00:28:46,980
pertenece a una placa, no

325
00:28:46,980 --> 00:28:48,680
pertenece a la cocina

326
00:28:48,680 --> 00:28:50,900
la cocina tiene las placas

327
00:28:50,900 --> 00:28:52,500
y las placas tienen su marca

328
00:28:52,500 --> 00:28:53,339
¿sabes?

329
00:28:54,759 --> 00:28:55,680
entonces

330
00:28:56,460 --> 00:29:17,480
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?

331
00:29:17,480 --> 00:29:21,720
tú tienes un aula donde hay personas, las personas tienen unas características

332
00:29:21,720 --> 00:29:25,880
y hacen una serie de cosas que son sus métodos, igual que está eso pues habrá

333
00:29:25,880 --> 00:29:29,519
un proyector, el proyector tendrá sus características y tendrá sus métodos

334
00:29:29,519 --> 00:29:34,119
entonces yo digo en el aula hay alumnos, defino alumnos

335
00:29:34,119 --> 00:29:38,299
en el aula hay un profesor, defino un profesor, en el aula hay un proyector, defino un proyector

336
00:29:38,299 --> 00:29:41,680
todos esos elementos pertenecen al aula, sí

337
00:29:41,680 --> 00:29:45,960
el proyector, los alumnos y el profesor, ahora el nombre de un

338
00:29:45,960 --> 00:29:52,079
alumno pertenece al aula para definirlo en una instancia mayor que es el aula? Pues no, el nombre

339
00:29:52,079 --> 00:29:56,440
del alumno pertenece a cada alumno. Entonces, si hemos definido un objeto alumno dentro de los

340
00:29:56,440 --> 00:30:03,099
alumnos, vamos a identificar esos alumnos. Mira, otra cosa que ayuda además a, que es simplemente

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

342
00:30:10,059 --> 00:30:15,619
piensa que estás haciendo un programa en el cual participa una persona que tiene un nombre y luego

343
00:30:15,619 --> 00:30:17,700
de repente dices, pues mira, esta clase de persona

344
00:30:17,700 --> 00:30:19,460
que la he probado en este proyecto me parece

345
00:30:19,460 --> 00:30:21,140
muy interesante cómo está trabajado

346
00:30:21,140 --> 00:30:23,339
y resulta que tengo que hacer otro proyecto

347
00:30:23,339 --> 00:30:25,519
este era de, yo qué sé qué decirte, de un

348
00:30:25,519 --> 00:30:27,759
campo de fútbol y ahora vas a hacer uno de tiendas

349
00:30:27,759 --> 00:30:29,500
pero dices, justo la

350
00:30:29,500 --> 00:30:31,559
definición de la clase de persona me viene muy

351
00:30:31,559 --> 00:30:33,079
bien para la clase de tiendas

352
00:30:33,079 --> 00:30:34,779
entonces si tú te vas a llevar

353
00:30:34,779 --> 00:30:37,259
todas las características

354
00:30:37,259 --> 00:30:39,200
de esa clase de persona de un proyecto a otro

355
00:30:39,200 --> 00:30:41,200
pues que te llevan la clase de persona

356
00:30:41,200 --> 00:30:43,119
que es la que está recogiendo las características

357
00:30:43,119 --> 00:30:44,619
y las acciones que hacen las personas

358
00:30:44,619 --> 00:30:55,079
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.

359
00:30:55,079 --> 00:31:26,009
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.

360
00:31:26,009 --> 00:31:38,160
imaginaros que tienes aquí un método que es public void saludar y yo conjo y tengo aquí un

361
00:31:38,160 --> 00:31:52,940
system punto out punto println y pongo aquí hola más imagínate que tengo aquí una variable ese

362
00:31:52,940 --> 00:32:05,579
saludo 2 entonces está ahora mismo no me compila porque esta variable no existe esta variable para

363
00:32:05,579 --> 00:32:11,950
que me compile, yo puedo definirla aquí, ya me compila, o puedo

364
00:32:11,950 --> 00:32:20,450
definirla aquí, en el ámbito local de esta clase, o la puedo

365
00:32:20,450 --> 00:32:24,670
definir como una variable de clase. ¿Dónde está más correcto

366
00:32:24,670 --> 00:32:30,369
definir esta variable? ¿Saludo2 es un atributo que caracterice

367
00:32:30,369 --> 00:32:34,670
a las personas o es una variable que parece que necesitamos

368
00:32:34,670 --> 00:32:37,369
de forma local para construir nuestro programa Java dentro

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

370
00:32:41,589 --> 00:32:45,450
Pues entonces, esta variable, donde hay que definirla, es aquí, porque aquí

371
00:32:45,450 --> 00:32:49,309
puedo tener otro método, que sea el método despedir,

372
00:32:56,660 --> 00:32:59,839
donde no tiene ningún sentido que exista una variable

373
00:32:59,839 --> 00:33:03,960
que sea saludo2. Esta variable es para un uso particular

374
00:33:03,960 --> 00:33:08,119
en un momento dado dentro del método saludar. Imagínate que aquí cogiésemos

375
00:33:08,119 --> 00:33:11,960
a través de un escáner el saludo que en verdad se va a sacar por

376
00:33:11,960 --> 00:33:15,599
pantalla. Esto no es una característica de las personas.

377
00:33:16,420 --> 00:33:19,900
Si tú pones esto aquí, el programa Java te compila

378
00:33:19,900 --> 00:33:23,619
un poquito algo parecido a lo que has necesitado hacer tú para resolver este

379
00:33:23,619 --> 00:33:27,299
problema que tenías. Pero aquí, por diseño, ¿está bien

380
00:33:27,299 --> 00:33:31,720
definida esta variable? No. Esta variable está bien definida aquí. Igual que el nombre, pues si

381
00:33:31,720 --> 00:33:35,359
parece correcto que esté aquí, porque sí que es algo que caracteriza a las personas.

382
00:33:40,390 --> 00:33:43,289
¿Sí? Bueno. Vale. Genial. Nada, nada.

383
00:33:43,289 --> 00:33:58,369
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.

384
00:33:58,369 --> 00:34:03,309
fijaros, aquí para comprobar de verdad

385
00:34:03,309 --> 00:34:07,009
que lo que hemos hecho ha sido en esta definición del array

386
00:34:07,009 --> 00:34:11,210
que fijaros, insisto, algo que nos puede mostrar que en verdad no hemos hecho reserva

387
00:34:11,210 --> 00:34:14,730
para el espacio de memoria RAM de las diferentes personas

388
00:34:14,730 --> 00:34:17,690
fijaros que aquí hay corchetes, en realidad no hay

389
00:34:17,690 --> 00:34:23,150
el constructor, no estamos llamados al constructor que es el que acompañamos a new cuando creamos

390
00:34:23,150 --> 00:34:26,650
espacio de memoria RAM para una determinada persona, aquí lo que estamos

391
00:34:26,650 --> 00:34:31,130
es con el new dimensionando el array, que es un array en este caso de punteros

392
00:34:31,130 --> 00:34:36,039
a personas. Entonces fijaros aquí

393
00:34:36,039 --> 00:34:40,280
para la persona 0 justo, una de las tres que se definen, al tener

394
00:34:40,280 --> 00:34:43,780
tamaño 3, estará mi per 0, mi per 1 y mi per 2

395
00:34:43,780 --> 00:34:48,000
para este sí que estamos haciendo una reserva de memoria RAM para esa persona en particular

396
00:34:48,000 --> 00:34:52,420
Entonces fijaros, si yo hago aquí un system.out.println

397
00:34:52,420 --> 00:34:55,780
de mi per 0, ese nombre

398
00:34:55,780 --> 00:35:02,849
es previsible que este no falle

399
00:35:02,849 --> 00:35:07,210
y es previsible que este falle. ¿Por qué?

400
00:35:07,349 --> 00:35:10,750
Porque para mi per 0 he hecho una reserva de memoria

401
00:35:10,750 --> 00:35:15,269
para esa persona aquí y para mi per 1 no la he hecho. Es verdad que existe esa

402
00:35:15,269 --> 00:35:19,289
referencia dada de alta en el array, pero no he hecho

403
00:35:19,289 --> 00:35:23,289
un new para esa persona en particular. Entonces fijaros

404
00:35:23,289 --> 00:35:27,369
como si ejecutamos esto, ¿veis? El programa

405
00:35:27,369 --> 00:35:35,940
me ha sacado un posición 0, dos puntos, es decir, ha ejecutado

406
00:35:35,940 --> 00:35:44,309
esta instrucción, me ha dicho que es null porque

407
00:35:44,309 --> 00:35:49,150
a esta variable no le hemos dado ningún valor, vamos a darle aquí un valor al constructor

408
00:35:49,150 --> 00:35:52,769
en el constructor, por ejemplo, vamos a decir

409
00:35:52,769 --> 00:36:04,099
public persona, vamos a hacer que todas las personas

410
00:36:04,099 --> 00:36:08,300
inicialmente tengan en este string algo que ponga sin nombre

411
00:36:08,300 --> 00:36:17,469
cuando llegamos al constructor damos al ese nombre

412
00:36:17,469 --> 00:36:23,570
un sin nombre para todo objeto que llame este constructor, que será lo que estará

413
00:36:23,570 --> 00:36:25,769
pasando aquí, entonces si hacemos esa ejecución

414
00:36:25,769 --> 00:36:29,969
fijaros como esta primera línea si funciona

415
00:36:29,969 --> 00:36:35,269
es capaz de mostrarme el nombre que es sin nombre porque no se lo hemos asignado

416
00:36:35,269 --> 00:36:38,130
tiene este valor porque se lo ha asignado aquí en el constructor

417
00:36:38,130 --> 00:36:42,130
pero cuando intentamos hacer este otro acceso

418
00:36:42,130 --> 00:36:47,070
en este en particular me pega un error, dice

419
00:36:47,070 --> 00:36:49,969
no puedo leer ese nombre porque

420
00:36:49,969 --> 00:36:52,150
mi per 1 es

421
00:36:52,150 --> 00:36:54,090
null. ¿Y por qué es null? Pues porque

422
00:36:54,090 --> 00:36:54,889
no le hemos hecho un new.

423
00:36:58,340 --> 00:37:00,440
¿Existe algo que apunta

424
00:37:00,440 --> 00:37:02,440
mi per 1 a lo que

425
00:37:02,440 --> 00:37:04,699
futuro será una persona? Sí, porque esto es

426
00:37:04,699 --> 00:37:06,059
un conjunto de

427
00:37:06,059 --> 00:37:07,820
punteros a personas.

428
00:37:09,159 --> 00:37:10,639
¿Pero existe la persona esa

429
00:37:10,639 --> 00:37:12,579
en particular? No, porque no le hemos hecho el new

430
00:37:12,579 --> 00:37:14,639
para ese puntero. Entonces, si yo

431
00:37:14,639 --> 00:37:16,099
cojo y pongo mi per 1

432
00:37:16,099 --> 00:37:17,039
new persona,

433
00:37:18,840 --> 00:37:19,500
ahora ya,

434
00:37:19,599 --> 00:37:21,440
Me funcionan los dos porque le he hecho el new.

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

436
00:37:39,429 --> 00:37:46,510
fijaros, podemos coger y hacer miper.eseNombre, vamos a decirle, vamos a darle un valor.

437
00:37:48,349 --> 00:37:49,429
Vamos a decirle que se llame no.

438
00:37:51,719 --> 00:37:53,179
Aquí lo tenemos completo, bien.

439
00:37:53,659 --> 00:38:03,579
Si yo ahora cojo y digo persona miper2, punto y coma, esto apuntará a null.

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

441
00:38:07,099 --> 00:38:11,579
es un puntero algo que será capaz de apuntar a una persona pero no hacerle el new

442
00:38:11,579 --> 00:38:15,239
no le ha asignado el sistema operativo una zona de memoria

443
00:38:15,239 --> 00:38:21,630
con lo cual en principio es null, si yo cojo y digo

444
00:38:21,630 --> 00:38:25,570
mi per 2 igual a mi per

445
00:38:25,570 --> 00:38:29,269
sin necesidad de hacerle el new

446
00:38:29,269 --> 00:38:33,190
mi per 2 ¿qué pasará a valer? pues pasará a valer

447
00:38:33,190 --> 00:38:44,429
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.

448
00:38:44,670 --> 00:38:53,809
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

449
00:38:53,809 --> 00:38:56,849
a partir de la zona del número 55.000.

450
00:38:57,769 --> 00:39:03,269
Mi per vale 55.000, que es el trocito a partir de donde van a guardar sus atributos.

451
00:39:03,889 --> 00:39:07,190
Aquí lo que estoy haciendo es mi per 2, que aquí valía nul,

452
00:39:07,469 --> 00:39:09,789
y el sistema operativo no le ha dado ningún espacio de memoria

453
00:39:09,789 --> 00:39:13,670
porque no le hemos hecho un new, le decimos que valga lo mismo que vale mi per.

454
00:39:14,010 --> 00:39:18,429
Entonces si yo cojo y hago eso, va a resultar que mi per 2 va a pasar a valer

455
00:39:18,429 --> 00:39:23,510
posición de memoria 55.000, donde sí que hay un trocito de memoria RAM

456
00:39:23,510 --> 00:39:26,590
reservado con datos de una persona, porque le hemos

457
00:39:26,590 --> 00:39:28,909
hecho este new, y en particular

458
00:39:28,909 --> 00:39:31,650
utilizando la referencia miper

459
00:39:31,650 --> 00:39:35,050
le hemos dado a su nombre noa, con lo cual a partir de

460
00:39:35,050 --> 00:39:38,469
55.000 habrá un trocito de memoria para el nombre, ese nombre

461
00:39:38,469 --> 00:39:41,650
que tendrá noa, y justo este mismo 55.000

462
00:39:41,650 --> 00:39:44,650
está compartido ahora por miper2, entonces si yo pongo

463
00:39:44,650 --> 00:39:47,429
aquí un system.out.println

464
00:39:47,429 --> 00:39:53,590
de miper2.ese

465
00:39:53,590 --> 00:39:56,429
nombre, el único

466
00:39:56,429 --> 00:40:05,889
system out es está referenciado a través de mi perdón yo cojo de aquí y me dice que es no aunque

467
00:40:05,889 --> 00:40:09,809
en realidad sólo habíamos aplicado a través de mi per pero como mi per apunta al mismo sitio que mi

468
00:40:09,809 --> 00:40:18,090
perdón o mi perdón se apunta al mismo que mi per pues ya funciona si yo cojo y comentó esto aquí

469
00:40:18,090 --> 00:40:24,789
mi perdón que es lo que vale bueno de hecho ni siquiera ya me deja aquí fijaros dice inicializa

470
00:40:24,789 --> 00:40:31,300
la variable. Vamos a inicializarla a nul. Como apunta

471
00:40:31,300 --> 00:40:35,059
a nul, no hemos hecho un new para que tenga su propio espacio de memoria y hemos

472
00:40:35,059 --> 00:40:38,659
quitado esta asignación, pues esto ahora me va a dar un error.

473
00:40:39,059 --> 00:40:43,340
¿Entiendo? ¿Veis? Me da una excepción, un null pointer excepción.

474
00:40:44,039 --> 00:40:45,780
Excepción de acceso a un puntero nulo.

475
00:40:46,739 --> 00:40:50,980
Porque mi per2 es nul, lo mismo que nos pasaba antes con los arrays.

476
00:40:56,230 --> 00:40:59,369
¿Alguna aclaración más con esto? ¿Necesitáis alguien por ahí?

477
00:40:59,369 --> 00:41:22,570
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.

478
00:41:22,570 --> 00:41:30,210
La verdad es que es algo en la que siempre, si fuese posible, uno empieza a pensar muchas alternativas.

479
00:41:31,610 --> 00:41:39,510
Entonces había algo como, se hacía algo así como string ese nombre de la variable.

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

481
00:41:53,809 --> 00:41:57,369
mientras y sea menor, por ejemplo, de tres

482
00:41:57,369 --> 00:41:59,750
y más más.

483
00:42:01,769 --> 00:42:04,889
Es decir, vamos a crear tres variables diferentes,

484
00:42:05,469 --> 00:42:09,469
algo que nos diera una funcionalidad del estilo de un array,

485
00:42:09,469 --> 00:42:13,170
un conjunto de variables, pero vamos a intentar

486
00:42:13,170 --> 00:42:17,469
automatizarlo con un bucle y que cada una de las variables tenga un nombre

487
00:42:17,469 --> 00:42:19,510
distinto. Entonces,

488
00:42:19,510 --> 00:42:23,550
lo que hacía por aquí era decir por ejemplo ese

489
00:42:23,550 --> 00:42:27,670
nombre var que sea igual

490
00:42:27,670 --> 00:42:33,929
al nombre más

491
00:42:33,929 --> 00:42:41,280
entonces como en cada una de las

492
00:42:41,280 --> 00:42:47,000
vueltas fijaros si ponemos aquí un system.out.println

493
00:42:47,000 --> 00:42:54,480
esta variable vamos a sacarlo por pantalla

494
00:42:54,480 --> 00:42:57,860
la ejecución del programa, fijaros que vale

495
00:42:57,860 --> 00:43:00,699
nombre 0, nombre 1, nombre 2, nombre siempre

496
00:43:00,699 --> 00:43:03,699
porque lo tengo aquí de forma literal puesto y luego

497
00:43:03,699 --> 00:43:06,760
en la iteración del bucle desde 0 hasta 2

498
00:43:06,760 --> 00:43:09,760
porque iteramos hasta que

499
00:43:09,760 --> 00:43:12,500
mientras i sea menor de 3

500
00:43:12,500 --> 00:43:15,519
pues me saca las tres alternativas, entonces

501
00:43:15,519 --> 00:43:18,699
lo que a alguien se le ocurría era decir

502
00:43:18,699 --> 00:43:21,559
pues mira, vamos a intentar darle estos nombres a través

503
00:43:21,559 --> 00:43:23,739
de un bucle y creo un grupo de personas

504
00:43:23,739 --> 00:43:28,159
entonces era poner algo aquí como persona

505
00:43:28,159 --> 00:43:32,739
e intentar darle el nombre de la variable

506
00:43:32,739 --> 00:43:36,000
que sabemos que está variando su valor

507
00:43:36,000 --> 00:43:39,420
¿qué es lo que sucede con esto? que cuando definimos una

508
00:43:39,420 --> 00:43:44,039
variable en el programa no me permite que ese nombre

509
00:43:44,039 --> 00:43:49,000
sea variable, tiene que ser un nombre constante, es igual que si

510
00:43:49,000 --> 00:43:52,659
sea para la clase persona o sea para un tipo primitivo

511
00:43:52,659 --> 00:44:05,099
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

512
00:44:05,099 --> 00:44:13,219
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

513
00:44:13,219 --> 00:44:17,300
de la clase persona es ese nombre par, lo que me está

514
00:44:17,300 --> 00:44:20,519
diciendo es, mira, ese nombre par, ese nombre var

515
00:44:20,519 --> 00:44:26,869
lo tienes definido en este ámbito aquí, o lo tienes definido

516
00:44:26,869 --> 00:44:31,250
en este ámbito aquí, en el mismo ámbito tienes definidas dos variables

517
00:44:31,250 --> 00:44:34,630
con el mismo nombre, que es igual que si intento hacer aquí int i

518
00:44:34,630 --> 00:44:38,769
y long i, pues me dice no, mira

519
00:44:38,769 --> 00:44:43,090
ya si tú asignas aquí un valor a i, no sé si

520
00:44:43,090 --> 00:44:45,030
se lo estás asignando a esta o a esta

521
00:44:45,030 --> 00:44:46,909
con lo cual directamente no dejo que compiles

522
00:44:46,909 --> 00:44:48,550
dos variables no se pueden llamar igual

523
00:44:48,550 --> 00:44:50,289
se llaman diferente y así me deja

524
00:44:50,289 --> 00:44:53,210
pues aquí al final lo que estamos haciendo es eso

525
00:44:53,210 --> 00:44:54,289
estamos dando

526
00:44:54,289 --> 00:44:55,730
a una variable

527
00:44:55,730 --> 00:44:58,889
de tipo string el nombre es en onBar

528
00:44:58,889 --> 00:45:00,929
y estamos dando a una variable de tipo

529
00:45:00,929 --> 00:45:03,210
persona, un objeto de la clase persona

530
00:45:03,210 --> 00:45:05,250
un mismo nombre

531
00:45:05,250 --> 00:45:06,550
entonces dice pues esto no me gusta

532
00:45:06,550 --> 00:45:08,030
y ya está

533
00:45:08,030 --> 00:45:12,420
que era otra de las alternativas que

534
00:45:12,420 --> 00:45:13,780
aparecían por ahí

535
00:45:13,780 --> 00:45:30,860
¿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.

536
00:45:30,860 --> 00:45:43,860
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.

537
00:45:45,320 --> 00:45:56,400
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.

538
00:45:56,400 --> 00:45:58,219
trabajaremos con las colecciones, ya veréis

539
00:45:58,219 --> 00:46:00,219
que nos dejan hacer cosas interesantes

540
00:46:00,219 --> 00:46:02,579
lo único que bueno

541
00:46:02,579 --> 00:46:04,280
pues los Arrays tienen como ventaja

542
00:46:04,280 --> 00:46:06,099
que proporcionan

543
00:46:06,099 --> 00:46:08,440
programas más eficientes

544
00:46:08,440 --> 00:46:10,579
si la solución se puede

545
00:46:10,579 --> 00:46:12,219
adaptar al Array que las colecciones

546
00:46:12,219 --> 00:46:14,179
pero bueno, conociendo las dos

547
00:46:14,179 --> 00:46:16,219
pues en cada caso utilizaremos una diferente

548
00:46:16,219 --> 00:46:18,460
según nos interese en cada momento

549
00:46:18,460 --> 00:46:23,019
bueno, esta era más o menos la segunda pregunta

550
00:46:23,019 --> 00:46:24,900
yo creo que teníamos por ahí

551
00:46:24,900 --> 00:47:16,500
pero

552
00:47:16,500 --> 00:47:30,300
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.

553
00:47:30,300 --> 00:47:45,659
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.

554
00:47:46,500 --> 00:48:10,079
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.

555
00:48:10,079 --> 00:48:31,460
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.

556
00:48:31,460 --> 00:48:58,000
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.

557
00:48:58,000 --> 00:49:21,500
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.

558
00:49:21,500 --> 00:49:25,840
Entonces, eso lo puedes hacer tú

559
00:49:25,840 --> 00:49:29,639
Tú puedes crear tu estructura en un array de los socios

560
00:49:29,639 --> 00:49:32,219
Pero para hacer esa comprobación en un array

561
00:49:32,219 --> 00:49:34,199
Tendrías que recorrer los socios

562
00:49:34,199 --> 00:49:36,380
Y comprobar que ya no está de alta

563
00:49:36,380 --> 00:49:38,039
En cambio, utilizando una colección

564
00:49:38,039 --> 00:49:40,900
Tú llamas a un método de un objeto de esa colección

565
00:49:40,900 --> 00:49:43,260
Y si estás utilizando la colección correcta

566
00:49:43,260 --> 00:49:44,380
Que no permite duplicados

567
00:49:44,380 --> 00:49:46,519
Pues directamente solo lo añades si no existe ya

568
00:49:46,519 --> 00:49:49,039
Ese código que hay en las librerías

569
00:49:49,039 --> 00:49:50,000
Hará esa comprobación

570
00:49:50,000 --> 00:49:51,139
Pues lo tiene que hacer

571
00:49:51,139 --> 00:50:08,599
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.

572
00:50:08,599 --> 00:50:27,179
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.

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

574
00:50:31,579 --> 00:50:39,619
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.

575
00:50:40,340 --> 00:50:48,039
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.

576
00:50:48,239 --> 00:50:50,260
Ya os digo, hay un tema en el que trabajaremos con esto.

577
00:50:50,260 --> 00:50:57,340
entonces para trabajar con grupos de objetos tenemos los arrays o las colecciones y esto que

578
00:50:57,340 --> 00:51:05,639
has visto de los mapas está colgando de las de la funcionalidad de colecciones así que lo veremos

579
00:51:05,639 --> 00:51:12,659
ya voy a cerrar la máquina virtual que si me deja cerrar eclipse no se ha quedado pillada voy a

580
00:51:12,659 --> 00:51:18,679
cerrar la máquina virtual y la arrancó de nuevo entonces pues bueno pues es una solución que sí

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

582
00:51:31,349 --> 00:52:09,500
¿dónde puedo cerrar yo la máquina? Uy, se ha quedado, no me da la opción, se ha quedado guardada, no me

583
00:52:09,500 --> 00:52:42,130
da la opción de apagarla por aquí y aquí está pillada. Bueno y vamos a comentar un poquito si

584
00:52:42,130 --> 00:52:44,989
os parece, si podemos dar por cerrado más o menos

585
00:52:44,989 --> 00:52:48,309
estas dos consultas que teníamos abiertas

586
00:52:48,309 --> 00:52:50,789
vamos a hablar un poquito de expresiones regulares

587
00:52:50,789 --> 00:52:53,909
que es algo totalmente nuevo

588
00:52:53,909 --> 00:53:04,739
que sí que aparece en este tema. Mira, las expresiones regulares

589
00:53:04,739 --> 00:53:08,019
no son una cosa exclusiva

590
00:53:08,019 --> 00:53:10,820
ni mucho menos de Java y lo que nos permite

591
00:53:10,820 --> 00:53:13,199
es manejar cadenas

592
00:53:13,199 --> 00:53:15,780
normalmente de caracteres

593
00:53:15,780 --> 00:53:25,599
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.

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

595
00:53:33,460 --> 00:53:44,380
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,

596
00:53:44,380 --> 00:54:08,539
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.

597
00:54:08,539 --> 00:54:35,179
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.

598
00:54:35,179 --> 00:54:56,110
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.

599
00:54:56,110 --> 00:55:01,300
a ver si la localizo por aquí, entre los papeles que tengo

600
00:55:01,300 --> 00:55:22,409
para iros contando, bueno, aquí en esta página

601
00:55:22,409 --> 00:55:26,969
pues se pueden poner la estructura regular que quieres comprobar, a ver cómo funciona

602
00:55:26,969 --> 00:55:30,650
y aquí ir poniendo textos para ir

603
00:55:30,650 --> 00:55:33,170
validándolo, mirad, por ejemplo

604
00:55:33,170 --> 00:55:38,349
cuando estamos trabajando con la sintaxis de las estructuras regulares

605
00:55:38,349 --> 00:55:42,710
pues hay un carácter, hay algo que te indica cualquier tipo de carácter

606
00:55:42,710 --> 00:55:46,389
que es el punto, entonces si yo pongo aquí ahora un texto

607
00:55:46,389 --> 00:55:50,690
pues fijaros como me está diciendo que la A

608
00:55:50,690 --> 00:55:54,269
lo cumple, que la B lo cumple, la C lo cumple, realmente

609
00:55:54,269 --> 00:55:57,869
un punto viene a significar cualquier cosa

610
00:55:57,869 --> 00:56:02,550
como cada una de las que lo cumplen pues me lo va poniendo en un color un poquito

611
00:56:02,550 --> 00:56:06,789
diferente, veis aquí azul más clarito, azul más oscuro, de nuevo va alternando

612
00:56:06,789 --> 00:56:10,929
azul claro y azul oscuro, cada uno de estos cumple este bloque

613
00:56:10,929 --> 00:56:30,300
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.

614
00:56:30,820 --> 00:56:42,260
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,

615
00:56:42,260 --> 00:56:46,420
porque hemos metido una condición más a la expresión regular que es

616
00:56:46,420 --> 00:56:51,440
que tenga el inicio y tenga un carácter

617
00:56:51,440 --> 00:56:55,300
antes, como no era el inicio, decía, pues mira, me vale cualquiera

618
00:56:55,300 --> 00:56:57,880
de todas ellas, en cambio si cojo y le digo

619
00:56:57,880 --> 00:57:03,380
el inicio, pues ya solamente me vale esta, ¿por qué? porque la B

620
00:57:03,380 --> 00:57:07,179
ya no cumple esa expresión regular, la expresión regular

621
00:57:07,179 --> 00:57:11,440
o la C o la D, la E o el 4, es, cumple la condición

622
00:57:11,440 --> 00:57:19,400
de que es un punto pero no de que se encuentra al principio si lo que quiero es identificar el

623
00:57:19,400 --> 00:57:25,980
inicio y el final el inicio se pone con el sombrerito este que es un carácter que tenemos

624
00:57:25,980 --> 00:57:32,980
justo a la derecha de la p y el final para el final se utiliza en la expresión regular el

625
00:57:32,980 --> 00:57:39,239
dólar entonces ahora lo que estamos diciendo es que quiero que me compruebe lo que hay aquí a

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

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

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

629
00:57:59,789 --> 00:58:04,489
Esta no cumple ni el inicio ni el final, y el 4 lo que no cumple es el inicio.

630
00:58:04,570 --> 00:58:08,250
Al inicio, el 4 no empieza, porque tiene todo esto por delante.

631
00:58:08,389 --> 00:58:09,909
Así que es cierto que es el último.

632
00:58:10,550 --> 00:58:13,409
Si lo dejamos aquí en uno, fijaros como ya sí que lo cumple.

633
00:58:14,130 --> 00:58:18,429
Tiene inicio, cualquier cosa y el final.

634
00:58:24,239 --> 00:58:32,519
Hay algunos caracteres que nos permiten ir manejándolo.

635
00:58:32,519 --> 00:58:42,900
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.

636
00:58:42,900 --> 00:59:15,690
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.

637
00:59:17,190 --> 00:59:46,730
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

638
00:59:47,190 --> 00:59:49,389
N veces, pues es cualquier número.

639
00:59:49,949 --> 00:59:53,050
Entonces fijaros como ya todo el rato la expresión regular se cumple.

640
00:59:58,489 --> 01:00:05,170
La interrogante era 0, 1, el más es 1, n, y el asterisco es 0, o n.

641
01:00:05,849 --> 01:00:10,510
Ahora metemos alguna cosilla más para ver bien la diferencia.

642
01:00:10,849 --> 01:00:11,909
0, o n veces.

643
01:00:16,739 --> 01:00:20,460
En la expresión regular también podemos poner valores en particular.

644
01:00:20,460 --> 01:00:43,139
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.

645
01:00:44,000 --> 01:00:47,679
Entonces fijaros, si ahora pongo aquí una A mayúscula, ya se cumple, ¿veis?

646
01:00:48,460 --> 01:00:54,039
Y como es o 0 o n veces, si yo quito todas, como es el asterisco, se sigue cumpliendo.

647
01:00:54,619 --> 01:00:55,320
0 o n veces.

648
01:00:56,059 --> 01:00:58,760
En este caso estaríamos con 0, en este caso estaríamos con 1,

649
01:00:59,980 --> 01:01:02,679
y en este caso con n hasta donde quisiéramos llegar.

650
01:01:03,000 --> 01:01:04,619
Fijaros, el espacio también le vale.

651
01:01:08,909 --> 01:01:12,190
Si yo pongo aquí, en lugar del asterisco, un más,

652
01:01:12,190 --> 01:01:17,010
el más hemos dicho que significa que a lo que antecede que es el punto

653
01:01:17,010 --> 01:01:20,949
aparezca una o n veces, entonces tenemos

654
01:01:20,949 --> 01:01:25,489
cierto que empieza por una A mayúscula, como indica aquí, si pusiéramos una A minúscula

655
01:01:25,489 --> 01:01:29,409
dejaría de cumplirse, ya no me la indica

656
01:01:29,409 --> 01:01:33,630
que es correcta, y luego como es uno o n veces

657
01:01:33,630 --> 01:01:36,590
con el más, estos son n, le vale

658
01:01:36,590 --> 01:01:42,800
esto es la A y uno, que le vale para el más

659
01:01:42,800 --> 01:02:00,239
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.

660
01:02:00,820 --> 01:02:03,519
Si ponemos un carácter, ya le vuelve a valer.

661
01:02:04,679 --> 01:02:09,079
Y la interrogante que decíamos antes, hemos dicho que era cero o n veces.

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

663
01:02:18,719 --> 01:02:21,320
pero si ponemos ya dos, pues ya no le vale.

664
01:02:22,099 --> 01:02:26,920
Tendríamos que manejarlo a través del más o del asterisco según nos interesase.

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

666
01:02:43,900 --> 01:02:54,219
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.

667
01:02:54,219 --> 01:02:58,400
Y tres caracteres. Y cualquier carácter tres veces.

668
01:02:58,400 --> 01:03:15,889
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í.

669
01:03:15,889 --> 01:03:30,369
si ponemos esta expresión regular

670
01:03:30,369 --> 01:03:31,710
lo que estamos diciendo es

671
01:03:31,710 --> 01:03:32,630
una A

672
01:03:32,630 --> 01:03:36,170
y en este caso es cualquier carácter

673
01:03:36,170 --> 01:03:38,989
entre 3 y 5 veces

674
01:03:38,989 --> 01:03:40,650
entonces tenemos la A

675
01:03:40,650 --> 01:03:42,550
y 1, 2, 3, 4

676
01:03:42,550 --> 01:03:44,170
pues bueno, está en el arranque ese que hemos dicho

677
01:03:44,170 --> 01:03:46,130
un quinto carácter también le valdría

678
01:03:46,130 --> 01:03:48,409
si metemos un sexto, ya no cumple la expresión

679
01:03:48,409 --> 01:03:51,639
3 todavía le vale

680
01:03:51,639 --> 01:03:52,820
fijaros la A

681
01:03:52,820 --> 01:03:54,940
1, 2, 3

682
01:03:54,940 --> 01:03:57,860
si quitamos otro más, ya no cumple la expresión

683
01:03:57,860 --> 01:04:03,889
si aquí quitamos el inicio y el final

684
01:04:03,889 --> 01:04:05,610
y mantenemos la expresión regular

685
01:04:05,610 --> 01:04:10,869
fijaros, esto le vale una A y tres caracteres

686
01:04:10,869 --> 01:04:13,389
una A y cuatro caracteres también le valdría

687
01:04:13,389 --> 01:04:16,030
y si ponemos algo aquí de antemano

688
01:04:16,030 --> 01:04:19,829
anterior, todos estos no lo cumplen

689
01:04:19,829 --> 01:04:22,969
pero como hemos quitado la condición de que fuese

690
01:04:22,969 --> 01:04:26,409
desde el principio, este bloque le sigue valiendo

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

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

693
01:04:39,070 --> 01:04:40,570
que es la propia expresión regular.

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

695
01:04:46,849 --> 01:04:52,309
Es decir, poner el inicio o el final nos marca que sea una expresión regular

696
01:04:52,309 --> 01:04:56,170
que cumple por completo la expresión regular, si indicamos

697
01:04:56,170 --> 01:04:59,769
principio y final, si ponemos solo principio, garantizar que

698
01:04:59,769 --> 01:05:04,389
la expresión regular empieza, el texto empieza por esa expresión regular

699
01:05:04,389 --> 01:05:08,429
y si ponemos el dólar, garantizamos que el texto finaliza

700
01:05:08,429 --> 01:05:12,329
con esa expresión regular. Si quitamos inicio y final, pues nos

701
01:05:12,329 --> 01:05:14,969
localiza todas las partes en el texto donde

702
01:05:14,969 --> 01:05:25,380
tenemos la expresión regular recogida. Mira, más cosas.

703
01:05:25,380 --> 01:05:30,219
imaginaos que tenemos que deciros

704
01:05:30,219 --> 01:05:33,519
que, por ejemplo, que queremos

705
01:05:33,519 --> 01:05:37,500
localizar la palabra

706
01:05:37,500 --> 01:05:42,860
que queremos localizar, alumno, en un texto

707
01:05:42,860 --> 01:05:49,449
simplemente poniendo como expresión regular

708
01:05:49,449 --> 01:05:52,869
un texto, esta clase

709
01:05:52,869 --> 01:06:02,619
hay muchos alumnos

710
01:06:02,619 --> 01:06:12,840
Ya veis que diferencia entre mayúsculas y minúsculas, alumnos y alumnas.

711
01:06:14,619 --> 01:06:19,579
Pues nada, fijaros que me ha localizado alumnos, pero no me ha localizado alumnas.

712
01:06:20,400 --> 01:06:22,300
¿Por qué? Porque es lo que he puesto aquí en la expresión regular.

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

714
01:06:29,739 --> 01:06:50,730
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.

715
01:06:50,730 --> 01:06:58,269
Entonces aquí decimos, tiene que poner alumn, n y una a, una o para que sea alumna o alumno

716
01:06:58,269 --> 01:07:01,769
y luego, bueno, por la s porque estamos hablando de mayúsculas.

717
01:07:02,469 --> 01:07:06,730
Entonces al poner la a y la o, fijaros como ya nos identifica a los dos.

718
01:07:07,389 --> 01:07:16,079
Podemos ponerlo de esta manera, con comas también.

719
01:07:16,079 --> 01:07:21,980
Imaginaos que tenemos alumnus también.

720
01:07:25,480 --> 01:07:30,539
Bueno, pues si tenemos varios lo podemos separar ahí por comas y sin comas también.

721
01:07:33,460 --> 01:07:53,070
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.

722
01:07:53,070 --> 01:07:57,010
entonces lo que podemos poner es un rango entre 5 y 8

723
01:07:57,010 --> 01:08:00,929
de esta forma, queda un poco raro poner aquí un número

724
01:08:00,929 --> 01:08:04,570
pero si ponemos un 6, fijaros, ponemos aquí un 8

725
01:08:04,570 --> 01:08:09,030
ponemos aquí un 5, de esta forma

726
01:08:09,030 --> 01:08:12,889
podemos identificar un rango, para no poner todos los valores

727
01:08:12,889 --> 01:08:17,350
individualmente que forman ese rango, si tenemos 20 caracteres

728
01:08:17,350 --> 01:08:21,130
y todos van consecutivos uno detrás de otro, pues podríamos

729
01:08:21,130 --> 01:08:25,130
poner desde la A a la P y no tener que poner A, B, C, D,

730
01:08:25,130 --> 01:08:29,229
F, G, H, I, J, K aquí todos. Mira, si ponemos aquí

731
01:08:29,229 --> 01:08:35,060
desde la A a la P, pues me valdría alumnas

732
01:08:35,060 --> 01:08:38,979
alumnus, que también está

733
01:08:38,979 --> 01:08:44,520
por ahí. No, alumno no está, está después de la P.

734
01:08:45,340 --> 01:08:48,420
OP, la O sí. Y en cambio, por ejemplo, la Z

735
01:08:48,420 --> 01:08:59,119
pues no le valdría. ¿Por qué? Porque no está en este rango. Más cosas por ahí

736
01:08:59,119 --> 01:09:12,880
de las expresiones regulares el inicio al final las llaves cualquier carácter el punto si lo que

737
01:09:12,880 --> 01:09:20,500
queremos es identificar algo dentro un corchete pero no decir que es que aparezca uno de esos

738
01:09:20,500 --> 01:09:25,439
caracteres en esa posición sino al contrario decir mira lo que no quiero es que aparezcan

739
01:09:25,439 --> 01:09:31,579
estos caracteres justo dentro del corchete podemos volver a utilizar el sombrerito el

740
01:09:31,579 --> 01:09:35,460
el mismo sombrerito que hemos puesto aquí para representar el inicio

741
01:09:35,460 --> 01:09:38,899
de la expresión regular, lo podemos poner aquí. Entonces, para hacer eso,

742
01:09:40,039 --> 01:09:44,560
si lo ponemos aquí, a ver, ahí lo tenemos el sombrerito.

743
01:09:45,159 --> 01:09:49,220
Ahora lo que hemos hecho ha sido invertir los caracteres que teníamos aquí.

744
01:09:49,220 --> 01:09:53,100
Es decir, lo que le estamos diciendo con el sombrerito es que estos caracteres

745
01:09:53,100 --> 01:09:57,140
justo no sean los que aparecen. Entonces, una vez que hemos puesto esto,

746
01:09:57,140 --> 01:10:00,279
fijaros como ya la A de alumnas

747
01:10:00,279 --> 01:10:03,479
que estaba dentro del bloque este que sí considerábamos válido

748
01:10:03,479 --> 01:10:05,819
ya no nos vale, la O tampoco

749
01:10:05,819 --> 01:10:08,880
porque lo estamos negando aquí y en cambio la Z

750
01:10:08,880 --> 01:10:12,260
que no pertenece a este rango ahora ya sí que le gusta

751
01:10:12,260 --> 01:10:15,119
entonces nos está marcando que la expresión regular se cumple

752
01:10:15,119 --> 01:10:17,880
para alum y con la Z

753
01:10:17,880 --> 01:10:21,260
pero ya no se cumple para alumnos y alumnas

754
01:10:21,260 --> 01:10:27,739
si lo que queremos es tener dos bloques

755
01:10:27,739 --> 01:10:31,520
para un determinado carácter, imaginaos que nos vale

756
01:10:31,520 --> 01:10:35,739
que ponga alumnas, alumnos con este rango

757
01:10:35,739 --> 01:10:39,760
de variables, pero queremos que pueda ser en mayúsculas o minúsculas

758
01:10:39,760 --> 01:10:44,180
pues un primer rango lo identificamos así y a continuación podemos poner aquí en mayúsculas

759
01:10:44,180 --> 01:10:49,340
un segundo rango, entonces ahora si aquí pongo

760
01:10:49,340 --> 01:10:53,439
aluv, la b mayúscula

761
01:10:53,439 --> 01:10:59,500
nb, a ver, pues también le vale

762
01:10:59,500 --> 01:11:13,880
¿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.

763
01:11:22,310 --> 01:11:36,670
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.

764
01:11:39,039 --> 01:11:44,220
Pues si queremos validar que una determinada variable tiene un número binario,

765
01:11:44,220 --> 01:11:57,399
pues podríamos decir que desde el principio y hasta el final todos sus valores sean 0 o 1.

766
01:11:59,359 --> 01:12:02,220
Pero claro, esto me está diciendo que un carácter sea 0 o 1.

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

768
01:12:09,159 --> 01:12:12,819
entonces, para considerar un número binario

769
01:12:12,819 --> 01:12:14,880
lo quiero considerar que

770
01:12:14,880 --> 01:12:18,739
tenga un número que no tenga ningún

771
01:12:18,739 --> 01:12:22,119
o sea, que no tenga ningún cero o ningún uno, lo consideramos como binario

772
01:12:22,119 --> 01:12:24,739
pues si que lo fuera así, podríamos poner aquí un asterisco

773
01:12:24,739 --> 01:12:27,859
entonces diríamos, esto lo considero

774
01:12:27,859 --> 01:12:29,199
el número binario vacío

775
01:12:29,199 --> 01:12:33,939
si tiene un solo carácter le vale, el asterisco recordad que era

776
01:12:33,939 --> 01:12:36,020
de cero a n

777
01:12:36,020 --> 01:12:37,979
entonces, todo ese le vale

778
01:12:37,979 --> 01:12:42,439
y si el vacío no lo quiero considerar como un número binario

779
01:12:42,439 --> 01:12:45,539
porque es como que no lo has incluido a la hora de valorar la expresión regular

780
01:12:45,539 --> 01:12:46,560
le puedo poner una más

781
01:12:46,560 --> 01:12:50,140
entonces en cuanto tenga un 0 o un 1 ya le vale

782
01:12:50,140 --> 01:12:52,739
fijaros como el 0 aquí aunque esté vacío

783
01:12:52,739 --> 01:12:55,140
me marca aquí que está cumpliendo la expresión regular

784
01:12:55,140 --> 01:12:56,399
lo veis aquí en el rosita

785
01:12:56,399 --> 01:12:59,000
pero si le pongo el más

786
01:12:59,000 --> 01:13:00,920
ya no está cumpliendo la expresión regular

787
01:13:00,920 --> 01:13:04,199
porque tiene que tener al menos una vez el 0 o el 1

788
01:13:04,199 --> 01:13:07,579
entonces yo pongo aquí ya cualquier número y ya le vale

789
01:13:07,579 --> 01:13:15,199
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.

790
01:13:19,819 --> 01:13:24,779
Imaginaos que en la expresión regular quiero asegurarme que sea un número en sí.

791
01:13:25,119 --> 01:13:26,619
Pues yo puedo coger y poner aquí.

792
01:13:28,180 --> 01:13:31,960
Podría poner que vaya entre 0 y 9, ese número.

793
01:13:33,779 --> 01:13:36,460
Entonces, cualquier combinación de números le vale.

794
01:13:37,460 --> 01:13:39,420
Cuanto meto una letra, pues ya no le gusta.

795
01:13:39,420 --> 01:13:49,260
esto tiene un atajo si son todos los números que es poner barra de de minúscula veis y ya pues le

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

797
01:13:59,890 --> 01:14:06,390
mayúscula lo que hace es indicar que al contrario que lo que tienes ahí dentro no sea un número

798
01:14:06,390 --> 01:14:11,149
cualquier cosa excepto un número entonces como esto tiene números le vale pero si ahora yo pongo

799
01:14:11,149 --> 01:14:16,390
aquí ya empieza a cumplirlo incluso espacios caracteres lo que sea mientras en el momento

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

801
01:14:29,850 --> 01:14:35,869
situaciones no vamos a pues que para validar ir jugando con las diferentes combinaciones que

802
01:14:35,869 --> 01:14:40,949
tenemos en la sintaxis estoy contando algunas en creo que en el aula virtual bueno pues aparecen

803
01:14:40,949 --> 01:14:42,869
alguna más. Con la W

804
01:14:42,869 --> 01:14:45,010
lo que te

805
01:14:45,010 --> 01:14:46,390
dice es que

806
01:14:46,390 --> 01:14:48,909
ahí, W

807
01:14:48,909 --> 01:14:49,590
minúscula.

808
01:14:50,850 --> 01:14:52,909
Lo que te dice es que, barra W,

809
01:14:53,090 --> 01:14:55,130
perdón, lo que te dice es que este carácter

810
01:14:55,130 --> 01:14:56,850
puede ser

811
01:14:56,850 --> 01:14:58,810
o bien un dígito numérico o una

812
01:14:58,810 --> 01:15:00,369
letra, pero no un símbolo.

813
01:15:00,890 --> 01:15:02,710
Entonces, si yo pongo aquí, si es lo que quiero

814
01:15:02,710 --> 01:15:05,109
valorar, ¿veis? A esto le gusta,

815
01:15:05,270 --> 01:15:06,890
minúsculas también. Ahora, si

816
01:15:06,890 --> 01:15:08,789
pongo algo que

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

818
01:15:12,529 --> 01:15:16,630
tampoco, el punto tampoco, y si utiliza

819
01:15:16,630 --> 01:15:21,189
la W mayúscula, pues lo que hace es

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

821
01:15:26,050 --> 01:15:29,949
eran los números y la D mayúscula era lo contrario a los números

822
01:15:29,949 --> 01:15:34,029
la W mayúscula pues lo invierte, entonces le vale la expresión regular

823
01:15:34,029 --> 01:15:38,270
cualquier cosa, siempre y cuando no sean ni números

824
01:15:38,270 --> 01:15:42,670
ni caracteres alfanuméricos

825
01:15:42,670 --> 01:15:46,149
en general. Entonces, a este no le gusta, fijaros

826
01:15:46,149 --> 01:15:49,109
si pongo solo números, tampoco

827
01:15:49,109 --> 01:15:53,569
aún poniendo solo letras, tampoco, pero si pongo solamente

828
01:15:53,569 --> 01:15:57,729
caracteres que no sean alfanuméricos, perdón, he puesto números ahora

829
01:15:57,729 --> 01:16:01,970
pues ya sí le gusta. ¿Por qué? Porque hemos puesto en la expresión regular la W.

830
01:16:07,449 --> 01:16:09,250
Imaginaos que queremos tener

831
01:16:09,250 --> 01:16:12,210
un número

832
01:16:12,210 --> 01:16:14,970
que permita tener decimales

833
01:16:14,970 --> 01:16:16,770
o no decimales. Entonces podríamos

834
01:16:16,770 --> 01:16:21,819
decir números decimales

835
01:16:21,819 --> 01:16:23,340
que tenga al menos un dígito

836
01:16:23,340 --> 01:16:25,399
y después de este bloque, que sea

837
01:16:25,399 --> 01:16:26,859
números decimales que tenga un dígito,

838
01:16:27,800 --> 01:16:29,119
podemos decir que si hay

839
01:16:29,119 --> 01:16:34,239
decimales, solamente

840
01:16:34,239 --> 01:16:36,119
aparezca el punto que

841
01:16:36,119 --> 01:16:38,039
separa la parte entera de la parte decimal

842
01:16:38,039 --> 01:16:40,199
en caso de que haya decimales, pero podemos

843
01:16:40,199 --> 01:16:42,319
poner números que no tengan decimales.

844
01:16:42,500 --> 01:16:43,260
Entonces podríamos poner

845
01:16:43,260 --> 01:16:47,720
para todo el bloque de los decimales, ponemos aquí algo

846
01:16:47,720 --> 01:16:51,560
vamos a poner entre paréntesis

847
01:16:51,560 --> 01:16:56,260
y decirle que esto que pongamos aquí dentro

848
01:16:56,260 --> 01:16:59,659
ahora lo rellenamos, puede aparecer o no. Entonces

849
01:16:59,659 --> 01:17:04,300
si no aparece, bien, y si aparece, lo primero que se encontrará será un punto

850
01:17:04,300 --> 01:17:08,159
pero si ponemos un punto es cualquier cosa. Para utilizar el punto

851
01:17:08,159 --> 01:17:11,180
en sí tenemos que escaparlo. Decimos que sea un punto

852
01:17:11,180 --> 01:17:13,779
verdad, esto era el carácter de cualquier cosa

853
01:17:13,779 --> 01:17:14,960
esto

854
01:17:14,960 --> 01:17:16,300
el punto

855
01:17:16,300 --> 01:17:19,560
y luego si aparece el punto

856
01:17:19,560 --> 01:17:21,680
sí que vamos a necesitar que aparezca

857
01:17:21,680 --> 01:17:23,159
al menos un dígito

858
01:17:23,159 --> 01:17:24,659
entonces le podemos poner aquí

859
01:17:24,659 --> 01:17:27,739
entre corchetes que aparezca un dígito

860
01:17:27,739 --> 01:17:29,300
y vamos a decir por ejemplo

861
01:17:29,300 --> 01:17:31,319
que solo tenga hasta tres decimales

862
01:17:31,319 --> 01:17:35,920
como mucho, que vaya entre uno

863
01:17:35,920 --> 01:17:37,079
y tres

864
01:17:37,079 --> 01:17:40,239
vamos a probar a ver si nos funciona

865
01:17:40,239 --> 01:17:42,180
ponemos cero

866
01:17:42,180 --> 01:17:46,479
punto, bueno, 0 le gusta, es decir, todo este bloque

867
01:17:46,479 --> 01:17:52,789
como esto puede aparecer o no aparecer, en este caso no está apareciendo y ya le gusta

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

869
01:17:56,590 --> 01:18:00,569
este punto, es cierto, pero aquí le estoy diciendo que aparezca

870
01:18:00,569 --> 01:18:03,829
entre 1 y 3 decimales, le digo 0,3

871
01:18:03,829 --> 01:18:08,750
2,4, vale, pues ahí está, y si pongo otro más, ya no le gusta

872
01:18:08,750 --> 01:18:19,989
pues vamos a pasar al código, para

873
01:18:19,989 --> 01:18:23,010
hacer y os enseño cómo integrarlo dentro de Java

874
01:18:23,010 --> 01:18:27,289
hasta donde nos dé tiempo. No sé si nos va a dar tiempo del todo.

875
01:18:28,310 --> 01:18:31,630
Bueno, aquí según la síntesis de las expresiones regulares

876
01:18:31,630 --> 01:18:35,149
se pueden validar un montón de cosas. Os cuento un poco ahí

877
01:18:35,149 --> 01:18:39,750
en la teoría. Si tenéis dudas, abrid un hilo

878
01:18:39,750 --> 01:18:43,729
y vamos comentándolo en el aula virtual. Voy a pasar al otro lado para que nos dé tiempo

879
01:18:43,729 --> 01:18:47,050
a ver cómo las expresiones regulares las podemos incorporar al código.

880
01:18:49,600 --> 01:18:50,739
Entonces, nos venimos por aquí.

881
01:18:51,619 --> 01:19:11,409
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.

882
01:19:11,409 --> 01:19:14,750
fijaros, o que estáis incluso viendo este tema

883
01:19:14,750 --> 01:19:18,029
antes de ir a las propias

884
01:19:18,029 --> 01:19:20,529
librerías que están para las expresiones regulares

885
01:19:20,529 --> 01:19:23,789
vamos a definir una variable aquí

886
01:19:23,789 --> 01:19:29,229
y vamos a meterle aquí un

887
01:19:29,229 --> 01:19:31,829
contenido, por ejemplo vamos a poner

888
01:19:31,829 --> 01:19:36,250
1 y vamos a utilizar

889
01:19:36,250 --> 01:19:38,630
las zetas para luego meterlo en las expresiones regulares

890
01:19:38,630 --> 01:19:40,949
vamos a poner 1, zeta, zeta, aquí dos zetas

891
01:19:40,949 --> 01:19:43,310
2, vamos a poner una zeta mayúscula

892
01:19:43,310 --> 01:19:53,279
vamos a poner varias zetas, este texto, imaginaos que tenemos

893
01:19:53,279 --> 01:19:56,520
en una variable un texto de este tipo, y luego

894
01:19:56,520 --> 01:20:01,319
podemos utilizar en algunos de los métodos que tenemos disponibles en Java

895
01:20:01,319 --> 01:20:05,180
ya directamente, cuando en Eclipse busquéis las opciones

896
01:20:05,180 --> 01:20:08,899
de métodos que os proporcionan, veréis que algunos de los métodos permiten

897
01:20:08,899 --> 01:20:13,479
recibir como parámetro expresiones regulares, una de ellas

898
01:20:13,479 --> 01:20:17,239
en la siguiente, fijaros, imaginaos que tenemos aquí, definimos un string

899
01:20:17,239 --> 01:20:21,260
vamos a poner sres, lo podemos llamar

900
01:20:21,260 --> 01:20:25,199
que lo queremos cargar con información de ese info

901
01:20:25,199 --> 01:20:28,640
si pusiéramos ese info, pues nos cargaría

902
01:20:28,640 --> 01:20:32,659
en sres esto, pero queremos esto, pero modificado

903
01:20:32,659 --> 01:20:37,300
bajo ciertas características, y vamos para ello a definir una expresión

904
01:20:37,300 --> 01:20:40,479
regular, entonces podemos utilizar el método replace

905
01:20:40,479 --> 01:20:45,180
replace all, por ejemplo, y fijaros como aquí el replace all

906
01:20:45,180 --> 01:20:48,699
me ofrece una expresión regular como primer parámetro.

907
01:20:50,460 --> 01:20:52,500
Replace first, replace all

908
01:20:52,500 --> 01:20:57,119
sustituirá todas las ocurrencias de la expresión regular por el texto

909
01:20:57,119 --> 01:21:01,180
que pongamos aquí. Replace first, pues sustituirá la primera

910
01:21:01,180 --> 01:21:05,060
aparición de algo del texto de la expresión regular por lo que

911
01:21:05,060 --> 01:21:09,159
pongamos aquí. Vamos a utilizar un replace all. Entonces, decimos

912
01:21:09,159 --> 01:21:15,270
aquí era donde me indicaba, me pedía la expresión regular, entonces aquí podemos poner

913
01:21:15,270 --> 01:21:23,020
como expresión regular, por ejemplo, podemos decir

914
01:21:23,020 --> 01:21:27,239
aquí, que me sustituya la Z

915
01:21:27,239 --> 01:21:35,319
o la Z, si aparece una o más veces

916
01:21:35,319 --> 01:21:38,180
por el texto

917
01:21:38,180 --> 01:21:54,390
cambio. ¿Qué es lo previsible? Pues que a esta información

918
01:21:54,390 --> 01:21:58,729
va a aplicarle esta expresión regular y donde la encuentre va a sustituir

919
01:21:58,729 --> 01:22:08,119
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,

920
01:22:09,340 --> 01:22:16,439
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,

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

922
01:22:23,319 --> 01:22:30,560
Entonces es previsible que esto me lo sustituya por la palabra cambio, que esto me lo sustituya por la palabra cambio

923
01:22:30,560 --> 01:22:34,000
y que esto me lo sustituya por la palabra cambio y lo cargue aquí.

924
01:22:34,619 --> 01:22:36,899
Si hacemos esta ejecución, vamos a ver si de verdad lo hace.

925
01:22:38,340 --> 01:22:40,920
Mirad, lo veis aquí. Me ha efectuado el cambio.

926
01:22:41,600 --> 01:22:44,520
¿Qué es lo que ha cambiado? Pues lo que hemos puesto aquí en una expresión regular.

927
01:22:45,140 --> 01:22:48,279
¿Qué expresión regular nos podemos poner aquí? Pues todas las que estábamos viendo

928
01:22:48,279 --> 01:22:51,319
en el documento.

929
01:22:52,659 --> 01:22:55,899
En el documento, en la web, está en la reges 101.

930
01:23:04,899 --> 01:23:06,359
¿Lo ha cambiado todas? Mira.

931
01:23:06,359 --> 01:23:09,760
dices, si aparece dos veces Z

932
01:23:09,760 --> 01:23:11,439
que pusiera dos veces cambio

933
01:23:11,439 --> 01:23:17,729
no, porque he puesto aquí esto

934
01:23:17,729 --> 01:23:19,229
si quito el más

935
01:23:19,229 --> 01:23:20,789
mira, si quito el más

936
01:23:20,789 --> 01:23:26,680
me aparece cambio, cambio dos veces, porque aquí lo que le estoy

937
01:23:26,680 --> 01:23:28,199
diciendo es que cuando aparezca una Z

938
01:23:28,199 --> 01:23:30,579
una Z mayúscula, que me lo ponga por cambio

939
01:23:30,579 --> 01:23:32,560
pero si le pongo esto, lo que le estoy diciendo

940
01:23:32,560 --> 01:23:33,840
en la expresión regular es que

941
01:23:33,840 --> 01:23:36,640
cuando aparezca esto, una o

942
01:23:36,640 --> 01:23:38,880
n veces, que aplique el cambio

943
01:23:38,880 --> 01:23:40,640
entonces, me aplica esto

944
01:23:40,640 --> 01:23:42,800
mira

945
01:23:42,800 --> 01:24:15,899
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.

946
01:24:15,899 --> 01:24:51,640
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,

947
01:24:51,659 --> 01:24:55,680
un campo, pues entonces utilizas el dato del pattern matcher

948
01:24:55,680 --> 01:24:59,199
este, que ahora a ver si nos da tiempo a desarrollarlo un poquito

949
01:24:59,199 --> 01:25:03,119
pues para hacer la comprobación de si está y validar si

950
01:25:03,119 --> 01:25:06,380
se ha ido correcto o no ha ido correcto, o sea, si el dato

951
01:25:06,380 --> 01:25:10,439
que estás validando responde a la expresión regular

952
01:25:10,439 --> 01:25:15,340
este método, el replace all de la clase

953
01:25:15,340 --> 01:25:18,180
string, bueno, pues nos ofrece esta posibilidad también

954
01:25:18,180 --> 01:25:21,399
pero no sustituye a la otra necesariamente

955
01:25:21,399 --> 01:25:24,720
sí

956
01:25:24,720 --> 01:25:43,350
pues

957
01:25:43,350 --> 01:25:44,949
claro

958
01:25:44,949 --> 01:25:53,810
bueno, que solamente

959
01:25:53,810 --> 01:25:54,569
sea dos

960
01:25:54,569 --> 01:26:03,189
ah bueno, si solo es una

961
01:26:03,189 --> 01:26:05,229
lo que puedes hacer aquí es poner la expresión regular

962
01:26:05,229 --> 01:26:07,109
de esta forma

963
01:26:07,109 --> 01:26:09,229
decir que la expresión regular

964
01:26:09,229 --> 01:26:10,210
a ver

965
01:26:10,210 --> 01:26:13,069
mira, lo que quieres decir tú

966
01:26:13,069 --> 01:26:15,310
yo creo que es esto, cuando aparezca dos

967
01:26:15,310 --> 01:26:16,729
coma

968
01:26:16,729 --> 01:26:21,859
yo creo que asterisco o sin nada, me parece que sin nada

969
01:26:21,859 --> 01:26:25,460
esto lo que quiere decir es que cuando aparezca dos veces o todas las que sean

970
01:26:25,460 --> 01:26:30,039
quiero que me lo cambies por una Z, lo único que aquí es cierto que te va a cambiar

971
01:26:30,039 --> 01:26:35,630
la mayúscula y la minúscula, ¿vale? por una Z, entonces decimos

972
01:26:35,630 --> 01:26:39,829
ejecutamos aquí, ¿ves? y ahora ya

973
01:26:39,829 --> 01:26:44,050
me deja aquí una Z, esta no la toca, porque está una Z

974
01:26:44,050 --> 01:26:47,829
solo, ¿ves? he puesto que sustituya por una Z minúscula

975
01:26:47,829 --> 01:27:02,829
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.

976
01:27:02,829 --> 01:27:18,729
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.

977
01:27:18,729 --> 01:27:34,010
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.

978
01:27:34,010 --> 01:27:55,939
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.

979
01:27:55,939 --> 01:28:08,000
si queremos considerar un punto

980
01:28:08,000 --> 01:28:12,180
en el hola, si pusiéramos esto, esto significaría

981
01:28:12,180 --> 01:28:16,000
cualquier carácter, entonces hay que escapar esto, en el aula virtual

982
01:28:16,000 --> 01:28:19,699
en la página web que hemos visto antes, hemos puesto este carácter

983
01:28:19,699 --> 01:28:24,079
pero si ponemos un solo carácter, se nos queja a la hora de escaparlo

984
01:28:24,079 --> 01:28:28,199
entonces aquí en Java tenemos que poner dos caracteres, esto lo que estamos diciendo es que

985
01:28:28,199 --> 01:28:32,220
esto lo considere como un punto, que si lo dejamos

986
01:28:32,220 --> 01:28:35,579
así, por tratarse de una expresión regular, va a considerar cualquier palabra.

987
01:28:36,319 --> 01:28:39,680
Si lo mantenemos así, pues expresiones que serían válidas serían

988
01:28:39,680 --> 01:28:43,680
hola z, ¿por qué? Porque la z lo considera un punto.

989
01:28:44,800 --> 01:28:48,100
También valdría hola porque hemos dicho que considere

990
01:28:48,100 --> 01:28:51,920
esto la h mayúscula y minúscula

991
01:28:51,920 --> 01:28:55,880
j, valdría también. Si lo que queremos es

992
01:28:55,880 --> 01:28:59,800
considerar que sea un punto, tenemos que escaparlo. Como Java no lo deja,

993
01:28:59,800 --> 01:29:02,899
lo escapamos dos veces, esto es una cuestión de Java del doble escape

994
01:29:02,899 --> 01:29:06,840
en la página web pusimos un escape solo

995
01:29:06,840 --> 01:29:12,560
entonces estas expresiones ahora ya no serían válidas porque serían válidas esta

996
01:29:12,560 --> 01:29:19,500
y sería válida esta, entonces vamos a utilizar

997
01:29:19,500 --> 01:29:23,619
la expresión regular para hacer ahí varias pruebas en las cuales

998
01:29:23,619 --> 01:29:27,520
ponga hola y acabe con un punto y vamos a decir que el punto

999
01:29:27,520 --> 01:29:33,970
sea opcional para que también me valga hola y hola

1000
01:29:33,970 --> 01:29:37,869
¿Vale? Eso en cuanto a la expresión. Y ahora vamos a definir aquí

1001
01:29:37,869 --> 01:29:40,949
un string, ese cadena. Esta es la que vamos a ir validando.

1002
01:29:44,270 --> 01:29:50,819
Vamos a poner, por ejemplo, hola de inicio aquí. ¿Cómo construimos

1003
01:29:50,819 --> 01:29:55,399
una validación con las clases pattern

1004
01:29:55,399 --> 01:29:59,319
y matcher, que son dos clases que tenemos disponibles en la librería de Java para trabajar

1005
01:29:59,319 --> 01:30:03,439
con las expresiones regulares? Pues primero definimos

1006
01:30:03,439 --> 01:30:07,239
un objeto de la clase pattern. Y hacemos uso

1007
01:30:07,239 --> 01:30:13,260
de un método estático que tiene, que es, y como es estático, fijaros,

1008
01:30:13,340 --> 01:30:19,840
que ponemos pattern punto algo, y lo que hacemos es compilar la expresión.

1009
01:30:23,020 --> 01:30:29,539
Y aquí, digamos que estamos definiendo el patrón que vamos a utilizar

1010
01:30:29,539 --> 01:30:33,199
como expresión regular, que la tenemos identificada en este string.

1011
01:30:34,340 --> 01:30:38,739
Ahí lo tenemos. Fijaros cómo Eclipse me ha incluido de la librería Java

1012
01:30:38,739 --> 01:30:45,029
Bautil-Reyes, la clase Pattern. A partir de aquí definimos

1013
01:30:45,029 --> 01:30:47,770
un objeto de la clase Matcher

1014
01:30:47,770 --> 01:30:56,840
y este objeto en lugar de hacerle un new lo que hacemos

1015
01:30:56,840 --> 01:31:00,880
es obtener la referencia del objeto

1016
01:31:00,880 --> 01:31:06,090
M desde el patrón

1017
01:31:06,090 --> 01:31:11,350
punto, llamamos al método Matcher que tiene y aquí

1018
01:31:11,350 --> 01:31:15,810
lo que le pasamos al Matcher es la cadena

1019
01:31:15,810 --> 01:31:19,829
que queremos validar. Al pattern con el método compiler le pasamos

1020
01:31:19,829 --> 01:31:23,810
la expresión regular. Al matcher, a través de este método del pattern,

1021
01:31:25,170 --> 01:31:27,210
le pasamos la que queremos

1022
01:31:27,210 --> 01:31:36,560
utilizar. Aquí, matcher con una T solo.

1023
01:31:39,319 --> 01:31:42,180
Y ahora, esto lo que tiene son diferentes

1024
01:31:42,180 --> 01:31:45,859
métodos. El matcher que nos dice

1025
01:31:45,859 --> 01:31:50,520
si aparecen o no aparecen. Si cumple, si

1026
01:31:50,520 --> 01:31:53,159
esta cadena cumple esta expresión regular.

1027
01:31:54,239 --> 01:31:57,159
Entonces, si utilizamos con un if

1028
01:31:57,159 --> 01:32:04,039
el m, que es el objeto de la clase

1029
01:32:04,039 --> 01:32:08,039
matcher, el método matches, bueno, ya veis

1030
01:32:08,039 --> 01:32:12,420
tiene diferentes métodos por aquí, hasMath

1031
01:32:12,420 --> 01:32:16,159
matches, hasMath devuelve un boolean, fine, bueno, tiene muchos, ¿no?

1032
01:32:16,159 --> 01:32:20,079
Lo más habitual es el matches, con el método

1033
01:32:20,079 --> 01:32:27,279
matches nos devuelve un boolean que será verdadero si cumple si os si cumple por

1034
01:32:27,279 --> 01:32:34,539
completo la cadena la expresión regular eso lo que implica el hecho utilizar matches es

1035
01:32:34,539 --> 01:32:45,159
que considera el sombrerito el dólar no es aparece en algún sitio en la cadena la

1036
01:32:45,159 --> 01:32:49,800
expresión regular no es cumple por completo sería como en el otro sitio poner esto

1037
01:32:50,079 --> 01:32:57,220
mirad aquí no me está dejando sería como poner esto en el otro sitio en una expresión regular

1038
01:32:57,220 --> 01:33:03,479
el hecho de utilizar matches es lo cumple por completo la expresión regular está recogida en

1039
01:33:03,479 --> 01:33:11,380
la palabra en su conjunto en lugar de ponerlo ahí utilizamos el método matches vamos a poner

1040
01:33:11,380 --> 01:33:24,380
aquí un system.out.println vamos a poner un cumple luego si nos da tiempo adornamos más el programa

1041
01:33:24,380 --> 01:33:36,170
else no cumple

1042
01:33:36,170 --> 01:33:41,710
en este caso cumple, fijaros, hola está cumpliendo con esta

1043
01:33:41,710 --> 01:33:45,750
expresión regular de principio a fin, pues parece que sí, porque tenemos

1044
01:33:45,750 --> 01:33:48,909
la h, la o, la

1045
01:33:48,909 --> 01:33:52,989
luego sería un punto, pero ese punto puede aparecer o no aparecer

1046
01:33:52,989 --> 01:34:01,460
entonces si damos aquí a ejecutar, me dice que cumple, como es la

1047
01:34:01,460 --> 01:34:05,539
expresión regular en su conjunto, si ponemos aquí una a, pues ya no

1048
01:34:05,539 --> 01:34:07,560
cumpliría, porque estamos utilizando el método machis.

1049
01:34:07,899 --> 01:34:08,979
Entonces dice ya que no cumple, ¿veis?

1050
01:34:11,079 --> 01:34:12,819
También hemos dicho que podría aparecer

1051
01:34:12,819 --> 01:34:14,000
el punto no aparecer

1052
01:34:14,000 --> 01:34:16,779
con este trocito de la expresión

1053
01:34:16,779 --> 01:34:17,199
regular.

1054
01:34:18,640 --> 01:34:20,680
Sin él, hemos visto que nos dice que cumple

1055
01:34:20,680 --> 01:34:22,039
y con el punto

1056
01:34:22,039 --> 01:34:24,939
pues también la debería cumplir

1057
01:34:24,939 --> 01:34:26,800
porque estamos diciendo que podría aparecer un punto

1058
01:34:26,800 --> 01:34:27,539
o no aparecer.

1059
01:34:29,399 --> 01:34:30,520
Pues también cumple.

1060
01:34:31,300 --> 01:34:32,720
Si ponemos dos puntos

1061
01:34:32,720 --> 01:34:36,609
pues ya no cumple.

1062
01:34:37,229 --> 01:34:38,430
Si ponemos aquí un más

1063
01:34:38,430 --> 01:34:45,430
a ver si localizo el más aquí, pues ahora diríamos

1064
01:34:45,430 --> 01:34:49,090
que el punto tiene que aparecer una o n veces, no cero o una

1065
01:34:49,090 --> 01:34:53,090
entonces le damos aquí y ahora ya dice que cumple a pesar de que tiene dos puntos

1066
01:34:53,090 --> 01:34:58,420
pero como es una o n, si quito esto, ahora ya me dice que no cumple

1067
01:34:58,420 --> 01:35:02,560
¿por qué? porque no tiene ningún punto, si pongo aquí un asterisco, cero puntos me valdría

1068
01:35:02,560 --> 01:35:06,239
pues sí me valdría, ¿veis? ya sigue cumpliendo

1069
01:35:06,239 --> 01:35:10,699
bueno, pues en función de la cadena

1070
01:35:10,699 --> 01:35:14,239
que queramos validar, que la pondremos aquí en el matcher

1071
01:35:14,239 --> 01:35:18,659
y de la expresión regular con la que queremos validar

1072
01:35:18,659 --> 01:35:22,539
esa cadena, que la pondríamos aquí en el compile

1073
01:35:22,539 --> 01:35:26,479
a través de una estructura de selección con un if

1074
01:35:26,479 --> 01:35:30,300
y el método matches, somos capaces de

1075
01:35:30,300 --> 01:35:34,399
aquí hacer lo que toque cuando cumple y aquí probablemente sería

1076
01:35:34,399 --> 01:35:38,720
mostrar un mensaje diciendo no cumples el correo electrónico que has puesto aquí

1077
01:35:38,720 --> 01:35:43,600
que has recogido aquí no cumple con la expresión regular de los correos electrónicos.

1078
01:35:44,100 --> 01:35:48,920
En definitiva, aquí te muestro un mensaje o te dejo en un bucle hasta que pongas bien el correo

1079
01:35:48,920 --> 01:35:50,800
o ya veremos a ver lo que hacemos.

1080
01:35:53,350 --> 01:36:00,270
El objeto de la clase Matcher nos permite comprobar la expresión regular de principio a fin,

1081
01:36:01,189 --> 01:36:02,430
pero luego tiene más métodos.

1082
01:36:02,430 --> 01:36:10,300
Entonces, si en lugar de Matches ponemos aquí, utilizamos el método Lookinat,

1083
01:36:10,300 --> 01:36:21,359
Esto lo que hace es mirar a ver si aparece en algún sitio

1084
01:36:21,359 --> 01:36:24,020
No a ver si lo cumple o no lo cumple

1085
01:36:24,020 --> 01:36:26,420
Entonces, esta expresión

1086
01:36:26,420 --> 01:36:30,619
Cumple, vamos a poner aquí para saber los dos mensajes

1087
01:36:30,619 --> 01:36:35,680
Cumple looking, no cumple looking

1088
01:36:35,680 --> 01:36:40,890
Entonces, cumple looking, cumple de normal

1089
01:36:40,890 --> 01:36:45,430
Si lo cumple estrictamente, lógicamente lo va a cumplir en el looking

1090
01:36:45,430 --> 01:36:47,770
Pero si yo pongo aquí una A aquí ahora

1091
01:36:47,770 --> 01:37:30,180
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.

1092
01:37:30,180 --> 01:37:52,369
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.

1093
01:37:52,369 --> 01:37:58,010
en cambio el looking at lo que hace es comprobar a ver si lo cumple al principio es como si

1094
01:37:58,010 --> 01:38:01,909
tuviéramos simplemente el sombrerito pero no tuviéramos el dólar aquí entonces dice que

1095
01:38:01,909 --> 01:38:18,359
cumple el looking para localizarlo en cualquier sitio tenemos el método find que sería no

1096
01:38:18,359 --> 01:38:42,289
considerar ni el sombrerito ni el dólar al final entonces si hacemos que cumple de forma estricta

1097
01:38:42,289 --> 01:38:43,390
Ahora vamos modificando.

1098
01:38:55,670 --> 01:38:58,810
Mirad, el fine no le vale encontrarlo, no lo considera.

1099
01:38:58,890 --> 01:39:02,350
Como tienes el looking at, entiendo que te lo localiza al principio.

1100
01:39:03,109 --> 01:39:06,869
Con el fine, si te lo cumple desde el principio, dice que no cumple.

1101
01:39:07,289 --> 01:39:07,729
Fijaros.

1102
01:39:09,069 --> 01:39:11,710
¿Veis? No cumple fine cuando cumple looking at.

1103
01:39:12,569 --> 01:39:14,449
Cumple el normal y el looking at.

1104
01:39:14,449 --> 01:39:21,000
Pero si dejamos aquí un espacio, algo anterior, no cumple la cadena normal,

1105
01:39:21,159 --> 01:39:24,680
no cumple el looking porque no está al principio, pero cumple el fine.

1106
01:39:30,750 --> 01:39:34,829
Es decir, la primera, el find, no te considera la primera de las veces

1107
01:39:34,829 --> 01:39:38,250
si se encuentra al principio, porque dice, bueno, ya lo validarás

1108
01:39:38,250 --> 01:39:39,670
con el lookinat, entiendo.

1109
01:39:40,489 --> 01:39:45,750
Yo, con el find, te voy a dar la solución para cuando no puedas utilizar

1110
01:39:45,750 --> 01:39:47,010
el lookinat al principio.

1111
01:39:48,350 --> 01:39:54,449
Mira, si ponemos aquí cualquier cosa, este no cumplirá la expresión regular,

1112
01:39:54,449 --> 01:39:56,649
no cumple el

1113
01:39:56,649 --> 01:40:02,090
ah, no, un momentito

1114
01:40:02,090 --> 01:40:04,329
que no es

1115
01:40:04,329 --> 01:40:05,970
creo, a ver, un segundín

1116
01:40:05,970 --> 01:40:08,170
mira, voy a poner esto

1117
01:40:08,170 --> 01:40:10,329
pero voy a comentar porque yo creo

1118
01:40:10,329 --> 01:40:12,250
que no va a ser exactamente ese el motivo

1119
01:40:12,250 --> 01:40:14,090
vamos a comentar el lookinat, un momentito

1120
01:40:14,090 --> 01:40:29,359
fijaros, he vuelto

1121
01:40:29,359 --> 01:40:31,319
aquí al principio, veis, sin dejar

1122
01:40:31,319 --> 01:40:33,279
el espacio ese en la parte

1123
01:40:33,279 --> 01:40:35,340
de adelante, vale, y ahora ya dice que cumple el fine

1124
01:40:35,340 --> 01:40:36,479
vale, os cuento

1125
01:40:36,479 --> 01:40:38,840
que es lo que estaba pasando, antes

1126
01:40:38,840 --> 01:40:42,399
os he dicho, os estaba comentando, pues parece que el find

1127
01:40:42,399 --> 01:40:46,899
como ya el servicio encontrado al principio lo tiene el looking at, pues el find

1128
01:40:46,899 --> 01:40:51,079
te encuentra las siguientes, por eso esta nos decía

1129
01:40:51,079 --> 01:40:55,140
el find que no cumple cuando si había cumplido el looking

1130
01:40:55,140 --> 01:40:59,119
up, pero en realidad no es eso, en realidad lo que sucede

1131
01:40:59,119 --> 01:41:03,079
es que estos métodos, el looking at y el find, lo que

1132
01:41:03,079 --> 01:41:10,279
hace es localizarlo y va avanzando digamos un cursor, que es lo

1133
01:41:10,279 --> 01:41:14,000
que ha hecho aquí? Bueno, el machis no avanzó un cursor, dice si cumple o no cumple

1134
01:41:14,000 --> 01:41:17,079
y luego se ha encontrado un lookinat, entonces ha dicho

1135
01:41:17,079 --> 01:41:21,300
¿lo he encontrado? Sí, hola, pues digo que lo cumplo.

1136
01:41:21,840 --> 01:41:25,979
Y como ya lo he encontrado este, lo que hago es avanzar el cursor y lo pongo por aquí

1137
01:41:25,979 --> 01:41:29,920
o por aquí, no sé exactamente dónde, después de la expresión. Y dice

1138
01:41:29,920 --> 01:41:33,939
¿cumple el find después? Y dice ya, como he avanzado

1139
01:41:33,939 --> 01:41:37,699
el cursor por aquí, ya no lo encuentro, entonces me dice que no cumple.

1140
01:41:37,699 --> 01:41:58,289
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.

1141
01:41:58,289 --> 01:42:07,470
Esto lo podemos gestionar con uno y con otro, a ver, haciendo un reset, creo.

1142
01:42:07,630 --> 01:42:08,470
A ver, reset, sí.

1143
01:42:09,850 --> 01:42:15,069
El método reset del matcher lo que hace es, si he avanzado con el cursor,

1144
01:42:15,329 --> 01:42:20,329
porque ya he ido encontrándolo y lo que espero es encontrar nuevas ocurrencias de la expresión regular,

1145
01:42:20,710 --> 01:42:23,770
con un reset lo que hago es volver a traer el cursor aquí al principio.

1146
01:42:24,729 --> 01:42:27,189
Entonces, si yo ahora cojo y ejecuto aquí, ¿veis?

1147
01:42:27,189 --> 01:42:54,569
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.

1148
01:42:54,569 --> 01:43:10,779
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.

1149
01:43:13,579 --> 01:43:20,399
Entonces vamos a, en lugar de poner un for, un if aquí, vamos a poner aquí un while.

1150
01:43:24,300 --> 01:43:29,600
Mientras lo vaya encontrando, sácame que cumple el find.

1151
01:43:29,600 --> 01:43:34,199
fijaros que este bucle, aunque no tengamos ningún avance en particular

1152
01:43:34,199 --> 01:43:37,439
por código, en realidad sí que está avanzando porque cada find

1153
01:43:37,439 --> 01:43:42,060
va avanzando el cursor, entonces encontrará aquí un find, luego dirá

1154
01:43:42,060 --> 01:43:46,119
que encuentra aquí otro, y cuando haya encontrado este llegará aquí

1155
01:43:46,119 --> 01:43:50,119
y dirá pues ya no lo he encontrado más veces, con lo cual es previsible

1156
01:43:50,119 --> 01:43:55,689
que con esto, con el find me salga dos veces, veis

1157
01:43:55,689 --> 01:43:59,430
me dice no cumple el matcher, cumple el looking

1158
01:43:59,430 --> 01:44:04,270
es verdad que habrá avanzado el cursor, pero como hacemos un reset, nos lo traemos al principio

1159
01:44:04,270 --> 01:44:07,909
de nuevo y cumple dos veces el find, ¿veis? que es

1160
01:44:07,909 --> 01:44:11,170
una este y otra este

1161
01:44:11,170 --> 01:44:16,989
y ya para terminar, por lo menos por aquí

1162
01:44:16,989 --> 01:44:21,170
mostraros que cuando hacemos

1163
01:44:21,170 --> 01:44:25,329
de este cursor del que os estoy hablando y cuando lo va encontrando

1164
01:44:25,329 --> 01:44:29,529
pues tenemos a ver un mstart, que es donde

1165
01:44:29,529 --> 01:44:33,890
empieza cuando lo ha encontrado la aparición

1166
01:44:33,890 --> 01:44:37,289
de la expresión regular dentro del texto

1167
01:44:37,289 --> 01:44:47,140
y un stop, y un end

1168
01:44:47,140 --> 01:45:02,029
entonces si ejecutamos esto, fijaros

1169
01:45:02,029 --> 01:45:05,949
que dice, no cumple, efectivamente como hemos dicho antes

1170
01:45:05,949 --> 01:45:09,869
cumple el looking at, está al principio, y el

1171
01:45:09,869 --> 01:45:14,029
find lo encuentra dos veces, una y dos, y dice

1172
01:45:14,029 --> 01:45:18,029
que aparece la expresión regular

1173
01:45:18,029 --> 01:45:21,710
en el texto entre el carácter 0 con una longitud de 4

1174
01:45:21,710 --> 01:45:24,869
desde el carácter 0, 1, 2, 3 y 4

1175
01:45:24,869 --> 01:45:28,930
y luego dice que en el 10, del 10 al 14

1176
01:45:28,930 --> 01:45:34,050
entonces, 1, 2, 3, 4, 5, 6, 7

1177
01:45:34,050 --> 01:45:37,750
8, 9, 10 y el 11, 12, 13 y 14

1178
01:45:37,750 --> 01:45:41,890
de esta forma podemos localizar donde aparece

1179
01:45:41,890 --> 01:46:02,560
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.

1180
01:46:02,560 --> 01:46:19,460
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.

1181
01:46:19,460 --> 01:46:22,760
escribieron una base de datos, no sé qué nombre, apareció tres veces.

1182
01:46:23,380 --> 01:46:25,180
He sustituido esto por esto.

1183
01:46:25,439 --> 01:46:29,180
Al final, no un texto por otro, sino una expresión regular

1184
01:46:29,180 --> 01:46:32,420
por el texto que sea o lo que toque hacer.

1185
01:46:32,840 --> 01:46:35,100
Pero nos da la posibilidad de gestionar expresiones regulares

1186
01:46:35,100 --> 01:46:39,720
para hacer búsquedas de esos patrones dentro de cadenas de caracteres

1187
01:46:39,720 --> 01:46:42,600
y los otros métodos, como el que os he enseñado antes,

1188
01:46:42,760 --> 01:46:46,119
era una cosa más particular, que no viene de Perlas,

1189
01:46:46,119 --> 01:46:48,319
pero para hacer un replays o un replays all

1190
01:46:48,319 --> 01:46:49,560
como en un stream

1191
01:46:49,560 --> 01:46:56,979
bueno, me hubiera gustado hacer algunos ejercicios más

1192
01:46:56,979 --> 01:46:58,319
por aquí, cosas tenía apuntadas

1193
01:46:58,319 --> 01:47:00,180
no sé si fuera de

1194
01:47:00,180 --> 01:47:02,739
este primer examen, pues podemos

1195
01:47:02,739 --> 01:47:04,760
algún día en la siguiente tutoría

1196
01:47:04,760 --> 01:47:06,579
repasamos un poco más alguna cosita

1197
01:47:06,579 --> 01:47:08,699
pero hoy ya no nos da más tiempo

1198
01:47:08,699 --> 01:47:10,399
desafortunadamente

1199
01:47:10,399 --> 01:47:12,340
así que

1200
01:47:12,340 --> 01:47:13,819
no sé, sí, dime

1201
01:47:13,819 --> 01:47:15,460
alguien me pregunta por Google

1202
01:47:15,460 --> 01:47:20,869
sí, sí, sí

1203
01:47:20,869 --> 01:47:22,350
hasta este tema incluido

1204
01:47:22,350 --> 01:47:26,010
si necesitáis desarrollar algo más de este tema

1205
01:47:26,010 --> 01:47:28,949
como no os he dado tiempo a muchas tutorías, pues preguntadme por ahí

1206
01:47:28,949 --> 01:47:31,130
por los foros, ya sabéis que intento andar pendiente

1207
01:47:31,130 --> 01:47:36,319
y poca cosa más, esta clase os la subo ahora al aula

1208
01:47:36,319 --> 01:47:39,340
bueno, ahora o a lo largo del día porque siempre

1209
01:47:39,340 --> 01:47:42,199
tardo un rato en subir y bueno

1210
01:47:42,199 --> 01:47:44,680
pues os veo la semana que viene a los que os animéis a hacer el examen

1211
01:47:44,680 --> 01:47:45,619
a ver que tal os va

1212
01:47:45,619 --> 01:47:53,220
¿alguna preguntilla queréis antes de cerrar?

1213
01:47:56,970 --> 01:47:58,829
no, pues venga, por aquí lo dejamos ya

1214
01:47:58,829 --> 01:48:01,229
Venga, hasta la semana que viene. Hasta luego.