Java pour tous : concepts de base de la programmation Partie 2 ! | Hadi Youness | Skillshare

Vitesse de lecture


1.0x


  • 0.5x
  • 0.75x
  • 1 x (normale)
  • 1.25x
  • 1.5x
  • 1.75x
  • 2x

Java pour tous : concepts de base de la programmation Partie 2 !

teacher avatar Hadi Youness, Computer Engineer

Regardez ce cours et des milliers d'autres

Bénéficiez d'un accès illimité à tous les cours
Suivez des cours enseignés par des leaders de l'industrie et des professionnels
Explorez divers sujets comme l'illustration, le graphisme, la photographie et bien d'autres

Regardez ce cours et des milliers d'autres

Bénéficiez d'un accès illimité à tous les cours
Suivez des cours enseignés par des leaders de l'industrie et des professionnels
Explorez divers sujets comme l'illustration, le graphisme, la photographie et bien d'autres

Leçons de ce cours

    • 1.

      Introduction

      0:52

    • 2.

      Matériau

      1:02

    • 3.

      Héritage.

      9:30

    • 4.

      Super référence

      5:58

    • 5.

      Méthodes de surclassement

      5:27

    • 6.

      Hiérarchies du cours

      4:22

    • 7.

      Visibilité

      9:27

    • 8.

      Polymorphisme

      5:14

    • 9.

      Exemple de polymorphisme partie 1

      8:43

    • 10.

      Exemple de polymorphisme partie 2

      10:52

    • 11.

      Exemple de polymorphisme partie 3

      10:43

    • 12.

      Recursion

      8:38

    • 13.

      Exemple : Sum en utilisant des récursions

      6:54

    • 14.

      Recursion: : Maze partie 1

      9:52

    • 15.

      Recursion: : Maze partie 2

      14:00

    • 16.

      Recursion : les tours d'Hanoi

      12:14

    • 17.

      Trier Insertion

      10:50

    • 18.

      Trier Sort à la

      9:38

    • 19.

      Trier des bulles

      5:52

    • 20.

      Sort de fusionnement

      13:57

    • 21.

      Trier rapidement

      11:21

    • 22.

      Recherche linéaire et ben ben

      10:20

    • 23.

      Recherche Jump

      10:09

    • 24.

      Recherche d'interpolation

      6:54

    • 25.

      Recherche exponentielle

      7:39

    • 26.

      Le problème supplémentaire : Inheritance

      13:54

    • 27.

      Séquence de Fibonacci

      10:13

    • 28.

      Cours d'appoint

      5:01

    • 29.

      Les problèmes supplémentaires : Recursion

      12:45

    • 30.

      Trier des cordes

      6:02

    • 31.

      XML

      8:13

    • 32.

      Processus local en XML

      14:00

    • 33.

      Processus local XML 2

      8:08

    • 34.

      Traduire XML à partir de navigateur

      13:58

    • 35.

      Traduire XML à partir du navigateur 2

      4:10

    • 36.

      Exemple de catalogue

      14:59

    • 37.

      Exemple de catalogue 2

      6:23

    • 38.

      Exemple d'entreprise

      14:55

    • 39.

      JSON

      14:58

    • 40.

      Exemple de Wordpress

      10:42

    • 41.

      Exemple de glossaire

      11:52

    • 42.

      Exemple de Quiz

      12:21

    • 43.

      Projet

      4:17

    • 44.

      Récap

      0:57

  • --
  • Niveau débutant
  • Niveau intermédiaire
  • Niveau avancé
  • Tous niveaux

Généré par la communauté

Le niveau est déterminé par l'opinion majoritaire des apprenants qui ont évalué ce cours. La recommandation de l'enseignant est affichée jusqu'à ce qu'au moins 5 réponses d'apprenants soient collectées.

171

apprenants

2

projets

À propos de ce cours

Ce cours aborde certains des algorithms algorithmes et concepts les plus commun. Certains matériaux sont déjà mentionnés dans le premier cours, mais nous avons pour but de l'expliquer davantage et de se plonger dans chaque sujet.

nous aborderons l'héritage et le polymorphisme, la polymorphism, la recherche et la tril. will Nous allons en plus voir les problèmes supplémentaires pour apprendre et utiliser chaque concept, de la méthode et de l'algorithme.

En plus de cela, nous allons apprendre à récupérer des données de XML et JSON et à travailler avec notre programme.

Il est recommandé de commencer avec les deux cours précédents, pour pouvoir bien faire dans ce cours.

J'espère que vous l'aimez !

Rencontrez votre enseignant·e

Teacher Profile Image

Hadi Youness

Computer Engineer

Enseignant·e

Hello, I'm Hadi. I am studying Computer Engineering at the Lebanese American University (LAU). I like to share my knowledge with everybody and I believe that teaching is a perfect way to understand anything since you must be well informed about something to be able to teach it in the simplest possible ways!

Voir le profil complet

Level: Intermediate

Notes attribuées au cours

Les attentes sont-elles satisfaites ?
    Dépassées !
  • 0%
  • Oui
  • 0%
  • En partie
  • 0%
  • Pas vraiment
  • 0%

Pourquoi s'inscrire à Skillshare ?

Suivez des cours Skillshare Original primés

Chaque cours comprend de courtes leçons et des travaux pratiques

Votre abonnement soutient les enseignants Skillshare

Apprenez, où que vous soyez

Suivez des cours où que vous soyez avec l'application Skillshare. Suivez-les en streaming ou téléchargez-les pour les regarder dans l'avion, dans le métro ou tout autre endroit où vous aimez apprendre.

Transcription

1. Introduction: Le codage peut être très difficile et pourtant extrêmement agréable en même temps. Bonjour tout le monde. Je suis des unités Hadi et voici Programmer pour tout le monde. Maintenant, si vous ne savez rien sur la programmation, je pense que vous devriez commencer avec les deux classes précédentes. Et le premier, nous avons vendu Java et Eclipse et en apprendre davantage sur certains concepts de base tels que les types de données, prise de décision, les boucles, et bien plus encore, mais le tout d'une manière générale. Et dans la deuxième classe avec un plus profond à ces concepts de la création de classes et d'objets, faites en utilisant des tableaux et ArrayLists. Maintenant, dans cette classe, nous allons explorer des concepts anciens et nouveaux. Certains d'entre eux sont déjà mentionnés dans la première classe que nous arrivons ici au fond d'eux. Cela étant dit, vous pouvez commencer et j'espère que vous apprécierez. 2. Matériau: Comme d'habitude, nous commencerons par notre matériel. Alors, qu'est-ce qu'on va couvrir ? Tout d'abord, nous allons parler de l'héritage, puis nous allons introduire le polymorphisme et comment l'utiliser via l'héritage. Et puis nous allons introduire un nouveau concept dans la programmation, récursivité et la façon de l'utiliser. Après cela va passer aux algorithmes de tri. Donc, si nous avions, si nous avons un tableau ou une liste de tableaux d'entiers, chaînes, de caractères, nous allons apprendre à les résoudre. Et puis nous parlerons des algorithmes de recherche. Donc, si nous avons un entier spécifique, par exemple, comment le trouver dans un tableau spécifique. Et enfin, nous allons parler de la classe Big Integer. Après cela va résoudre certains problèmes sur chaque sujet comme d'habitude. Et enfin, nous avons notre projet. Alors, c'est ça. Et commençons. 3. Héritage.: Tout d'abord, nous commençons par l'héritage, technique fondamentale pour organiser et créer des classes. C' est une idée simple mais puissante qui implémente est la façon dont nous concevons des logiciels orientés objet. Vous pouvez dire qu'une classe est à un objet ce qu'un Blueprint est à loger. De nombreuses maisons peuvent être créées à partir du même plan. Ils sont essentiellement la même maison dans différents endroits avec différentes personnes vivant en eux. Maintenant, supposons que vous voulez loger qui est similaire à un autre, mais avec des fonctionnalités différentes ou supplémentaires. Vous voulez commencer par le même Blueprint de base, mais le modifier pour s'adapter à de nouveaux besoins légèrement différents. De nombreux aménagements de logements créent de cette façon. Les maisons dans le développement ont la même disposition de base, mais ils ont des caractéristiques uniques. Par exemple, ils peuvent tous être des maisons à deux niveaux avec la même configuration de base pour mariés, mais certains ont une cheminée ou un sous-sol complet, tandis que d'autres ne le font pas. Maintenant, via l'héritage, la nouvelle classe contient automatiquement les variables et les méthodes dans la classe d'origine, puis ils quittent la classe selon les besoins. Le programmeur peut ajouter de nouvelles variables et méthodes à la classe dérivée ou modifier celles héritées. La classe d'origine qui est utilisée pour en dériver une nouvelle est appelée la classe de bande, superclasse ou la classe de base. Voici donc le parent de Pictionary et le verre. La classe dérivée est appelée classe enfant ou sous-classe. Et Java utilise le mot réservé étend pour indiquer que la nouvelle classe est dérivée d'une classe existante. Maintenant, le processus d'héritage devrait établir un est une relation entre deux classes. Nous avons donc une relation entre le livre et le dictionnaire. Autrement dit, la classe enfant devrait être une version plus spécifique de la classe parent. Par exemple, le dictionnaire est un livre, mais tous les livres ne sont pas des dictionnaires. Maintenant, si une telle déclaration n'a pas de sens, alors cette relation n'est probablement pas une utilisation appropriée de l'héritage. Maintenant, nous montrons l'utilisation d'une méthode héritée. Par exemple, nous avons des mots, nous avons ici notre méthode principale. Et le dictionnaire aura trois méthodes. Problème d'ordinateur, définir des définitions, obtenir des définitions et un entier variable. Et enfin, notre classe de parents, le livre. Nous avons une variable n et deux méthodes définir des pages et obtenir des pêches. Allons de l'avant et créons nos trois classes. Nous avons Cook et V8 dictionnaire. Et enfin, mot. Des lunettes. Alors maintenant, commençons par le livre. Donc, c'est la classe parent de la classe dérivée pour l'utiliser pour démontrer l'héritage. Donc, nous avons des légumes et des entiers, disons est protégé et ensuite l'expliquera plus tard. Et vous pages égale à 1500 pages. Et nous avons deux méthodes. Tout d'abord, définir la page, qui est des pagers, lui donner une valeur d'entier en tant que paramètre, num, et que les pages égales à cette valeur. Alors maintenant à la place des plages et encore des plages, pour retourner la valeur des pages. Nous retournons juste des pages. Maintenant, quel est le protégé modifié ? Comme nous l'avons vu, les modificateurs de visibilité sont utilisés pour contrôler l'accès aux membres d'une classe. Cet effet s'étend également au processus d'héritage. Ainsi, les méthodes privées et les variables de la classe parent ne peuvent pas être référencées dans la classe enfant ou via un objet de la classe enfant. Et si nous déclarons une variable avec visibilité publique pour cela afin que la classe dérivée puisse la référencer. Nous violons le principe de l'encapsulation. Par conséquent, Java fournit un troisième modificateurs de visibilité protégés. Donc, nous utilisons protégé. Nous pouvons avoir accès à cette variable et à notre classe enfant, dictionnaire. Maintenant, c'est bon de dictionnaire. Et ici, nous avons notre classe de dictionnaire. Donc cette classe, dictionnaire, qui est un livre, ils sont dérivés de la classe de livre. Alors sauvegardons ce dictionnaire d'hommes de classe. Nous avons trois méthodes et une variable. Utilisons privé. Modifiez cette définition pour qu'elle soit égale à 2005500 par exemple. Mais nous avons 52 500 définitions. Maintenant, créons notre première méthode pour calculer le problème JHU. Maintenant, comme nous l'avons dit, nous pouvons utiliser et le livre, parce que nous les avons dit comme protégés. Et calculer les ratios, nous retournons simplement un W définitions divisées par le problème. Je suis désolé, sur le nombre de pages, les âges et le problème que nous avons prolongé du travail. Et maintenant, nous avons deux méthodes de repos. Maintenant, la méthode est définie définitions. Comme d'habitude, des nations engourdies. Et nous avons dit que les cliniciens sont égaux à neuf. Et enfin, nous avons les définitions get pour retourner combien de définitions il y a une définition de def entier sans et simplement retourner des définitions. Donc maintenant ce sont nos méthodes et allons de l'avant et les utiliser dans notre classe mondiale. Donc, il classe vers l'extérieur. Donc, c'est notre méthode principale et notre dictionnaire d'objets en W. Maintenant, nous allons travailler avec elle. Nous avons donc une méthode. Imprimons le nombre de pages. Donc, nombre de pages. Et vous allez utiliser obtenir des plages. Nous n'avons pas encore terminé les pages de saut. Et si nous allons de l'avant et exécutons ce code, obtenez un nombre de pages, cent cinq cents. Et nous allons également imprimer le nombre de définitions différentes. On dirait des définitions et des définitions. Nous avons donc 52 500 définitions. Et enfin, calculons-les simplement par des définitions. Donc, pas combien de définitions qui est dans la page et utiliser W.com et l'imprimer. Nous obtenons des définitions. Trente-cinq définition. Maintenant, rappelez-vous que nous avons également défini Pages et défini la définition. Ainsi, par exemple, si nous voulons changer les pages, il suffit d'utiliser le jeu de points W. H est par exemple, dix et nations pour la qualité. Et si nous imprimons les définitions, page une fois de plus, un autre nombre qui est égal à quatre. Donc c'est tout pour cette vidéo. se voit dans la prochaine. 4. Super référence: Maintenant, nous avons aussi une référence que nous devrions connaître. C' est la super référence. Ainsi, le mot réservé Super peut être utilisé dans une classe pour faire référence à sa classe parent. Nous pouvons donc avoir accès au membre d'un parent en utilisant la super référence. Maintenant, le mot super fait référence dépend de la classe dans laquelle il est utilisé. À. Maintenant, démontrons que l'utilisation de référence supérieure restera. Avec ces exemples. Nous avons nos routes de classe mondiale, nous avons notre méthode principale, et nous avons le dictionnaire, et nous avons étendu le livre. Et enfin, nous avons notre classe. Maintenant, supposons que nous ayons dans notre livre un constructeur. Donc, cela a mis un constructeur ici, en disant que le secteur public a le même nom que le verre. Et donnons-lui un paramètre d'entiers, qui est le nombre de ponts. Et à l'intérieur de ce constructeur, réinitialisez les pages pour être égales aux plages données par le constructeur. Et maintenant c'est notre constructeur en classe de livre. Maintenant, nous allons créer un autre constructeur dans la classe de dictionnaire. Donc, nous avons simplement créé un dictionnaire de sortie et nous allons lui donner la valeur deux pages et définitions. Changeons cela à la Donc, nous allons tout d' abord les définitions égales à la définition. Et donc maintenant je peux invoquer le super, le constructeur du parent en utilisant la super référence. Très bien, super et donnez-lui la valeur de religieux. Et maintenant, nous utilisons le super. Ainsi, le constructeur Dictionary prend deux valeurs entières en tant que paramètres. Nous avons des pages et des définitions représentant un certain nombre de pages et un certain nombre de définitions dans le livre. Donc, parce que la classe de livre a déjà un constructeur qui effectue le travail pour configurer le chemin du dictionnaire qui ont été hérités. Nous comptons sur le constructeur de pont pour faire ce travail. Donc, au lieu de dire que les pages égales à la, cette base, nous nous appuyons simplement sur ce constructeur de la classe, en disant super. Donc, il ira au constructeur dans la classe de livre et lesdites pages pour être égales à ces pages. Maintenant, un constructeur chargé est responsable d'appeler le constructeur de son parent. Généralement, la première ligne du constructeur doit utiliser l'appel de super référence au constructeur de la paire. Et si aucun code de ce type n'existe, Java fera automatiquement un appel à super Au début du constructeur. Donc, cette règle assure que apparemment initialise ses variables avant que le constructeur de classe enfant commence à s'exécuter. L' utilisation de la super référence pour invoquer le constructeur avancé ne peut être fait que le constructeur enfant. Et si inclus, il doit être la première ligne du constructeur. Ainsi, la super référence peut également être utilisée pour référencer d'autres variables et méthodes définies dans la classe parent. Et nous utilisons ces données techniques. Passant à l'héritage multiple, l'approche de Java en matière d'héritage est appelée héritage unique. Ce terme signifie que la classe dérivée ne peut avoir qu'un seul parent. Certains langages orientés objet permettent à une classe enfant d'avoir plusieurs canaux. Cette approche est appelée héritage multiple et est parfois utile pour décrire des objets qui se trouvent entre deux catégories de classes. Par exemple, supposons que nous avions une classe et le camion de classe. Et nous voulions créer une nouvelle classe appelée pick-up. Une camionnette est un peu comme une voiture et un peu comme un camion. Avec l'héritage unique, nous devons décider si c'est un meilleur, s'il est préférable de dériver le nouveau gars de classe par camion avec héritage multiple, il peut être dérivé des deux, comme le montre cette figure. L' héritage multiple fonctionne bien dans certaines situations, mais il vient avec un prix quand il, fois camion et voiture ont des méthodes avec le même nom. Quelle méthode ? Pickup hérite ? La réponse à cette question est complexe, et cela dépend des règles du langage qui prend en charge l'héritage multiple. Les concepteurs du langage Java ont explicitement décidé de ne pas prendre en charge l'héritage multiple. Au lieu de cela, nous pouvons compter sur l'héritage et les interfaces pour fournir les meilleures fonctionnalités de l'héritage multiple sans la complexité supplémentaire. Bien qu'une classe Java puisse être dérivée d'une seule classe parent, peut implémenter plusieurs interfaces. Par conséquent, nous pouvons interagir avec une classe particulière de la manière spécifique avec l'héritage et les interfaces, tout en héritant des informations de base d'une classe parent et en utilisant des interfaces. Et nous parlerons des interfaces plus tard. Donc c'est tout pour l'héritage super et multiple. Et la vidéo suivante, nous allons apprendre comment une classe enfant peut remplacer la définition des parents d'une méthode héritée. 5. Méthodes de surclassement: Passage aux méthodes de remplacement. Lorsqu' une classe enfant définit une méthode avec le même nom et la même signature qu'une méthode dans la classe parent, nous disons que la vierge de l'enfant remplace la version du parent en faveur de la sienne. La nécessité de remplacer se produit souvent dans les situations d'héritage. Allons donc de l'avant et démontrons l'utilisation d'une méthode remplacée. Crée un nouveau package, nommez-le. Droit ? Et, et ce paquet va créer trois classes. Le premier, nous allons le nommer message. Le second sera à deux fois. Et enfin, nous allons créer une classe appelée pensée. On a donc trois classes. Et le message. Ici, nous avons notre méthode principale et nous allons la travailler plus tard. Mais pour l'instant, nous allons connecter le vice et la pensée. Donc, à la troisième est dépendre classe et la classe de conseil est l'enfant étendre. Et créons la même méthode. La même méthode et les deux classes. Donc, dans la pensée, créerait un message vocal public sans paramètre, il suffit d'imprimer. C' est le message du parent. Et la classe de conseil aurait la même méthode. Message public, public. Sans paramètre, il imprime simplement. Ceci est un message de la classe. Et nous allons utiliser le super, super.message pour invoquer explicitement les parents vierges. Maintenant, allons de l'avant et utiliser vous avez ici une erreur indéfinie pour le temps. Vous devez enregistrer ceci et tout correctement. Et maintenant, passons à notre message. Utilisons deux objets. Un pour des conseils, vous avez des conseils, un nouveau conseil, et la même chose pour le nom et le nouveau. Maintenant, nous allons utiliser la même méthode dans les deux avantages. Donc, nous disons .me et le message qui les échange, utilisez d'abord, cette clé, puis imprimez une ligne. Alors voyons ce qui va se passer. Donc, nous avons imprimé que c'est un message de la classe parent, puis aligné. Donc c'est notre sortie de D, ce message. Et puis c'est la sortie d'un, ce message. Dans un message va obtenir, il s'agit d'un message de la classe enfant. Et depuis qu'on a utilisé ici, le Super, on a invoqué quoi ? Le message de la troisième classe que nous avons ici. Ceci est un message de la classe parent, donc nous allons imprimer un message de la classe parent. Maintenant, une méthode peut être définie avec le modificateur final. Et puis Jet enfant Cass ne peut pas remplacer une méthode finale. Cette technique est utilisée pour s'assurer que la classe dérivée utilise une définition particulière d'une méthode. Et maintenant, nous allons parler de variables d'observation. Bien que non recommandé pour la classe interne, pour déclarer une variable avec le même nom que celle qui est héritée du parent. Maintenant, il y a une différence entre une déclaration d' une variable et simplement donner un hérité par une valeur particulière. Par exemple, si nous avons une variable entière ici dans la troisième classe, nous pouvons lui donner une valeur dans la classe de conseil, mais il n'est pas recommandé de la redéclarer comme, par exemple, une chaîne ou comme un double. Maintenant, cette déclaration crée de la confusion, et cette confusion provoque des problèmes et ne sert aucun but utile. Donc, la déclaration de tableau d'un nom de variable particulier pourrait changer son style, mais c'est, et les variables d'ombrage généralement inutiles et générales devraient être évitées. Donc, c'est tout pour l'observation des variables et les méthodes de remplacement. se voit dans la vidéo suivante. 6. Hiérarchies du cours: Maintenant, nous allons parler des hiérarchies de classes. enfant issu d'un parent peut être le parent de sa propre garde d'enfants. Ainsi, plusieurs classes peuvent être dérivées d'un seul parent. Par conséquent, les relations d'héritage se développent souvent en hiérarchies de classes. Donc, ici, ce diagramme nous montre une hiérarchie de classes qui inclut la relation héréditaire entre mammifère et classe hôte, par exemple, oiseau et perroquet, animal et naissance. n'y a pas de limite au nombre d'enfants qu'une classe peut avoir, ni au nombre de niveaux auxquels la hiérarchie de classes peut s'étendre aux enfants que le même parent est appelé frères et sœurs. Donc ici, cheval et mauvais sont des frères et sœurs. Bien que les frères et sœurs aient perdu les caractéristiques transmises par le parent commun, elles ne sont pas liées par héritage parce que l'une n'est pas utilisée pour dériver l'autre. Dans les hiérarchies S, les entités doivent rester aussi élevées que possible dans la hiérarchie. De cette façon, la seule caractéristique d'établir explicitement le casting enfant sont celles qui rendent la classe distincte de son parent et de ses frères et sœurs. Donc, par exemple, si nous avons une méthode dans l'animal, disons-le. Donc tous les animaux mangent. Donc on va le garder dans la classe des animaux. Cependant, tous les animaux ne volent pas. Donc, cette méthode voler, nous pouvons créer et la classe d'oiseau. Ainsi, cela facilite également activités de maintenance car lorsque les modifications sont rendues permanentes, elles sont automatiquement reflétées dans les descendants. N' oubliez pas de maintenir la relation est une relation lorsque création de hiérarchies de classes n'est pas une organisation de hiérarchie optimale unique pour toutes les situations. Les décisions que vous prenez lorsque vous concevez une hiérarchie de classes limitent et guident des décisions de conception plus détaillées et des options d'implémentation. Vous devez donc les prendre très soigneusement. Passant à la classe d'objet en Java, toutes les classes sont dérivées en fin de compte de la classe d'objet d'une classe. La définition n'utilise pas la clause extends pour se dériver explicitement d'une autre classe. Et cette classe est automatiquement dérivée de la classe d'objet par défaut. Donc, quand nous disons dans, par exemple, créons une classe. Et appelons-le. La chose aura une classe appelée « chose ». Cette représentation est équivalente à dire étend l'objet. Parce que toutes les classes sont dérivées certains objet sur les méthodes publiques d'un objet sont hérités par API classe Java. Ils peuvent être invoqués via n'importe quel objet créé et n'importe quel programme Java. La classe Object est définie dans le paquet java.lang de la bibliothèque de classes standard de Java. Donc, nous avons quelques méthodes dans cette classe d'objet, comme il s'est avéré, utilisé des méthodes d'objet tandis que souvent dans nos exemples, la méthode toString, par exemple, est définie dans la classe d'objet. Ainsi, la méthode de coloration peut être appelée sur n'importe quel objet. Et c'est pourquoi lorsque nous définissons une méthode ToString et une classe, nous écrasons en fait une définition héritée. Définition de ToString fournie par la classe d'objet. Nous avons également une autre méthode que nous voyons plusieurs fois auparavant. Cela équivaut à ce qu'il renvoie true si l'objet est un alias de l'objet spécifié. Les classes remplacent souvent la définition héritée de la méthode .equals en faveur d'une définition plus appropriée. Par exemple, la classe String remplace la valeur égale, sorte qu'elle ne renvoie true que si les deux chaînes contiennent les mêmes caractères dans le même ordre. Donc c'est tout pour les hiérarchies de classes. se voit dans la vidéo suivante. 7. Visibilité: Comme nous l'avons discuté précédemment, toutes les variables et méthodes, même les membres privés qui sont définis dans une classe parent, sont hérités par les clubs enfants. Ils existent pour un objet de la classe dérivée, même s'ils ne peuvent pas être référencés directement, ils peuvent être référencés indirectement. Regardons donc un exemple qui démontre cette situation. Allons de l'avant et créons un nouveau paquet, et appelons-le. Visibilité. Et à l'intérieur de ce paquet aura trois classes. Comme d'habitude. Créons une classe appelée analyseur alimentaire. Et ici, nous avons notre méthode principale. Et une autre classe. Donnons-le un nom. Par exemple, l'aliment, l'exemple de l'Alaska. On va le nommer bêta. Maintenant, nous avons trois classes. Mettez analyseur, aliment et pizza. Donc, l'élément de pied est dépendante verre et la pizza s'étend. Pied est de créer quelques méthodes. Donc, NPDES va créer, par exemple, créons un constructeur. Simplement pizza publique, lui donner une valeur de GM et simplement appelé la méthode super et mettre élément qui pourrait créer des données. Donc, ceci, par exemple, ce super Nous allons prendre deux paramètres, le g que nous obtenons de la méthode pizza. Et par exemple, disons huit. Et maintenant, nous allons créer la méthode dans l'aliment afin que nous le comprenions mieux. Maintenant, ici dans l'élément alimentaire est de créer trois entiers. Comme créer des galeries privées. 30 grammes. Mettons-le à neuf. Et un autre privé. Mais grammes. Et enfin, créer un protégé. Maintenant, créons notre construit et il faudra deux paramètres. Appelons ça un aliment. Et vous prenez deux paramètres. Un nombre de pétagrammes, grammes, et le second est le nombre de portion, portion. Alors maintenant, quand on a appelé le Super ici, on a appelé le constructeur. Et la classe des aliments, il faudra deux paramètres, donc nous avons deux paramètres. Maintenant. Allons-y et utilisons-le. Nous avons des gros grammes et donc des banques. Donc juste attribué des grammes de graisse égale au nombre de grammes que nous avons déjà obtenu de l'utilisateur. Et la même chose pour les portions sera le nombre de portions. Maintenant, créons quelques méthodes. Par exemple, pour retourner les calories, grammes de graisse, multipliés par les calories par plante. Et une autre méthode pour calculer les calories par portion, il suffit de tourner les noms, galeries, les portions, et nous simplement calories et divisé par le service. Donc, nous allons retourner les galeries à tourner. Les terroristes auront la méthode des calories. Nous l'appelons simplement en utilisant des piles et le divisons par le nombre de portions que nous avons le nombre de portions en service. Et c'est nos calories par portion. Maintenant, allons de l'avant et utilisons cette méthode et notre classe principale. Donc nous allons créer une pizza. Pizza. Nommons la pizza spéciale avec une valeur de 275. Et nous allons imprimer les calories par portion. Calories. C' est par portion. Et nous allons obtenir des calories spéciales par portion et exécuter le code recevra des calories par portion, 309. Maintenant, la classe de pizza est dérivée de la classe d'articles alimentaires, mais elle n'ajoute aucune fonctionnalité ou donnée spéciale. C' est le constructeur appelle le constructeur de l'article alimentaire en utilisant la super référence, affirmant qu'il s'agit de huit portions de pizza. L' objet pizza ici appelé spécial, est dans la méthode principale et utilisé pour invoquer la méthode calories par portion, qui est définie comme une méthode publique d'article alimentaire. Maintenant, ici, notre message devrait être privé. Et ce que nous avons fait ici, c'est que nous pouvions calories par portion, ce qui est une méthode publique. Ensuite, cette calories par portion appelle des calories. Calories est une méthode privée et galeries appelées grammes gras et diseurs par gramme, et ils sont également privés. Donc, ce que nous essayons de dire ici que même si la classe de pizza ne peut pas explicitement faire référence aux calories, calories par gramme, et cinq grammes. Ils sont disponibles pour une utilisation directement. Et l'objet pizza a besoin de bouchon. Objet bizarre ne peut pas être utilisé dix fois la méthode des calories, mais il peut appeler une méthode qui peut. Ainsi, l'objet de pied n'a jamais été créé ou nécessaire. Maintenant, puisque, par exemple, calories par gramme est, nous sommes absolument sûrs qu'il est égal à neuf. Nous pouvons simplement ajouter ici privé, final et la chaise. Donc, ce que nous disons ici, c'est que cette variable est finie et nous ne pouvons pas la changer. Maintenant, les autres utilisations du modificateur final impliquait héritage et peuvent avoir une influence significative et la conception du logiciel, en particulier le modificateur final, peut être utilisé, réduire la capacité est liée à l'héritage. Donc, plus tôt, nous avons mentionné que la méthode peut être déclarée comme finale, ce qui signifie qu'elle ne peut pas être remplacée dans les classes qui étendent celle qu'elle est. La méthode finale est souvent utilisée pour insister pour que la fonctionnalité particulière soit utilisée dans toutes les classes essayées. Maintenant, le modificateur final peut également être appliqué à une classe entière. La classe finale ne peut pas être prolongée du tout. Donc, nous pouvons simplement dire que l'article de classe publique. Et maintenant, nous aurons le destinataire disant que la pizza de type ne peut pas sous-classer l'élément de mise de classe finale car il est fini et vous ne pouvez pas étendre. Donc, en donnant cette déclaration, cette classe ne peut pas être utilisée dans la clause d'extension d'une classe d'actifs. Le compilateur générera un message d'erreur dans ce cas. L' utilisation du modificateur final pour restreindre les capacités d' héritage est une décision de conception clé et doit être effectuée dans les situations où une classe enfant pourrait éventuellement être utilisée pour modifier les fonctionnalités que vous, en tant que concepteur, les citoyens voulaient être traités d'une certaine façon. Cette question revient et la discussion du polymorphisme, et nous en discuterons plus tard. Alors on se voit dans la prochaine vidéo. 8. Polymorphisme: Maintenant, nous discutons du polymorphisme et d'autres principes fondamentaux du logiciel orienté objet. Souvent, le type d'une variable de référence correspond la classe de l'objet à laquelle préfère Exactement. Donc, quand on dit, par exemple, on est égal à nouvelle chaîne. Et dire, maintenant, ce que nous avons fait ici est le type de variable de référence est le même que l'objet de classe, qui est maintenant le terme polymorphisme alors être défini comme ayant de nombreuses formes. Une référence polymorphique est une variable de référence qui peut faire référence à différents types d'objets à différents moments dans le temps. La méthode spécifique invoquée via une référence polymorphique peut passer d'une invocation à l'autre. Supposons que nous ayons une méthode appelée duo. Et s'il y a un objet de référence ici est polymorphe, il peut se référer à différents types d'objets à différents moments. Donc, si cette ligne pourrait se discorde, s'exécute, puis boucle, ou c'est une méthode qui est appelée plus d'une fois. Cette ligne de code pourrait appeler une version différente de la méthode duet. Chaque fois qu'il est invoqué, nous pouvons créer une référence polymorphique en Java de deux façons, en utilisant l'héritage et en utilisant des interfaces. Regardons chacun à son tour, commencera par le polymorphisme Vodafone via l'héritage. Donc, lorsque nous déclarons une variable de référence en utilisant un nom de classe particulier peut être utilisé pour faire référence à n'importe quel objet de cette classe. En outre, peut également se référer à n'importe quel objet de n'importe quelle classe qui est liée. Et c'est déclaré type par héritage. Donc, par exemple, essayons ceci ici, nous avons notre méthode principale est de créer quelques classes ici. Par exemple, créer une classe appelée mammifère, une autre créature de classe. Et les derniers hôtes de classe. On a donc trois classes. La classe parent, devinez la créature, et il a un système de classe enfant Emile, il devrait s'étendre. Et c'est le courrier principal, il devrait étendre la créature. Et enfin, nous avons notre cours, qui est une classe de domaine enfant, et il devrait aussi l'étendre. Alors maintenant, nous avons appris trois verres. Avec l'héritage. Maintenant, la référence principale peut être utilisée pour faire référence à n'importe quel objet de la classe détient. Donc, par exemple, si nous disons, appelons-le H. Donc, c'est notre cheval objet. Et par exemple, nous, par exemple, nous pouvons dire égal à bord et de travailler correctement. Donc, cette relation fonctionne dans toute la hiérarchie des classes. Donc, si la classe des mammifères ont été dérivées d'une créature cascode ici, nous pouvons aussi dire que Ranger, Par exemple, limitons c égal à nu. Et cela fonctionnera correctement. Et vous pouvez également vous connecter aux codes. Depuis Horus est l'enfant de peut-être. Maintenant, la variable de référence SC peut être polymorphe car à tout moment, elle peut se référer à un objet Animal, créature à permettre à l'hôte. Supposons donc que ces trois classes aient une méthode appelée move qui est implémentée de différentes manières et lorsque cette ligne est exécutée. Donc, si la créature fait actuellement référence à un objet de créature, si c fait référence à un objet de créature, la méthode de déplacement de la classe de créature est invoquée. De même, si c garanti fait référence à un objet mammifère, la version continentale du MOOC est invoquée. Et enfin, si C est actuellement pays se référant à un objet cheval, le cheval, que la méthode en classe de cheval sera invoquée. C' est donc une idée générale sur le polymorphisme. Et la prochaine vidéo, nous allons faire un exemple pour mieux la comprendre. 9. Exemple de polymorphisme partie 1: Maintenant, jetons un coup d'oeil à une autre situation. Considérez donc cette hiérarchie de classes. Les classes de cette hiérarchie représentent différents types d'employés qui peuvent être employés dans une entreprise donnée. Examinons donc un exemple qui utilise cette hiérarchie pour payer un ensemble d'employés de différents types. Donc, tout d'abord, nous avons la classe d'entreprise contient dans le Maine, détourné crée un personnel d'employés et invoque la méthode de paie pour payer leur appel. Le programme. La sortie comprend des informations sur chaque employé et la quantité de mauvais. Si quoi que ce soit. Cette firme, nous avons le personnel. Il maintient un tableau d'objets qui représentent des employés individuels de divers types. Donc, la zone est déclarée avoir à tenir des références de membre du personnel, mais est en fait rempli d'objets créés à partir de plusieurs autres classes telles que l'employé bénévole, exécutif. Et ces classes sont toutes les descendants de la classe des membres du personnel. Et donc l'affectation est valide. Le tableau établi est rempli de références polymorphes. Donc, ici, dans ce membre du personnel, nous pouvons accéder à des cadres bénévoles, sans aucun doute. Voie polymorphe. Maintenant, chaque classe a ses caractéristiques spécifiques. Donc, tous les travailleurs doivent avoir leur nom, leur adresse et leur téléphone. Mais si une personne est adverse td, elle n'a pas besoin d'avoir un numéro de sécurité sociale ou un taux de rémunération. Et c'est là que le bénévole est différent de l'employé. Et la même chose pour les cadres et toutes les heures. Donc exécutif ont, a un bonus et horaire a travaillé. Alors allons de l'avant et créons nos cours. Pour commencer. Créons notre paquet. Finissons donc avec un exemple, exemple de polymorphisme, et nous allons créer notre classe. Nous avons ici notre méthode principale. Allons créer une autre classe. Créer le membre du personnel nommerait ça trucs. Donc nous avons notre deuxième classe. Alors. Nous avons aussi allons-y et voir quoi. Nous avons notre personnel, nous avons des membres du personnel. Créer une classe de membre du personnel. Ensuite, nous avons fait du bénévolat l'employé Scott, c'est le potentat en classe. Et puis nous avons aussi des exécuteurs, et ce sont les deux dernières classes, exécutive. Et enfin. Alors maintenant que nous avons créé toutes nos classes, allons les assigner ensemble. Nous avons donc le membre du personnel, le bénévole et l'employé qui prolongent le membre du personnel. Donc volontaire ici étend les membres du personnel. Et la même chose avec le membre du personnel. Et comme nous pouvons le voir dans cette hiérarchie de classes, nous avons des classes d'employés exécutifs et enfants. Il va aller ici et les étendre à partir de. Et la même chose avec étend. Et commençons par le membre du personnel. Comme nous pouvons le voir ici, nous avons un membre du personnel, trois variables, nom, adresse et téléphone, et à la méthode toString. Et allons de l'avant et créons-les. Et nous-mêmes. Donnez-leur un nom de référence protégé, adresse. Et nous aurons nos trois variables. Et maintenant, nous pouvons créer notre constructeur pour configurer le membre du personnel en utilisant l'inflammation spécifiée. Nous avons donc ces trois informations à créer. Nous avons construit ces informations comme d'habitude. Et les trois cordes dans la barre d'adresse. Et il suffit de les assigner à regarder les variables. Et pour n égal à p. Donc c'est notre constructeur. Maintenant, créons nos deux méthodes. Nous avons toString, toString, et il imprimera le nom, l'adresse et le téléphone. Allez-y et créez ceci. J' ai appelé trois, dont nous avons le nom plus, plus. Nous allons créer une nouvelle ligne par simplement vous ligne en tapant simplement n. Donc c'est notre nom. Et sur la deuxième ligne, nous aborderions. Adresse. Et l'adresse. La dernière ligne, numéro de téléphone. Donc c'est le numéro de téléphone. Et maintenant, nous devons ajouter une nouvelle ligne. Donc, c'est notre méthode toString, et finalement nous retournons le résultat. Maintenant, la dernière méthode que nous avons dans cette classe est les méthodes de la baie de Dublin. Les méthodes ont doublé. Chaque employé a un mode de paiement différent, permettra aux classes dérivées de définir une méthode pour chaque type d'employé. Donc, cette méthode n'aura aucun corps. C' est pourquoi ce sera abstrait. Et nous devrions également assigner la classe à être abstraite aussi. Puisque nous avons une méthode abstraite. Donc c'est notre classe de membre du personnel, et nous continuons avec les autres classes dans la prochaine Purdue. 10. Exemple de polymorphisme partie 2: Maintenant, puisque nous avons fini avec notre classe de membres du personnel, va passer à notre bénévole. Donc, nous avons un additif ici disant que le volontaire doit implémenter la méthode abstraite héritée. Fonctionnaire. Maintenant sera hérité. Mais avant, allons à notre hiérarchie de classe et voir que nous avons un volontaire n'avait pas seulement une méthode double B. Alors revenons en arrière et créons notre constructeur. Nous avons constructeur volontaire, sergé prendre comme d'habitude, trois forces. Fessée et une adresse doivent être effectuées. Et notre super constructeur et donner ces trois valeurs. Donc maintenant créé notre constructeur. Créons notre méthode, qui est B. Et en tant que bénévole ne paiera rien. Nous venons de retourner 0. C' est notre classe de bénévolat. Passons maintenant à notre classe d'employés représente un employé rémunéré général. Dans cette classe. Nous avons notre constructeur comme d'habitude, mais revenons à notre hiérarchie de classes. Nous pouvons voir que nous avons deux nouvelles variables, numéro de sécurité sociale et l'aide à la bade. Nous avons deux méthodes pour chaîner et payer. Donc, tout d'abord, créons nos deux variables. Chaîne protégée. Nous avons le numéro de sécurité sociale, et un autre protégé par un double type 8. Maintenant encore, créer un public non construit. Et le paramètre maintenant nous avons cinq variables au lieu de trois. Nous avons le nom, l'adresse et le téléphone. Et nous allons ajouter le numéro de sécurité sociale et la période. Allons de l'avant et dans ces cinq investissements et pour le nom, pour l'adresse, le téléphone, et demander le numéro de sécurité sociale. Et enfin, un double standard joué. Et ce que nous allons faire est d'affecter les trois variables comme d'habitude au super, en utilisant la super référence à la classe constructeur. Et maintenant on en a fini avec le nom, adresse et le téléphone. Ils le sont automatiquement. Ils sont allés voir le membre du personnel et ils sont affectés ici. Et maintenant fonctionnerait avec notre numéro de sécurité sociale. Numéro de sécurité sociale, nous allons lui donner une valeur de S. Et le taux que nous avons appâté avec une valeur de taux. Maintenant, travaillons avec nos méthodes. Nous avons deux méthodes qui toString que nous devons modifier et le taux que le débat. Tout d'abord, allons modifier les deux brins. Qui est la méthode du réservoir ? Et si nous utilisons super D2 souche obtiendra la méthode toString, ce que nous stockons ici. Nous avons donc le nom, l'adresse et le numéro de téléphone. Alors allons de l'avant et utilisons un niveau. Nous l'avons fait. Créons un argot appelé résultat et utilisons le super pour appeler la méthode toString et le supertype membre du personnel. À. Maintenant, nous avons toutes les informations et le membre du personnel comme adresse numérotée et étranger ici. Et nous ajouterons à notre numéro de sécurité sociale en disant simplement numéro de sécurité sociale avec une valeur de numéro de sécurité sociale. Et puis retournez le résultat. À. Maintenant, nous en avons fini avec cette méthode. Allons de l'avant et travaillons avec notre méthode de baie, qui est publique et rendrait une valeur de thêta. Maintenant, voici notre employé. Allons travailler avec notre exécutif. Et maintenant, revenons à notre hiérarchie de classe et nous voyons que les cadres ont bonus, la variable w, bonus et deux méthodes, notre bonus et ils allaient à l'exécutif et un nouveau double bonus privé. allons créer notre exécutif public construit maintenant et vous donner quelques valeurs que nous avons comme d'habitude, le nom et l'adresse est trouvé, puis le numéro de sécurité sociale, nom adresse. Et enfin, il y en a huit. Et comme d'habitude, on appellera le super, donne-lui un nom. Adresse par téléphone comme social et augmenter. Le bonus ici sera égal à 0. Nous avons donc fixé un bonus égal à 0. Maintenant, c'est notre constructeur. Créons nos deux méthodes. Nous avons awoid bonus, public, bonus poète. Si vous prenez un paramètre d'une tablette, Nommez-le coronas, et nous allons attribuer un bonus à cette boîte. Et la dernière méthode est la rémunération calculera et retournera pour un cadre supérieur, qui est le paiement régulier de l'employé plus la prime unique. Donc nous obtenons notre méthode. Et cette méthode, créons un paiement, ce qui est super bon. Nous allons donc calculer la date de paye comme d'habitude à partir de l'employé et plus la prime, puis revenir. Donc c'est notre classe de direction. Allons maintenant à notre classe. Et notre classe, nous aurions une nouvelle variable, heures travaillées et trois méthodes à la nôtre et à chaîne. Donc ici, tout d'abord, nous créons notre variable privée, heures travaillées. Et créons notre constructeur comme d'habitude. Et nous avons un, B, Jang. Et enfin, et nous allons attribuer ces quatre variables, cinq variables au super ET A, B, S et R. et donner aux heures de travail la valeur de 0. Ici, nous n'avons pas une méthode appelée ajouter des heures pour ajouter notre méthode d'évitement, heures publiques et les heures. Et il attribuera des heures sauvages. Donc quoi que nous ayons, inverser les heures, nous y ajoutons ces heures. Et une autre méthode est le débat pour cet employé. Donc, dans cette méthode reviendrait. Et nous avons un double paiement. Et le paiement est payé. Nous devons payer le nombre d'heures qu'ils travaillent simplement. Donc nous avons nos heures de travail. Et puis après cela, chaque fois que nous payons, l'employé se réinitialisera automatiquement à 0. Ensuite, nous retournons en paiement. Donc c'est notre paiement. Et enfin, nous avons notre méthode toString est une chaîne publique. Et nous pouvons simplement prendre le résultat du char et ensuite le modifier en ajoutant les heures actuelles. Combien d'heures d'amortisseur fonctionnent actuellement. Nous ajoutons donc une nouvelle ligne. Et puis nous ajouterons, disons les heures et heures actuelles, les heures travaillées. Ensuite, retournez les résultats. Nous avons terminé avec nos cours parents et enfants, membre du personnel, bénévole, cadre, et avidement, la prochaine vidéo nous parlerons du personnel et des cours. 11. Exemple de polymorphisme partie 3: Maintenant, nous avons encore deux classes, classe ferme et la classe du personnel. Travaillons avec la classe du personnel. À l'intérieur de cette classe va créer une liste de certains membres du personnel. Donc, un membre du personnel privé, comme Adam et son nom est, trucs, obtient créer un constructeur pour mettre en place un personnel de télescope par tout simplement sans paramètres et donnera cette valeur de liste de choses. C' est le nouveau truc. Nous avons donc huit éléments dans cette liste et quelques éléments. Liste des trucs, poste 0, cadre par exemple. C' est le nom de la chaîne. Et l'adresse sera 1-2-3. Numéro de téléphone de la ligne principale, par exemple, disons moins 0.51111. Et ce numéro de sécurité sociale, c'est, par exemple, le 123456789. Et enfin, le taux est, par exemple, disons 2423.07.07. Élément à la première position , employé et employé. Et comme d'habitude, par exemple, comme d'habitude, disons par exemple, 0,01. Numéro de sécurité sociale 12345451234. Et enfin, itérer, disons cent deux cent quarante six. 0,15. Et nous faisons la même chose avec les autres juste pour ne pas les copier. Et c'est donc le second 17567. Et changeons Haïti par exemple. Disons, gardons-le en tant qu'employé à la seconde. Et puis celui après il est brisé en tant que professeur. Et l'autre a assez, alors ajustez la taille et faites-le six. Maintenant, modifions ce nom, cet employé. Et par 55 au numéro de téléphone et 99. Et enfin itérer par exemple, 3,246. Et la même chose ici. Et nous avons le 999. Même chose chauffée. Changeons les chiffres et le taux comme d'habitude. Par exemple, mettons-le à 1010. Et enfin, nous devons voter et on sait que c'est le cas. Et c'était juste le nom, adresse et le numéro de téléphone sans ces deux supplémentaires. Alors allons de l'avant et supprimez-les. Et c'est notre premier, et c'est notre deuxième volontaire. Changez juste ici. P5. Et oui, cette ligne principale 123. Et il l'est. Voilà donc, ce sont nos membres et cette liste. Maintenant, nous avons encore deux méthodes. Un et exécutif, un mot empoisonné et rassemblé et le nôtre. Et utilisons-les. Et nos membres du personnel, notre personnel. Maintenant, nous devons travailler avec l'exécutif. Donc, nous écrivons simplement exécutif. Et dire au programme que nous avons besoin d'un membre du personnel de direction. Nous spécifions ce que la liste de portée lorsque vous commencez à le mettre entre parenthèses et bonus ascendants, et c'est 500 par exemple. Et la même chose. Et nous aurons le personnel en liste trois. Et maintenant, nous avons le personnel, la méthode de paye pour le payer ou les membres. Donc, après avoir créé le constructeur va créer un salaire vide public. Et nous avons un montant à payer, donc nous allons l'économiser et il a doublé le montant. Et tout d'abord, nous allons imprimer toutes les listes de personnel. Chaque membre de la liste de portée en imprimant. Et puis si le montant est égal à 0, alors c'est sûrement un volontaire. Ensuite, nous allons juste imprimer des chars. Sinon, imprimerait le montant que nous allons payer. Et le montant est égal à chaque établi. Avec la méthode donne le montant est égal à 0. Alors, merci. C' est un bénévole qui le remercie. Sinon, quand je suis sorti. Plus le montant. Maintenant, nous avons notre méthode dans le personnel. Allons-y et utilisons-le dans notre cabinet. Donc, il recrée l'objet de portée. S est la nouvelle chose et utilisez une méthode. Et lançons le code, voyons ce qui va se passer. Donc, ici, nous avons tout d'abord, notre premier. Revenons en arrière et imprimons la ligne entre F3, moins tous les membres de la liste et cette liste, juste pour, pour être plus clair. Donc, après avoir imprimé chaque, chaque quantité, imprimez une nouvelle ligne. Et maintenant à l'intérieur de la photo et exécutez le code une fois de plus, nous obtenons la même sortie, mais avec une ligne pour diviser chaque membre de cette liste. Donc, tout d'abord, nous avons une adresse, numéro de téléphone et le montant, et ensuite nous avons la même chose. Et enfin, nous devons faire du bénévolat. Et connu et Karla, puisqu'ils sont bénévoles, ne sera pas imprimer le montant parce qu'ils ne sont pas payés. Donc on vient d'imprimer. Merci. Je pense donc que cet exemple démontre l'utilisation du polymorphisme que nous avons établi. Et chaque fois membre du personnel, chaque fois qu'il imprimera des choses différentes depuis chaque fois pour travailler différemment. Donc c'est tout pour le polymorphisme. se voit dans la vidéo suivante. 12. Recursion: Nous avons parlé de récursivité. récursion est une technique de programmation puissante qui fournit une solution élégante à certains problèmes. Nous avons vu plusieurs fois dans des exemples précédents qu' une méthode peut appeler une autre méthode pour atteindre un objectif. Ce que nous n'avons pas encore vu, cependant, c'est qu'une méthode peut s'appeler elle-même. récursion est une technique de programmation dans laquelle une méthode s'appelle pour remplir son but. Mais avant d'entrer dans les détails de la façon dont nous utilisons la récursivité dans un programme, nous devons explorer le concept général de récursivité. La capacité de penser récursivement est essentielle pour pouvoir utiliser la récursivité comme technique de programmation. En général, la récursivité est le processus de définition de quelque chose en termes d'elle-même. Par exemple, supposons que nous voulions définir formellement une liste d'un ou plusieurs nombres séparés par des virgules. Une telle liste peut être définie de manière récursive comme un nombre ou un nombre, suivie d'une virgule, suivie d'une liste. Donc, nous pouvons dire que nous voulons un nombre suivi d'une virgule. Et alors ce sont deux exemples. Nous avons un nombre, puis une virgule, puis une liste. Quelle que soit la durée de la liste, la définition récursive la décrit. Une liste d'un élément, tel que cet exemple, est définie complètement par la première partie non récursive de la définition pour toute liste plus longue qu'un élément qu'elle va si une partie de la définition est utilisée autant fois que nécessaire jusqu'à ce que le dernier élément soit atteint. Ce que nous disons ici, c'est que nous avons un nombre, puis suivi d'une virgule, et ensuite nous avons une liste. Et puis la même chose se passe pour 88 est un nombre, suivi d'une virgule, puis de cette liste. Et 40 est la virgule numérique, puis une liste d'un élément. Et enfin, nous avons un numéro. Maintenant, la définition de la liste contient une option qui est une option cursive et une option qui ne l'est pas. La partie de la définition qui n'est pas récursive est appelée le cas de base. Si toutes les options avaient le composant récursif, cette récursivité ne se terminerait jamais. Par exemple, si la définition des listes était simplement numérotée suivie d'une virgule, suivie d'une liste. Aucune liste ne pourrait jamais se terminer. Ce problème est appelé récursivité infinie, différente de la boucle infinie Glenn, sauf que la boucle se produit dans la définition elle-même. Alors maintenant, allons de l'avant et parlons de la récursivité en mathématiques. Par exemple, supposons le facteur n. Donc disons et factoriel. Ainsi, la valeur appelée n factoriel est définie pour tout entier positif n comme le produit de tous les entiers compris entre un et n inclusivement. Donc, si nous disons n factoriel est égal à trois fois deux fois. Un, c'est six. Maintenant, la même chose si on dit cinq factoriels est cinq fois quatre fois trois fois deux, jusqu'à un. Les formules mathématiques sont souvent exprimées récursivement. Et la définition de N factoriel peut être supplémentaire exprimé comme. Et factoriel est égal à n fois n moins un. Ici, nous avons factoriel quatre et plus grand. Donc, tant que n est supérieur à un, n factoriel est égal à n fois n moins un factoriel. Et la même chose vaut pour ça. Et ainsi de suite. Maintenant, le cas de base de cette définition est un factoriel. Un factoriel est égal à un. Toutes les autres valeurs de n factoriel définies récursivement comme N fois la valeur n moins un factoriel. Donc, en utilisant cette définition, quand on dit 50 factoriel, il est égal à 50 fois 49 factoriel. Et 49 factoriel est égal à 49 fois 48 factoriel et ainsi de suite. Et ce processus se poursuit jusqu'à ce que nous arrivions au cas de base d'un. Étant donné que n factoriel est défini sur les entiers positifs, cette définition est complète et se terminera toujours par le casse de base. Maintenant, travaillons avec les bactéries et la programmation. Tout d'abord, nous devrions créer une méthode de matière pour retourner un entier. Nommez-le factoriel et le sergé prend un entier comme paiement. Et maintenant, comme nous l'avons dit, le cas de base est quand n est égal à un. Donc nous allons dire que si m est égal à un, nous allons juste en retourner un. Sinon, si n n'est pas égal à un, nous venons de retourner et multiplié par le factoriel de n moins un. Maintenant, pour effectuer cette opération, nous appelons simplement la méthode une fois de plus avec le paramètre n minus1. Maintenant, allons de l'avant et utilisons-le. Par exemple, disons que n est égal à quatre. Et cette méthode et, et exécutez le code, nous obtenons 24. Donc, ce qui s'est passé ici, c'est nous, nous avons effectué factoriel avec un paramètre de quatre. Donc, il va à cette méthode. Nous avons car il n'est pas égal à un. Nous avons donc quatre fois le facteur n moins un, qui est trois. Donc quatre fois factoriel trois. Donc on en a quatre. Frappe ici, quatre fois quelque chose. Maintenant factoriel de trois, il va à la méthode une fois de plus. Nous avons trois fois factoriel deux. Donc nous avons trois fois quelque chose. Et la même chose, une fois de plus, deux fois factoriel 12 fois factoriel. Donc, la dernière fois que nous sommes entrés dans la méthode, nous avons n est égal à un, donc il suffit de retourner un. Et c'est ça, c'est quatre fois trois fois deux fois une. On imprimera ça quatre fois 312 fois 224, et on en aura 24. Maintenant, nous pourrions faire face à quelque chose. Par exemple, si nous entrons une valeur négative, disons moins sept, nous obtiendrons une erreur. Parce qu'on n'a pas fait face à ça. Nous avons juste le nombre positif et le multiplions par le nombre en dessous. Et nous avons le cas de base, qui est quand n est égal à un peut le réparer en disant que n est inférieur ou égal à un, retournez un, donc nous en obtenons un. Et si nous ne voulons pas en obtenir un, par exemple, si nous voulons obtenir minus1, nous pouvons dire que si n est inférieur à un, retournez minus1. Et, et puis nous déplaçons ça d'ici et exécutons le code, nous obtiendrons moins un. Il s'agit donc d'un petit exemple et d'une récursivité. Et dans les prochaines vidéos, nous allons l'explorer plus. 13. Exemple : Sum en utilisant des récursions: Utilisons maintenant une autre opération mathématique simple pour démontrer le concept de programmation récursive. Considérez le processus de sommation des valeurs entre un et n inclusivement, où n est un entier positif. La somme des valeurs de un à n peut être exprimée comme et plus la somme des valeurs de un à n moins un. Donc, nous pouvons dire que la somme de n est égale à n plus et moins un. Alors gardons ceci ici comme commentaire. Et commençons par notre méthode. Donnons-le un nom. Certains statiques publics renvoie un entier avec la valeur et, et notre cas de base étant sourd et est égal à un. Retourner un sinon serait tourné le nombre et plus la somme de n minus1. Donc, comme nous l' avons dit ici, nous devrions retourner une partie de n est égal à n. Ceci est n plus la somme de n moins un. Et c'est notre méthode et utilisons-la ici. Imprimez certaines moyennes. Dans ce cas, quatre. On obtient quatre plus trois plus deux plus un égal à dix. Maintenant, le cas de base dans l'exemple de sommation est quand n est égal à un, à quel point aucun autre appel récursif n'est effectué. La récursivité commence à retomber dans les versions antérieures de la méthode de somme, retournant la valeur appropriée à chaque fois. Chaque valeur de retour contribue au calcul du Soleil au niveau supérieur. Sans un cas de base, récursivité infinie résulterait. La fonction de somme différentes valeurs initiales de non-fin et jusqu'à ce que le traitement devient familier. Donc, dans cette figure illustre les appels récursifs lorsque la méthode principale invoque certains pour déterminer la somme des entiers de un à quatre. Chaque zone représente une copie de la méthode telle qu'elle est dans. invocations sont affichées sous forme de lignes pleines ici et retournées sous forme de lignes pointillées. Le résultat de la valeur de retour est affiché à chaque étape. Le chemin récursif est suivi complètement jusqu'à ce que le casse de base soit lorsque la somme est égale au nombre ici, valeurs égales à un. Et après cela, la base est maintenant atteinte. Donc, la cause a alors commencé à retourner le résultat à travers la chaîne. Donc, quand n est égal à un, nous commençons à retourner leurs résultats. Tout d'abord, nous en rendons un. Ensuite, nous avons deux plus 133 plus trois est égal à six, retournera 66 plus 410 reviendrait dix. Maintenant, bien sûr, il y a une solution non récursive au problème de sommation serait juste exploré. Une façon de calculer la somme des nombres entre un et un nombre et inclusif de manière itérative est, par exemple, nous allons utiliser la boucle for pour un à n inclusivement, donc égale à n et somme plus égale à. Et tout d'abord, nous avons un entier, somme égale à 0. Et puis nous imprimons un peu plus somme, et ici nous devons ajouter. Donc la somme est égale à 0 plus un plus deux plus trois, plus cinq plus quatre. Et quand i est égal à quatre, la sortie, la boucle for et la somme d'impression. Et ici, j'ai ajouté une ligne d'impression ici. Maintenant, si on exécute le code, on en aura dix. Maintenant, bien sûr, nous pouvons dire ici que je suis égal à un. Et on a la même chose. Ou peut définir r est égal à un et commencer par i égal à deux. Et bien sûr, nous obtenons le même résultat. Bien sûr, la solution est certainement plus simple que la version récursive. Nous utilisons le problème de sommation pour démontrer la récursivité car c'est simple, pas parce que vous utiliseriez la récursivité pour le résoudre dans des conditions normales. récursion a la surcharge de plusieurs invocations de méthode et dans ce cas présente une solution plus compliquée. Alors c'est l'équivalent itératif. Le programmeur doit savoir quand utiliser la récursivité et quand ne pas l'utiliser. détermination de l'approche la plus appropriée dépend du problème résolu. Tous les problèmes peuvent être résolus de manière itérative. Mais dans certains cas, la version itérative est beaucoup plus compliquée pour certains problèmes et nous permet de créer des programmes relativement courts et élégants. Enfin, nous parlerons de récursivité directe et indirecte. corrosion dialectique se produit lorsqu'une méthode s'invoque elle-même, par exemple lorsque certains objectifs, récursion indirecte se produit lorsqu'une méthode invoque une autre méthode, ce qui entraîne finalement la méthode originale à nouveau être invoquée. Par exemple, la méthode m1 appelle une méthode M2 et M2 appelle la méthode m1. On peut dire que m1 est indirectement récursif. La quantité d'indirection pourrait être de plusieurs niveaux de profondeur. Comme lorsque m1 dans les livres, m2, qui invoque M3, qui invoque M4. Et enfin, cette méthode et pour invoque m1. Et la récursivité directe nécessite toute la même attention pour avoir des cas que la récursivité directe nécessite. En outre, dans la récursivité directe peut être plus difficile à goûter car, comme l'appelle la méthode intermédiaire, extrait est donc terminé lors la conception ou de l'évaluation dans des méthodes directement récursives. Et a montré que l'indirection est vraiment nécessaire et clairement expliqué que vous voulez. 14. Recursion: : Maze partie 1: Après avoir utilisé la récursivité pour certains programmes simples, utilisez-le maintenant avec des programmes plus complexes. Allons de l'avant et créons un nouveau paquet. Nommez ça les programmes. Et nous créons deux classes. Deux fabuleux. Cela signifie que nous avons le premier est appelé recherche labyrinthe. Ici, nous avons notre méthode principale. Et le second, on le nommera labyrinthe. Maintenant, il est surprenant de basculer implique beaucoup d'essais et d'erreurs, suivre un chemin, revenir en arrière lorsque vous ne pouvez pas aller plus loin et essayer d'autres options non essayées. De telles activités sont souvent bien gérées en utilisant la récursivité. Nous avons nos deux classes. Ceci est notre classe de pilote, peut rechercher. Nous avons ici une méthode principale et notre labyrinthe où nous allons créer notre méthode récursive. Donc, ici, tout d'abord, écrivons MA et nous allons utiliser le bidimensionnel ajouté. utilisera jamais auparavant, comme un tableau, mais un tableau bidimensionnel. Nous allons donc utiliser un tableau bidimensionnel d'entiers pour représenter ce labyrinthe. Et le but est de passer du coin supérieur gauche au coin inférieur droit et de l'écrire et ensuite nous reviendrons vers vous. Donc c'est notre labyrinthe. Initialement, un indique un chemin clair et un 0 indique un chemin noir. Au fur et à mesure que le labyrinthe est résolu, ces éléments de tableau sont remplacés par d'autres valeurs pour indiquer chemins tentés et finalement le chemin réussi dans le labyrinthe. Donc nous aurions deux valeurs. On leur donnera une référence finale, et l'un est, limitons. Donc, si nous essayons un chemin, alors la valeur sera de 31 sur le chemin de nommage inférieur passé. Et nous lui donnerons une valeur de sept. Maintenant, la première méthode que nous allons créer est la méthode toString pour imprimer cette grille, ce labyrinthe. Et pour aller de l'avant et nous utiliserons le public. Ici, nous avons de la tension. Souche et il reviendrait. Un domaine labyrinthe va créer sous la forme d'une chaîne. Donc, tout d'abord, nous avons notre force et notre endurance. Et ce résultat. Tout d'abord, nous allons imprimer une ligne et imprimer une ligne ici. Et on l'imprime. Nous allons donc créer deux pour les boucles imbriquées pour les boucles. Une pour les lignes et la seconde pour les colonnes. Donc, ici, nous avons la longueur du grand point. Et l'autre aperçu est cette longueur. Donc si nous disons grand je cette longueur. Donc nous prendrons chaque rangée et, et nous verrons la longueur du coup. Donc il aura 131313. Ainsi, la longueur de l'extérieur pour la boucle comme huit et l'intérieur pour la boucle est de 13. Et maintenant, nous allons aller de l'avant et les stocker dans le résultat. Nous stockons la grille à i et j et ajoutons des guillemets doubles ici. Et nous avons fait, après cela, nous allons juste imprimer aligné. Donc avec ça ici et vous faites la ligne. Et ça va les additionner. Et puis nous devrions faire semblant des résultats. Alors allons-y et essayons-le. Un objet signifie que nous allons utiliser la méthode toString et imprimer le code. Regarde notre labyrinthe. Donc c'est notre secteur. Maintenant, comme nous l'avons dit, on indique un chemin et 0 indique un bloc. Mais maintenant, pour savoir si cette position est valide ou non, je vais créer une méthode, appelons-la pilote. Avant de créer notre méthode parce que si. Donc, nous allons aller de l'avant et créer une nouvelle méthode. Donnons-le un nom. Et il retournera true si cette position est valide et false. Sinon. Donc, prenez deux éléments. Et enfin, nous avons un résultat booléen. Tout d'abord, c'est faux. Et maintenant, nous vérifions si la cellule est dans les limites de la matrice. Donc, vérifiez si rho est supérieur ou égal à 0. Et si rho est inférieure ou égale à cette longueur. Et bien sûr, la même chose pour la colonne. Si le courant est supérieur ou égal à 0 et que la colonne est inférieure ou égale à la longueur du point rho. C' est donc le cas. Ensuite, nous vérifions maintenant si la cellule n'est pas bloquée et pas précédemment liée. Donc, si cette ligne grille égale ligne et colonne est égale à un, alors c'est un mouvement pilote, aurait jamais essayé auparavant et il n'est pas bloqué. Donc, si ce n'est pas égal à 0 ou ce n'est pas égal à trois, alors nous allons de l'avant et nous allons obtenir le résultat. Nous changeons les résultats de false à true. Et puis après cela, nous avons retourné le résultat, quel que soit le résultat, vrai ou faux, le retournerait. Maintenant. C' est donc maintenant une méthode pour vérifier s'il s'agit d'un déplacement valide. Donc, ce que nous disons ici est, par exemple, vérifions cette position. C' est donc à la position 012 et à l'approche 0. Donc, tout d'abord, ceci, si vous voulez accéder à cette position, nous pouvons écrire cred, ligne et colonne. Il se trouve à la colonne 3012. Je suis désolé d'entendre. Donc, à la position 02, nous avons ce 012, nous avons cette position, que 22 ici, 03, 0s et ainsi de suite. Donc, cette méthode valide, tout d'abord, nous allons prendre les deux paramètres, ligne et colonne. Et tout d'abord, il vérifiera que la cellule, ce sont les limites de la matrice. Donc, si rho est supérieur à 0 et inférieur à la longueur, donc si elle est comprise entre 08 et même ici, il vérifiera si le courant est compris entre 0 et la longueur 13. Après cela, si c'est le cas, alors nous allons de l'avant et vérifions le nombre et discret. On y accède, lise Joe Cannon dans cette affaire 12. Et nous verrons ici nous avons 12012012 ici. Donc c'est 12. Si c'est égal à un, alors nous allons changer le résultat à vrai. Dans ce cas, nous en avons un, donc nous allons le changer à true et il retournera le résultat comme vrai. Maintenant, nous avons tous les outils et nous avons tendance à commencer par notre méthode récursive. Donc nous allons commencer avec ça dans la prochaine vidéo. 15. Recursion: : Maze partie 2: Nous avons encore notre dernière méthode, qui est notre méthode récursive. Et les seuls mouvements valides à travers le labyrinthe sont dans les directions directes prioritaires vers le bas, séchées et à gauche. Les déplacements en diagonale ne sont pas autorisés. Ainsi, dans cet exemple, le labyrinthe est de huit lignes par trois colonnes. Bien que le code est conçu pour gérer étonné de souligner. Mais pour l'instant, travaillons avec 813. Alors réfléchissons à cela récursivement. La ms peut être traversée avec succès si nous pouvons la traverser en position 00 jusqu'à la position 712. Donc, dans ce cas, à la position 00, nous devons travailler avec, donc nous allons vérifier si c'est une position valide. Si elle est valide, elle est égale à un. Ensuite, nous avons quatre directions. Nous avons 01100 moins un et moins 10, moins 10100 moins un et non valide. Donc, nous avons encore deux mouvements valides, soit 0110. Et nous irons avec 01 par exemple. Et nous vérifierons si c'est valide. Il est valide. Et maintenant, nous allons nous retrouver dans la même position que nous étions dans le premier. Donc, nous avons aussi quatre directions : haut, bas, droite et gauche. Et nous devons vérifier entre eux. Donc la même chose se produit chaque fois qu'on se déplace dans ce labyrinthe. Maintenant, créons notre méthode. Appelons-le Avars. Et cette méthode est booléenne. Retour vrai, faire semblant voyage dans le labyrinthe et faux autrement. Booléen public. Et pour commencer avec 0-0 érudit 22 paramètres, intro et incarné et travaillerait avec le corps ici. Tout d'abord, nous avons besoin de notre booléen. Donnons le nom qu'il a fait. Tout d'abord, il sera égal à faux. Et à la fin de la méthode, nous devrions retourner un booléen. Donc, nous reviendrons fait. Maintenant. Nous devons vérifier que la position dans laquelle nous sommes est valide. Nous allons donc utiliser la méthode valide. Nous avons créé un effet de levier. Donc, si valide, nous lui donnerons deux paramètres, ligne et colonne. Et si c'est le cas, on travaillera ici. Après avoir vérifié qu'il s'agit d'une position valide. Maintenant va changer de un à trois depuis que nous l'avons essayé. Donc, nous allons changer la ligne et la colonne de la grille de un à trois puisque nous la trouvons ici. Donc, nous pouvons dire que ceci a été essayé. Maintenant, il n'y a qu'un seul cas où le secteur sera résolu et nous retournerons vrai. C' est donc quand rho est égal à la longueur de la grille minus1. Donc rho égal à cette longueur moins un, et m est égal à ligne rouge moins un. Et puis nous allons changer fait de faux à vrai. Sinon, nous devons vérifier. Donc, ici, nous disons que si nous sommes dans la position 712 dans ce cas, puisque la longueur du point moins un est huit moins 17. Et quid pro dot longueur quand S1 est 13 moins 1 12e. Donc, si nous sommes à la position 712, alors les moyens sont résolus. W1 égal à, et puis nous reviendrons fait et nous avons fini. Sinon, nous devons vérifier avec pas encore dans cette position. Nous devons vérifier le bas en utilisant w1 equal pour traverser vers le bas. Nous allons ajouter la première ligne. Donc, si nous sommes au pro 66 plus un, nous savons à travers sept rangs un avec la même colonne. Et la même chose n'est pas faite. Ou nous pouvons dire si w1 n'est pas égal à, est égal à faux. Si nous ne l'avons toujours pas fait. Même chose. Nous essayons d'écrire ligne, colonne plus un égal à rho moins un. La même chose. Essayez ro minus1, ligne et colonne moins un. Alors, c'est ça. Et maintenant, nous allons l'expliquer. Mais avant dun, dun et dislocation fait partie du fini, mais alors nous devons le changer de trois ou un ou quoi que ce soit à sept, qui est égal à. Donc, c'est ce que nous avons fait ici, c'est que nous avons créé une méthode appelée la traversée, qui est une méthode booléenne. Il renvoie une valeur booléenne qui indique si une solution a été trouvée. Tout d'abord, la méthode détermine si un déplacement vers la ligne et la colonne spécifiées est valide. Ainsi, un déménagement est considéré comme valable, comme nous l'avons déjà dit, s'il reste à l'intérieur des limites et si une décennie en contient un à cet endroit indiquant qu'un mouvement dans cette direction n'est pas bloqué. Ainsi, l'appel initial à traverser passe à l'emplacement supérieur gauche, 0-0 commencera par 00. Et si le déplacement est valide, cette entrée Vint est modifiée de un à trois. Si elle est valide, alors changera l'entrée de grille de un à trois. Et puis ces marques cette délégation telle que visitée afin que plus tard nous ne retrace pas nos pas. Et cette méthode détermine ensuite si le labyrinthe a été terminé en ayant atteint l'emplacement en bas à droite. Donc, si nous avons atteint l'occasion en bas à droite, alors changerait fait de faux à vrai. Et notre labyrinthe s'est terminé alors. Et sinon nous avons quelques étapes à suivre. Donc, dans cette méthode, nous essayons différents chemins. Ainsi, par exemple, nous pouvons commencer par U1, puis descendre un. Et il a été bloqué par trois zéros. Et en fait il y en a trois, il y a trois possibilités du cas de base pour ce problème qui mettra fin à tout particulier en raison du premier si un mouvement non valide, parce que le film est hors limites. Donc, par exemple, ici, si nous arrivons ici, nous en avons une et la position de gauche est hors de limite. Donc, il va mettre fin au programme. Et l'autre est un mouvement invalide parce que la lune a déjà été essayée. Donc, par exemple, si nous allons ici 21 et puis y retournerons, alors je ne sais pas, peut-être aller essayer à gauche et ensuite retourner aux deux vers le bas. Nous l'avons essayé avant, donc il ne sera pas valide. Enfin, un déménagement qui arrive au lieu final. Donc, après avoir traversé le labyrinthe et atteint le bas juste ici, un, alors nous avons cherché le labyrinthe et il terminera notre chemin. Maintenant, CurrentLocation est dans le coin inférieur droit. Nous avons cherché une solution dans chacune des directions principales si nécessaire. abord, nous m'avons regardé, regardé vers le bas en appelant récursivement la méthode de traversée et le passage et le nouvel emplacement. Donc la logique de la méthode terroriste recommence à zéro. Utilisation de la nouvelle position. Une solution est finalement trouvée en essayant d'abord de descendre de l'emplacement actuel ou elle n'est pas trouvée. Par exemple, si nous commençons par 00 et que nous avons ici 01, recherche en premier, d'abord, nous avons 010, excusez-moi. Donc, ici, nous sommes à la position 1-0 essaierait toute la logique à nouveau. Et on va vérifier d'abord, on n'a rien, on a 0. Ensuite, il n'est pas valide. Alors on va essayer, non ? 0, on ne peut pas essayer bien ? Comme ce n'est pas valide, alors nous allons essayer. Maintenant est égal à trois, alors ce n'est pas valide aussi. Puis enfin essayer à gauche, ce qui est égal, ce qui est hors de limite. Donc, ce n'est pas valide. Ensuite, nous retournerons faux et retournerons à ici. Après cela, ce que nous allons faire est d'essayer dérivé. Nous sommes dans la bonne position. C' est 01. Donc, nous voici à l'emplacement 01. Tout d'abord, nous allons commencer par regarder vers le bas. Il est 0 invité. Donc nous allons retourner ici et regarder, accord, nous en avons un, c'est valide. Donc, nous allons à cette position x. Donc maintenant, nous sommes à cette position, va faire la même logique encore une fois. Nous commençons par le bas, nous en avons un, nous trouvons le chemin. La même chose avec un. On va chercher. Nous avons 0 invalide, allez avec droite. La même chose ici. Jusqu' à ce que nous atteignions un mouvement bloqué. Si j'en ai ajouté un et continuer jusqu'à ce que nous atteignions le coin inférieur droit, étape par étape jusqu'à atteindre le coin inférieur droit. Mais pour l'instant, nous allons aller à la recherche et nous avons, cette méthode est booléens. Nous créons donc une variable booléenne, nom et maïs. Deux égal à M. Traverse commenceraient par 00. Donc, si cela est égal à vrai, si labyrinthe, nous pouvons dire tout aussi bon, laissez-le vide. Les données à la même. Et si c'est un cas, juste l'impression a été réussie. Sinon, nous imprimerons qu'il n'y a pas de chemin possible. Et enfin, on imprimera le labyrinthe. Exécutez plus de temps. Allez-y et exécutez ce code, obtiendra le labyrinthe a été traversé avec succès. Et ici, nous avons notre chemin 777 vers le bas Septième, jusqu'à ce que nous atteignions ici que vers le haut sept, tout le chemin vers le bas, puis jusqu'à atteindre le dernier centime et le coin inférieur droit. Donc c'est tout pour le problème du labyrinthe, problème. Et dans la prochaine vidéo, nous parlerons de la Tour de Hanoi. 16. Recursion : les tours d'Hanoi: Et cet exemple servira les tours de Hanoï puzzle. Le puzzle Tours de Hanoi a été inventé dans les années 80 par le mathématicien français, devenu un favori parmi les informaticiens parce que c' une illusion est une excellente démonstration de l'élégance récursive. Le paysan se compose de trois sacs verticaux et un ensemble de disques avec des trous au milieu de sorte que la glissière sur les dos. Chaque disque a un diamètre différent. Initialement, tous les disques sont empilés sur une cheville par ordre de taille, sorte que le grand, le plus grand disque est sur le fond, comme le montre cette figure. Et le but de ce puzzle est de déplacer tous les disques de la cheville d'origine vers le PEC de destination. Mais c'est la banque d'origine. Le pack de destination est celui-ci. Donc, nous pouvons utiliser le Peg supplémentaire comme un endroit temporaire pour mettre des disques. Mais vous devez obéir aux trois règles suivantes. Tout d'abord, nous ne pouvons pas placer un disque plus grand sur un disque plus petit. Par exemple, nous ne pouvons pas prendre ce bureau, placer ici, puis prendre l'autre et le placer sur le dessus. Deuxièmement, Nous pouvons déplacer un seul disque à la fois. Et enfin, l'ancien bureau doit être sur une cheville, sauf pour le bureau en transit entre les paquets. Donc nous ne pouvons pas prendre aujourd'hui des tours. Ces règles impliquent que vous devez déplacer un disque plus petit afin de déplacer le disque le plus grand de 1 à un autre. Donc, ici, nous avons un exemple de solution étape par étape pour les tours de Hanoï puzzle en utilisant trois bureau. Donc, pour finalement déplacer les trois disques de la première cheville à la troisième cheville, vous devez d'abord arriver au point où le plus petit à cela hors du chemin et la deuxième banque de sorte que le plus grand disque peut passer de la première cheville à la troisième cheville. Ici, nous avons la configuration d'origine. Donc, tout d'abord, nous déplaçons le premier, c'est le plus petit disque au dernier Peck. Et puis après cela, nous déplaçons le second à la, à ici, à la deuxième cheville. Et puis nous allons reprendre cette fumée que le plus petit disque et le mettre sur le dessus du deuxième disque. Et maintenant, nous pouvons déplacer le dernier disque d'ici à la destination. Et puis nous déplaçons le premier disque dans le premier sac. Déplacez le deuxième disque, fait le dernier sac, puis déplacez le premier disque à la dernière page. Donc nous avons sept mouvements. Et cet exemple, tout en utilisant trois. Utilisons cette idée pour former une stratégie générale. Donc, pour déplacer une pile de n disques de la cheville d'origine vers la cheville de destination. Tout d'abord, nous avons ici n disques. Ce que nous avons fait, c'est que nous avons déplacé et moins1 sur le disque de cette cheville à la deuxième cheville. Donc, ce que vous devriez faire est de déplacer le plus n moins un disque haut de la cheville d'origine à la cheville supplémentaire ici. Ensuite, déplacez le plus grand disque de la cheville d'origine vers le Peg de destination, comme nous l'avons fait ici. Et enfin, déplacez les disques n moins un de la cheville supplémentaire vers le pack de destination et utilisez la récursivité tôt. Donc, l'étape pour déplacer n moins un disque après le chemin est le même problème à nouveau. Donc quand nous avons ici et moins 1 bureaux ici, alors nous devons les déplacer ici. Nous pouvons effectuer les mêmes étapes que d'habitude. Et après avoir atteint ce point, nous pouvons ensuite effectuer la même étape. Tous les autres comptes. Alors maintenant, allons à ce programme et créer un nouveau paquet. Notre rassemblement. Ici, nous avons notre méthode principale. Et la deuxième classe, nous l'appelons Tour de ennuyé. Et maintenant, tout d'abord, nous avons mis en place le puzzle avec un nombre spécifié de disque. Nous créons donc nos tours de construction. Et puis il faudra un entier, combien de disques ? Alors nommez-le. Et nous avons, bien sûr, je voudrais bureaux locaux variables totaux. Et ce que nous allons faire est égal à n. Et maintenant nous devons résoudre ce programme, ce bouton. Donc, nous allons utiliser deux méthodes ici. La première méthode consiste à déplacer le nombre spécifié de disques d'une tour à l'autre en déplaçant une sous-culture de n moins un disque sur le chemin. Donc, comme nous l'avons dit, ce que vous faites, c'est de le rendre privé. On l'appellera « tour de déplacement ». Et maintenant aujourd'hui, le nombre de disque comme paramètre et le début et la fin, et l'extra. Comme on l'a dit, s'il ne nous reste qu'un seul bureau, on le déplace d'ici au dernier Peck. Et c'est donc notre cas de base. Si le nombre de cela est égal à un, alors nous le déplacons juste. Donc, créons la méthode qui va déplacer les disques au lieu de l'écrire à chaque fois ici. Donc, nous avons un vide privé. Donnons-le un nom, déplacez un disque. Aujourd'hui, deux entiers commencent à partir de l'endroit où nous allons le déplacer à deux. Et jusqu'à ce qu'il soit simplement imprimer que déplacer un disque du début à la fin. Maintenant, donc si le nombre de disque est égal à un, déplacez un disque depuis le début pour agir. Sinon. Ce qui va faire, c'est ce que nous avons dit ici. Nous devons donc déplacer n moins un disque de la première cheville à la cheville supplémentaire, puis déplacer n moins un. Déplacez ce dernier de la cheville de départ du premier jour à la cheville de fin ici, comme nous pouvons le voir ici. Et puis replacez ceux-ci à la première cheville. Donc, comme nous l'avons dit, nous devons bouger. La première étape consiste à déplacer n minus1 du début au extra. Donc, nous allons effectuer cette tour de mouvement. Nous avons n moins un ici, donc un certain nombre de moins un. Et nous commençons par commencer. Et on les a déplacés en extra. Et le sac d'extrait serait le Peck final. Après cela, nous devons déplacer un disque. Maintenant, on est là. Donc ce que nous devrions faire est de déplacer ce disque du premier sac au dernier picot. Nous effectuons donc cette opération en appelant simplement la méthode que vous avez créée ici. Déplacez une mort du début à la fin. Et enfin, nous devrions déplacer ces disques vers l'animal de compagnie final. Donc nous allons créer, déplacer notre nombre de morts de l'extra, l'extra ici à la fin. Donc ici nous avons et, et commencer. Et maintenant, cette méthode est dite. Maintenant, nous pouvons créer une méthode publique juste pour utiliser cette méthode facilement sans entrer le début et la fin supplémentaire, renommez-le en vendu. Et il prendra le total des disques comme paramètre, un entier. Et deux simplement appelés déplacé notre méthode avec un certain nombre de cela, qui est le total. Ce sac est la cheville numéro un, l'extrémité est trois, et l'extra est deux. Et maintenant, allons de l'avant et exécutons ce code et notre méthode principale. Nous allons donc créer un objet Tour de Hanoi et T, les nouvelles tours de Hanoi. Et utilisons-le avec 34 bureau. Et ici, nous avons de la terre. Et ce code obtiendra les lignes suivantes. Et la même chose. Par exemple, disons dix. Cela aura tellement de lignes pour déplacer tous les disques de la première cheville à la dernière. Maintenant, pensez à la version itérative. À quoi ressemblerait ? Et si c'est aussi simple que cette version récursive. C' est ça pour le problème de la tour de Hanoi. Et on se voit dans la prochaine vidéo. 17. Trier Insertion: Considérez que vous avez une liste d'entiers tels que cette liste. Et vous voulez qu'ils soient triés du plus bas au plus haut. Hé, tu peux utiliser le salage. Et il y a en fait plusieurs algorithmes de tri et nous parlerons de certains d'entre eux. Donc à l'intérieur par tri d'insertion. Le tri d'insertion est un algorithme de tri simple qui fonctionne la même manière que vous avez vu jouer aux cartes dans vos mains. Le tableau est virtuellement divisé en une partie triée et non triée. Les valeurs de la pièce non triée sont sélectionnées et placées à la position actuelle dans la pièce triée. Deux ici, nous pouvons commencer par cet exemple. Supposons que nous ayons cette liste, et cette liste sera divisée en deux parties, une partie triée et non triée. Donc, tout d'abord, je vais le résoudre par deux, sera le premier élément seulement. C' est donc notre première liste et c'est la deuxième partie. Maintenant, quatre sont déjà triés car il n'y a qu'un seul élément, il n'y a qu'un seul élément dans cette liste. Et tu n'as rien à faire. Il n'y a pas d'élément à gauche de qui est supérieur à quatre, alors nous devons ajouter trois. Donc on en a 43. On compare trois à quatre. Donc quatre, c'est plus grand que trois. Donc on devrait les échanger et on en aura 34. Maintenant, la partie triée de la liste est 34 et la partie non triée est ce qu'il y a ici. Et nous passerons à l'élément suivant. Nous devons comparer deux à 44, c'est supérieur à deux, puis nous les échangerons. Et la même chose que nous comparons deux avec 33 est plus grand que deux aussi. Alors échange-les encore une fois, on aura 234. Et maintenant c'est la partie triée, et c'est la partie non triée, et ainsi de suite jusqu'à atteindre le dernier élément de la liste. Et puis on aura fini. Donc, l'idée générale est de comparer chaque élément avec tous les éléments à gauche. Échangez. Chaque fois que nous trouvons un élément à gauche supérieur à l'élément que nous utilisons. Alors allons de l'avant et écrivons le code. Vous allez créer une classe. Et tout d'abord, créons notre tableau entier, notre liste d'entiers. Et par exemple, nous avons cinq éléments dans ce tableau. Laissez-moi les stocker directement au 5110. Donc c'est notre tableau et créons notre méthode. Mais appelons-le l'insertion. Et pour prendre paramètre un tableau, nommez-le au travail ici. Donc, tout d'abord, nous avons la boucle for pour passer à travers tous les éléments de 0 à la longueur listée moins un. zéros sont déjà triés, donc nous n'avons pas besoin de commencer par 0. Donc, on commence par un. Donc, notre résultat de boucle pour avec un et se termine une longueur de point moins un. Maintenant, nous allons créer un entier. Nommons la clé ID, et ce sera notre élément dans cette liste. Donc, nous allons comparer un de i. Donc voici trois à 1012 et ainsi de suite. Et nous l'avons vendu et un entier appelé jeu. Et nous aurons un autre entier sera j, i moins un pour commencer par minus1 et revenir en arrière jusqu'à atteindre 0. Et ce que nous faisons ici, c'est que nous commençons ce numéro, par exemple, que l'État fait la cause. La troisième ligne, la troisième clé d'un entier. Et nous avons pensé que ce nombre à un entier appelé clé. Et puis nous avons stocké la position que nous récupérons pour commencer, qui est la position i moins un, j i moins un. Donc nous allons nous mettre d'accord avec cette position et revenir en arrière jusqu'à atteindre 0. Donc, nous allons créer une boucle while. Alors que j est supérieur à 0 et la clé est inférieure à a de J, nous devons échanger. Donc, à dire ici est que y j est moins, est supérieur à 0. Donc ici, dans ce cas, j est égal à un. Tellement bien. Et la deuxième condition, tandis que la clé, qui est deux, est inférieure à un de J, dans ce cas quatre. Donc nous devons les échanger. On échange. Et puis une fois de plus, nous vérifions les conditions. Nous avons j supérieur ou égal à 0. Dans ce cas, j est égal à 0. Donc, cette condition est valide. Et deux dans ce cas, nous avons ici aussi et ici quatre, donc 23, donc trois est plus grand que deux, alors cela aussi valide. On doit échanger une fois de plus. Et puis nous finissons avec ceci pour la boucle puisque j sera supérieur à 0. Et dans ce cas, donc chaque fois que nous exécutons ceci pour la boucle, j sera décrémenté par un. Et ici, nous devons échanger cela, créer un entier appelé tamp. Et comme d'habitude, les échanger prendront un de j et le stockage ici, et dix et un de j A de j plus un dans ce cas. Et enfin, nous prendrons un j plus un et lui donnerons la valeur de w. donc nous les échangerons. Et maintenant nous avons dit, revenons en arrière et imprimons. Tout d'abord, nous allons imprimer le tableau tel qu'il est avant le tri. Donc, imprimez à un espace et un peu. Ensuite, effectuez cette méthode avec un a. et puis c'est imprimé une fois de plus. Pour imprimer la lumière du code et du temps et obtiendra tout d'abord, le non salé ajouté et ensuite nous obtenons le trié, puisque nous avons utilisé la méthode d'insertion que nous avons créée ici. Maintenant, nous pouvons voir comment cela a changé à chaque fois. Nous allons donc imprimer le tableau pour en créer une autre pour la boucle après chaque changement. Après l'exécution de la boucle. Et imprimez un J2, dans ce cas, un peu d'espace. Et puis, et ici, nous devons imprimer une île. Avant d'exécuter cette boucle et d'exécuter le code obtiendra ceci. Donc, tout d'abord, nous avons 32510. Nous commençons par i égal à un. Donc j'égal à onRestart, t égal à a de i, j est égal à a de 12, et j est égal à 0 dans ce cas, qui est i minus1 0. Ensuite, nous avons une boucle while qui ne fonctionnera qu'une seule fois puisque J est égal à 0, puis lu recommandé. Donc, la condition ici, il ne sera pas valide pour une autre exécution. Nous devons donc les échanger puisque les deux conditions sont remplies. La même chose avec cinq. On compare cinq à maintenant. Cinq avec 25 est supérieur à deux, alors cette condition n'est pas satisfaite. N' entrera pas dans la boucle for avec simplement si et incrémentera I par un. Maintenant, nous avons le numéro un. La même chose ici. Nous allons comparer celui-ci avec chaque élément et échanger les deux nombres. Ainsi, par exemple, 15 les échangeront. Et puis 13, on les a échangé une fois de plus. Et enfin, 12, échangez-les. Et enfin, nous aurons Dan. Dan est plus grand que tous les autres éléments. Donc, il n'entrera pas dans la boucle, la boucle while, et nous aurons fini avec les deux boucles, la boucle interne et externe. Et nous pouvons imprimer, imprimer vous disant regarder dehors et un nouveau tableau dehors. Donc c'est tout pour le tri d'insertion. Nous explorerons d'autres algorithmes de tri dans les prochaines vidéos. 18. Trier Sort à la: Passons maintenant à un autre algorithme de tri est la sélection. L' algorithme de tri de sélection trie un tableau en trouvant à plusieurs reprises l'élément minimum de la pièce non triée et en le plaçant au début. Maintenant, nous envisageons l'ordre croissant. Nous avons également l'ordre décroissant dans lequel nous pouvons trouver l'élément maximum et le stocker au début. Et comme le tri d'insertion, nous avons deux parties. Celui qui était déjà trié et la partie non triée. Et chaque itération de tri de sélection, l'élément minimum du sous-tableau non trié est ramassé et déplacé vers le sous-tableau trié. Donc, prenons un exemple. Nous allons utiliser la même liste ici. Et supprimons ceci. Nous avons cette méthode, supprimez-les. Et nous garderons cette méthode ici. Mais avant, exécutons ce code et utilisons cette liste. Maintenant. Mais nous allons faire dans cet algorithme de tri est de trouver le minimum à chaque fois et de le stocker au non trié la partie triée. Donc, tout d'abord, nous allons trouver le minimum et cette liste ici nous en avons un comme le minimum, prendra ce 11 et l'échanger avec ce nombre. Quel que soit ce numéro, on l'échangera avec un. Donc, nous en avons un maintenant. Laisse-moi l'écrire ici. Nous avons donc 1253 et que l'étape suivante est de trouver le minimum et cette liste. Donc, le minimum est vrai, et nous devons commencer à cette position. Donc on va bien puisque le minimum est deux. Donc, la prochaine étape serait la même que la première. Sens, on n'a pas besoin de changer quoi que ce soit. Maintenant, nous allons regarder cette liste. Nous avons 5310 et nous trouvons le minimum ici. Le minimum est de trois. Nous devons le stocker au premier élément. Nous devons donc échanger trois avec cinq pour le suivant. Autrement dit, pour les échanger. Donc, nous allons obtenir 123510 et schéma de verre comparé ces deux nombres comme d'habitude, Trouver le minimum entre eux et le stocker au premier élément de cette liste. Et comme dix, c'est plus que cinq, alors on n'a rien à faire. Et voici notre liste finale. Alors maintenant, allons de l'avant et écrivons-le comme un code. Public statique, void, paramètre de sélection d'un tableau, entier. Et dans ce cas, par exemple, tout d'abord, nous devons stocker la longueur, la longueur pour l'utiliser dans la boucle for. Donc, nous avons ici la longueur de cette liste. A côté de notre boucle for, nous pouvons dire array.length ou les deux, la même chose. Et maintenant, nous devons trouver l'élément minimum dans la partie non triée. Donc, la partie non triée devrait commencer par i plus un. Donc, chaque fois que nous finissons avec je vais comparer et trouver le minimum dans la partie de i plus un à la longueur. Et ici, nous avons n moins un. Puisque nous n'avons pas à terminer au dernier élément, nous pouvons simplement ajouter et ici. Et la boucle interne for comparerait les deux derniers éléments. Donc, dans ce cas, stockons le minimum comme je égal à i. Et maintenant nous devrions trouver le minimum et la partie non triée. Donc, nous commençons avec i plus un et le tableau angulaire, array.length ou et la même simplicité Maxwell. Et maintenant, nous allons comparer chaque élément pour trouver le minimum. Donc, tout d'abord, nous avons considéré que le minimum est à l'index i. l'index et un entier appelé minimum. Tout d'abord, je suis égal à 0. Nous avons donc considéré que le nombre minimum dans cette liste est à l'index 0 pour aller et regarder l'index 0. On en trouvera trois et ce n'est pas le minimum. Nous devons donc comparer ce nombre à tous les autres. Et c'est ce que nous allons faire pour comparer un j. Dans ce cas, j est la liste de i plus un d'ici à la fin. Donc si je de j est moins que tableau d'hommes, alors nous devons échanger l'indice et les hommes, ce sera en fait le prochain. Donc, ce que nous disons ici, c'est que les hommes seraient égaux à, et travaillons avec cet exemple pour mieux le comprendre. Donc, tout d'abord, nous allons commencer par i égal à 0, i égal à 0. Nous stockons n minimum 0. Maintenant, nous regardons ce nombre et j sera égal à 0 plus un est celui qui était assis avec un et, et avec 1234. On finira par quatre. Nous allons comparer tableau d'un. F d'un est moins que la multitude d'hommes, I des hommes. Rappelez-vous, beaucoup xn égal à 0 et J, dans ce cas, il est égal à un, va comparer T2, va comparer T2, qui ajoute un avec trois, juste tableau de minimum, tableau de 0. F. Deux, c'est moins de trois, alors le minimum n'est plus celui-ci. Ce n'est plus à l'index 0. C' est à l'index j, dans ce cas à l'index 1. Donc, nous allons donner une valeur minimale et nue d'un. Et la même chose qu'avant. Maintenant, J est égal à deux. Comparer j, I, a de j et a de deux. Nous avons I2 ici, cinq avec n'importe quel nouveau minimum, qui est un. Donc, vous devriez comparer maintenant comme cinq avec 25 est supérieur à deux, alors rien ne se passera. Ensuite, nous allons ici, nous avons comparé tableau de trois, qui est un avec L2. Donc, un est inférieur à T2. Nous devons donc donner la valeur minimale et nouvelle, la valeur d'un. Et enfin, nous avons ici à quel index, la valeur minimale comme après avoir trouvé le minimum en utilisant cette boucle pour, nous devons échanger ce minimum avec l'élément à la liste triée où nous devrions les trier. Donc, ce que vous devriez faire est comme d'habitude, nous allons prendre un minimum consulté dans un entier appelé amorti que. Nous changeons tout ce qu'il y a de minimum avec nos yeux. Et enfin, donnez ce tableau d'ID d'index i à l'index i, la valeur de n. Donc ici, nous les permutons et revenons en arrière et utilisons cette méthode ici. Donc, la sélection et les tableaux, tableau, et la même chose. On les imprimera et on aura 123510. Donc, je pense que le tri de sélection est plus facile que l'insertion. Donc, en termes de compréhension, il est fondamentalement juste de trouver le minimum dans la boucle interne pour, puis l' échanger avec le premier élément ici. Mais ici. Et c'est tout pour la sélection, donc il vous voit dans la prochaine vidéo. 19. Trier des bulles: Le troisième algorithme de tri dont nous allons parler est bubblesort. Bubblesort est l'algorithme de tri le plus simple qui fonctionne en échangeant plusieurs fois les éléments adjacents s'ils sont dans les eaux souterraines. Considérez donc cette liste de cinq éléments. Tout d'abord, nous comparons les deux premiers éléments et les échangeons puisque cinq est supérieur à un. Et puis nous faisons la même chose pour le numéro 235 est supérieur à quatre, alors nous devrions échanger. Donc c'est le nid maintenant. Et la même chose pour le numéro d'élément. 345 est supérieur à deux, elle devrait échanger. Et enfin, nous en avons 58. Et comme ils sont dans le bon ordre, huit est supérieur à cinq, alors nous n'échangerons pas. Maintenant, nous pouvons voir que cette liste n'est pas encore triée, puisque nous avons 1424 est supérieur à deux. Donc, ce que vous devriez faire est de répéter les mêmes étapes et encore jusqu'à ce que nous atteignions la liste triée. Le pire scénario, si nous avons ici un élément, par exemple, qui disent 0. Donc, ce 0 devrait être échangé 12345 fois. Nous avons six éléments dans cette liste. Et le pire scénario est d'échanger ce 05 fois. Donc, si nous avons une liste de n éléments, nous devrions échanger n moins une fois. Donc, nous pouvons effectuer cette opération n moins une fois, et finalement vous obtiendrez cette liste triée. Alors allons de l'avant et écrire ce code pour créer une autre méthode. Ou il bulle avec un tableau d'ID de nom de paramètre comme d'habitude et fonctionnerait ici. Donc, tout d'abord, nous avons une boucle for. Comme nous l'avons dit, de 0 à n moins un, nous pouvons dire array.length. Et à l'intérieur de cette boucle pour nous avons une autre boucle pour échanger tous les deux éléments. Si le mauvais code pour nous comparons tous les deux éléments adjacents, a de j est a de j est supérieur à a de j plus un. Alors on va les échanger. Créons un tamp entier. Maintenant, ici, RAM ressort, et la même chose ici. Et si nous considérons que cette température est égale au point de tableau a j et a j, quoi qu'il y ait à j plus un. Et puis si j plus1, le sel de valeur, et c'est notre méthode et je suis désolé, nous aurons n moins un et n moins un. Utilisons cette bulle et utilisons-la ici, et imprimez la dernière fois. Et on aura 325110. C' est avant de manger et après le salage 123510. Maintenant, notre code peut être amélioré en faisant une tâche simple. Donc, par exemple, ici, nous avons échangé les éléments ici. Première fois. Et la deuxième fois, nous n'avions besoin que d'échanger 42. Et cette liste est triée maintenant. Mais dans notre exemple, nous sommes obligés de passer par toute la liste et moins1 fois. Donc, une chose que nous pouvons améliorer est f. Et nous sommes arrivés à un point où notre boucle interne pour n'effectuer aucune tâche, alors nous pouvons assimiler parce que nous n'avons pas d'éléments à échanger. Donc, nous pouvons faire cette tâche en utilisant un booléen. Alors appelons-le swat. Tout d'abord, il est, devrait être et ne pas lui donner la valeur ici lui donnera la valeur à l'intérieur de notre boucle externe for. échange deux sera d'abord égal à faux dans ce cas. Et si, si nous avons vomi au moins une fois, alors après être sorti de cette boucle interne vérifiera swap. Si l'échange est égal à false. Ensuite, nous n'avons pas effectué d'échange ici. Nous pouvons donc quitter la boucle for puisque notre liste est triée maintenant. Pour qu'on puisse se casser. Sinon sera l'échange continu. Et nous exécutons le code, nous obtenons le même résultat qu'avant. Mais maintenant, c'est beaucoup plus simple et cela ne prendra pas autant de temps qu'avant. Donc c'est tout pour bubblesort, l'algorithme de tri le plus simple entre tous. Et on se voit dans la prochaine vidéo. 20. Sort de fusionnement: Passer à un autre algorithme de tri, fusionner le tri. Le tri de fusion est un algorithme de diviser et de conquérir. Alors laissez-moi aller de l'avant et créer une nouvelle classe. Sous-classe, créé nom d'insertion qu'il a fusionné. Et il discutera de la fusion tri. Tout d'abord, considérons une petite liste de quatre éléments, puis discutons d'une plus grande liste. Par exemple, considérons une liste avec quatre éléments, 2431. Donc, à, nous allons faire est de diviser cette liste en deux listes. Le premier que nous aurons 24, contiendra deux éléments, et le second aura les deux derniers éléments, 31. Ensuite, nous allons trier chaque liste seule. Donc 24 sont déjà triés, donc nous n'avons pas besoin de faire quoi que ce soit, il suffit de les taper. Et ici, nous en avons 31, nous devons les échanger. C' est donc notre deuxième liste triée. Et après cela, nous devons les fusionner. Puisqu' ils sont triés. Donc, le premier élément devrait être le plus petit. Nous allons donc comparer le premier élément dans les deux listes. Ici, nous avons 21. Donc on est exploité et en écrirait un. Et puis nous allons comparer deux avec 32 est plus petit que deux, puis trois avec quatre. Même chose, fierté v et puis ont encore le dernier élément dans la première liste, depuis quatre. Et puis on a fini. Maintenant, nous allons utiliser une plus grande liste. Nous avons dans cette liste sept éléments. Nous divisons cette leçon aux toilettes. Et la première liste sera quatre éléments et les trois autres éléments. Ensuite, nous faisons la même chose avec cette liste divisée deux à 22, la même chose avec l'autre aussi. Et nous n'avons encore qu'un seul élément, donc nous allons le diviser en un et nous ferons la même chose. Et cette liste, nous avons deux éléments, diviserait en un élément et chaque liste. Et puis nous aurons 1234567 liste. Chaque liste ne contient qu'un seul élément. Après cela, nous devons les fusionner. Nous commençons par les deux éléments ici. Nous avons vingt sept et trente huit. Vingt-sept, c'est plus petit que ce que tu écrirais 2738. Même chose ici, 343982. Et puis après cela, nous devons fusionner les deux listes ici, comme nous l'avons fait dans l'exemple précédent. Donc, tout d'abord, nous en avons trois, puis nous en avons vingt sept, trente huit, quarante trois. La même chose ici. Et nous avons enfin notre liste finie salée finale. L' idée de tri de fusion est assez simple. Il faut appeler la méthode serait plus de 1s, deux jusqu'à ce que nous atteignions. Liste d'un élément, puis recréer des listes triées comme indiqué ici. Allons-y et écrivons-le maintenant. Donc, pour terminer le tri de fusion, besoin d'écrire deux méthodes. La première méthode pourrait être pensée, la fonction principale qui trie le tableau en utilisant une autre méthode. Alors écrivons-le. Vide public. Appelons-le public statique, vide. Et il acceptera un entier et pas d'index et d'index élevé. Ils représentent par où devrions-nous commencer ? Et puis si le bas est inférieur au dur, alors nous pouvons continuer. Sinon, nous n'avons rien à faire. Cela signifie que faible est supérieur ou égal à élevé. Dans ce cas, nous n'avons qu'un seul élément dans la liste et nous n'avons pas besoin de le citer. Donc, nous travaillons sur si le bas est inférieur à élevé. Donc, ce que nous devrions faire ici, c'est à l'indice moyen égal à faible divisé par deux. Et puis ce que nous ferons, c'est de trier et de diviser la liste en deux listes. Et puis, de sorte que la partie gauche seule et alors la droite mais peut faire cela va entrer dans notre A un, nous avons avec bas et puis trier la droite, mais à un milieu plus un. Et après cela, nous devons fusionner les moitiés triées. Donc, nous allons appeler une fusion de limite de méthode. Et il faudra comme paramètres à gauche, bas et haut. Et allons de l'avant et créons notre méthode de fusion. Donc, nous avons ici peut le rendre privé, privé, statique, vide, fusionné et comme d'habitude méthode. Et maintenant, nous devons trouver les tailles des deux sous-tableaux et être fusionnés. Donc, le premier type est limite n un égal à moins un. Et le second est N2 égal à hi moins. Maintenant, nous avons les deux tailles. Nouvelles listes. Donc nous le nommons une liste. Ou on peut émettre à gauche et à droite. Donc, nous avons laissé la taille et la droite. Cette deuxième taille. Après cela, vous devez copier les données de ce tableau d'origine vers nos deux tableaux. Maintenant, on fait ça. Nous utilisons simplement une boucle for avec la limite de un1 et copions toutes les données de droite à gauche. Donc j'ai laissé égal à i. et une autre boucle pour copier les données de la partie droite du tableau dans notre liste appelée droite. Dans ce cas, nous allons commencer par un tableau de milieu plus un et plus j. Et maintenant nous avons copié les données ici. En plus, je suis désolé. Et c'est ainsi que nous copions nos données. Maintenant, nous devons les fusionner ensemble. Donc, ce que vous devriez faire est de créer une boucle while pour copier toutes les données que nous avons stockées et copiées à gauche et à droite vers notre mise à jour originale. Donc, comme nous l'avons dit dans cet exemple, après être allé à cette phase, nous devons les stocker dans la liste d'origine. Donc, ici, nous allons comparer les deux éléments et ensuite nous allons les démarrer et le tableau original et la même chose ici. Nous comparons ces éléments ensemble et nous obtiendrons notre liste triée. Revenons donc à notre code et écrivons une boucle while. Et la condition de cette boucle while que nous avons encore des éléments à la fois à gauche et à droite. Donc, ici, créons des entiers i égal à 0, et la même chose pour J, 0. Et créons un entier et un nom pour le nommer, qui est égal à o. maintenant, alors que i est inférieur à n, un, qui est la taille de gauche et J est inférieur à. Et deux travailleront sur la pente. Maintenant, tout d'abord, nous allons comparer gauche à droite de j, de i est inférieur à j, puis nous le stockons. Ce composant et la liste d'origine. Donc un sera égal à gauche. Et puis nous augmentons i. Puisque nous avons fini avec ça, par exemple, revenons ici. Ce que nous avons fait dans ce cas, c'est que nous avons comparé la gauche de moi, 27 avec trois. F, 27 est moins de trois. On devrait le stocker ici. Maintenant, dans ce cas, 27 est supérieur à trois, alors nous devrions stocker trois dans ce cas. Sinon, nous devrions le stocker. Et à tout composant dérivé k et incrément j par un. Et dans les deux cas, nous devrions mettre en œuvre k Étant donné qu'il sera rempli de toute façon. Maintenant, après avoir terminé cette boucle while, nous pourrions avoir quelques éléments dans n'importe quelle liste. Donc, pour remplir l'original, nous devrions compléter tout ce qui reste dans nos deux listes. Cela créerait une boucle while. Alors que i est inférieur à N1. Le N1 si i est égal à N1. Et nous avons éclaté de cette boucle while à cause de i égal à un, alors cette boucle while ne fonctionnera pas car elle serait déjà égale ligne un. Donc, si c'est le cas, nous ne devrions acheter que ce qu'il y a dans la partie gauche et l' incrément, incrémenter k. Et la même chose avec n2 si j est inférieur et de faire la même chose exacte, écrire incrément j et k. Donc maintenant, nous avons fini avec notre fonction de fusion. Et allons-y et utilisons-le. Et je vais méthode principale. Alors revenons en arrière. Mais avant de vérifier nos limites. Ici, nous avons à gauche et à droite. Et ici, nous devrions commencer par un noeud. Puisque nous ne sommes pas assis avec des zéros, assis avec tout ce que notre index est ici. Et maintenant, revenons en arrière et documentés ici. Notre méthode principale. Cela crée un délai égal à, dans ce cas, quatre à 718 et utilisez-le maintenant, utilisez le tri avec une longueur 0 moins un. Et puis utilisez une boucle for pour imprimer nos éléments. Et la discorde 12478. Donc c'est tout pour la fusion. Alors il vous voir la prochaine vidéo. 21. Trier rapidement: Comme le tri de fusion, quicksort est un algorithme de diviser et de conquérir. Il prend un élément comme Pivot et partitionne le tableau autour du pivot. Il existe de nombreuses versions différentes de quicksort ce grand pivot et différentes façons. Nous pouvons choisir le pivot comme premier élément. Premier élément, élément aléatoire, ou le média. J' avais expliqué ce qu'est le pivot en un instant. D' abord, nous allons écrire une liste. Alors considérez que nous avons une liste contient 101819. Et c'est donc notre liste. Maintenant, nous choisissons l'élément comme un pivot. Alors allons de l'avant et choisissons, par exemple, le dernier élément et les séparer pour le comprendre. Et ça va avoir la même chose ici. Donc, ici nous avons cette liste et c'est notre pivot. Donc, juste ici. Et ici, nous avons le premier élément. Maintenant, nous avons besoin de deux flèches, 2.2 à deux positions sur cette liste. Le premier, nous commençons par le premier élément de la gauche et le dernier élément avant le pivot. Donc, ici, nous avons notre premier, disons que c'est le premier élément et c'est le dernier. Maintenant, ce qui va faire est de comparer le premier élément s'il est supérieur au pivot, que nous avons besoin de l'échanger, nous devons nous retrouver avec un budget inférieur au pivot et l'autre partie devrait être supérieure au pivot. Donc, pour ce faire, d'abord, dix est plus grand que le pivot. Maintenant, alors va se déplacer, va passer à 80. Ici, nous en avons 80. Maintenant, on est au 8050. Donc 80 est prêt à être échangé. Maintenant, nous allons regarder 5050. 50 est plus grand que le pivot ? Non, alors on pourra l'échanger. Alors maintenant, on échange 50 avec 80. Ici aura 80, et ici nous avons 15. Maintenant, nous changeons les positions de ces flèches. Nous avons cette flèche à 42e 30. Maintenant, la même chose fera la même chose ici. Nous avons 13, est 30 inférieur au pivot ? Oui. Alors on n'a pas besoin d'échanger. Il ira à un autre aller à 90. Et maintenant, nous allons comparer 90 à 40. 90 plus grand que le pivot ? Oui. Alors nous devons l'échanger. Est-ce que 40 est inférieur au pivot ? Oui. Ensuite, nous devons échanger ces deux éléments, aura 90 ici. Et le, maintenant les deux flèches, appelons-les pour être en mesure de voir ce qui va se passer. Nous avons bas et haut. Maintenant, avant l'échange, ce sont les biens, bas et haut. Faible à la position 0123 et position haute pour. Maintenant, après avoir échangé les deux éléments, nous devons incrémenter d'un et décrémenter haut d'un. Donc, je serai en position, à cette position et bas sera à cette position. Et chaque fois que le bas est égal ou supérieur à élevé, nous pouvons savoir que nous avons fini ici. Depuis lobe a passé haut. Maintenant, la dernière chose que nous devrions faire est d'échanger cet élément avec le pivot. Donc, vous aurez 17 et au pivot 90. Maintenant, nous pouvons voir que tous les éléments inférieurs à 70 et tous les éléments ici sont grands et 70. C' est donc l'idée du QuickSort. Nous pouvons effectuer ce même algorithme exact à cette liste. Nous pouvons choisir 40 comme pivot et travailler en conséquence. Et la même chose se passe ici. Et nous laissons la récursion faire le travail pour nous. C' est l'idée générale et nous allons utiliser la récursivité pour être en mesure de l'implémenter plus d'une fois a émergé. Nous avons donc deux méthodes ici. La première méthode sera privée, entière. Renommons la partition. Il prendra les paramètres et émettra. Et bas que cette méthode, où nous prenons le dernier élément comme pivot. L' élément pivot à sa position correcte dans le tableau trié. Et cas tous les éléments plus petits, plus petits que le pivot vers la gauche et plus grand vers la droite. Alors allons de l'avant et commençons avec cette méthode. Tout d'abord, nous avons notre pivot est créé. Maintenant, le vecteur est égal au dernier élément de cette liste. Et nous avons l'indice de plus petit élément. C' est un sname i, qui est égal à minus1. Et ce cas, nous commençons par notre boucle for. Nous commençons par bas. Tout le chemin jusqu'à. Maintenant, nous devons vérifier si l'élément actuel est plus petit que le pivot. Donc, si j est moins dans ce cas, et nous avons besoin d'incrémenter i. Un, swap et array j. Donc, échangons-le. Et à a. puis égal à, désolé, a égal à i, égal à j. Et enfin, retour à G. Donc maintenant nous avons échangé les deux éléments. Après avoir terminé avec cette boucle de mots, nous devons échanger le pivot avec un i plus un. Donc, dans ce cas, créez une autre fois et échangez les deux éléments. Comme nous l'avons dit. Ici, nous avons le pivot est à l'emplacement a. Et puis donner le bronzage deux. Maintenant, nous avons échangé les deux métadonnées en éléments, puis nous allons simplement retourner plus un. C' est donc notre méthode, la méthode de partition. Cette méthode a pris le dernier élément comme Pivot, placer l'élément de pivot à sa position correcte dans le trié à un, et place tous les plus petits à gauche et plus grands à dérivé. Maintenant, l'autre méthode est la fonction principale qui implémente ce quicksort. Et appelons-le public statique, vide. Alors qu'il faudrait trois paramètres comme d'habitude, et faible et élevé. Tout d'abord, nous allons vérifier si le débit n'est pas supérieur à élevé. Nous pouvons travailler autrement ne fonctionnera pas parce que cela n'aura pas de sens. Et nous aurons, nous allons créer un entier, laissez-nous le nommer par, par est ce partitionnement et la profondeur. Ce sera, où nous allons utiliser cette méthode que nous avons créée ici. Donc pi utiliserait la partition au bas. Maintenant, après avoir obtenu l'index, maintenant, on devrait trier les deux, abase la partie gauche, non ? Mais donc nous allons utiliser la même méthode une fois de plus sans autre moyen de Pi moins un. Et la même chose par plus une autre façon d'écrire. Et puis nous en avons fini avec cette méthode. Vous pouvez l'utiliser. Et notre méthode principale. Donc, nous créons un tableau, par exemple, vapeur, et avec quelques valeurs 426173. Et nous appellerons la méthode de tri 0 et la longueur mise à jour minus1. Ensuite, créez une boucle for et imprimez les éléments de cette liste. Comme d'habitude, avec un peu d'espace ici, et allons de l'avant et courons. Le code obtiendra 1234567. Donc, c'est le tableau est trié tableau après avoir effectué ce QuickSort. C' est ça pour Quicksort. se voit dans la vidéo suivante. 22. Recherche linéaire et ben ben: Parfois, nous voulons vérifier, mettre un élément de la liste. Et ici, nous pouvons utiliser des algorithmes de recherche. Nous avons plusieurs algorithmes de sessions et nous allons commencer par la recherche linéaire. Alors allons de l'avant et créons un nom de classe. Et puis la méthode principale, créons notre tableau. Donc c'est notre tableau. Et supposons que vous voulez rechercher le nombre à un entier, nombre égal à deux. Maintenant, cette recherche linéaire est supposée parcourir toute la liste et vérifier si l'élément de cette liste est égal à deux. Retourne la position. Sinon, si aucun élément ne correspond à ce nombre, nous devrions retourner moins un. Alors allons de l'avant et créons notre méthode. Et il faudra cette liste et un nombre entier. Donc, ce que nous allons faire est de comparer ce nombre avec chaque élément de cette liste. Utilisez donc une boucle for pour parcourir tous les animaux de la liste. Et la position numéro deux. Ensuite, nous devrions retourner cette position spécifique. Sinon. Donc, la méthode ne fonctionne pas. Nous devrions retourner un entier. Et sinon, si nous avons le mieux à travers toute la liste et que nous n'avons pas renvoyé d'entier, alors nous n'avons pas trouvé que le nombre est spécifié numéro moins un. Et si nous utilisons le numéro t à n et l'imprimons, nous obtiendrons alors les decks du numéro deux. Maintenant, 22. Changeons le nombre, par exemple, deux à six. Donc, nous avons trouvé le numéro six à l'index trois dans cette liste. Et la même chose si on le change, par exemple, à neuf et l'imprime, on en aura quatre et quatre. Maintenant, nous avons essayé un autre numéro qui n'est pas dans la liste, nous obtenons moins un. C' est ainsi que la recherche fonctionne. C' est très simple, mais ça prend. Beaucoup de temps. Nous parlerons plus tard de la complexité temporelle pour chaque algorithme. Maintenant, passons à un autre algorithme de recherche est la recherche binaire. Ici, nous devrions avoir un tableau trié ou une liste, et vous saurez pourquoi dans un instant. Donc, l'idée de la recherche binaire est de rechercher un tableau trié en divisant à plusieurs reprises l'intervalle de recherche en deux pour commencer par un intervalle couvrant l'ensemble du tableau. Si la valeur de la clé de recherche est inférieure à l'élément au milieu de l'intervalle, réduit l'intervalle à la moitié inférieure, sinon, réduisez-le. La moitié supérieure. Vérifiez à plusieurs reprises jusqu'à ce que la valeur de l'intervalle soit trouvée ou que l'intervalle soit vide. Alors regardons un exemple. Ici, nous avons cette liste. Tout d'abord, nous prenons l'élément médian. Ici. Dans ce cas, il est 16. Et maintenant, nous voulons chercher 23. Et notre tableau est trié, comme nous l'avons dit. Donc, nous vérifions si 23 est supérieur à 16, alors nous prenons cette moitié. Sinon, qui devrait prendre cette moitié ? Maintenant, comme il est supérieur à 16, alors nous allons ignorer tous les éléments ici parce que nous sommes absolument sûrs que 23 est créé puis tous, car ils sont triés. Et nous devons vérifier maintenant pour cette partie. Et nous prenons le milieu de cette partie et faisons la même chose ici. F2 et F3 est supérieur à 56. Non, ce n'est pas le cas. Ensuite, nous devons prendre à gauche. Mais, et il a commencé à utiliser le milieu comme 23. Et nous avons trouvé 23 pour retourner l'indice 5, dans ce cas. Pour l'instant. Et notre méthode. Créons une nouvelle méthode, la recherche binaire. Et il faudra un tableau comme d'habitude. Et l' index bas X. Donc X est l'élément de la session quatre dans cette liste. Et maintenant, nous devons trouver le milieu et la profondeur. Et pour ce faire, revenons en arrière et voyons dans cet exemple, ici nous avons bas et élevé à ce que nous avons fait est deux, soustrayez neuf moins 0 sur 4.5 parce que son entier, il faudra quatre. Et la même chose ici, qui a pris 59 moins 54 sur deux, ce qui est deux plus l'indice bas plus cinq égal à sept, sept fondamentalistes. Et la même chose qu'on a fait ici. Et revenons en arrière et définissons la condition que si haute est inférieure à la charge, alors inférieure ou égale au nœud que nous l'avons fait. Sinon, nous devrions travailler. Donc, ici est plus grand que la charge fonctionnera. Sinon, quand nous tournons, nous ne devrions pas retourner minuscule 1. Maintenant, nous allons trouver notre milieu, comme nous l'avons dit, est égal à faible plus élevé moins bas de deux. Donc c'est notre métal. Si élément métallique est égal à notre x est égal à deux assertion. Et puis nous reviendrons. Sinon, nous devrions vérifier, comme nous l'avons dit, revenons ici. Dans ce cas, nous avons 2323 est supérieur à 16. Alors on va travailler avec ça. Mais nous ferons les mêmes timbres exacts et cette partie, sinon, nous devrions le faire étapes sur ce bug. Donc, pour ce faire, nous comparons simplement à a à x. F à a est supérieur à x, nous devrions retourner BinarySearch. C' est la même chose, mais faible, et nous devons changer comment au milieu minus1 va. Nous sommes absolument sûrs que le vieux milieu et tous les autres éléments sur le côté droit supérieur à S, alors le non x sinon reviendrait. Et la recherche binaire pour rechercher le côté gauche. Donc nous commençons par le côté droit, je suis désolé, le métal plus un jusqu'au haut et le même nombre X. Donc c'est tout . Revenons en arrière et mis en œuvre ici. Et notre méthode principale, nous allons imprimer la recherche binaire à un 0 et moins un et le nombre de recherche de nombres. Allons de l'avant et exécutons le code. On aura moins 12, par exemple, 6. Et on aura. Donc le sexe est à la troisième position. Et c'est une recherche binaire. La recherche binaire est beaucoup plus rapide que la recherche linéaire. Depuis chaque fois qu'on passe par la liste, on la coupe en deux. Cependant, dans la recherche linéaire, nous sommes obligés de parcourir tous les éléments de la liste. Nous avons encore quelques algorithmes de recherche et nous en parlerons dans les prochaines vidéos. 23. Recherche Jump: Comme la recherche binaire, sauts est un algorithme de recherche pour trier les tableaux. L' idée de base est de vérifier moins d'éléments que la recherche linéaire en sautant en avant par des onglets fixes ou en sautant certains éléments au lieu de rechercher tous les éléments de la liste. Donc, par exemple, considérons que nous avons cette liste. Nous avons 16 éléments ici. Supposons qu'on cherche le numéro 55. Ainsi, la recherche de saut trouvera la valeur de 50 en utilisant quelques étapes. abord, considérons que la taille du bloc à sauter comme depuis 16, racine carrée de 164. Donc, tout d'abord, il va passer de l'index 0 à l'index quatre. Donc, il va sauter à 01234. Aller à cet élément par rapport à 5535 est toujours supérieur à trois. Ensuite, nous sauterons une fois de plus à n'importe lequel. Même chose ici, 21 est moins de 55, alors nous avons besoin de sauter, va sauter à 144. Et puis nous pouvons voir que 144 est supérieur à 55. Donc, nous allons revenir à 21 et effectuer une recherche linéaire de 21244 jusqu'à ce que nous trouvions notre élément au numéro 55. Nous utilisons généralement la racine carrée de longueur comme taille de bloc à sauter. Parce que dans le pire des cas, c'est la meilleure taille de pas à prendre. Commençons par notre code. Passez aux ij principaux d'entier et x que nous allons chercher dans cette liste. Et ici, tout d'abord, nous devons stocker la durée de la journée. Nous devons choisir notre pile. Et comme nous l'avons dit, nous allons prendre la racine carrée de n en utilisant la masse. Et cette masse racine carrée, par exemple, supposons que nous ayons 17 éléments, donner US 14 certains nombres. Donc, après avoir pris la racine carrée de et nous avons formaté en utilisant Math.Floor. Et puis puisque nous le stockons dans un entier pour converger en ENT. Et si l'élément existe, alors nous devons trouver un bloc où l'élément est présent. Revenons donc à notre exemple. Et il 55 est entre 2144. Nous devons donc trouver ces deux éléments. Et nous avons déjà un nombre entier. Nous créons une autre entité ou appelons, par exemple, précédent, liquide à 0. Donc, au début, précédent est égal à 0, donc il est à la position 0 et l'étape est à la position quatre. Et si l'élément n'est pas trouvé dans cet intervalle, alors nous devrions donner la valeur précédente de quatre. Donc précédent est maintenant à la position quatre et nous devons ajouter quatre à l'étape. Donc l'étape serait à la position huit et continuer jusqu'à ce que nous trouvons notre élément dans cet intervalle et notre intervalle. Donc, pour ce faire, nous devons créer une boucle while et définir la boucle sauvage comme à un est inférieur à x. maintenant, nous pourrions arriver à un point où si nous continuons à ajouter quatre, l'étape, nous aurions pu marcher plus grand que n, alors, nous ne pouvons pas y accéder à un demi-pas. Donc, au lieu d'accéder au tableau de l'étape qui dit un minimum radar entre l'étape et, et. Donc, chaque fois que nous exécutons cette boucle, nous devons changer avant la nouvelle valeur. Et la même chose pour l'étape créer à ajouter. Tout ce qu'on a ici. Donc, il a ajouté. Et puis nous allons obtenir précédent est supérieur ou égal à. Et puis on a fini. Nous n'avons pas trouvé l'animal qui revient tout simplement minus1. Et il nous devrions changer en entier. Maintenant. Donc, ce que nous disons ici dans cette boucle while, utilisons-le dans cet exemple. Tout d'abord, nous avons déjà égal à 0 et pas égal pour la possession. Pour. Maintenant. Nous passons par cette boucle while. Tout d'abord, nous allons vérifier tableau du minimum entre l'étape et ensuite l'étape est sûrement inférieure à n. Dans ce cas, l'étape est égale à quatre. Donc maths à un de quatre, ce qui est trois. Dans ce cas, nous allons vérifier si trois est inférieur à x. oui, alors nous allons continuer à exécuter cette boucle while va changer les valeurs. Maintenant, précédent est égal à quatre et l'étape est égale à huit. Et puis nous vérifierons si nous passons les limites. Si précédent est supérieur ou égal à n, Ensuite, nous avons passé les limites et nous avons fait, nous n'avons trouvé aucun nombre qui correspond aux actes. Maintenant, nous sommes à la position 4. Et la position huit. La même chose. Nous comparons ce 21 avec 5521 est inférieur à 55 et nous devons exécuter la boucle while une fois de plus précédente est maintenant à la position huit. C' est donc la position pour cette aide de position. Et l'étape est à la position 12. Dans ce cas, nous avons 144. Alors comparez cent quarante quatre, cinquante cinq et cinquante cinq ans de moins qu'un 144, puis sortira de la boucle. Ayant précédé la valeur de huit et l'étape de la valeur de 12, alors nous avons notre intervalle et 55 est dans cet intervalle. Maintenant, après avoir quitté la boucle while, nous devons effectuer une recherche linéaire pour x et y et une autre boucle while. Donc, alors que nous nous sommes assis avec le précédent, maintenant puisque le précédent est à la position huit et l'étape est à la position cent quarante quatre et cinquante cinq, ce qui a montré que le récepteur est indistinct troisième intervalle, alors nous allons Commencez par 21 et continuez. Si large carry au précédent est inférieur à x, alors nous allons incrémenter d'un. Et si nous sommes arrivés à un point où précédent est égal à l'une ou l'autre étape, égal à 12 sur n, Donc égal au minimum entre les deux entiers, soit timbre. Et puis nous devons casser ou retourner minus1 peut simplement retourner moins un. Dans ce cas, puisque nous n'avons pas trouvé notre numéro. Et puis nous vérifions si nous avons trouvé l'élément. Donc, si tableau précédent est égal à x, alors nous retournons cette position et retournons moins un. Si on meurt, on ne l'a pas trouvé. Donc c'est ici. Nous avons un additif ne peut pas converger de n booléen, nous avons un égal manquant. C' est ça, c' est notre fonction. Et allons de l'avant et choisissez-le ici. Donc on va imprimer morceau et on va chercher 55. Alors prenons ceci et mettez-les dans notre tableau. Donc c'est notre tableau et il retournera dix. Donc 55 est à la position dix. Donc ces deux premières lignes provenaient des fonctions passées maintenant cette heure que notre position où 55 est sur cette liste. Donc c'est ça pour les sauts. se voit dans la vidéo suivante. 24. Recherche d'interpolation: Et d'autres algorithmes de recherche comme recherche d'interpolation. La recherche d'interpolation fonctionne mieux que la recherche binaire. Parce que la recherche binaire vérifie toujours sur une base d'élément intermédiaire. Mais la recherche d'interprétation peut aller à différents endroits en fonction de la valeur de P à rechercher. Donc, par exemple, si nous voulons rechercher le numéro trois et cette liste, si nous utilisons la recherche binaire, ira vérifier au milieu. Donc soit 1321034, donc c'est le milieu de la liste. Cependant, si nous utilisons la recherche d'interpolation ira à la valeur qui est plus proche de notre nombre en utilisant une formule spécifique et nous en parlerons plus tard. Donc il trois est plus proche de 0 qu'il est plus proche de 610. Donc notre formule nous mènera à un nombre entre ces deux. Donc la même idée que la recherche binaire, mais au lieu d'avoir un élément intermédiaire, nous aurons une position qui changera en fonction de nos éléments. Alors allons de l'avant et créons notre méthode publique. Appelons ça l'interpolation. Et comme d'habitude de prendre un tableau d'éléments et la taille de l'élément, ainsi que le t ou laisser dire x. maintenant, nous devons définir notre bas et haut et bas égal à 0 et sera et minus1. Maintenant, nous allons entrer dans notre boucle while. Faible est inférieur ou égal à i. sinon nous n'avons plus besoin de travailler parce que nous n'avons pas trouvé notre élément. Donc c'est la même chose que nous l'avons fait dans la recherche binaire. Et nous devons ajouter quelques conditions. Bien que notre élément x soit inférieur ou égal à, notre faible est supérieur ou égal à, je suis désolé, et est inférieur ou égal à notre élément. Aussi longtemps que ces conditions sont remplies, nous pouvons travailler ici. Maintenant, chaque fois que nous arrivons à un point où notre bas est égal à notre indice élevé, cela signifie que nous l'avons fait, soit nous trouvons l'élément ou non. Donc, nous allons vérifier si j'ajoute la même chose car ils sont égaux, est égal à notre x. et c'est le cas retour faible, sinon, retour minus1. Et après avoir vérifié cette condition, maintenant nous pouvons travailler, peut créer notre formule cette même position qui va sauter. Comme nous l'avons fait dans notre recherche binaire, nous avons créé une position appelée élément métallique. Chaque fois que nous allons à l'élément central maintenant, nous créons un autre entier appelé position. Et la formule est la suivante. C' est ainsi que nous calculons l'interpolation. Et un de haut moins bas. Ensuite, nous le multiplions avec je x moins un de charge. Et maintenant, nous vérifions si un rayon à cette position est égal à notre élément, alors nous retournons juste notre position. Sinon, nous vérifierons qu'un à cette position est inférieur à notre élément. Ensuite, nous devons passer de la position basse à la position haute plus un. La même chose que nous avons fait et dans la recherche binaire, mais au lieu de la position, nous avons utilisé la méthode sinon sera la position moins un. Donc, sinon, si le nous avons à une position est supérieure à x, alors du serait égal à la position minus1. Et après avoir terminé cette condition et tout, la boucle while, nous pouvons retourner moins un si nous ne trouvons pas l'entier. Et maintenant, revenons en arrière et utilisons-le ici. Donc j'imprime l'interpolation. Nous avons le a et B et x sera le nombre. Donc, par exemple, supposons une recherche pour b. Et allons de l'avant et courons. Notre code. Va obtenir pour SO trois est à la position 401234. Cela change ce nombre à 89 et nous aurons la position 11. Donc 89 est à la position 11. Et la dernière chose que nous allons vérifier si nous entrons un numéro qui n'est pas dans cette leçon, 900, nous obtenons moins un. Donc c'est tout pour la recherche d'interpolation. se voit dans la vidéo suivante. 25. Recherche exponentielle: Le dernier algorithme de recherche dont nous allons parler est la recherche exponentielle. recherche exponentielle comporte deux étapes. abord, nous devons trouver une plage où l'élément est présent. Et puis nous ferons une recherche binaire dans l'étrange. Alors considérons cette liste. Nous avons 16 éléments et nous devons trouver, par exemple, 89. Donc, ce que nous allons faire est, tout d'abord, considérer si notre nombre est égal au premier élément de cette liste. Si c'est le cas, nous retournons 0, donc c'est à la position 0. Sinon, nous vérifions tous les autres éléments. Nous commençons par i égal à un et avec doublet I égal à deux, puis i égal à 24816 et ainsi de suite. Et allons de l'avant et mis en œuvre pour mieux comprendre cela. Va ici et tu as du statique public, et appelons-le exponentielle. Comme d'habitude, prenez un tableau d'entiers et, et, et la valeur que nous allons chercher, nous le nommons x ici. Tout d'abord, comme nous l'avons dit, nous devons vérifier si à l'index 0, si la valeur est à l'index 0, alors nous retournons simplement 0. Sinon, nous devons trouver la plage pour la recherche binaire par doublement répété. Nous allons donc définir un entier avec la valeur de un. Et nous entrons dans la boucle. Alors que i est inférieur à n, la longueur du tableau. Et ajouter un, i est inférieur à notre, inférieur ou égal à notre nombre. Cette boucle sera exécutée. Donc nous allons simplement multiplier i par deux. Donc, chaque fois que nous entrons dans cette boucle, nous multiplions i par deux. Voyons donc ici dans cet exemple, quand nous pouvons quitter cette boucle. Par exemple, si nous voulons rechercher le nombre 13, tout d' abord, nous vérifions si 0 est égal à 13. Non, ce n'est pas le cas. Ensuite, nous définissons i égal à un et entrons dans cette boucle. Je suis égal à un, va vérifier. Alors que je à a, à i est inférieur ou égal à x, un est inférieur ou égal à 13. Oui, alors nous multiplions i par. Donc maintenant, je suis égal à deux, et nous allons passer à notre prochain élément. Ici, nous avons aussi un, il est moins de 13 et i est inférieur à n. Ensuite, nous multiplions i par 21 plus de temps. Maintenant, nous avons deux fois 24201234. Maintenant, nous vérifions que l'est moins de 13. Nous pouvons donc multiplier une fois de plus à quatre fois 28. Donc maintenant on est 5678, on est à 21. Maintenant. On vérifiera que 21 est moins de 13. Non, ce n'est pas le cas. Alors. Nous sortons de la boucle avec i égal à huit. Maintenant, je suis égal à huit. Et pour obtenir notre intervalle, nous avons i égal à huit et i égal à quatre, ce qui est huit divisé par deux. Donc, après avoir trouvé notre intervalle ici, nous utilisons simplement la recherche binaire. Et je travaille à un. Et ici nous avons je divisé par deux. C' est notre intervalle et notre minimum entre i et un, i et n. Puisque c'est peut-être le cas, il se peut que je soit supérieur à n et que nous ne puissions pas travailler en dehors de nos frontières. Et ici, nous avons notre entier x. et puisque nous avons besoin de retourner le type, donc nous tournons simplement la recherche binaire. Et puis on a fini. Allons-y et utilisons-le ici. Donc, nous allons aller de l'avant et imprimer exponentielle à array.length et w. Nous allons chercher, par exemple, 13. Et le code en aura sept. Donc 13 est à la position 7. Alors rendons ça mieux, plus gentil. Et exponentielle. Stockons comme exponentielle et un entier. Comme résultat intime est égal à cette exponentielle. Si le résultat est supérieur à 0, alors nous imprimons l'élément est présent à l'index. Et nous imprimons l'index. Sinon, nous imprimons cet élément n'est pas présent. Et Ray et le clustering le code obtiendra élément est à l'index sept. Maintenant, nous avons un raccourci en Java que vous pouvez utiliser. Donc, au lieu d'écrire tout cela, nous pouvons simplement imprimer l'une des deux lignes. Donc, nous devons définir ici la condition si le résultat est inférieur à 0, c'est le cas. On peut imprimer. L' élément n'est pas présent. Et l'autre déclaration serait élément est présent, index. Et nous imprimons l'index. Allons donc voir ce qui aurait été ici. Exécutons le code et nous obtenons l'élément est présent et index sept. Donc, ce raccourci, Tout d'abord, NDA System.out.Print méthode. Nous définissons la condition que votre résultat soit inférieur à 0. Ensuite, cette méthode imprimera automatiquement la première instruction. Sinon, il imprimera tout ce qu'il y a après les deux points ici. Donc nous leur avons demandé si l'acte est inférieur à 0, oui, imprimez ceci. Sinon. Imprimez ceci. Ceci est très utile si nous ne voulons pas compliquer les choses et nous avons besoin d'une forme d'impression très simple. C' est donc pour les algorithmes de recherche. se voit dans la vidéo suivante. 26. Le problème supplémentaire : Inheritance: Maintenant que nous avons fini avec notre matériel, allons de l'avant et résolvons quelques problèmes supplémentaires. Et vous commencez par l'héritage. Permet de créer le compte bancaire. J' ai donc déjà créé un paquet appelé BankAccount. A l'intérieur de ce paquet, nous aurons notre classe parent, nommez-le, compte bancaire. Et nous avons deux types de comptes. Nous avons un compte épargne et un compte chèques. Alors allons de l'avant et créons deux nouvelles classes. Le premier que nous nommons vérifier, et l'autre sera le compte d'épargne. Et bien sûr, nous devons créer notre méthode principale. C' est notre méthode de plongeur, et nous créons notre méthode principale. Maintenant, les deux classes, compte bancaire et juste la même chose étend compte bancaire. Maintenant, revenons à notre compte bancaire et créons quelques méthodes ici. Tout d'abord, nous avons une variable. C' est notre équilibre. Donc, appelons-le comme protégé w. et créons un constructeur. Et ensuite, nous utiliserons nos méthodes. Donc le solde du compte bancaire. Et dites cet équilibre à l'équilibre. Maintenant, Jaffa nous permet d'avoir le même nom ici. Et dans ce cas, nous devons faire est de se référer à cette variable locale. On doit utiliser ça. Et maintenant, nous nous référons à celui-ci à l'extérieur et cet équilibre est celui dans le paramètre. Maintenant, créons notre méthode. Nous avons le public d'équilibre. Ww2 obtenir l'équilibre sera simplement de retour. Une autre méthode, par exemple, pour retirer void avec un nombre spécifique. Nous irons plus précisément et soustrayons simplement ce montant de la dépendance. Et une autre méthode si nous voulons ajouter un montant spécifique. Nous avons donc simplement ajouté à la balance. Maintenant, nous allons travailler sur notre compte d'épargne. Donc, dans le compte descendant, nous avons un intérêt. Donc, tout d'abord, créons notre compte d'épargne constructeur. Et nous avons obtenu le soutien de notre classe de parents avec notre solde. Et pour ajouter les intérêts, nous devons avoir un taux. Alors créons un vinyle protégé et nommage. Et nous avons dit le taux à 0,04. Maintenant, nous allons créer notre méthode à nos intérêts, intérêt public vide, et nous allons simplement utiliser la méthode pour le créer dans notre dépôt de compte bancaire et pour ajouter notre intérêt, qui est date fois notre solde. Passons à notre compte chéquier. Et notre compte chèques. Tout d'abord, créons notre constructeur, puis parlons des méthodes. Donc, dans notre construit comme vous vivez, vérification publique, solde du compte. Et on appellera le super et la pénitence. Maintenant, chaque fois que nous retirons ou ajoutons un montant à notre compte, nous avons un flux que nous devons payer. Donc, créons des entiers, des variables à l'extérieur. À. Le premier est juste de tenir compte du nombre de fois que nous avons utilisé notre compte soit pour retirer, pour ajouter un montant spécifique. Donc protégé et le nombre de sections. L' autre est tout d'abord, nous devons temps libres ont commencé retirer ou ajouter un montant gratuitement pour deux fois. Donc, les deux premières fois, nous nous retirons à son plein libre. Donc, créons notre entier fini et nommez-le 32. Et le dernier sera turbulent. Et c'est le champ que vous devez payer après avoir passé les 23 fois. Alors appelons-le v égal à 0,25. Maintenant, nous devons définir le nombre de transactions I sera égal à 0 égal à 0. Donc, vous utilisez la méthode go et dépôt. Nous devons les remplacer. Donc ici, nous avons notre dépôt et nous retirons. Donc, ils ont déjà appelé la ligne de largeur de super point. Nous n'avons pas besoin de faire ces étapes ici. Nous avons juste besoin de garder une trace de notre compte de transactions. Donc, chaque fois que nous entrons dans cette méthode, nous incrémentons simplement le nombre de transactions par un. Et la même chose ici. Maintenant, voici notre méthode et la dernière méthode que nous allons créer est la méthode pour déduire les frais. Alors appelons-le. Et cette méthode vérifiera simplement si le nombre de transactions est supérieur à deux. Ensuite, nous devons ajouter quelques frais. Sinon, on réinitialise juste le compteur. Nous fixons les frais de transaction, ce compte de transaction à 0. Transaction au centre-ville est plus grand que l'antigène à l'extérieur, nous le nommons trois est supérieur à trois. Alors on devrait prendre le W. Allons-le. Frais. Et ce serait égal à la transaction 23 fois. Et multiplié par v. Nous l'avons nommé dehors. Supposons donc que nous ayons ici des IED. Maintenant, après avoir obtenu cette variable va juste la retirer de L. Donc ce sont notre méthode. Maintenant, nous allons créer deux méthode de chaîne pour notre classe de compte bancaire. Ici. Nous avons String ToString public et nous allons simplement imprimer avec la balance des tours. Notre équilibre est notre équilibre. Dans notre compte de chèques. On appellera, on appellera super. Donc, créons une chaîne et appelons-la résultat, qui stockera notre force. Et puis une ligne et imprimez nos comptes. Donc, ici, nous pouvons ajouter notre nombre de transactions et juste le résultat de retour maintenant et notre compte d'épargne. Surpassons la méthode toString. Donc, on devrait le remplacer. Et la chaîne serait égale à super point toString. Et Ajouter à ce résultat, aligner et retourner le résultat. Ensuite, nous allons passer à notre méthode principale et créer un compte chéquier et un compte d'épargne. Compte vérifié, appelons-le, voyez-le. La violence pourrait être de 1000. Et compte d'épargne S égal à de nouvelles économies à bannir serait 10 mille. Utilisons quelques-unes des méthodes. Donc c point avec Joe irait 150. Et puis ce mot sans compte d'enregistrement comme point avec TO 2003. Après ça. Utilisons comme. Alors allez-y et imprimez le compte en chèques avec notre C. Et nous allons imprimer la ligne. Puis compte d'enregistrement. Et nous imprimons s avec une ligne. Ensuite, nous allons utiliser notre méthode et voir, voir, déduire et imprimer une fois de plus. Et nous allons de l'avant et effectuons un solde de compte de chèques, économisant le solde du compte avec le taux de comptage. Et vous pouvez voir que l'équilibre ici est le même puisque même si nous utilisons des données, mais le nombre est égal à deux. Donc, nous allons utiliser et la méthode une fois de plus. Par exemple C, déposer tout montant, par exemple 20. Et nous verrons que même si nous déposons et nous avons ajouté 20, notre Vanessa est maintenant un 169.735, nous avons déduit 0.250 p. Donc c'est pour cet exemple pour vous dans le prochain. 27. Séquence de Fibonacci: Maintenant, nous allons parler de la séquence de Fibonacci et de la résoudre en utilisant trois méthodes. Tout d'abord, la séquence de Fibonacci est la série de nombres dans laquelle le nombre suivant est trouvé en ajoutant les deux nombres avant lui. Laisse-moi aller de l'avant et l'écrire ici. Les deux premiers nombres sont 01, puis nous ajoutons 0 plus 111 plus 121232 plus 35, et ainsi de suite, 8132134 et ainsi de suite. C' est donc l'idée de cette séquence. Maintenant, continuons et résolvons récursivement, itérativement et en utilisant la classe Big Integer. Nous parlerons de la classe Big Integer plus tard. Donc, tout d'abord, résolvons itérativement. Donc, créons une méthode, statique privée qui est prédéterminée le long, par exemple. Et appelons-le, senti IT. Cela prendra un entier et la position. Et ce que nous devrions retourner est le nombre à la position spécifiée. Donc, par exemple, si nous avons entré cinq, nous devrions retourner 01235, nous devrions retourner trois. Si nous entrons dans sept, nous devrions retourner huit, et ainsi de suite. Maintenant, comme nous l'avons dit, tout d'abord, créons un entier et donnons-lui une valeur. Et la valeur à 100. Et nous devons ajouter l'élément précédent est égal à 0 au premier abord, h égal à un, et le précédent, précédent, xi précédent est égal à 0. Maintenant, nous créons une boucle for avec, nous commençons par i égal à deux et inférieur ou égal à n. Et maintenant, chaque fois que nous entrons dans cette boucle, nous ajoutons à la solution précédente, précédente, précédente. Maintenant, nous devons changer nos deux valeurs ici. Donc précédent précédent prendra la valeur de précédent, précédent, précédent, précédent. Précédent aura avec la valeur de la solution. Maintenant, nous retournons juste ce nombre après la boucle for. Alors allons de l'avant et créons notre méthode principale. Ici. Nous avons notre méthode principale et l'utilisons. Donc, nous imprimons Fibonacci itérativement durée. Et nous allons juste imprimer le TPIY avec la valeur. Et demandons à l'utilisateur d'entrer la valeur. Scanner, scanner. S' il vous plaît entrer un nombre, et nous stockerons ce numéro suivant n. Et nous le donnerons comme paramètre ici. Maintenant, si nous allons de l'avant et exécuter ce code, va obtenir, s'il vous plaît entrer un numéro. Supposons qu'on entre cinq, obtienne l'itération de Fibonacci 568, et ainsi de suite. Et par exemple, nous obtenons 55. Maintenant, utilisons la récursivité. Alors allons de l'avant et créons une autre méthode, méthode, Karen privée pour lui donner une valeur. Et comme nous l'avons dit, nous devons créer notre cas de base. Cas de base si n est égal à un ou 0, nous devrions terminer. Sinon, nous devrions retourner récursion de Fibonacci de n moins un plus récursion de Fibonacci de N moins deux. Donc les deux derniers éléments. Et allons de l'avant et exécutons ce code. Utilisez-le dans notre méthode principale. Donc nous imprimons les nazis. Parce que plus. Et exécutez ce code. Nous obtenons un nombre, par exemple, le sexe, aide à l'itération Fibonacci, et le même résultat que nous utilisons la méthode de récursion. Maintenant, la dernière méthode utilisera comme grand entier. Donc, nous allons utiliser Big Integer classe. Donc, cette classe est généralement utilisée pour l'opération mathématique qui implique très gros calculs entiers qui sont en dehors de la limite de tous les types de données primitives disponibles. Par exemple, factoriel d'un 100 contient 158 chiffres. Nous pouvons donc le stocker dans n'importe quel type de données primitives disponible. Nous pouvons le stocker et ce grand entier et utiliser les méthodes et entier discret plus. Donc maintenant, nous allons créer notre méthode en utilisant l'entier MC sera une statique privée avec la valeur d'entier rapide. Habituellement, nous retournons appartenu ou entier ou chaîne, retournant maintenant Big Integer et juste le nom. Et la valeur de n. Comme d'habitude. Maintenant, la même chose, je ferais la même chose que nous l'avons fait dans notre méthode d'itération. Alors. Tout d'abord, nous devons stocker la solution. La valeur du grand entier, nommez-le. Solution égale au grand point entier 0. C' est ainsi que nous stockons 0. Et la solution. Nous ne disons pas Big Integer solution, solution égale à 0. Nous disons gros entiers. Maintenant, la même chose pour précédent, précédent, précédent. Donc grand entier, précédent égal à grand entier. Mais un et Big Integer précédent, précédent, grand entier, 0. Maintenant, nous commençons par notre boucle for et nous commençons par deux et nous terminons par n égal à n. Et la solution sera précédente, précédente, précédente, précédente, précédente, précédente, précédente. Et puis précédent maintenant serait égal à notre solution précédente et précédente. Et puis nous allons simplement retourner la solution. Donc c'est ça. Et maintenant, nous allons imprimer System.out.Print entier nombre de paramètre entier. Exécutons le code. Et on aura 556, on en aura huit. Maintenant, par exemple, si nous utilisons un grand nombre tel que 10 000, nous pouvons le voir parce que cela prendra un certain temps. Et si nous utilisons un 100 mille concède qu'il génère une erreur. Cependant, si nous utilisons uniquement cette classe Big Integer, et nous allons entrer ce nombre. Vous pouvez voir que 20 morts cette séquence. Et c'est un très grand, Pas vraiment, pas être en mesure de le stocker dans n'importe quel type de données primitif. C' est pourquoi nous utilisons la classe Big Integer. Maintenant, c'est tout pour Fibonacci Sequence. Nous avons utilisé trois méthodes et nous avons appris une nouvelle classe sur une nouvelle classe, la classe Big Integer. 28. Cours d'appoint: Parlons maintenant de la classe Big Integer. Nous en avons déjà parlé et Fibonacci, mais il va l'exploser plus. Donc, cette classe est disponible pour nous en Java à la classe de maths. Et tout d'abord, créons notre grand entier, capturé ce grand entier préféré un égal à un. Donc maintenant, nous donnons à cet objet une valeur de 1. Tout d'abord, calculons le factoriel du code par exemple. Alors appelons-le. Et nous créons notre boucle pour deux, le début de 12 jusqu'à. Et chaque fois que nous passons à travers cette boucle pour, nous multiplions deux gros entier. Nous avons une méthode, grand point entier multiplier et le multiplier par grande valeur entière de i. Et puis allons de l'avant et imprimer la zone de plus grand entier. Exécutez le code. Vous obtenez factoriel de 24. Maintenant, utilisons d'autres méthodes. Nous l'avons fait. Par exemple, créons un autre objet, Big Integer, grand entier, deux. Nouveau grand entier avec la valeur d'un 197. Maintenant, utilisons-la méthode confirmée et obtenons le minimum entre les deux objets. Alors nous allons imprimer je pense que le grand T2. Et maintenant, nous obtenons le minimum entre les deux valeurs. On en a 24. Et si nous utilisons le gros entier Macs, entier pour obtenir un 197. Maintenant, par exemple, si nous voulons obtenir le nombre premier suivant supérieur à 197. Nous pouvons donc utiliser cette méthode. Alors imprimons le numéro premier suivant. À côté d'un 197 est, et utiliser grand Institut à prochaine probablement premier. Et nous obtenons le prochain premier et c'est un 199. Maintenant, nous avons encore beaucoup de méthodes et nous utilisons certaines d'entre elles. Par exemple, nous avons l'annonce. Donc, si nous disons gros entiers, l'entier deux, et commençons en grand nom entier. Appelez l'édition égale à cela, puis imprimer l'édition atteindra un 121. Donc, la méthode de repos, nous allons utiliser le toString. Donc, cette méthode retournera la représentation de chaîne décimale du grand entier. Donc on peut le stocker dans une chaîne. Appelons cela égal à entier, un à chaîne. Et donc nous avons déjà n ici, donc nous devons choisir un nom de cruncher nombre, nom de modèle. Maintenant, si nous imprimons le nom, obtiendra 24 et le nom point CharAt 0, par exemple, obtiendra aussi. Donc, nous avons converti ce gros entier en une chaîne et maintenant nous pouvons manipuler ses caractères. Donc c'est tout pour la classe Big Integer. Nous ne l'utilisons pas autant lorsque nous traitons avec de petits entiers. Et nous avons encore beaucoup de méthodes. Ils sont si utiles et nous pouvons les utiliser dans notre code. Pour que vous puissiez les explorer par vous-même. Et maintenant on se voit dans la prochaine vidéo. 29. Les problèmes supplémentaires : Recursion: Maintenant, allons de l'avant et résolvons certains problèmes en utilisant la récursivité. Donc, le premier problème que nous allons résoudre est de changer les anciens x et une chaîne, trop sage pour considérer. Nous avons un exemple de code X. Ensuite, nous devons le changer en dû par la même chose. Par exemple, x x x x. Nous devons le changer en y, y i par la lumière. Et ne le ferait pas sans utiliser de boucles. Alors créons notre méthode, statique publique. Et il devrait tourner en restant ce nom, changer x, y, et ça prendra position. C' est maintenant que nous devons passer à travers les animaux, les personnages dans la corde. Et tout d'abord, nous devons vérifier si cette chose, notre cas de base est si la chaîne est de longueur 0, alors nous avons fini. Nous n'avons pas de caractère. Donc nous vérifions la longueur du SDR. Si SDR ce temps est égal à 0, alors nous retournons simplement une chaîne vide. Sinon, nous devons travailler. Maintenant, la première chose que nous devons faire est de vérifier si le premier caractère de notre chaîne est x. si c'est le cas. Si le SDR est à z est égal à x, alors nous devons faire quelque chose. Et nous devons retourner X et converti en y. donc nous devrions retourner y plus. Maintenant, après avoir terminé sans premier personnage, nous devons faire la même chose pour le reste des personnages. Maintenant, dans cet exemple, disons que nous avons x, x, x. Donc, ce que nous devrions faire ici est de comparer ceci à x. Si c'est le cas, alors nous devons le convertir en i. Maintenant, nous avons Y et quelque chose. Maintenant, après avoir terminé avec le premier personnage, nous devons faire la même chose avec le reste des personnages. Nous devons donc entrer cette méthode une fois de plus et vérifier si ce caractère est X. Maintenant, nous devons le convertir en, donc nous allons laisser la récursivité pour le faire. Nous l'appelons simplement la méthode elle-même avec une nouvelle chaîne, qui est une sous-chaîne d'un jusqu'à la fin de la chaîne. Maintenant, quand nous arrivons au point où nous n'avons qu'un seul élément dans la chaîne, alors cela générera une erreur. Parce que lorsque la chaîne n'a qu'un seul élément, un caractère, et que nous disons que nous avons besoin de tous les éléments après le premier caractère. Donc, pour faire face à cela, nous devons définir la condition STR, cette longueur est égale à un. Alors, nous devrions simplement revenir. Pourquoi ? Sinon, nous devrions retourner y plus méthode quota une fois de plus. Maintenant, c'est pour le graphique standard à 0 égal à x. sinon, nous devons faire une autre tâche. Donc, si la longueur de point SDR est égale à un, nous retournons simplement STR à 0. Sinon, nous retournons stdio.h I qui citent la méthode une fois de plus. Et oui, cette sous-chaîne, sous-chaîne d'une extrémité de la chaîne. Et maintenant, nous devons le convertir en une chaîne. Donc, nous ajoutons simplement une chaîne ici. Et maintenant, nous en avons fini avec cette méthode. Allons-y et utilisons-le dans notre méthode principale. C' est notre méthode principale. Et demandons à l'utilisateur de nous fournir la chaîne, s'il vous plaît et stocké. Une chaîne appelée nom. Ensuite, utilisez cette méthode et imprimez le résultat. Alors changez x, y avec notre nom. Exécutons le code ceci dans une chaîne. Par exemple, x x x x, y, y, y, y, y. Et si nous n'avons pas de x, ici, par exemple, nous devenons élevés. Passons maintenant à un autre exemple simple. Le précalculé, la puissance de n. Par exemple, si nous avons 32, alors c'est, comme nous le disons, que nous avons besoin, que nous voulons t à la puissance de deux sur trois à la puissance de 45 et ainsi de suite. C' est donc très simple. Créons notre méthode. Et il retournera un enseignant à prendre deux entiers, et, et, et. Et. Et je serais le cas de base, si n est égal à et 0, alors retournerais simplement un. Sinon, nous devrions retourner nos temps de base notre base avec un minus1, puisque nous multiplions la base. Et allons-y et utilisons-la ici. Prenons, par exemple, n égal à cinq et n égal à trois. Et imprimez avec la base. Et puis exécutons le code. Et on aura, tu auras un 125. Passons maintenant à un autre exemple. Et cet exemple, nous allons utiliser des entiers ou un tableau d'entiers. Supposons que nous ayons cette liste, de 1 à 20. Nous en avons donc deux, puis 20, soit deux fois dix. Et prenons un autre exemple, 14315 et mangeons la même chose. Nous avons trois multiplié par dix, nous obtenons. Donc trois sont suivis de 13. Maintenant, notre code devrait retourner vrai si nous avons deux éléments et si nous multiplions le premier par dix, alors nous obtenons le second. Donc, ici, nous revenons vrai ici. Et par exemple, 12345 devrait revenir. Allons de l'avant et écrivons notre code. Public static devrait renvoyer un booléen. Et donnons-le un nom. Par exemple, multiple. Et cela prendra une valeur. Les entiers ont une limite à un et le nombre. Et ce nombre est l'index que nous allons utiliser le passage à travers notre tableau. Et maintenant, commençons. Donc, tout d'abord, si alors dx est égal à array.length minus1, alors nous avons passé tout le tableau et nous n'avons pas trouvé deux éléments qui correspondent à notre condition. Et dans ce cas, nous devrions retourner faux. Donc c'est notre cas de base. Sinon, nous devrions travailler. Maintenant, si l'indice est inférieur à un jour, longueur moins un, alors nous pouvons travailler. Dans ce cas, nous allons vérifier que si tableau à l'index horodatage est égal à tableau à l'index plus un, alors nous devrions, nous devrions retourner true. Sinon, nous devons appeler à nouveau la même méthode avec et incrémenter l'index. Donc multiple avait un index et plus un. Maintenant, ce n'est pas le cas, alors nous revenons simplement. Voyons ce qu'on a fait ici dans cette affaire. Tout d'abord, nous obtenons, par exemple, utilisons ce tableau. Et au début, ce sera 0. Donc n dx n'est pas égale à cette longueur moins un. Donc, nous entrons dans ce bloc et ici nous allons vérifier si l'index est inférieur à array.length un est un. C' est le cas. Ensuite, nous devrions vérifier si l'index du tableau fois dix. Donc, si une fois dix égal à dix est égal à quatre, non, alors nous devrions appeler la méthode une fois de plus. Et maintenant notre indice est incrémenté d'un. Donc, ici, notre indice serait quatre, puis ce qui est aussi quatre fois dix égal à trois. Maintenant, que notre indice sera en position, à cette position. Et nous faisons la même chose. Trois fois dix est égal à 30. Maintenant, notre condition est satisfaite. Ensuite, nous n'avons pas besoin de refaire cette méthode. Donc, nous allons juste revenir vrai. Maintenant, dans ce cas, par exemple, si nous utilisons cette liste, alors nous ne trouvons pas, alors tout élément qui correspond à notre condition ici. Donc, nous allons juste continuer à entrer la même méthode jusqu'à ce que l'index soit, finira par être à array.length minus1 et nous retournerons false. Donc, c'est notre méthode et allons de l'avant et l'utiliser dans notre méthode principale. Permettez-moi donc de les commenter. Et nous allons imprimer plusieurs et créer un égal à, par exemple, 12355310. Et dans ce cas, c'est utilisé cette méthode avec ceci à un et 0. Voyons ce qui va se passer. Va devenir vrai. Maintenant, si nous supprimons 15 va obtenir des flux. Alors, c'est ça. Quelques exemples simples sur la récursivité. se voit dans la vidéo suivante. 30. Trier des cordes: Maintenant, nous revenons à nos algorithmes de tri. La curiosité les a essayés avec des tableaux d'entiers. Maintenant, nous allons utiliser des tableaux de chaînes. Donc, ici, une méthode principale. Créons un tableau de chaînes. Mettez à l'échelle les noms, et il serait égal à certains noms. Par exemple, Alix et appuyez sur. Donc c'est que je listerais. Maintenant, allons de l'avant et utilisez l'insertion. Donc, nommez-le public statique, void, insertion de tableaux, tableaux de chaînes, les appelait des noms. Donc, c'est la même chose que nous l'avons fait pour les entiers avec une certaine variation. Donc, nous commençons avec notre boucle for à i égal à un. Et nous devons définir notre force est égale aux noms à i et j serait égal à i moins un. Maintenant entrera dans notre boucle while. Alors que j est supérieur ou égal à 0. Et nous utiliserons une méthode disponible pour nous. Et c'est la classe String en Java. Ceci décomposé à, nous allons comparer la clé à une autre chaîne. Dans ce cas, il a été nommé à j. Si elle est inférieure à 0, alors nous devons les échanger. Nous devons créer une chaîne appelée comme d'habitude, lui donner la valeur des noms, des noms de j plus un, et des noms de j plus un. Nous prenons la valeur de l'amortissement. Maintenant. Donc, c'est notre méthode et allons de l'avant et l'utiliser dans notre méthode principale. Et chercher et avec des noms. Et puis la boucle for pour imprimer nos éléments. Nous imprimons ciblé plus d'espace. On va chercher Alex, Chris et James pour qu'ils soient triés maintenant. Donc, nous avons utilisé, par rapport à cette méthode est disponible dans la classe String. Et nous l'utilisons. Nous avons la même méthode ici. Mais au lieu de comparer avec ce signe, nous avons utilisé la méthode de comparaison dans la classe String et Java. Maintenant, nous allons utiliser la sélection tri. Alors continuons et copions-le sans l'écrire une fois de plus. Trier la sélection, et nous allons la modifier ici. Alors allons de l'avant et modifions-le. Maintenant. Tu prends une force. Et ici, nous fixons le minimum est égal à je le ferai. D' accord ? Et si nous avons besoin d'utiliser la méthode CompareTo, les deux chaînes. Et puis enfin, nous avons un tableau de chaînes qui par rapport à gay et minimum, il devrait être inférieur à 0. Et puis on a fini. Retournons ici et utilisons-le. Donc, au lieu d'utiliser l'insertion, imprimons le tri de l'insertion. Et pourrait effectuer la sélection sont des noms et les imprimer. Maintenant, nous avons déjà trié les noms, alors créons un autre à un. Appelons ça nom. Deux seront égaux à des noms et utilisez-le ici. Sélection de sorte que ici. Allons-y et imprimez-les. On va avoir, on a juste besoin d'imprimer une ligne ici. Et le code une fois de plus pour obtenir l'insertion. Donc, c'est notre sortie et notre sélection, donc il obtiendrait la même sortie. Donc, ceci est, cette, cette vidéo est juste pour vous montrer que vous pouvez utiliser ces algorithmes de tri non seulement pour les entiers, mais pour la force. Et vous pouvez aussi les utiliser pour les personnages. Ainsi, vous pouvez aller de l'avant et serrer en utilisant des caractères au lieu de chaînes ou d'entiers. Et non seulement la technique de tri, mais vous pouvez également utiliser les algorithmes de recherche avec des chaînes et des caractères à cela est-il pour le tri et la recherche des algorithmes ? se voit dans la vidéo suivante. 31. XML: Bonjour et bienvenue. Et dans cette vidéo, nous allons parler de XML et comment extraire des données de XML en utilisant Java. Maintenant, avant de le faire, nous allons parler de XML en général. On ne va pas entrer dans les détails. Cependant, nous devons savoir ce qu'est XML et comment nous pouvons l'utiliser. Donc, tout d'abord, XML signifie langage Extensible Markup. Cela signifie que c'est un langage informatique qui utilise le balisage et est capable d'être étendu. Alors, qu'est-ce que le balisage ? Les balises sont les notations et les symboles utilisés pour corriger le texte et indiquer comment la taxe doit être affichée. Par exemple, chaque fois que nous utilisons les symboles, la fermeture. Et donc ces symboles sont les symboles de balisage. Maintenant, extensible signifie qu'il est capable d'être étiré ou étendu. Ainsi, dans la technologie de l'information, extensible décrit programme sur le langage de programmation qui est conçu de sorte que les utilisateurs et les développeurs peuvent développer, ajouter à ses capacités. Donc, dans ce langage XML, nous pouvons créer nos propres balises. n'y a pas de balises prédéfinies dedans. Et voyons juste un exemple à propos de ce XML. Et c'est un exemple, comme vous pouvez le voir, nous pouvons le lire et nous pouvons comprendre les informations que nous avons ici. Donc, tout d'abord, nous avons une entreprise, et à l'intérieur de cette entreprise, nous avons du personnel et un autre membre du personnel. Comme nous pouvons le voir, nous avons une carte d'identité pour la première cent dix cent un, et pour la seconde 12 mille. Maintenant, à l'intérieur de la portée, vous avez des informations sur la dispersion. Nous avons donc le prénom, le nom, le surnom et le salaire. Et la même chose pour le deuxième membre. Et parlons de la syntaxe de XML. Prenons par exemple cet exemple. Donc, nous avons ce premier, FirstName et nous avons faible. Comme nous pouvons le voir ici, nous avons deux balises, la balise de départ et l'attaque. Donc, chaque fois que nous voulons écrire, l'antilog ajoutera simplement ce caractère ici. Et à l'intérieur des balises, nous pouvons simplement écrire notre texte. Maintenant, cette chose s'appelle un élément. C' est donc un élément de notre code ou de notre texte. Maintenant, xml est sensible à la casse. Donc, chaque fois que nous écrivons une balise de départ, nous devons conduire le type n, la même chose exacte. Donc, nous pouvons juste écrire ici le capital F. Cela ne fonctionnera pas puisque XML est comme Java, est sensible à la casse. Maintenant, la même chose s'applique ici, se trouve ici, pour que nous puissions l'essayer. La majuscule F, prénom ici et suivi de prénom. Pour que nous puissions voir que nous l'avons fait. Et donc le type d'élément firstname doit être terminé par la balise de fin correspondante. Comme vous pouvez le voir. Donc, c'est un sensible et il est important de se souvenir de cela puisque notre code en dépendra. Maintenant, une autre chose est que les éléments ne devraient pas se chevaucher. Donc supposons que j'ai FirstName et laissez-moi simplement copier ceci et le coller ici. Et déplacez ça jusqu'à la fin. Comme vous pouvez le voir, il va générer une erreur disant que le type d'élément lastName doit être terminé par la balise de fin correspondante lastname. Comme vous pouvez le voir ici, nous avons le nom de famille ici et la balise de fin de nom est après le nom de famille. Donc, XML vérifie si cette balise correspond à celle-ci, tout est bon. Cependant, dans ce cas, LastName n'est pas comme ça, ce n'est pas le FirstName. Et pour générer une erreur. Cependant, si je me suis basé ici, rien ne se passera puisque tout est en ordre. Nous avons le nom, et cela correspond à la balise d'ouverture ou à la balise de départ, et nous avons le prénom ici. Laisse-moi juste les déplacer comme avant. Et passons à la structure des éléments dans les documents XML. Donc, tout d'abord, nous avons l'entreprise et à l'intérieur de cette entreprise, nous avons du personnel. Et nous pouvons appeler cette société l'élément parent, et le personnel est l'enfant. Maintenant, une autre chose est la Déclaration, et cette déclaration est facultative et elle indique le nombre de version de XML en cours d'utilisation. Et dans ce cas, c'est divergent 1,00. Et chaque fois que nous utilisons cette déclaration, elle doit être au sommet. Même les espaces ou les commandes ne devraient pas devenir avant. Donc, nous pouvons simplement ajouter un peu d'espace blanc. Voici quelques commentaires ici. Nous devons l'ajouter. La première ligne dans notre document. Et cette déclaration est également sensible à la casse, sorte qu'elle peut essayer des majuscules XML, comme vous pouvez le voir. Passons maintenant aux attributs. Et un attribut spécifie une seule propriété pour un élément. Et il se compose d'un nom et d'une valeur séparés par un signe égal. Donc, comme nous pouvons le voir ici, nous avons notre élément personnel. Et dans le personnel, nous avons quelques éléments ici, et ce sont l'enfant. Cependant, nous pouvons voir que nous avons un ID, et cet ID est un attribut de choses. Comme nous pouvons le voir, cet ID, c'est le nom de l'attribut, et ce 101 est la valeur de l'attribut. Et il n'est conservé que dans la balise de départ. Et comme vous pouvez le voir, c'est après le nom sans virgule ou espace ou semi-virgule, ainsi de suite. Donc, nous avons ce nom égal et dévalué suivi. Après ça. Ensuite, nous fermons notre startup. Maintenant, nous pouvons avoir plus d'un attribut, mais nous ne pouvons pas avoir deux valeurs pour un attribut dans le même début que. Donc encore une fois, dites 10000 plus quelque chose. C' est faux. Cependant, nous pouvons avoir deux attributs. Supposons que j'ai un numéro, et dans ce cas, ce nombre est trois. Laisse-moi juste l'écrire. Et comme vous pouvez le voir ici, il n'y a pas d'erreur et cela fonctionne bien. Donc, c'est fondamentalement, c'est une idée générale sur XML, comment nous pouvons lire les données de ces documents. Et dans la vidéo suivante, nous allons créer notre classe, notre programme, afin que nous puissions extraire ces données en Java. Mais cela étant dit, c'est la fin de cette vidéo et vous voir dans la prochaine. 32. Processus local en XML: Et revenons à notre processus local. Et c'est notre programme Java ici, nous allons écrire notre programme. Donc, tout d'abord, nous devons créer notre méthode principale. Et bien sûr, nous allons lancer toutes les exceptions qui pourraient se produire ici. Et nous allons juste, nous pouvons. Donc d'abord, nous devons prendre ce dossier. Donc, ceci est doté de points XML et il est stocké ici comme nous pouvons le voir. Maintenant, la première chose que nous allons faire est de créer un fichier et ce fichier, nommez-le Fichier et nouveau personnel de fichier ce XML. Alors maintenant notre dossier est là. Bien sûr, nous devons l'importer. Et comme avant, nous importons simplement le fichier java.io dot. Maintenant que nous avons notre personnel de fichier dot xml, comment nous pouvons en extraire des données. Donc, nous commençons par quelque chose qui s'appelle document. Et si je viens d'éviter, c'est dans les actes Java que les analyseurs XML package. Et cela définit une API d'usine qui permet aux applications d'obtenir un analyseur qui produit des arborescences d'objets DOM à partir de documents XML. Nous devons donc extraire les données du maximum. Nous allons utiliser ce document, construire une usine. Et maintenant que nous avons importé, laissez-moi juste le nommer DVF. Et si je l'écris encore une fois, Factory. Et laissez-moi voir quelles méthodes sont disponibles pour nous. Nous avons la nouvelle méthode d'instance. Et comme nous pouvons le voir, cette nouvelle instance, c'est une méthode statique qui crée une nouvelle instance d'usine. Et cette méthode utilise ce qui suit. Nous pouvons voir qu'il utilise l'usine de constructeur de documents et Java que les analyseurs XML, cette usine de constructeur de documents. Et nous utilisons simplement cette méthode. Et maintenant, nous avons nos objectifs DVF. Il est documenté dans l'usine. Maintenant, laissez-moi juste utiliser ce DBF et voir ce qui est, quelles sont les méthodes ici. Et comme nous pouvons le voir, si nous faisons défiler vers le bas, nous pouvons voir que nous avons tant de méthodes. Cependant, nous sommes intéressés par ce nouveau générateur de documents. Et ce nouveau générateur de documents crée une nouvelle instance de notre usine de création de documents. Maintenant, laisse-moi juste l'utiliser. Et ici, je vais définir le constructeur de documents. Bien sûr, je vais l'importer. Donc, il sera importé à partir des analyseurs de points XML Java X dot comme l'usine du constructeur de documents et laissez-moi le nommer. Db sera égal à cela. Maintenant. Après la création de ce document sera usine et le constructeur de document. Je vais passer notre fichier et ce document, donc le document que nous nommons dans le document d. Et à l'intérieur de ce document, nous allons utiliser Db dot. Comme vous pouvez le voir, nous avons tant de méthodes aussi. Ce bus nous intéresse. Et comme vous pouvez le voir, biais, il analyse le contenu du fichier donné comme un document XML. C' est donc ce que nous allons faire. On va barrer notre dossier. Et enfin, nous avons notre fichier analysé. Et bien sûr, nous allons l'importer. Et nous allons l'importer depuis org dot trois, WC dot dm. Et maintenant on a fini de passer notre dossier. Nous avons toutes les données et ce document D. Revenons à notre document et nous remarquerons que nous avons du personnel. Donc nous sommes intéressés par le personnel ici, des trucs et des trucs aussi. Laisse-moi retourner ici. Et si j'ajoute d dot, nous pouvons voir que nous avons quelques méthodes. Cependant, si nous voulons prendre les éléments de ces documents, nous pouvons simplement utiliser les éléments get par nom de tag. Et dans ce cas, nous pouvons utiliser cette méthode, getElementsByTagName. Et nous pouvons spécifier le nom du personnel. Et bien sûr, nous pouvons le stocker dans une liste ordonnée. Laissez-moi simplement créer notre liste de nœuds. Et bien sûr, importé de point AHRQ W3C point vers le bas. Et laissez-moi le nommer liste du personnel. Maintenant, nous avons notre liste de personnel. Nous avons le personnel trucs un et le personnel à la liste stockée et non ordonnée. Comme on peut le voir. Comment on y accède ? Utilisera simplement des nœuds. Donc, nous avons une liste non ordonnée. Comment accéder à une liste de nœuds en utilisant un impair ? Maintenant et laissez-moi créer un clin d'œil et par nom personnel ID rien. Et bien sûr, l'élément à l'intérieur de ce nœud, permettez-moi de nommer ELT comme éléments. Et bien sûr, nous allons les importer comme d'habitude. Et laissez-moi faire défiler vers le bas. Nous avons ici tous les trois WC DOM cette connaissance. Maintenant que nous avons notre liste d'éléments, de nœuds et de nœuds, nous pouvons commencer avec nos données d'extraction. Maintenant, tout d'abord, nous allons utiliser quelque chose que nous avons utilisé auparavant, et c'est le StringBuilder. Et à l'intérieur de la chaîne fera l'affaire. Laissez-nous, nous, nous allons juste le définir. Et maintenant, nous avons notre StringBuilder. Et bien sûr, nous allons ajouter combien de membres du personnel nous avons. Donc nous allons accélérer ce groupe là-bas. Et nous allons prendre la liste statistique et voir combien de membres du personnel. Nous utilisons donc simplement la troisième ligne directrice. Il y a donc des membres plus longs et du personnel. Et bien sûr, nous allons arriver à une nouvelle ligne. Et on peut l'utiliser. Et maintenant, nous en avons fini avec notre longueur. Maintenant, laissez-moi ajuster, extraire des données de notre document. Donc la première chose que nous allons faire est de passer à travers les éléments à l'intérieur de cette liste de statistiques, je suis désolé, indiquent à l'intérieur de la liste de personnel. Et pour ce faire, nous allons créer la boucle for, ainsi de suite. Comme d'habitude, soudainement à r égal à 0 et se terminant à la longueur de point de liste avec personnel. Cette longueur. Et la première chose que nous allons faire est de prendre ce noeud de portée et d'extraire un noeud de la liste de portée. Alors, comment faire ce point StatPlus ? Nous pouvons voir que nous avons quelques méthodes ici. Cependant, nous allons prendre cet élément, cet élément de méthode, et comme vous pouvez le voir, il retourne un nœud de sorte que i, nous allons extraire cet élément et le stocker. Et maintenant, nous allons ajouter à ce nœud, au StringBuilder, le nombre. Donc sba dot ajouter. Nous allons ajouter que c'est le numéro de balise et suivi par I plus un, puisque nous commençons à 0, cependant, nous ne voulons pas commencer à 0. Donc, le personnel numéro 12 et ainsi de suite. Maintenant, après cela, nous allons vérifier si ce nœud de portée est un élément. Et comme vous pouvez le voir ici, nous pouvons voir que ce truc comme un élément. Et laisse-moi revenir en arrière. Alors, comment faites-vous ça ? Donc f, notez cet écart. Comme nous pouvons le voir, nous avons quelques méthodes et nous sommes intéressés et pourtant le type de nœud, nous allons être notés. Et Eschyle est égal à noter ce noeud d'élément. Donc, si c'est un élément, nous allons le prendre et le stocker dans un élément, comme vous pouvez le voir. Nous avons donc créé ici un élément. Nous disons simplement que si ce nœud est un élément, stockez-le et ELT. Et comment convertir deux éléments et comparer le nœud de portée en un élément. C' est donc le cas. On peut le convertir, rien ne se passera. Il sera simplement converti à partir du nœud deux élément. Après cela, nous allons créer une liste d'attributs. Et c'est ainsi que nous pouvons extraire certains attributs de XML. Comme vous pouvez le voir, nous avons notre carte d'identité. Nous pouvons l'extraire en utilisant cette méthode. Donc, la première chose que nous allons faire est de créer une carte de noeud nommé. Et bien sûr, l'acide importé que nous allons juste l'initialiser. Donc, je vais le nommer attribut et bien sûr, élément personnel. C' est donc notre élément. Et nous obtenons simplement, obtenez ces attributs de cet élément. Après cela, nous allons créer notre nœud. Et c'est un nœud attributaire. Et ici, nous allons extraire nos éléments de ce nœud, de cette liste d'attributs. Donc, nous pourrions avoir plus d'un élément ou un attribut de plus d'un ici. Nous allons donc créer une boucle for et passer à travers tous les attributs à l'intérieur. Cependant, il arrive que nous n'ayons qu'un seul élément ou un attribut dans ce cas. Et les résultats devraient fonctionner correctement pour d'autres exemples. Donc, nous allons créer ceci pour la boucle. Et dans ce cas, nous allons obtenir la longueur de cette liste d'attributs. Et dans ce cas, je vais, noeud d'attribut sera égal à la liste d'attributs comme avant cela ou cet élément ce cas et j. Donc c'est tout. Maintenant, nous avons notre attribut. Nous pouvons simplement ajouter à ce StringBuilder. Donc, comme accéléré bande. Et nous allons ajouter le nœud d'attribut. Et nous pouvons obtenir le nom du nœud en utilisant la méthode get. Et je vais simplement écrire égal. Et bien sûr, je veux obtenir la valeur. Donc, les nœuds d'attribut qui obtiennent la valeur du nœud. Et bien sûr, laissez-moi juste sauter aligner. Et on a fini ça. Donc, jusqu'à maintenant, nous venons de créer notre liste de nœuds, noeud un élément. Nous avons pris ce document et l'avons stocké et créé la liste du personnel. Ici, nous avons le personnel. Comme vous pouvez le voir, nous avons deux employés, qui est, qui a l'id 101, et nous commençons par l'ID 2001. Maintenant que nous avons notre personnel et la liste de personnel avec juste les extraire un par un en utilisant cette boucle pour. Et à l'intérieur de cette boucle pour, nous allons prendre l'élément de la liste de portée histoire et noeud de portée. Et puis ce nœud de portée est un élément, va simplement le convertir en un élément, puis juste extraire les attributs. Et dans ce cas, nous n'avons qu'un seul attribut. C' est l'idée. Cependant, nous pourrions en avoir plus d'un. C' est pourquoi nous avons créé notre deuxième boucle for, et c'est la boucle interne for. Et dans ce cas, nous allons simplement ajouter les attributs que nous avons et nous devons toujours extraire les éléments. Donc nous avons le surnom et le salaire, et nous allons les extraire dans la prochaine vidéo. Alors, à vous voir. 33. Processus local XML 2: Maintenant, nous devons encore extraire les informations du personnel. Nous avons donc le surnom et le salaire de première classe. Et dans ce cas, nous pouvons simplement utiliser l'élément de portée que nous avons créé et extraire les données d'ici. Donc, nous allons utiliser sba dot append. Et tout d'abord, nous allons extraire le prénom. Et puis après cela, nous allons utiliser l'élément de staff et obtenir des éléments par nom de tag. Donc, l'élément est le prénom. Et bien sûr, l'article est 0. Et nous allons le convertir en quelque chose qui est lisible ou puanteur. Nous pouvons donc utiliser beget, contenu contextuel taxé. Et dans ce cas, il retournera le nœud sous forme de chaîne. Et bien sûr, laissez-moi le stocker MS drain first_name. Et puis je vais simplement utiliser ce prénom. Donc, je vais ajouter ce prénom. Et laissez-moi juste sauter dans une autre ligne. Et je vais faire la même chose pour l'autre. Donc nous avons le nom de famille. Et dans ce cas, laissez-moi juste copier ceci. Fondamentalement, ici. Et c'est le nom de famille. Je vais extraire les éléments par nom de balise et c'est le dernier. Et bien sûr, la même chose ici, élément à 0 et obtenir le contenu du contexte de texte. Et bien sûr, je vais dérailler donc nom et sauter. Maintenant, la deuxième ou la troisième information que nous allons extraire est le, comme vous pouvez le voir, surnom. Et enfin, nous avons le salaire. Donc nous allons ajouter un surnom. Et bien sûr, string, laissez-moi le copier. Nous avons ici notre surnom et le nom getElementsBytagName. Et enfin, nous allons ajouter ainsi nommé saut. Donc, la dernière chose est d'ajouter la bande. Nous avons dans le salaire. Et dans ce cas, nous allons le stocker et la retenue aussi. Donc le salaire de chaîne égal à, désolé, laissez-moi juste le copier. Donc le salaire ici. Et obtenir des éléments par cette poutre, salaire. Et enfin, nous allons simplement ajouter nos informations et à notre StringBuilder, salaire plus saut. Et dans ce cas, laissez-moi juste, à peu près ce qu'on a fait ici. Donc, tout d'abord, nous avons notre élément et à l'intérieur cet élément, nous avons quelques autres éléments enfants. Donc, nous avons notre personnel qui est stocké dans notre, comme nous pouvons le voir, élément personnel. Maintenant, pour extraire les données de cela, nous avons utilisé getElementsByTagName. Cependant, rappelez-vous que chaque fois que nous utilisons ce get, getElementsBytagName, Nous allons obtenir une liste de nœuds. Il les a restaurés dans une liste ordonnée. On aurait pu faire la même chose ici. Cependant, puisque nous n'avons qu'un seul élément, nous pouvons simplement utiliser chaque méthode d'élément et extraire le premier élément qui est à l'index 0. Et puis nous allons le convertir en une chaîne en utilisant le contenu du texte get. Donc nous aurions pu le faire d'une autre façon. Donc, nous pouvons simplement créer une liste de nœuds et nous allons la nommer. Et bien sûr, nous pouvons utiliser l'élément de staff qui obtiennent des éléments par nom de tag. Et bien sûr, nous pouvons utiliser le prénom. Et c'est donc notre liste de nœuds. Ensuite, nous pouvons utiliser et ajouter cet élément 0 ou P8, créer notre boucle for et ainsi de suite. Donc nous pouvons faire exactement la même chose qu'avant. Cependant, nous savons déjà que notre document de personnel est composé du premier surnom au salaire, donc nous n'avons qu'un seul de chacun d'entre eux. Nous pouvons donc simplement utiliser cette méthode. Maintenant que nous avons notre bien, laissez-moi aller de l'avant et le faire. Alors exécutez comme application Java que parce que vous obtenez une déchirure. Et rien ne s'est passé juste parce que nous n'avons pas imprimé notre StringBuilder. Donc, ici, nous avons notre premier pour les extrémités de boucle ici. Donc System.out.print. Exécutez ce code une fois de plus. Nous allons obtenir nos données. Donc la première chose que nous avons fait est que nous pouvons voir que nous avons juste un petit zoom avant. Et comme vous pouvez le voir ici, la première chose que nous avons fait est d'imprimer le nombre de membres du personnel que nous avons. Il y a donc deux membres du personnel ici. Ensuite, nous sommes passés à notre personnel et avons extrait des données. Donc, bien sûr, nous avons annexé. Donc le personnel numéro un ici, je suis désolé, je n'aurais pas pu sauter et mourir. Et laissez-moi courir ça une fois de plus. On va avoir ça. Donc le personnel un pour que l'ID 101. Donc on a imprimé à partir de ça. Maintenant, puisque nous n'avons qu'une seule idée, nous aurions pu l'utiliser à 0 et supprimer ceci pour la boucle. Une fois de plus, j'aurai le même résultat qu'avant. Cependant, si nous avons plus d'un attribut, cela ne fonctionnera pas. Il va simplement revenir pour nous cette ligne. Maintenant, laisse-moi revenir ici. Après cela, nous imprimons juste le prénom, le nom, le surnom et le salaire, et faisons exactement la même chose pour le deuxième membre du personnel. Donc, nous avons du personnel pour ID 2001, premier surnom et salaire. Maintenant, il s'agit d'un exemple simple et rapide sur XML et comment extraire des données à partir de documents XML. Dans les prochaines vidéos, nous allons creuser plus profondément dans ce document XML extraire quelque chose et vous voir alors. 34. Traduire XML à partir de navigateur: Bonjour et bienvenue. Et dans cette vidéo, nous couvrons toujours XML. Toutefois, ce terme ne traiterait pas le XML local. Nous allons aller à Google et extraire des données d'un site Web. Donc supposons que nous l'avons fait, allons à Google et BBC News. Et comme vous pouvez le voir, si nous allons ici, alors ce sont les nouvelles. Et bien sûr, nous pouvons simplement, si nous voulons extraire des données à partir de XML, nous pouvons simplement écrire RSS dot xml. Et ce sera nous diriger vers une page, et ceci est le flux RSS de la BBC News. Donc notre programme devrait prendre ces nouvelles et simplement les extraire et les stocker soit en les imprimant dans le conseil, soit en les stockant dans un dossier. Et on verra ce qui va se passer. Laisse-moi juste créer un nouveau fichier. Will simplement une classe, je suis désolé, quand le nommer. Nouvelles de la Bbc. Maintenant, c'est notre classe. Et à l'intérieur de cette classe, comme d'habitude, nous allons utiliser la méthode principale et lancer une exception. Maintenant, nous allons commencer par notre cours. Donc, tout d'abord, c'est l'URL, et nous allons simplement le stocker dans une URL. Bien sûr important. Mais le net que u r, l, alors je vous nomme. Et, et dans ce cas, si je veux créer cette URL, je peux simplement créer une nouvelle URL et copier le lien d'ici et d'ici. Donc maintenant, nous avons notre URL. Maintenant, comment nous pouvons l'utiliser, nous pouvons utiliser le flux d'entrée. Et dans ce cas, laissez-moi le nommer, je suppose. Et je vais utiliser le point URL. Nous avons le flux d'ajout, je suis désolé, ajouter le flux. Et cela générera un InputStream. Et bien sûr, je devrais l'importer de java.io, ce flux d'entrée. Maintenant que nous avons nos données, notre XML, nous pouvons simplement commencer avec Baden Document Builder usine comme avant, importé DBF égal à documenter l'usine. Et la nouvelle instance. Ensuite, nous allons créer notre générateur de documents. Même chose qu'avant. La base de données de document est égale au point DBF et suivie par le générateur de nouveaux documents. Ensuite, nous allons créer notre document et limiter l'argument cette fois. Et DB cette boîte. Nous allons passer le flux d'entrée que nous venons de créer. Maintenant, bien sûr, nous devons les employer. Donc, importer à partir de octet trois WC, entrée de Java, d'excellents analyseurs XML. Maintenant, nous avons notre configuration. Nous pouvons simplement commencer par extraire des données. Donc, la première chose que nous allons faire est de créer le StringBuilder pour stocker des données. Donc la vitesse StringBuilder égale à la nouvelle StringBuilder. Et dans ce cas, j'ajouterai une certaine force ici puisque je peux utiliser le point SP append, cependant, je peux utiliser ce paramètre, donc je vais les démarrer en HTML. Alors laissez-moi simplement créer la tête ayant droit à notre fichier HTML. Donc HTML. Et à l'intérieur de cette tête, nous avons le titre. Dans ce cas, il s'agit de BBC News. Et bien sûr, je devrais fermer le titre, alors. Fermez la tête et suivie par le corps. Je devrais arriver maintenant, le corps. Maintenant c'est notre StringBuilder. Commençons par notre XML. Donc, la première chose que nous allons faire est comme avant, la liste de noeuds BAD. Et dans ce cas, je vais le nommer liste des articles. Bien sûr, je vais utiliser le document qui obtient éléments par nom de balise et ce nom est élément. Alors maintenant laissez-moi juste importer ceci. Et tout l'est. Alors pourquoi ai-je écrit un article ici ? Si je retourne à notre BBC News et cliquez avec le bouton droit de la souris, nous avons voir la source de la page. Et voici notre document XML. Comme vous pouvez le voir, nous avons le titre, description, le lien, l'image, et ainsi de suite. Cependant, nous sommes intéressés par les articles. Et ces éléments sont soit l'élément, le titre et la description. Donc, nous avons ce titre et bien sûr dans la description, alors nous avons un autre article avec le titre et la description aussi. Nous sommes donc intéressés par les articles. Comme vous pouvez le voir, nous avons tellement d'articles et nous allons tous les extraire. Donc, revenons ici et travaillons avec notre article comme avant, noeud, article, noeuds et élément élément élément, ELT. Et bien sûr. Importez ces deux-là de tous les trois WC que stupide. Maintenant, après avoir créé notre noeud, dernier noeud et élément, nous allons créer notre boucle for. Et la limite est le document ou document.GetElementById. Désolé, nous pouvons simplement utiliser la liste d'articles que nous avons créée. Donc la liste des objets mais obtenir la longueur, n'est-ce pas ? Sauf si ça prend de la longueur. Et maintenant, nous pouvons travailler avec notre boucle for. Donc, à l'intérieur de la boucle carrée, nous allons prendre une note à la fois, donc nous allons la stocker dans le nœud d'élément que nous avons créé. Donc, item naught sera égal à items, liste item à l'index i. Maintenant, après cela, nous allons vérifier si c'est un élément. Maintenant. Et le processus local. Ici. Nous l'avons utilisé comme, comme vous pouvez le voir ici, nous avons vérifié si le noeud de personnel pour obtenir les types de noeud. Nous utilisons donc la méthode get. Et si cela est égal au nœud d'élément, maintenant nous allons utiliser une autre méthode. Et nous pouvons simplement utiliser ce noeud d'élément est instance un élément si c'est le cas. Donc, instance de signifie que cette note d'article est une instance de cet élément, je suis désolé ici, instance comme celle-ci. Et donc si ce nœud d'élément est une instance d'élément, nous allons entrer cette instruction. C' est donc le cas comme avant, nous allons convertir en élément une histoire, l'histoire dans l'article ELT. Et comment on fait, on fait ça ? Nous allons simplement écrire élément et suivi par item.name. Maintenant que nous avons notre élément d'article, nous pouvons simplement le stocker et notre StringBuilder. Cependant, nous créons du HTML. Donc, laissez-nous utiliser le, comme vous pouvez le voir, nous avons le titre et la description. On pense donc que le titre dans H2 et la description dans un paragraphe. Alors, comment faites-vous cela comme point v ajouter H2. Donc, nous avons le bord deux. Et bien sûr, après cela, nous allons utiliser l'élément élément qui obtient des éléments par nom de balise. Et ce nom est le titre. Comme nous l'avons dit avant. Si nous revenons ici, nous avons à l'intérieur de l'article, le titre et la description. Donc, nous allons obtenir le titre comme avant, l'élément à 0 qui obtient TextContent. Et puis je vais fermer cette étiquette. Donc, je vais simplement utiliser proche de. Maintenant. Après cela, je vais simplement utiliser la balise de paragraphe pour créer la description. Donc sba dot ajouter. Et à l'intérieur de cela, je vais créer notre balise de paragraphe, suivie par des éléments d'élément qui obtiennent des éléments par nom de balise. Et dans ce cas, nous avons une description. Et comme d'habitude, cet article à 0. Ensuite, le contenu du texte. Bien sûr que je vais le fermer aussi. Donc, nous fermons ça. Et maintenant, nous avons nos données ici. Enfin, après avoir terminé de ds, permettez-moi de modifier ceci. Donc, ici, nous avons notre boucle for. Après avoir terminé de cette boucle while, nous devons fermer notre corps et HTML. Donc j'ajoute simplement ici, accélère ça, renverse notre corps proche. Fermez ensuite HTML. Maintenant, nous avons fini avec l'ajout et nous sommes prêts. Donc, si je vais de l'avant et imprimer non et vitesse, on fait ça. Et comme nous pouvons le voir, nous avons ici tant de mots. Cependant, je viens de les avoir dans une ligne parce que je ne les ai pas stockés dans des clients ici. Donc, après chaque description ou chaque titre, je vais sauter aligné. Et bien sûr, et si je fais le tour une fois de plus, nous allons les obtenir. Maintenant. Pourquoi je les ai stockés comme ça ? Pourquoi ai-je créé un code HTML ? Donc, laissez-nous simplement obtenir ces données et les stocker dans un HTM L phi. Donc, si je vais ici avant de créer notre document, Linda usine document builder et document, nous pouvons créer notre fichier que nous allons stocker ces données. Et donc après le flux d'entrée, je vais simplement créer notre fichier. Appelons ça des nouvelles, et ce sera égal à nu. Dans ce cas, je vais nommer qu'il a utilisé ce SDM. Donc HTM signifie HTML. Maintenant que nous avons créé notre fichier, je dois m'y opposer, bien sûr, de java.io. Après cela, je vais employer le FileWriter. Nous avons déjà appris ce rédacteur de fichiers. Donc, nous allons imposer le rédacteur de fichiers Phyla. Et après cela, nous allons créer un rédacteur de fichiers. Et à l'intérieur de ce fichier news, alors nous allons créer l'écrivain tamponné, BW. Et bien sûr, le nouvel écrivain tamponné avec le paramètre de f w a défié l'écrivain. Ensuite, nous allons créer le graveur, et cela va l'utiliser pour extraire, pour écrire des données dans notre fichier. Donc Brin écrivain, PW pour être égal à nouveau graveur d'impression et Vw comme paramètre. Et maintenant, on s'est mis. 35. Traduire XML à partir du navigateur 2: Maintenant, après avoir défini notre fichier dans lequel nous allons écrire nos données XML, nous allons l'utiliser ici après avoir ajouté la balise de fin du corps et HTML, nous allons utiliser le BW, cette marque, Sb. Ensuite, nous allons le fermer un type p en raison de la fermeture. Et maintenant, si je lance ce code, nous pouvons voir que nous avons ici à l'intérieur de notre projet, nous avons des nouvelles que SDM, donc c'est notre fichier HTML. Maintenant, si nous cliquons dessus, nous allons obtenir le titre et la description de toutes les nouvelles. Nous avons donc la première description de titre que la deuxième description de titre, et ainsi de suite. Donc nous avons toutes les nouvelles ici et notre BBC News. En ce moment. C' est quelque chose que vous pouvez faire comment maintenant c'est modifiable. Donc à chaque fois que nous cliquons, donc si je lance ce code, maintenant, je vais obtenir cette nouvelle que HTML. Cependant, si je cours ce demain, je vais obtenir différents titres et descriptions. Cela dépend de la discorde de temps Iran. Depuis lors, utilisez le changement tous les jours. Maintenant, nous pouvons ajouter quelque chose ici, et ceci est de lier cette nouvelle que HTML au navigateur. Donc, une façon de le faire est d'utiliser le bureau. Et nous avons une méthode qui est appelée bureau gad. Et à l'intérieur de cette méthode, nous pouvons parcourir et nous allons recevoir les nouvelles. Cependant, nous devons le convertir en URI. Tellement habitué à URI. Maintenant, si j'exécute ce code, il me redirigera dans le navigateur. Et à l'intérieur de ce navigateur, je vais obtenir ces titres et descriptions. C' est donc les nouvelles de la BBC. Je les prends juste à partir du fichier XML ou d'un document, puis les étudie dans mon propre fichier en tant que HDMI. Maintenant, bien sûr, je pourrais utiliser ceci à partir d'ici ou générer un navigateur en utilisant cette méthode ici. Et laissez-moi vous expliquer juste un peu sur MDM. Et pour ceux qui ne savent pas. En HTML, nous avons des balises prédéfinies. Par exemple, l'arête deux est l'en-tête deux, et B, le paragraphe. Donc, chaque fois que nous voulons créer un nouveau fichier HTML, première chose que nous allons faire est de créer la balise HTML, puis la tête, puis le titre. Bien sûr, nous allons écrire un plus serré puis fermer le titre suivi par la tête. Après cela, nous allons écrire notre corps. Donc, nous ajoutons cette balise body. Nous avons écrit tout ce que nous voulons ici de H2 et paragraphe. Ensuite, après avoir terminé, nous fermons simplement le corps et fermons le HTML. Et maintenant, nous avons notre SDM magnifié. Ensuite, nous l'avons stocké dans le fichier. Nous avons créé le nouveau HDR. Et bien sûr, nous le parcourons simplement en utilisant cette méthode ici. Et c'est tout pour cet exercice. Nous pouvons utiliser ce programme chaque fois que nous voulons vérifier les nouvelles. Nous pouvons simplement aller à Eclipse et exécuter ce code. Et nous allons recevoir les nouvelles directement. Et c'est tout pour cette vidéo. J' espère que vous apprécierez ce programme et vous verrez le prochain. 36. Exemple de catalogue: Maintenant, résolvons un autre problème. Et ici, nous avons un catalogue. Donc c'est notre fichier catalogue point x m n. Donc c'est notre document. Et à l'intérieur de ce document, nous avons un catalogue. Et à l'intérieur de ce catalogue, nous avons des CD. Ainsi, comme nous pouvons le voir, dans chaque CD, nous avons le titre, nom de l'artiste, le pays, entreprise, le prix et le rendement. Maintenant, ce que nous allons faire ici, c'est que nous allons examiner tous ces CD. Donc, nous avons tellement de CD et de respect pour extraire le CD le moins cher et le plus ancien. On va extraire deux CD. Celui qui est le moins cher, et le second est le plus ancien quand toutes ces villes. Donc, comme nous pouvons le voir ici, nous avons 1971, nous faisons défiler vers le bas, nous trouverons 19881987 et ainsi de suite. Alors allons de l'avant et créons notre dernier ici. Donc ici nous avons notre somme L, et je vais créer notre classe par nom catalogue. Et commençons comme d'habitude. Donc, la première chose que nous allons faire est de créer notre méthode principale. Bien sûr, jetez l'exception. Et puis nous pouvons commencer avec la sortie. Maintenant, nous avons notre fichier ici, donc va simplement créer une importation de fichier, importé de java.io. Et limitons Phi à Phi. Et à l'intérieur de ce fichier, nous avons tous le catalogue de nom de fichier que l'eczéma. Et après cela, nous pouvons commencer par créer notre usine de création de documents. Donc, le fournisseur de document Factory importé à partir de Java en plus du XML. Et je limite DVF comme d'habitude et documente l'usine, cette nouvelle instance. Ensuite, nous allons créer notre générateur de documents. Nommons DB. Et important bien sûr. Donc dB il sera égal à DBF, ce nouveau constructeur de documents. Et enfin, créons notre document. Et c'est notre document et nous devons l'importer à partir de trois WC que vers le bas. Maintenant, nous avons notre document et nous avons passé nos déclarations de fichiers, commencer par nos données d'extraction. Nous avons donc indiqué la liste comme d'habitude importée d'ici. Et appelons-le, note ou L. Donc, cela se réfère à la liste de noeuds. Et nous avons aussi un noeud, et nous allons le nommer noeud avec un n. minuscule Et enfin, nous avons notre élément comme d'habitude importé et je limite ELT. Revenons maintenant à notre document XML de points de catalogue et voyons ce que nous allons faire. Nous allons donc imprimer le nom de l'artiste et le titre du CV, suivi de l' année au cas où nous allons extraire le CD avec l' année la plus ancienne et suivi du prix chaque fois que nous voulons imprimer la ville avec le moins cher prix. Nous allons donc créer un ArrayList de chacun de ces éléments. Nous allons donc créer un ArrayList pour le titre, le test et le prix. Et l'équipement finira simplement croître, et ignorer le pays et l'entreprise dans ce cas. Donc, la première chose que nous allons faire est de créer un ArrayList importé. Et nous allons le prendre comme une corde. Et c'est donc le nom. Et bien sûr, initialiser une nouvelle liste de tableaux. Et laissez-moi le copier et le coller. Donc, nous avons quatre ArrayList. Et dans ce cas, un pour le nom. Nous avons dit qu'il nous fallait un pour le titre et un prix. Et le dernier est pour le titre. Et c'est pour le prix. Et enfin, c'est pour le. Maintenant, après avoir créé les listes de tableaux, nous pouvons commencer par notre code. Donc, la première chose que nous allons faire est, comme d'habitude, commencer par une boucle for pour passer à travers tous les éléments ou tous les CD dans ce cas. Jusqu' à présent. Et bien sûr, avant de le faire, nous allons indiquer que nous avons besoin de tous les CD. Comment on fait ça ? Nous allons simplement assigné à indiquer la liste db point, obtenir des éléments par nom de balise. Et c'est un CD. Maintenant, nous avons tous les CD dans notre et moi, et nous pouvons commencer à les extraire un par un. Donc, la limite ici est un point L obtenir longueur. Donc, la longueur de notre liste de nœuds. Maintenant, nous pouvons commencer par assigner pour désigner un élément à i et vérifier si ce nœud est une instance d'un élément. Donc nœud f, instance de l'élément. Si c'est des désintégrations, alors nous allons précéder avec le code R. Et dans ce cas, nous allons convertir ce nœud en un élément et le stocker dans ELT, donc élément. Et ici, nous allons convertir le noeud que nous avons. Et enfin, nous pouvons obtenir les données maintenant. Donc, à l'intérieur de ce nœud, nous avons un CD, et dans chaque ville, nous avons le titre, artiste, le pays, l'entreprise, le prix et l'année. Donc, nous allons simplement prendre ce titre, par exemple, et le stocker dans notre ArrayList. C' est le titre. Alors comment on fait ça ? Nous allons prendre le titre de ce pad et nous allons ajouter. Elt dot obtenir des éléments par nom de balise. Et à l'intérieur de cette balise, nous allons indiquer que nous avons besoin du titre. Et bien sûr, nous avons besoin du premier élément de ce titre. Et c'est à l'élément 0 et obtenez le contenu supplémentaire. Maintenant que nous avons notre titre, nous pouvons faire exactement la même chose pour tous les autres éléments. Laissez-moi le copier et le coller trois fois. Et maintenant nous avons notre comme nous, comme nous l'avons dit précédemment, nous avons le titre, nous avons le nom. Et nous avons aussi le Bryce ici. Et laissez-moi juste modifier les États-Unis. Donc, ici, nous avons le, nous avons dit titre et nous avons dit l'artiste et le prix. Et enfin l'année. Maintenant, laisse-moi être juste une chose. Pourquoi avons-nous ajouté cet article à 0 ? Rappelez-vous que chaque fois que nous utilisons getElementsByTagName, cela va générer, générer pour nous une liste de nœuds. Et dans ce cas, nous pouvons clairement voir que nous n'avons qu'un seul élément dans cette liste de nœuds, et c'est le titre. Et dans ce cas, nous pouvons simplement extraire le premier élément. Puisque nous n'avons qu'un seul élément, nous pouvons extraire l'élément à l'index 0. C' est le premier élément, et cela fonctionnerait ici. Maintenant, nous avons nos données et elles sont stockées dans l'ArrayList. Nous procédons ensuite maintenant avec notre code. Donc, après avoir extrait toutes ces données de catalogue dot xml, et maintenant nous pouvons les utiliser en dehors de notre boucle for car ils sont stockés dans le tableau laisse la liste ici. Alors maintenant, commençons par notre comparaison. Maintenant, nous avons dit que nous voulons la ville avec le prix le plus bas. Nous allons donc prendre le prix et comparer chaque prix ici avec le prochain. Et chaque fois que nous trouvons le minimum, nous allons simplement imprimer le titre, le prix de l'artiste, puis procéder à notre plus ancienne ville. Donc, tout d'abord, commençons par le prix. Alors laissez-moi simplement créer un entier et ce sera le prix minimum de hausse. Donc le prix. Et dans ce cas, j'attribuerai un entier cette valeur maximale, c'est-à-dire une constante tenant la valeur maximale et n peut avoir. Donc, puisque nous allons vérifier un minimum, il est préférable de commencer avec un très grand nombre entier. Maintenant, après cela, nous allons passer à travers tous les éléments ici et voir quel est l'élément avec le prix le plus bas. Donc, créons une boucle for et ça commencera par i égal à 0 et égal à la taille de point Bryce. Maintenant, nous allons passer à travers ça et vérifier si les hommes. Le prix est supérieur au prix minimum ici. Donc le prix qui arrivent à i, f, ce sont des désintégrations. Alors laissez-moi juste commencer l'index ici. Donc, l'indice du minimum doit être égal à 0 au début. Maintenant, nous allons vérifier pour ce prix ArrayList. Et si nous trouvons un élément qui est plus petit que ce minimum, nous allons attribuer ce minimum pour être égal à l'élément que nous venons de trouver. Alors, comment faites-vous ça ? Donc, le prix des hommes devrait être égal au prix, mais on va stocker, acheter. Donc l'indice sera égal à i. Maintenant, nous avons notre indice et notre minimum ici. Laisse-moi juste voir ce que c'est. Donc, nous avons ici, donc nous avons ici le prix qui est une force. Comme nous l'avons dit, nous avons créé une liste de chaînes de tableau et notre prix moyen est un entier. Alors, comment traitez-vous ça ? Nous pouvons simplement convertir cette chaîne en un entier en utilisant la fin Integer.parseInt. Et dans ce cas, c'est le paramètre. Et la même chose s'appliquera ici. Donc entier ce bus et ici nous avons le capital M. Et maintenant nous obtenons, donc après avoir quitté toute cette boucle, nous allons avoir notre minimum et nous allons avoir l'indice. Donc, comme nous avons besoin d'imprimer le titre, l'artiste et le prix, nous pouvons simplement imprimer l'élément du titre à l'index. Cet index. Et la même chose pour les artistes et les prix. Donc nous pouvons imprimer ici, sauver que le CD avec le prix le plus bas et obtenir le prix qui a obtenu à l'indice. Et nous pouvons simplement dire que le CD avec le prix le plus bas du prix est créé par et enregistrer le nom ainsi est créé par. Et nous allons simplement ajouter. Alors ici. Laissez-moi juste créer une nouvelle chaîne ici. Et nous allons dire qu'il est créé par l'artiste. Et c'est le nom.gov. Et nous dirons simplement, je vais y mettre fin et le nom de la ville et le nom. Donc le nom du CD et le titre. Et ici, j'ai l'index. Alors maintenant laissez-moi juste, laissez-moi juste, juste cette année, nous avons une liste de tableaux, nom, titre, prix, et nous avons utilisé le prix. Nous avons utilisé, je suis désolé, j'ai besoin d'ajouter un signe plus et nous obtenons, et si nous exécutons ce code, nous allons obtenir une exception de format numérique. Donc, ici dans notre catalogue, nous avons eu certains, comme vous pouvez le voir dans notre catalogue, que XML nous avons le prix aussi double et nous avons utilisé entier. Donc, une façon de faire face à cela est de simplement utiliser le double. Et puis nous allons doubler. Et la même chose s'applique ici. Double.ParseDouble. Et nous avons, maintenant, après avoir terminé cela, nous allons simplement exécuter ce code une fois de plus. Et nous avons obtenu le CD avec le prix le plus bas de 7.20 est créé par simple lecture et le nom de la ville est livre d'images. Maintenant, si nous retournons à notre catalogue et faisons une recherche dans tous les CDC, nous pouvons trouver que cette information est correcte. Nous avons encore l'année et nous le ferons dans la prochaine vidéo. 37. Exemple de catalogue 2: Notre prochaine tâche est de trouver le CD avec le niveau le plus ancien ou le plus bas. Revenons à notre code. Et comme nous l'avons fait ici, nous allons appliquer la même chose exacte, cependant. Maintenant, avec notre Dieu, je suis désolé, a donné un ensemble de prix. Alors laissez-moi juste copier ceci et le coller une fois de plus ici. Et changez ça. Donc année minimum et x deux. Et bien sûr, nous devons les changer aussi ici. Donc, nous allons vérifier notre ici. Et tu as de l'essence. Mais au lieu de le passer dans un double, nous allons le passer dans un entier. Donc, Integer.parseInt. Aussi la même chose ici, Integer.parseInt. Et la dernière chose que nous allons faire est de changer l'indice deux ans. Maintenant, on est bons. Nous pouvons effectivement nous donner, puisque notre prix ici sont des tests admissibles sont, ont la même longueur exacte. Donc nous n'avons pas besoin de vraiment le changer, cependant, nous le modifions juste pour que nous puissions comprendre ce que nous allons faire ici. Maintenant que nous avons notre minimum et l'index, nous pouvons simplement écrire aussi comme nous l'avons fait ici. Alors laissez-moi simplement copier ceci une fois de plus et le coller. Donc le CD avec nous pouvons dire en fait la ville la plus ancienne que nous pouvons dire est créé. Et par, nous pouvons simplement supprimer. Donc, nous allons obtenir la ville la plus ancienne est créé, puis l'année par le nom et le nom de la ville est, et les titres qui obtiennent. Donc, ici, nous devons changer le prix à l'année. Et nous sommes bons. Si je lance ce code une fois de plus, je vais obtenir le CD avec le prix du système d'exploitation. Il s'agit de la première déclaration imprimée recréée ici. Maintenant, la deuxième déclaration imprimée est la ville la plus ancienne est créée en 1985 par simple lecture et le nom du CD est livre d'images. Maintenant, remarquez ici qu'ils sont les mêmes, donc quelque chose est fort. Comme si nous revenons ici, nous pouvons simplement remarquer que nous utilisons l'index du premier. Cependant, nous avons besoin de l'index deux et exécutons ce code une fois de plus. La ville la plus ancienne est créée en 1968 par Otis Redding et le nom de la ville est le berceau du débat. Maintenant, nous avons nos informations, nous les avons extraites de notre catalogue, ce XML. Et si nous revenons à notre document et faisons une recherche dans tous ces CD ici, nous pouvons simplement simplifier l'exactitude et l'exactitude de toutes ces informations. Donc le prix le plus bas est 7.20 et le plus ancien est 1968. Et c'est essentiellement pour cet exemple. Si nous voulons modifier certaines d'entre elles, nous pouvons simplement énumérer toutes les entreprises. Donc, une façon de le faire, nous avons déjà ArrayLists. Et dans ce cas, nous pouvons créer une nouvelle liste de tableaux juste pour le nom de l'entreprise. Donc ArrayList, compagnie avec deux nouveaux ArrayList. Et en fait, si nous spécifions le type ici, nous n'avons pas à le spécifier une fois de plus ici dans la balise de fin. Donc, nous pouvons simplement supprimer cela et cela fonctionnera correctement. Maintenant, nous avons notre compagnie. Ajoutons les informations de la société à l'intérieur de cette ArrayList. Donc compagnie que, que nous allons ajouter un élément qui obtient des éléments par nom de balise. Et le nom de la balise est société. Et puis cet élément à 0 et les convertir en une chaîne en utilisant le get TextContent. Maintenant que nous avons les noms de nos sociétés, nous pouvons simplement créer une boucle for et passer par tous les noms de sociétés. Comme nous l'avons dit, nous pouvons utiliser la taille de l'entreprise et imprimer l'entreprise. Et permettez-moi juste d'ajouter ici la société i plus 12 points et puis j'ai simplement imprimer la société à l'indice i. Et avant cela, nous pouvons simplement les entreprises. Et maintenant, si nous exécutons ce code une fois de plus, nous allons avoir toutes ces entreprises. Nous venons donc d'avoir la société une, Columbia, la troisième, RCA, BMG, CBS, et ainsi de suite. Voici donc une liste de toutes les entreprises à l'intérieur de ce catalogue, mais XML. Maintenant. Donc, chaque fois que nous avons un document XML, maintenant nous pouvons le modifier. Nous pouvons prendre l'inflammation, extraire ce que nous voulons, et les utiliser comme nous le voulons. Et c'est cela essentiellement pour cet exemple. se voit dans la vidéo suivante. 38. Exemple d'entreprise: Maintenant, regardons un autre exemple. Et dans ce cas, nous avons un fichier XML qui est société. Et à l'intérieur de cette entreprise, nous avons des employés. Comme vous pouvez le voir, nous avons le premier employé, nous avons le prénom , le nom et le salaire. Donc, nous avons brut et net à l'intérieur du salaire. Ensuite, nous avons le deuxième employé, et ainsi de suite. Nous avons quatre employés. Maintenant, allons créer notre classe, et appelons-la compagnie. Donc c'est notre classe. Comme d'habitude, nous commençons par créer notre méthode principale, en lançant l'exception. Donc l'exception Rose. Ensuite, nous pouvons commencer par créer notre fichier. Donc 55 à un nouveau dossier et pauvre souillé. Et par son nom, c'est la compagnie. Ce XML. Maintenant que nous avons notre amende, nous pouvons commencer par créer notre document Builder Factory. DBF importé égal au document, construisez l'usine. Et dans ce cas, le nouvel encens comme d'habitude. Ensuite, passons à la création de notre générateur de documents. Donc boulonné db égal à DBF que vous filtrez le document. Et enfin, nous pouvons créer notre document importé de o à trois WC.com. Comme d'habitude, estimé Document DB, qui bloque notre dossier. Maintenant que nous avons notre document, nous pouvons commencer par extraire nos données. Donc, la première chose que nous allons faire est comme d'habitude, créer notre liste de nœuds et L. Ensuite, bien sûr, nous devons l'importer. Ensuite, après avoir obtenu notre liste de nœuds, nous pouvons créer notre importation de nœuds. N' oubliez pas de l'importer depuis Ogden PWC dot-com et non depuis sun.org et ainsi de suite. Donc, c'est là que vous avez Bartlett et l'élément importé aussi ELT. Maintenant, on peut passer à autre chose. Donc, la première chose que nous allons faire est de créer la liste de noeuds et l. Et de ce côté, ce document de liste de noeuds qui obtient des éléments par tag, nom. Et nous allons obtenir, si nous retournons dans notre entreprise, nous allons avoir l'employé. Et dans ce cas, nous avons un employé. Et maintenant à l'intérieur de cette liste de nœuds, nous avons les informations de l'employé telles que prénom, nom et salaire. Maintenant passons à autre chose. Donc, notre boucle commencera à 0 et se terminera avec et pourtant la longueur. Maintenant, nous allons assigner le nœud deux. À l'élément i, alors bien sûr, nous allons vérifier si cette instance de noeud d'élément, c'est le cas. Nous pouvons procéder avec notre code. Et maintenant, si ce nœud est un élément, nous pouvons simplement convertir l'élément de sorte et suivi de dénote. Revenons à notre document d'entreprise et nous pouvons voir que nous avons le premier siècle dernier. Et dans ce cas, nous devons créer une liste de tableaux pour simplement stocker ces données dans nos tableaux. Et dans ce cas, vous pouvez les créer ici. Donc, liste de tableau, et cette liste est une chaîne. Et dans ce cas, nommez-le FirstName. Et bien sûr la liste des tableaux. Et le second est le nom de famille. Chaîne également nom de famille égal à mu Array List. Et définir une liste de tableau sera, nous avons en fait deux, comme vous pouvez le voir ici, nous avons un qui est un entier et le second double. Donc, créons-les comme entier et double. Donc tableau liste d'entiers. Et dans ce cas, j'ai besoin d'utiliser la classe wrapper ici, désolé. Et le nom de ceci est grossier et simplement l'initialiser. Et la dernière liste de tableau sera de type double. Dans ce cas, c'est le salaire net et l'initialiser comme d'habitude. Maintenant, nous avons notre liste de tableaux, et maintenant nous pouvons stocker nos données dans ces ArrayLists. Revenons à notre élément. Et à l'intérieur de cet élément, nous pouvons stocker les valeurs. Donc prénom, mais ajouter, nous allons ajouter le LT, mais getElementsByTagName et le nom de type est prénom. Et après avoir obtenu ce prénom, nous allons obtenir le premier élément. Donc cet article, je suis désolé. Ici, nous devons juste modifier quelque chose pour simplement ajouter les parenthèses supplémentaires ici. Et après avoir terminé De cela, nous pouvons simplement me laisser juste en fait ici, nous ajoutons juste quelque chose et ce n'est pas nécessaire. Donc élément à 0 et qui obtiennent le contenu du texte. Et nous avons maintenant le deuxième est le nom de famille. Donc nom de famille, mais ajouter. Et à l'intérieur qui obtiennent des éléments par tag, nom, nom, nom, cet élément. Et bien sûr fermé cet élément à 0 comme d'habitude qui obtiennent le contenu du texte. Maintenant, après avoir terminé avec le prénom et le nom, nous devons passer à entier et double. Nous avons dégueulasse. Et maintenant pour créer notre Actually pour ajouter notre élément dans la liste de tableaux d'entiers, nous devons l'avoir comme un entier. Donc, chaque fois que nous en avons besoin, nous voulons ajouter un entier ici dans notre croissance. Vous pouvez simplement dire brillant cette annonce. Et la première chose que nous allons faire est d'utiliser la méthode Integer.parseInt. Et à l'intérieur de cette méthode, nous pouvons simplement utiliser l'élément plt.plot. Et dans ce cas, nous devons obtenir la croissance et l'élément à 0 et j'obtiens le contenu du texte. Alors qu'avons-nous fait ici ? Nous avons juste obtenu les éléments par tag name grass, obtenu le premier élément et converti en une chaîne, puis le stocker et un entier après l'avoir converti en un entier aussi. Maintenant, la dernière chose est le point net. Et comme d'habitude, analyse à double point. Et nous pouvons simplement utiliser ELT mais obtenir l'élément comme avant, et cet élément à 0 qui obtient textContent. Maintenant, je pense qu'on l'a, si on retourne ici et qu'on trouve qu'on a un filet de classe, prénom et un nom de famille. Maintenant, nous avons toutes nos données ici. Nous pouvons travailler avec eux comme nous le voulons. Donc, notre objectif ici est de trouver l'employé avec le salaire le plus bas, le plus bas et avec le salaire le plus élevé. Donc, nous devons trouver aux employés. Et pour ce faire, qui a créé, après avoir terminé de cette boucle pour, créons. Donc entier max qu'il obtiendra, il aura un entier qui signifiait valeur. Et le minimum prendra entier cette valeur maximale. Et ces deux entiers, Max et signifié par responsable de trouver le salaire brut le plus élevé et le plus bas. Alors allons de l'avant et commençons avec notre code ici. Nous avons un nombre entier min et max. Et nous allons passer aux éléments d'herbe dans la liste d'herbe. Et comment faites-vous ça ? Nous avons simplement assigné à saisir la taille et commencer. Donc, laissez-moi juste en fait créer deux et les indices à l'extérieur, si faible égal à 0 et élevé aussi égal à 0. Maintenant f, notre herbe qui arrive à i est moins d'une heure minimum. Nous devons changer notre minimum. Donc minimum sera l'herbe point obtenir à i et notre bas sera égal à ce i. Et bien sûr, nous devons vérifier le maximum. Donc f point d'herbe à i est supérieur au maximum. Nous allons assigner max à être égal à la prise d'herbe obtenir à i. Et la même chose sera égale à moi maintenant, après avoir fini de ça, nous allons obtenir notre bas et haut. Nous pouvons simplement imprimer après avoir terminé l'édition pour boucle, nous pouvons imprimer nos employés. Donc, pour ce faire, il suffit d'utiliser la méthode System.out.print. Et nous allons imprimer FirstName et First_name.gov à bas niveau. Ensuite, nous allons ajouter de l'espace que le nom de famille, mais devenir bas aussi. Et nous pouvons ajouter l'employé avec le salaire brut le plus bas. Et nous pouvons le spécifier. Et bien sûr, la croix mais gad à bas. Maintenant, nous allons copier coller ce même exactement aligné ici. Cependant, maintenant, nous avons besoin d'imprimer pour l'acte LastName élevé je aussi en tant que l'employé avec le salaire le plus élevé de, et bien sûr imprimer point herbe obtenir élevé. Maintenant, si je lance ce code et voyons ce que nous allons obtenir. On va faire en sorte que Stephen Colbert soit l'employé avec le salaire brut le plus bas de 340. Cristiano Ronaldo est l'employé avec le salaire brut le plus élevé de 300 mille. Maintenant, si nous retournons ici, nous pouvons simplement remarquer, puisque nous n'avons que quatre employés, vous pouvez simplement remarquer que c'est 600. Si nous descendons 400.300 mille, c'est donc le plus élevé et 340 est le plus bas. Et ces informations sont correctes, comme vous pouvez le voir ici. Maintenant, une autre chose à faire est de juste comparer le salaire net au lieu du salaire brut sera exactement le même. Cependant, nous avons maintenant affaire à des doubles. Donc, au lieu de créer nos entiers ij, le minimum et le maximum, ils seront doublés et les comparés que de trouver le bas et le haut comme d'habitude, puis simplement imprimer le premier nom. Et bien sûr qu'il ici nous devons passer de l'herbe au filet deux en fait, laissez-moi juste le faire rapidement. Donc ici, nous avons besoin d'avoir double, double Max et ensuite nous allons comparer le filet. Bien sûr, ici, nous devons également comparer le dans cela et bien sûr changé. Et ici aussi. Et enfin net. Et après avoir terminé à partir d'ici, nous devons simplement modifier ici aussi. Et avec le salaire net le plus bas et le salaire net le plus élevé. Si je lance ce code une fois de plus, je vais voir que Stephen Colbert est l'employé avec le salaire net le plus bas de 327. Et Cristiano Ronaldo est l'employé avec le salaire net le plus élevé de 1881000. Donc si je retourne ici et me laisse vérifier une fois de plus. Ici, nous avons le salaire net est 378. On en a 440. Et nous pouvons voir que c'est le plus bas. Et le plus élevé est 288 mille. Maintenant, laissez-moi juste changer le salaire net. Dépêchez-vous ici d'être égal à 44. Et dans ce cas, si je soulignais encore une fois, nous allons obtenir que Richard Saul soit l'employé avec le salaire net le plus bas de 44. Et nous pouvons remarquer que c'est maintenant le salaire net le plus bas au lieu de ce 1227. Et c'est en fait pour cet exemple. Maintenant, nous avons appris les bases de la façon d'extraire des données à partir de XML en utilisant Java. Maintenant, chaque fois que nous avons un document XML, nous pouvons appliquer la même chose exacte que nous l'avons fait ici. Et nous allons obtenir nos données. Nous pouvons les stocker dans ArrayList, peut les stocker dans un fichier ou un IRA ou tout ce que nous voulons. Donc, c'est à fondamentalement et vous voir dans la prochaine vidéo. 39. JSON: Passons maintenant à JSON. Et tout d'abord, nous allons apprendre ce qu'est JSON et comment lire les données de ce type de fichier ? Donc, comme nous pouvons le voir ici, nous avons le menu ce document JSON. Et JSON signifie JavaScript Object Notation. Laisse-moi aller de l'avant et essayer de descendre ici. Donc, il signifie notation d'objet de script Java. Et c'est un auto-description et facile à comprendre. Donc, comme vous pouvez le voir ici, nous avons Menu et à l'intérieur de ce menu, nous avons la valeur id et pop up. À l'intérieur de la fenêtre contextuelle, nous avons ces différentes valeurs de haut en bas, et vers le haut et documenter. Alors allons de l'avant et creusons plus profondément et faisons la syntaxe de JSON. La première chose que nous allons faire est de prendre un objet à la fois. Donc supposons que j'ai pris ça. Nous pouvons voir que nous avons la valeur ici ou un type, et il est suivi d'une valeur. Donc, comme nous pouvons le voir, nous avons le nom, et dans ce cas c'est l'ID. Et il est en guillemets doubles, comme nous pouvons le voir, et suivi de la colonne et puis de la valeur de cette NAPE, donc fichier ID. Et puis nous avons aussi le nom. Dans ce cas, il est, il est appelé valeur et la valeur de ceci comme fichier avec le capital F. Maintenant, tout dans les accolades est en fait un objet. Donc, chaque fois que nous définissons des accolades et écrivons du code ici ou quelques lignes, ce sont un objet. On peut supposer que c'est un objet. Maintenant, chaque fois que nous écrivons des crochets, cela indique que nous avons un tableau. Comme nous pouvons le voir, cela contient trois éléments, donc ce tableau contient trois éléments. Il s'agit donc de l'objet un, l'objet deux et de l'objet trois. Maintenant, continuons et créons notre programme Java afin que nous puissions extraire ces données ou informations de notre fichier JSON. Donc, tout d'abord, afin d'utiliser un centime et d'utiliser les méthodes disponibles pour nous dans JSON, nous avons une bibliothèque, des entités, une bibliothèque spécifique, et externe ne construit pas en Java, donc nous devons téléchargez-le. Alors allons de l'avant et allons sur Google et download.com. Et ici nous avons téléchargé Jason ce pot. Je vais laisser un lien ou un vécu toute la bibliothèque et la description. Maintenant, nous avons notre JSON. Bibliothèque. Laissez-moi revenir ici à notre code. Et bien sûr, nous devons l'extraire de nos téléchargements. Donc, après avoir téléchargé notre bibliothèque, vous pouvez aller à notre projet, et ce cas, ce projet un, cliquez avec le bouton droit sur le chemin de la ceinture et configurer le chemin de construction. Ici, nous avons nos bibliothèques et nous pouvons voir que nous n'avons aucun chemin, aucune bibliothèque ajoutée. Donc, je vais juste ajouter des bocaux externes. Et laisse-moi aller au bureau. À l'intérieur du bureau, nous avons des fichiers jar profonds. C' est JSON, de sorte que nous venons d'ajouter appliquer et fermer, et maintenant nous définissons afin que nous puissions maintenant utiliser JSON. Laissez-moi simplement créer un nouveau paquet spécifiquement pour JSON. Et dans ce cas, créons notre première classe et nous allons le nommer menu. Donc maintenant, nous avons notre menu de classe et notre menu Fichier, ce JSON. Commençons par ce fichier. Extrayons quelques données d'ici. La première chose que nous allons faire est, comme d'habitude, créer notre méthode principale et bien sûr à travers l'exception. Donc, chaque fois que nous lançons une exception et des types, le type lance une exception, cela signifie que nous allons lancer toutes les exceptions qui pourraient se produire ici. Et bien sûr, nous ne voulons pas dire les adders ou cern, nous voulons juste dire peut-être une exception de fichier ou quelque chose comme ça. Donc, fichier égal au nouveau fichier. Et dans ce cas, nous avons le menu que JSON. Et bien sûr, nous devons l'importer comme d'habitude de Java vers l'E/S. Maintenant, nous pouvons commencer avec notre jason. Donc, la première chose que nous allons importer le flux d'entrée de fichier. Donc flux d'entrée de fichier et importé, appelons-le T, o. et dans ce cas, ou peut-être que je peux le nommer FIOS comme flux d'entrée de fichier et créé comme d'habitude initialiseur. Donc flux d'entrée, et il prendra le fichier comme paramètre. Ensuite, cela sera suivi par le jeton JSON. Et laissez-moi juste l'écrire. Et puis on en parle. Alors laissez-moi l'importer. Et comme vous pouvez le voir ici, laissez-moi juste taper Tokyo enter égal à nouveau JSON Falconer. Et dans ce cas, laissez-moi simplement le prendre comme une entrée. Stream. Donc c'est ce que nous voulons et à l'intérieur de ce bâtiment d'écrire la FIS. Il s'agit donc d'un flux d'entrée défini. Et maintenant que nous avons notre toner jason, Nous pouvons effectivement lire les données de l'intérieur du stock. Laissez-moi revenir à notre menu, JSON. Et lui, comme vous pouvez le voir, laisse-moi juste supprimer ça. Et nous avons déjà dit que chaque fois que nous avons des accolades, C'est un objet. Chaque fois que nous avons des crochets, c'est un tableau. Donc, ici, nous pouvons voir que c'est un objet et c'est un objet. Comment on fait face à ça ? Nous pouvons simplement créer un objet JSON. Donc, l'objet JSON, et cela le nommera, l'objet qui sera égal au nouvel objet JSON, et il prendra l'URL de jeton entière comme paramètre. C' est ainsi que nous pouvons extraire des données de notre fichier JSON si nous avons un objet. Maintenant, nous avons commencé avec ça. Maintenant, nous avons tout notre objet à l'intérieur de cet objet. Maintenant, après cela, voyons quoi, ce que nous avons déjà ici aussi. Maintenant, nous pouvons voir que nous avons un autre objet, et cette fois nous avons le nom qui est menu. Alors, comment on fait face à ça ? Si nous voulons extraire ces données d'ici, nous pouvons simplement créer un autre objet JSON, car c'est aussi un objet. Et dans ce cas, appelons-le. Par exemple, i. Et bien sûr, ce sera égal aux objets. Et nous allons utiliser, Désolé, j'ai un objet. Et si je JSON, nous avons cet objet JSON. Donc, cette méthode nous obtiendra l'objet et avec le menu nom. Maintenant, nous avons aussi, laissez-moi revenir en arrière et comme vous pouvez le voir ici, nous avons l'ID, nous avons la valeur, et nous avons la pop-up. Laisse-moi revenir ici et le nommer. Celui-ci sera l'ID. Et bien sûr, laissez-moi juste créer aussi objet adjacent pour la valeur et la popup. Maintenant, nous avons maintenant laissez-nous extraire quelques données. La première chose que nous allons extraire, laissez-moi revenir à notre menu, ce JSON. Et nous pouvons voir clairement que nous avons l'ID et nous avons la valeur qui est définie. Maintenant, si je veux extraire la valeur de cet ID, je peux simplement imprimer id dot, get, string et decay qui est PID. Maintenant, comme je l'ai dit précédemment, j'aurais pu juste créer cet objet JSON en o et l'utiliser. Pour extraire les données. Donc je peux supprimer ça. Et là, je peux écrire o. et maintenant, si je fais ça, je vais prendre Phi. Maintenant, si je veux, revenons à Menu ce JSON. Si je veux cette valeur, cette majuscule F cinq, je peux simplement retourner getString. Et dans ce cas, je vais retourner la valeur et courir. On va avoir un dossier et un dossier. Maintenant, comme nous pouvons le voir ici, nous avons notre pop-up et à l'intérieur de cette popup nous avons un objet. Et à l'intérieur de cet objet, nous avons l'élément de menu qui contient un tableau d'objets. Donc, jusqu'à maintenant, nous avons cet objet et cet élément de menu comme un tableau. Laisse-moi revenir ici et créer ce qu'on a dit. Nous avons donc besoin d'un objet JSON et nous l'appellerons comme nous l'avons dit. Laissez-moi revenir en arrière et l'un d'eux est pop up et le second est, désolé, laissez-moi juste supprimer ceci. Et votre Burke. Donc ici, l'un d'eux est le proverbe et l'autre est l'élément de menu. Donc objet JSON, pop up et Jason par jour. Et ceci est l'élément de menu. Maintenant, après avoir créé ça, on peut simplement prendre cette pop-up et Dave, l'objet de cette pop-up, comment faire ça ? Nous pouvons simplement écrire que nous avons besoin de pop-up pour être égal à point. Obtenir l'objet JSON. Nous allons obtenir l'objet JSON dans lequel nous avons pop-up. Après cela, nous allons prendre le tableau de l'élément de menu à l'intérieur de la fenêtre pop-up. L' élément de menu sera égal à sauter le tableau get JSON. Et nous avons besoin de l'élément Menu. Et maintenant on a fini. Nous avons notre élément de menu. Nous pouvons créer une boucle for à partir de 0 et l'élément de menu cette longueur. Donc élément de menu cette longueur. Et à l'intérieur de cela, nous pouvons simplement obtenir la valeur de l'élément de menu. Alors laissez-moi simplement créer un objet JSON pour dévaluer. Je peux le créer à l'extérieur. Donc, l'objet JSON, la valeur et la valeur seront égaux à l'élément de menu point obtenir l'objet JSON. Nous allons avoir tous les objets ici. C' est donc le premier, deuxième, troisième objet. Donc, à l'index i, puis simplement imprimé. Nous allons imprimer la valeur pour obtenir la force de cette valeur. Ensuite, c'est l'espace que la valeur que getString de débrancher. Et maintenant considérer, donc nous avons dévaluer et sur clic. On va avoir les deux valeurs. Et maintenant, si je lance ceci, nous allons obtenir le fichier, le fichier comme avant, la nouvelle création, nouveau document de haut en haut et le document, fermer, fermer le document. Donc, comme nous pouvons le voir ici, nous venons d'extraire ces valeurs d'ici. Et c'est en fait, c'est une idée générale sur JSON et comment nous pouvons extraire des données de JSON en utilisant Java. Maintenant, dans les prochaines vidéos, nous allons creuser plus profondément et à JSON. Et nous allons obtenir exemples beaucoup plus complexes et apprendre comment nous pouvons traiter chacun d'entre eux. Et nous allons voir qu'ils sont les mêmes. Cependant, nous devons les comprendre et les traiter avec soin. Et c'est tout pour cette vidéo. Rendez-vous dans l'exemple suivant. 40. Exemple de Wordpress: Maintenant, résolvons un autre exemple de Jason. C' est Wordpress point JSON. Et cet exemple simple, laissez-moi aller de l'avant et créer une autre classe dans notre déclaration de paquet JSON, word press. Comme d'habitude, commencez par créer notre méthode principale, lançant l'exception, puis en commençant par notre fichier, bien sûr, en l'important. Ensuite, c'est Wordpress point JSON. Maintenant que nous avons créé notre fichier, nous pouvons créer notre jeton JSON. Et bien sûr, nous allons commencer par notre dossier. Flux d'entrée. Peut métafile un nouvel écran avec le fichier comme paramètre. Après cela, nous allons créer le jeton JSON sont importants. Donc, c'est tout ce que JSON à la bibliothèque que nous avons créée plus tôt. Et bien sûr, nommons un documentaire qui sera égal au nouveau jeton de jason et avec FIOS comme paramètre. Maintenant, revenons à notre point WordPress JSON et voyons ce que nous avons ici. Donc, la première chose que nous avons remarqué est WordPress dot JSON commence avec un tableau. Comme nous pouvons le voir ici, nous avons les crochets. Et pour faire face à cela, nous allons créer une annonce par an. Donc, si je retourne à notre menu.html et voir. Et donc nous allons remarquer que chaque fois que nous avons créé l'objet JSON, c'est un objet car il a commencé avec les accolades indiquant qu'il s'agit d'un objet. Cependant, nous avons ici les crochets. Nous devons créer un tableau. Et pour créer cela, nous pouvons simplement créer ce JSON. Et appelons-le. A, il sera égal à nouveau JSON à une URL de jeton en tant que paramètre. Donc, comme vous pouvez le remarquer, JSON ou traiter avec JSON en Java est assez simple. Cela ne prend pas beaucoup de temps, et c'est simple. Il a recréé notre tableau. Maintenant, nous allons créer des objets. Donc je viens de les nommer l'objet un et l'objet deux. Donc l'objet, l'objet un, l'objet deux. Maintenant, bien sûr, laissez-moi revenir en arrière et voyons, nous y avons. Par exemple, nous allons simplement imprimer l'ID et la date. Et voyons ce qu'on a ici ? Nous avons aussi les catégories et les tags. Alors laissez-nous imprimer. Nous avons dit que nous allons imprimer l'identité, date et les catégories et les balises. Comme vous pouvez le constater ici, les catégories et les balises sont des tableaux et des objets ID et date. Donc, ici, nous avons l'objet un, l'objet deux, et ici nous avons l'objet JSON. Nous ne l'avons pas importé. Et nous avons une affaire comme nous l'avons dit. Donc, nous avons les catégories et nous avons aussi les tags, je pense. Alors. Ouais, essentiellement des catégories et des tags. Maintenant, continuons et créons notre objet de transfert d'objet un sera égal à un point get objet JSON. Nous avons cette méthode maîtresse. Et comme nous pouvons le voir, nous devons ajouter un index ici. Donc, si j'ajoute l'index 0, cela nous donnera le premier objet. Et à l'intérieur de ce tableau, comme nous pouvons le voir, c'est le premier objet. C' est tout cela est le premier objet. Donc, nous avons, nous ouvrons les accolades et il le fermera. Et comme nous pouvons le voir, ce n'est qu'un seul objet, donc toutes les données ici sont à l'intérieur de cet objet unique. Maintenant, revenons en arrière. Et si je vais l'imprimer, laisse-moi juste imprimer la carte d'identité. Si je veux l'ID, vous pouvez simplement utiliser. Permettez-moi juste d'indiquer que c'est l'idée et l'utilisation de l'objet un. Comme nous l'avons dit, c'est l'objet d'un point. On peut en finir. Et en utilisant cette méthode, nous allons obtenir un entier. Et nous avons entré l'identifiant en tant que paramètre. Et maintenant, si je fais ça, je vais avoir l'idée, et c'est 157538. Et c'est exactement l'idée. Maintenant, si je veux extraire aussi la date, je peux simplement écrire que la date est. Et les objets d'utilisation n'étaient pas encore. Laisse-moi revenir en arrière. Donc, c'est une chaîne, sorte que get string et le paramètre est une chaîne de date. Maintenant, allons courir. Nous allons obtenir la pièce d'identité est et la date est 2017, et bien sûr l'heure. Donc, c'est essentiellement pour extraire des objets d'un tableau. Et ici, nous utilisons les méthodes GetInt et GetString puisque nous savons ce que nous allons extraire le regard pour extraire l'ID et la date. Et c'est une méthode utile dans ce cas. Maintenant, allons faire défiler ici nous avons nos catégories et tags. Alors créons notre catégorie d'abord. Donc la première chose qu'on va faire est de me laisser. Il suffit d'aller ici et la catégorie sera égale à, comme nous l'avons dit, objet un point obtenir tableau JSON. Dans ce cas, nous allons obtenir la LDA et tout ce que nous avons les catégories. Et maintenant, nous avons créé notre journée. Si nous voulons créer les balises aussi objet un, point get JSON ajoute a et b. Nous avons des balises. Maintenant, puisque nous savons que nous avons seulement un élément dans cet ID, je peux simplement l'utiliser, je peux simplement l'imprimer en fait, donc des catégories. Et je peux utiliser la méthode dot get et nous allons obtenir l'entier à 0. Après cela, nous allons imprimer la danse. Et dans ce cas, nous savons que nous avons plus d'une étiquette. Donc, nous allons créer une boucle for commençant à 0 et se terminant la longueur. Désolé, balises cette longueur. Et c'est fondamentalement que je peux maintenant l'imprimer. Donc, les balises qui se terminent à l'espace i. Maintenant, si je lance ça, je vais obtenir la carte d'identité est, la date est, et les catégories nous avons 6132 et puis suivi des étiquettes, nous avons deux chiens, 17, 986 à 98. Et c'est une idée générale à propos de cet exemple que nous retournons ici et voyons ce qu'il nous reste. Donc, par exemple, nous avons, donc ceux-ci sont les mêmes qu'avant. Ceci est modifié ou vous pouvez l'utiliser comme ID ou une date. Cependant, utilisons ceci. Ici, nous avons le Guide et le guide intérieur que j'ai plié. Donc, nous savons que chaque fois que nous utilisons des accolades, cela indique que nous avons un objet à l'intérieur. Donc, nous avons un objet qui a créé un objet JSON, puisque nous avons un autre objet dans ce cas que nous venons de le nommer, rendu. Et rendu sera égal à l'objet un point obtenir objet JSON. Et dans ce cas, l'objet adjacent est le guide. Et laissez-moi juste essayer. Guide. Et après cela, je peux simplement utiliser un imprimé. Donc rendu égal à rendu que get, laissez-moi revenir ici et rendu. Nous pouvons utiliser la chaîne getString et la clé dans ce cas est rendue. Et maintenant, si je fais ça et laissez-moi d'abord. Donc ici, nous avons été rendus et la valeur de rendu. Donc, c'est ça fondamentalement. Et c'est ainsi que nous pouvons utiliser JSON et extraire des données de Jason et les utiliser ainsi que notre programme Java. Maintenant, dans la prochaine vidéo, nous allons jeter un oeil à un autre exemple. Et c'est un peu plus compliqué, mais la même idée ou les mêmes concepts s'appliquent toujours à tous les documents adjacents. Alors, à vous voir. 41. Exemple de glossaire: Bonjour et bienvenue à vous exemple Jason. Et dans ce cas, nous avons un glossaire que JSON. Et c'est notre dossier. Et nous pouvons voir que cet exemple est un peu plus compliqué que les autres, puisque nous avons des objets qui sont imbriqués ou dans d'autres objets, comme nous pouvons le voir ici, nous avons la liste. À l'intérieur de la liste de verre, nous avons un objet, et cet objet est à l'intérieur du dernier div, et la div de verre est à l'intérieur du glossaire et ainsi de suite. Alors maintenant, créons notre fichier JSON ou Java. Et c'est notre classe. Donnons-le un nom au glossaire. Et commençons comme d'habitude fait et jette l'exception. Ensuite, commencez avec notre phi, phi égal à o et glossaire que JSON. Et maintenant, nous pouvons créer notre jeton JSON. Et c'est égal à nu Jason. Et je suis désolé. Le nous avons besoin de créer notre flux d'entrée de fichier. Totalement oublié. Et flux d' entrée de fichier . Et puis après ça, nous donnons cette conversation Jason, ce FIS comme paramètre. Et après cela, nous pouvons commencer avec notre code JSON. Donc, la première chose que nous pouvons remarquer ici est en fait de créer le jeton JSON ou est que n, notre glossaire, nous avons un objet. Donc, nous commençons par créer l'objet. La première chose est l'objet JSON. Et dans ce cas, nommons l'objet égal au nouvel objet JSON. Et il faudra le document. Après ça. Nous pouvons créer nos autres objets afin que nous puissions voir que nous avons l'objet glossaire. Ensuite, nous avons l'objet de cluster, objet de liste de verre plus N3 et sourd brillant. Alors créons les ici, tous à la fois. Nous avons donc un glossaire. Puis la perte, suivie par le verre, puis l'anarchie et l'arbre, et enfin le verre, sourd. Et ce sont donc nos objets. Et notre objectif est d'imprimer certains des éléments ici de certaines données. Et nous devons imprimer ceci à un alors laissez-moi simplement créer ce tableau et JSON. Un jour. Et plus c. aussi. Donc, c'est fondamentalement maintenant que nous pouvons commencer par extraire des données. Donc la première chose que nous allons extraire est le titre. Comme nous pouvons le voir ici, nous avons le titre. Donc, c'est après la création de l'objet. La première chose que nous allons faire est de prendre le glossaire pour être égal à la première chose, l'objet et l'USD pour obtenir l'objet JSON. Et on doit avoir un glossaire. Et après cela, après avoir obtenu ce week-end de glossaire d'épicerie, il suffit d'imprimer le titre, le titre comme et le glossaire. Bien sûr. Glossaire. Et obtenez, nous allons obtenir la chaîne avec le titre clé. Et si je fais ça, vérifions. C' est le titre comme exemple de glossaire. Si nous revenons ici, le titre est en fait l'exemple x, donc c'est correct. Maintenant, après avoir créé cet objet, nous pouvons remarquer que gloss live est un autre objet. Ainsi, nous pouvons utiliser le glossaire et extraire les objets du glossaire. Donc, nous avons plus f. Dans ce cas, il sera égal à point Glossaire. Obtenir l'objet JSON. Et dans ce cas, nous avons, laissez-moi revenir en arrière et essayer correctement. Nous avons la mort de verre. Et c'est en fait div en verre. Maintenant, nous avons notre objet plus en direct. Si, par exemple, pour un supplément, extrayez le titre. Dans ce cas, je peux simplement imprimer le deuxième titre comme et le getString et le titre. Fait. Nous allons obtenir le deuxième titre est S, et c'est le cas ici. Maintenant, nous pouvons également remarquer que nous avons un autre objet ici qui est sans perte. Donc nous ferons exactement la même chose ici. Donc, plus L2 sera égal à l'objet JSON point get. Et nous avons plus. Et laissez-moi juste imprimer quelque chose de la liste de verre. En fait, on n'a rien à l'intérieur. Laisse-moi vérifier. Ici. Nous devons créer un autre objet qui est pour l'entrée de gloss. Et dans ce cas, du verre. Et trois seront égaux à la liste de verre qui obtiennent l'objet JSON plus N3. Et après ça, revenons ici. Nous pouvons voir qu'à l'intérieur du verre et deux, nous avons une carte d'identité et en terme de verre, allons les imprimer juste pour nous assurer que nous sommes sur la bonne voie. Donc on doit imprimer. L' ID et utiliser LAS et point d'arborescence obtenir. Et revenons ici pour vérifier que l'id est une force de get string. Et c'est l'idée. Maintenant, courez. On va avoir une identité comme G, m, l. et c'est exact. Et l'autre chose est, laissez-moi juste l'utiliser ici. Et on doit extraire le bluster. Alors tournez et utilisez du verre et une fois de plus. Mais getString comme d'habitude, puisque c'est une chaîne. Et toute l'année dernière, nous allons obtenir GlusterFS, langage de balisage généralisé standard. Et c'est aussi correct. Maintenant, nous en sommes arrivés à un point où nous extrayons des données réellement de cette phase. Maintenant, on peut voir que la mort par explosion est un autre objet. Donc nous avons déjà ici la mort en verre comme objet. Et nous pouvons simplement faire exactement la même chose qu'avant. Donc le verre, le sera égal à plus et traiter qui obtiennent l'objet JSON et dans ce cas le verre. Et extrayons quelque chose de toi. Laisse-moi voir ce qui ne va pas. Et changer de type de, je suis désolé, ici nous devons créer un objet, obtenir un objet JSON. Et maintenant, on est bons. Dans un nerf de verre. Nous avons le par. Donc laissez-moi juste imprimer comme et plus le getString. Et dans ce cas, nous allons simplement imprimer tout ce que nous avons Empire. Exécutez ce code. Nous allons obtenir un langage de balisage méta utilisé pour créer des langages de balisage tels que bloc-notes. Et c'est aussi correct. La dernière chose que nous allons faire est d'utiliser le tableau que nous avons créé plus tôt et d'imprimer g, m, l XML ici. Donc nous avons déjà ça. Donc, c'est brillant aussi, c'est une mise à jour et laissez-moi l'utiliser ici. Donc, le verre C aussi, et dans ce cas, il sera égal à un plus le get JSON à un. Et dans ce cas, c'est plus C aussi. Et créons une boucle for pour passer à travers tous les éléments à l'intérieur du tableau, commençant par i égal à 0 et se terminant par le verre. Aussi cette longueur. Et bien sûr, nous pouvons imprimer plus C aussi. Et, et nous allons obtenir la chaîne à l'index i. et laissez-moi juste imprimer ici juste pour savoir ce que nous sommes partis. Et donc c'est un plus c. Aussi à un. Et bien sûr, laissez-moi ajuster ceci et certains espaces courir une fois de plus. Nous allons obtenir brillant aussi à un GM L et XML. Et c'est fondamentalement, ceci est considéré comme un fichier JSON compliqué pour extraire des données et Java. Et c'est la même idée qu'avant. Nous avons juste besoin de suivre la route recréée. Donc, chaque fois que nous voyons des accolades, nous créons un objet. Chaque fois que nous voyons un crochets, nous créons un à un et ainsi de suite. Donc maintenant, nous avons extrait certaines des données de ce fichier, et c'est essentiellement pour cette vidéo. Dans la vidéo suivante, nous allons faire un autre exemple. Alors, à vous voir. 42. Exemple de Quiz: Passons maintenant au dernier exemple de Jason. Et dans ce cas, nous avons un quiz ce fichier JSON. Tout d'abord, laissez-moi créer notre classe. Donc, c'est notre classe Java comme d'habitude. Et nous avons un quiz, désolé, il a juste refactorisé le nom de la clé et la fin. Et comme d'habitude, créez une méthode principale, l'exception. Et puis créez le fichier. Donc, si phi égal à acheter et qui est le adjacent, alors flux d'entrée de fichier VHD, flux, puis créer le jeton JSON. Et dans ce cas, nommons un jeton égal au nouveau jeton JSON a et phi S en tant que paramètre. Maintenant, si vous revenez ici, nous ne pouvons pas dire que c'est un objet. Donc, la première chose que nous allons faire est de créer l'objet en objet JSON. Objet égal au nouvel objet JSON. Je suis désolé, ici nous pouvons simplement utiliser le centre de désintoxication ici. Et on est bons. Alors maintenant, nous avons notre objectif. C' est notre objectif principal. Et si on y retourne encore une fois, tu peux voir qu'on a ça. C' est le premier objet ou le premier élément à l'intérieur de l'objet, et c'est le second. Alors, comment traitez-vous ça ? Nous pouvons simplement créer un objet de quiz. Et à l'intérieur de cet objet de quiz, nous allons prendre de l'objet principal pour obtenir l'objet JSON et nous avons besoin du quiz. Ensuite, nous avons aussi, comme nous l'avons dit, l'exportation. Et bien sûr, à l'intérieur de la quête, nous avons la question 1 et la question 1 et les maths. Donc, à l'intérieur du quiz, nous avons du butin et des maths. Et dans ce cas, nous avons la première question et le sport et la première question et la deuxième question, m. Donc, nous avons stimulé et q un, q deux. Et bien sûr, maintenant que nous avons nos objets JSON, nous pouvons commencer par est égal à l'objet get JSON. Nous allons obtenir l'objet JSON avec le sport. Et après ça, nous pouvons obtenir, alors maintenant nous sommes là et le sport. Et à l'intérieur du sport, nous avons Q1, c'est aussi un objet. Donc Q1 sera égal à repérer l'objet get JSON et Q1. Maintenant, nous sommes à l'intérieur Q1, Nous avons une question et des options et suivi par la réponse. Laisse-moi juste plonger ou imprimer la question. Donc, comme nous l'avons dit question comme d premier. Donc, nous pouvons simplement écrire la question comme. Et puis nous pouvons écrire pour un énorme Q1 qui se lancent et questionnent. Mais maintenant, si je lance ça, je vais avoir la question. Autrement dit, la question est laquelle est le nom d'équipe correct dans la NBA. Maintenant, après cela, je peux simplement créer un accro puisque ces options à l'intérieur de ce tableau. Donc Jason, et laissez-moi le nommer des options égales à Q1. Vous obtenez le tableau JSON. Et nous avons des options. Après cela, nous pouvons créer notre boucle for en commençant à l'index i égal à 0 et les options de fin cette longueur. Maintenant, nous pouvons simplement imprimer toutes les options. Nous avons donc l'option i plus un et suivie de l'option elle-même. Donc, plus l'option qui obtient la chaîne et à l'index en exécutant ceci juste pour vérifier. Nous allons obtenir, parce que dans S, lequel est correct son nom en NBA, nous allons obtenir des options par défaut après cela. Maintenant, nous pouvons imprimer la réponse. Dans ce cas, la réponse sera simplement répondre comme et suivie de la réponse elle-même. Donc Q1, ça se boit. Annonceur. Et maintenant, si je lance ce code une fois de plus, nous allons obtenir la réponse en tant que fusée Huston. Maintenant, après cela, nous avons aussi la question 1 et la question 2, n, les mathématiques. Alors allons de l'avant et créons notre objet mathématique. La masse sera égale à, comme nous l'avons dit, était l'objet get JSON. Et dans ce cas, nous avons des maths. Et après ça, on pourra retourner aux maths. Nous pouvons voir qu'à l'intérieur des mathématiques nous avons deux objets, c'est-à-dire Q1 et Q2. Donc, nous pouvons simplement créer Q1 sera égal à un point mathématique, obtenir l'objet JSON comme Q1. Et bien sûr, q pour être égal à la même chose adjacente à Q2. Après cela, nous pouvons travailler avec chaque question à la fois. Donc, la première chose que nous allons imprimer comme, la première question comme et puis suivie par le Q1 qui obtiennent, désolé il obtenir chaîne. Et nous allons avoir la question elle-même. Après cela, nous allons stocker et ajouter beaucoup d'options. Donc, les options, nous serons, je suis désolé, ici, nous allons écrire Options Q1 point get tableau JSON à Options. Et puis après avoir créé ceci à un, nous pouvons simplement créer notre boucle for comme avant, commençant à 0 et ajouter des options de cette longueur que l'impression de chaque option. Donc, les options que getString cet index i que nous allons imprimer la réponse. Donc, la réponse comme et bien sûr suivie par P1 point getString incertain. Alors maintenant le feu et jeter va obtenir ce qui suit. Donc la question est, lequel est correct son nom en NBA ? C' est la première partie. Deuxième partie la question comme cinq plus sept égale, nous avons 10111213 et la réponse est 12. Et dans ce cas, nous avons encore la question et les mathématiques. Donc, je peux simplement écrire la deuxième question. Et pour être Q2 cette question GetString. Et dans ce cas, après avoir écrit la question, nous pouvons également utiliser la même option. Et il sera égal à Q2, le get JSON, ajoutez un. Et bien sûr, les options que vous devez créer avant la boucle comme avant. Et ces mêmes limites. Options de cette longueur. Ensuite, imprimez toutes les options qui se boivent. Et après cela, nous pouvons écrire la réponse ou imprimer la réponse. Donc, la réponse est et imprimez q2 point get answer. Après ça. Laissez-moi juste exécuter ce code une fois de plus. Donc c'est pour le premier quiz. Et puis on a les maths. La première question est cinq plus sept. Donc la réponse est 12. La deuxième question est 12 moins huit, la réponse est quatre. Donc, juste pour les rendre clairs, nous pouvons simplement diviser cela. Après avoir terminé de celui-ci, nous pouvons simplement imprimer un peu égal. Et bien sûr, on peut sauter une ligne ici. Et après ça. Et après la première question, nous pouvons également mettre à l'échelle la course alignée. On va avoir ça. C' est donc la première question. Alors, la question est laquelle ? Comme d'habitude ? Et puis nous avons les maths et cette affaire nous avons deux questions. C' est donc la première question, suivie de la deuxième, comme nous pouvons le voir ici. Donc, c'est essentiellement pour JSON. Nous avons appris comment extraire des données et comment les utiliser dans notre code Java. Écrit toujours dit ces données et ajouter des jours moins ou tout ce que nous voulons. Si par exemple, nous venons de les obtenir sous forme de chaîne et de les imprimer directement. Cependant, nous pourrions avoir juste alors ceci et le stocker dans une chaîne, puis faire ce que nous voulons avec. Nous pouvons l'imprimer et nous pouvons le modifier. Ou nous pouvons simplement obtenir des entiers, les ajouter ensemble et obtenir la moyenne de quelque chose, par exemple. Et c'est ce fichier ou document JSON, fonctionne exactement comme n'importe quel autre fichier. Nous pouvons faire ce que nous voulons avec les données une fois que nous avons extrait et de façon correcte. Et c'est essentiellement pour JSON. étant dit, c'est la fin de cette floraison. se voit dans la prochaine. 43. Projet: Notre projet est donc de créer un compte pour l'étudiant ou l'instructeur. Ceci est notre méthode principale et vous permet de le voir et vous devez créer le compte étudiant de classe et instructeur en tant qu'enfants de ce compte de classe parent. Allons de l'avant et voyons ce que fait cette classe. Donc, si nous allons de l'avant et exécutons le code et nous obtenons un étudiant ou un instructeur. Alors, bien sûr, nous sommes des étudiants. Et pour nous demander d'entrer notre prénom et notre nom de famille comme ordinateur principal. Et G. Et je devrais entrer dans mes cours. Par exemple, disons que je prends CoA à un, English 101 et physique. Pour aller à. Maintenant, mon compte est créé, avait des syndicats étudiant, ma carte d'identité est un cours majeur d'ingénierie informatique. Et de nous demander d'essayer à nouveau. Essaie encore. Tapez oui. Supposons que nous soyons instruits maintenant. Prénom et nom. Alors Alex, le département, voyons. Donc les cours que j'enseigne, disons deux. Et donc ce compte est également créé instructeur Alexei, Département des finances des cours d'enseignement ces et sans idée parce que l'instructeur n'a pas 90. Maintenant, si j'appuie sur Entrée par erreur, je vais obtenir une entrée invalide. Si je veux réessayer, par exemple, essayez à nouveau. Les minuscules. Supposons un étudiant en premier et en dernier. Par exemple, un major. Supposons l'ingénierie électrique et des cours à un ELE D03. Et ce compte est également créé et l'idée est maintenant de, puisque nous sommes aux étudiants maintenant, la déontologie. Et enfin, si par exemple nous tapons par erreur, obtiendra une entrée invalide pour réessayer une fois de plus. Donc, si nous ne voulons pas réessayer, tapez simplement no. Et c'est la fin du programme. Maintenant, votre élève et instructeur. Tout d'abord, nous avons commencé avec l'étudiant. Nous avons un cours et nous avons quelques méthodes ici. Tout d'abord, vous devez créer un constructeur en utilisant un objet Student. Et puis nous devons définir les cours majeurs et définir les cours et la classe d'instructeur. Nous avons le constructeur pour prendre seulement deux paramètres. Ici, nous avons trois paramètres, nous avons l'ID et nous avons deux méthodes, définir des cours et définir le département. Et nous avons aussi d'autres si c'est une entrée invalide et alors que nous entrons quelque chose de différent que oui ou non, nous continuons à demander au programme et nous continuons à demander à l'utilisateur d'essayer à nouveau. Donc c'est tout pour le projet. Et j'espère que vous apprécierez et vous verrez dans la prochaine vidéo. 44. Récap: Donc c'est la fin de la classe. Tout d'abord, nous avons parlé de l'héritage et du polymorphisme. Ensuite, nous sommes passés à la récursivité et certains, ont résolu certains problèmes dans ce sujet. Ensuite, nous avons parlé des algorithmes de tri et de recherche. Et bien sûr, à la fin, nous avons résolu quelques problèmes sur tous les sujets. Et nous avons notre projet. Donc c'est tout pour cette classe. La classe suivante, nous allons parler de l'analyse XML et JSON. Nous avons appris à analyser JSON et XML en utilisant Java. Et puis on parle de piles et de files d'attente et on les utilise dans notre liste Saint-Louis et à double lien. Et enfin, nous allons parler de la classe des collections et comment l'utiliser, ne l'utiliser en Java. J' espère que ce cours a été bénéfique. Et on se voit dans la prochaine.