1
00:00:00,180 --> 00:00:07,680
Bien, continuamos con el método recursivo que recorre este árbol, entonces estático public static

2
00:00:08,670 --> 00:00:10,860
void no devuelve nada por ahora.

3
00:00:10,980 --> 00:00:12,060
Método recursivo

4
00:00:15,150 --> 00:00:23,650
en que lo que recibe el componente que el que vamos a iterar entonces componente C y eso por ahora bien,

5
00:00:23,820 --> 00:00:26,370
vamos a partir primero imprimiendo el nombre.

6
00:00:26,550 --> 00:00:36,720
Entonces Shout compone el punto Vietto nombre, pero casualmente imprimir el nombre de principal del

7
00:00:36,720 --> 00:00:38,660
padre que sería bueno.

8
00:00:38,760 --> 00:00:39,200
Psé.

9
00:00:39,820 --> 00:00:44,730
Entonces ahora tenemos que preguntar si este componente principal o padre contiene hijos.

10
00:00:44,940 --> 00:00:47,970
Entonces, utilizando un IF recuerden que ya tenemos el método.

11
00:00:48,030 --> 00:00:50,730
Entonces sería C punto.

12
00:00:50,790 --> 00:00:53,040
Tiene hijo, entonces?

13
00:00:53,040 --> 00:00:54,840
Si tiene hijos, perfecto.

14
00:00:55,020 --> 00:00:56,100
Los vamos a iterar.

15
00:00:56,220 --> 00:01:07,160
Entonces utilizando un for común y corriente del tipo componente hijo 2 punto C de componente padre

16
00:01:07,170 --> 00:01:09,750
principal punto get hijos.

17
00:01:10,290 --> 00:01:12,030
Acá obtenemos la lista de sus hijos.

18
00:01:12,570 --> 00:01:18,870
Perfecto, la recorremos y de forma recursiva invocamos nuevamente el método recursivo para cada hijo.

19
00:01:18,940 --> 00:01:22,310
Entonces cada hijo va a repetir este método y va a preguntar si tiene hijo.

20
00:01:22,450 --> 00:01:24,930
Bueno, imprime el nombre de este componente.

21
00:01:25,020 --> 00:01:28,530
Recorre los hijos y así por cada uno, así sucesivamente.

22
00:01:28,530 --> 00:01:32,700
Se empieza a construir este árbol y comienza a navegar de forma recursiva.

23
00:01:32,950 --> 00:01:37,620
Entonces por eso es importante invocar este método recursivo, ya que pasamos el hijo.

24
00:01:38,790 --> 00:01:45,780
Entonces por cada hijos invocamos este método method recursivo, por cada hijo, por cada uno y listo.

25
00:01:45,870 --> 00:01:46,440
Eso es todo.

26
00:01:47,310 --> 00:01:48,930
Entonces ahora vamos a levantar.

27
00:01:49,350 --> 00:01:50,040
Vamos a probar.

28
00:01:51,110 --> 00:01:52,970
Sí, pero ante la Antar, qué nos faltaría?

29
00:01:53,090 --> 00:01:55,970
Faltaría algo importante llamar a este methos recursivo.

30
00:01:56,570 --> 00:02:01,840
Pero quien lo enfoca lo tiene que invocar el padre, que sería pecé componente principal.

31
00:02:02,690 --> 00:02:05,560
Que finalmente está compuesto y construido por los demás.

32
00:02:05,650 --> 00:02:06,850
Entonces por acá.

33
00:02:08,600 --> 00:02:14,240
Método recursivo pasamos psé, siempre principal y a partir de este.

34
00:02:15,110 --> 00:02:19,250
Se comienza a navegar en el árbol a s ejecutamos.

35
00:02:20,820 --> 00:02:27,810
Se fijan bien navega gabinete psa этих que tiene la fuente poder, a su vez tiene una tarjeta madre,

36
00:02:27,900 --> 00:02:35,640
la tarjeta madre compuesta por una CPU m, MD, Reisen, ventilador CPU disipador que son patra CPU

37
00:02:36,090 --> 00:02:43,680
y así cada componente bien, pero le podríamos dar un Lucasfilm o alguna plantilla para que se muestren

38
00:02:43,890 --> 00:02:45,960
de forma jerarquía cada elemento.

39
00:02:46,140 --> 00:02:47,670
Eso lo podríamos hacer con niveles.

40
00:02:47,880 --> 00:02:55,260
Entonces, como segundo argumento en el metodo recursivo vamos a colocar acá un entero nivel bueno,

41
00:02:55,320 --> 00:02:57,000
siempre a partir en el nivel cero.

42
00:02:57,090 --> 00:03:02,790
Acá meto recursivo pecé coma cero, en nivel cero meto recursivo.

43
00:03:02,790 --> 00:03:07,350
Acá en los hijos vamos a colocar koma nivel +1.

44
00:03:07,890 --> 00:03:14,550
Entonces siempre a cada hijo le sumamos uno al nivel perfecto, pero ahora tenga que imprimir acá según

45
00:03:14,550 --> 00:03:17,850
el nivel alguna rayita, algún tabulador o línea.

46
00:03:17,970 --> 00:03:20,520
Veamos entonces por acá un string.

47
00:03:21,150 --> 00:03:23,190
Lo vamos a hacer con un tabulador, con un té.

48
00:03:24,090 --> 00:03:24,510
Punto.

49
00:03:24,510 --> 00:03:28,170
Repito, según la cantidad niveles.

50
00:03:31,730 --> 00:03:35,750
Es decir, vamos a repetir el string tabulador dependiendo al cante nivele.

51
00:03:35,870 --> 00:03:43,520
Cuando nivel es cero no imprime nada, pero cuando uno tábula una línea, cuando el nivel 2, es decir

52
00:03:43,550 --> 00:03:49,040
está dentro de esta jerarquía, dentro de los hijos, imprime un tabulador y así sucesivamente.

53
00:03:49,160 --> 00:03:51,740
Los hijos de los hijos son dos tabuladores y así.

54
00:03:52,990 --> 00:03:56,950
Entonces, con este pequeño cambio vamos a ver cómo se muestra de forma gráfica.

55
00:03:58,740 --> 00:04:01,360
Perfecto gabinete pesea takis contiene.

56
00:04:01,380 --> 00:04:10,920
Fuente poder 700 tarjeta madre, luego contiene teclado y mouse, pero a su vez main board ASUS contiene

57
00:04:11,040 --> 00:04:15,000
una CPU que sube la CPU compuesta por ventiladores por disipador.

58
00:04:15,360 --> 00:04:22,760
Luego tenemos tarjeta de video ENVÍDIA Retegui tres mil ochenta ocho gigas compuesta por la GPU RDX

59
00:04:22,920 --> 00:04:30,630
y 2 RAM de 4 Halligan ventiladores también memoria RAM y disco duro, que son parte de la tarjeta madre.

60
00:04:30,660 --> 00:04:31,560
Así que está perfecto.

61
00:04:31,890 --> 00:04:34,650
Incluso podremos cambiar esto por esto como lo queramos manejar.

62
00:04:35,370 --> 00:04:35,940
Veamos.

63
00:04:40,420 --> 00:04:40,990
Se fijan?

64
00:04:42,770 --> 00:04:44,180
Como si fuera un directorio.

65
00:04:44,510 --> 00:04:47,660
Bien, creo que me gusta más con tabulador.

66
00:04:48,470 --> 00:04:52,040
Bien, pero estuvimos se podría hacer conlleva 8 con el API Stream.

67
00:04:52,250 --> 00:04:57,230
Bueno, veamos cómo podríamos modificar esto para que sea recursivo utilizando el API Stream, pero

68
00:04:57,230 --> 00:05:02,330
antes lo vamos a copiar y pegar este método para que tengamos estas dos formas y no perder una.

69
00:05:02,690 --> 00:05:04,070
Entonces voy a copiar esto.

70
00:05:05,840 --> 00:05:07,040
Lo pegamos por acá.

71
00:05:08,510 --> 00:05:11,210
Entonces voy a renombrar acá, este queda respaldo.

72
00:05:11,330 --> 00:05:15,920
Acá ya va 8 o stream, da lo mismo.

73
00:05:16,130 --> 00:05:17,900
Acá vamos a utilizar ya 8.

74
00:05:19,640 --> 00:05:20,600
Esto lo modificamos.

75
00:05:21,320 --> 00:05:22,700
Entonces te lo vamos a quitar.

76
00:05:23,600 --> 00:05:28,070
Lo primero es agregar un atributo nivel a la clase componente acá.

77
00:05:28,700 --> 00:05:33,740
Entonces private int nivel bien.

78
00:05:33,920 --> 00:05:35,750
Método lletra setter para nivel.

79
00:05:36,380 --> 00:05:38,060
Entonces al final por acá.

80
00:05:40,550 --> 00:05:43,470
Generai Guiteras Sette Nivel.

81
00:05:44,430 --> 00:05:44,850
Listo.

82
00:05:44,940 --> 00:05:45,450
Nada más.

83
00:05:45,780 --> 00:05:50,550
Atributo nivel del tipo entero Guiteras Z volvemos acá.

84
00:05:51,180 --> 00:06:00,030
Entonces asignamos el nivel a este componente set, punto, set, nivel nivel, lo que pasamos por argumento

85
00:06:00,150 --> 00:06:00,690
perfecto.

86
00:06:01,080 --> 00:06:03,630
Ahora comenzamos con el API Stream, pero es simple.

87
00:06:03,930 --> 00:06:06,230
Este método va a devolver en vez de vey.

88
00:06:06,600 --> 00:06:12,270
Va a devolver un stream stream del tipo componente.

89
00:06:12,600 --> 00:06:22,170
Vamos a importar de llebaba útil el stream perfecto y acá proton y comenzamos stream junto con catá.

90
00:06:22,230 --> 00:06:23,100
Vamos a concatenar.

91
00:06:23,190 --> 00:06:25,980
Es decir, vamos a unir dos string el padre con sus hijos.

92
00:06:26,920 --> 00:06:32,250
La idea de tener un solo flujo con todos los elemento completo padre y con los hijos uno solo.

93
00:06:32,400 --> 00:06:35,310
Bien, el padre sería el primero componente C.

94
00:06:36,470 --> 00:06:43,180
Pero sé del tipo de componente y acá lo tenemos que concatenar como un stream.

95
00:06:43,430 --> 00:06:46,910
Por lo tanto, tenemos que convertir este c a un tipo string.

96
00:06:47,630 --> 00:06:51,470
Entonces, cacería de stream punto off.

97
00:06:52,010 --> 00:06:52,570
Se acuerdan?

98
00:06:52,940 --> 00:06:53,540
Off de.

99
00:06:55,010 --> 00:06:56,030
Bien, ahí tenemos uno.

100
00:06:56,180 --> 00:07:05,630
El padre coma con sus hijos, pero los hijos es bastante simple porque sería C punto get hijos punto

101
00:07:05,720 --> 00:07:06,130
stream.

102
00:07:06,290 --> 00:07:08,030
Ahí tenemos el estilo de los hijos.

103
00:07:08,180 --> 00:07:12,500
Pero además teme que navegar de forma recursiva porque los hijos también podrían tener hijos.

104
00:07:12,930 --> 00:07:23,720
Para eso podríamos utilizar un flat map hijo y acá devolvemos en el flan map otro stream, que sería

105
00:07:23,720 --> 00:07:25,710
justamente lo que devuelve el método recursivo.

106
00:07:26,450 --> 00:07:27,380
Entonces cacería.

107
00:07:27,470 --> 00:07:28,730
Método recursivo.

108
00:07:32,120 --> 00:07:36,560
Hijo, y el nivel nivel más?

109
00:07:37,130 --> 00:07:37,460
Perdón.

110
00:07:37,520 --> 00:07:42,050
En vez de metodo recursivo método recursivo ya 8 9 8 s.

111
00:07:43,940 --> 00:07:44,630
Marca.com.

112
00:07:47,880 --> 00:07:52,170
Entonces por cada hijo invocamos el methos recursivo por cada hijo.

113
00:07:52,470 --> 00:07:57,060
Y esto devuelve un string de componente cómo devuelve un stream?

114
00:07:57,720 --> 00:07:58,860
Por eso utilizamos flat map.

115
00:07:58,980 --> 00:08:06,030
Recuerde que Fatma lo que hace es tomar varios stream y lo une bajo una única salida, un solo stream.

116
00:08:06,090 --> 00:08:06,840
Todo junto.

117
00:08:07,080 --> 00:08:09,630
Entonces, por cada hijo lo navegamos de forma recursiva.

118
00:08:09,910 --> 00:08:13,860
De acá pasamos su stream y lo concatenados con el padre y listo.

119
00:08:14,040 --> 00:08:14,700
Ahí lo tenemos.

120
00:08:15,330 --> 00:08:19,530
Entonces ahora simplemente este método recursivo ya 8 que tenemos acá.

121
00:08:20,040 --> 00:08:22,560
Lo que hace es solamente el flujo.

122
00:08:22,620 --> 00:08:27,060
Pero acá tenemos que tener un operador terminal, por ejemplo, un forillo para recorrerlo.

123
00:08:27,780 --> 00:08:33,300
Acá se emite el componente cada uno y lo vamos a imprimir Shout.

124
00:08:35,000 --> 00:08:42,800
Con el tabulador conté punto, repito, ya pasamos el nivel, pero el nivel lo tenemos trae de componente,

125
00:08:42,950 --> 00:08:44,210
componente, punto.

126
00:08:44,480 --> 00:08:45,010
Qué nivel?

127
00:08:45,380 --> 00:08:50,420
Recuerde que el nivel sólo asignamos acá en este método recursivo a cada uno según corresponda, según

128
00:08:50,420 --> 00:08:51,140
su jerarquía.

129
00:08:51,680 --> 00:08:53,900
Luego acá concatenados con el nombre.

130
00:08:54,090 --> 00:08:55,130
Entonces por acá.

131
00:08:55,430 --> 00:08:57,560
Acá tenemos el repite por acá.

132
00:08:58,040 --> 00:08:59,810
Más C punto.

133
00:08:59,990 --> 00:09:01,130
Guet nombre.

134
00:09:02,550 --> 00:09:03,010
Y listo.

135
00:09:03,600 --> 00:09:04,140
Eso es todo.

136
00:09:05,660 --> 00:09:06,530
Levantamos.

137
00:09:08,670 --> 00:09:16,270
El resultado es el mismo gabinete técnico en Fuente Poder, con placa madre, CPU, ventilador disipador,

138
00:09:16,450 --> 00:09:24,910
tarjeta video con la GPU, RAM y ventiladores, memoria RAM, disco duro en placa madre y luego tenemos

139
00:09:24,910 --> 00:09:25,690
teclado y mouse.

140
00:09:25,930 --> 00:09:26,730
Empecé bien.

141
00:09:26,800 --> 00:09:32,380
Entonces, para finalizar, yo sé que esta parte puede ser un poco enredada, pero básicamente por cada

142
00:09:32,380 --> 00:09:34,450
componente podría tener hijos.

143
00:09:34,840 --> 00:09:42,820
Entonces lo que hacemos es concatenar el stream del propio componente con el stream de sus hijos, pero

144
00:09:42,820 --> 00:09:43,810
a su vez cada hijo.

145
00:09:43,990 --> 00:09:47,100
Bueno, por eso concatenados con get hijos trim.

146
00:09:47,230 --> 00:09:47,620
Pero sube.

147
00:09:47,650 --> 00:09:49,750
Cada hijo puede tener otros hijos.

148
00:09:50,050 --> 00:09:54,970
Entonces por eso utilizamos el flat map para navegar de forma recursiva utilizando el método recursivo

149
00:09:54,970 --> 00:09:55,510
ya 8.

150
00:09:56,260 --> 00:09:57,310
Como devuelve un stream.

151
00:09:57,400 --> 00:10:01,300
Tenemos que utilizar un plasma para aplanar este stream en una única salida.

152
00:10:02,050 --> 00:10:04,900
Pasamos al componente hijo por cada uno.

153
00:10:05,020 --> 00:10:10,000
El hijo en cuestión con su nivel correspondiente y así se vuelve a invocar este método recursivo para

154
00:10:10,000 --> 00:10:11,110
este componente hijo.

155
00:10:11,320 --> 00:10:17,170
Le asignamos el nivel de concatenados y también con sus propios hijos y a su vez sus hijos pueden tener

156
00:10:17,230 --> 00:10:17,980
otros hijos.

157
00:10:18,100 --> 00:10:20,440
Y así empieza a navegar de forma recursiva.

158
00:10:20,640 --> 00:10:26,460
Bueno, muy parecido a lo que hicimos acá, pero es otra forma común y corriente sin utilizar stream

159
00:10:26,830 --> 00:10:28,450
de acá utilizando 100 porciento string.

160
00:10:29,410 --> 00:10:35,800
Esto devuelve un flujo, pero acá lo tenemos que utilizar con un operador final, por ejemplo con un

161
00:10:35,800 --> 00:10:42,100
forillo para iterar y mostrar la información utilizando el nivel con el repite y el nombre.

162
00:10:42,160 --> 00:10:42,880
Eso sería todo.

163
00:10:43,090 --> 00:10:45,310
Espero que le haya gustado bien completo.

164
00:10:45,430 --> 00:10:47,230
Y cómo se dan cuenta al final?

165
00:10:47,290 --> 00:10:49,130
Recursividad no es tan complicado.

166
00:10:49,240 --> 00:10:54,540
Simplemente una clase que contiene elementos de su mismo tipo y también podría ser utilizando interfaces.

167
00:10:54,670 --> 00:10:57,460
Es decir, que este componente todo implementen la misma interfaz.

168
00:10:57,550 --> 00:10:58,210
Nada más.

169
00:10:58,270 --> 00:11:00,210
Continuamos en la siguiente clase.