Comment utiliser les boucles if et for ?
1 conversion directe
2 conversions forcées
octet -- court
/
char
De gauche à droite, conversion directe
De droite à gauche, conversion forcée
Le booléen ne peut pas être converti en d'autres types
// Convertissez directement long en float (si la valeur de long est relativement grande, convertissez-la en float et utilisez notation scientifique pour l'exprimer)
float f2 = 3.14f;
long l2 = ( long)f2;
System.out.println(l2);
---------------- --------------------------------- -----
Classification des instructions en Java
1 Instructions séquentielles
Exécuter une instruction d'avant en arrière
Choisissez l'instruction appropriée à exécuter. if, if/else, if/else if/else, switch/case
3 Instruction de boucle
Boucle pour exécuter un certain morceau de code (y compris plusieurs instructions) . pendant que, faire/pendant, pour
---------------------------- -- -----------------------
Comment écrire une déclaration if
1 seulement s'il n'y a pas d'autre
if(score >= 60) {
System.out.println("pass");
🎜>
2 Un si et un autre
if(score >= 60) {
System.out.println("pass");
} else {
System.out.println("Failed");
}
3 si inclut plusieurs branches else
if(score >= 90) {
System.out.println("Excellent") ;
} else if(score >= 80) {
System.out.println("Bon");
} else if(score >= 70) {
System.out.println("medium");
} else if(score >= 60) {
System.out.println("Pass");
} else {
System.out.println("Échec ");
}
Réflexion : Comment implémenter ce code à l'aide de switch...case...
-------------------------------------------------------------- - ---
switch case break default
Quels types de données sont pris en charge dans switch
La norme est int, mais aussi Les types suivants peuvent être pris en charge
byte short int char String string
Remarque : boolean float double long
la norme n'est pas prise en charge Syntaxe : - - - - - - - - - - - - - - - - - - - - - - - - - - Utilisez la réalisation ci-dessus exemple Pour écrire un cas switch, c'est Initialisation ; Il est à noter que l'instruction conditionnelle dans while doit être de type booléen Itération; }while(condition); pour La première façon d'écrire // Initialisation sum = sum + i; La deuxième façon d'écrire pour. La condition d'initialisation est externe La troisième façon d'écrire pour la déclaration de jugement. est intégré for(int i = 0; i < = 100 ; ) { La cinquième façon d'écrire. Conditions d'initialisation externes, instructions de jugement intégrées et instructions d'itération intégrées * Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
int value = 1;
switch(value) {
cas 1 :
System.out.println("1");
break;
🎜> System.out .println("2" );
break;
défaut :
System.out.printl n("default"); > pause;
}
switch(score/10) {
cas 10 :
cas 9 :
System.out.println("Excellent");
break;
cas 8 :
System.out.println("Bon");
pause;
cas 7 :
System.out .println("modéré");
break;
cas 6 :
System.out.println(" passe") ;
pause;
cas 5:
cas 4:
cas 3 :
cas 2 :
cas 1 :
cas 0 :
System.out. println("Échec");
break;
par défaut :
System.out.println("Score d'exception");
pause;
}
-------------- -- ------------------------------------
pendant
while(condition) {
Instruction de boucle ;
Itération ;
}
// Initialisation
int sum = 0;
int i = 0; // Instruction de boucle
i++;
somme = somme + i;
.out.println("sum="+sum);
do... while
Initialiser
do {
// Initialisation
int sum = 0;
// La boucle démarre
faire {
> somme = somme + 1;
} while(i < 100);
for
for(initialisation; condition; itération) {
Instruction de boucle
}
Les différentes manières d'écrire pour sont les suivantes :
int sum = 0;
for(int i = 0; i < = 100; i++) {
}
System.out.println("sum="+sum);
int sum = 0;
int i = 0;
for(; i <= 100; i++) {
// Instruction de boucle
sum = sum + i;
}
System.out.println("sum="+sum);
int sum = 0 > if(i; > 100) {
pause ;
>
somme = somme + i;
}
System.out.println( "somme= "+sum);
La quatrième façon d'écrire pour. Instruction d'itération intégrée
// Initialisation
int sum = 0;
somme = somme + i;
i++;
}
System.out.println("sum="+sum);
// Initialisation
int sum = 0;
int i = 0,
pause;
🎜>
somme);
Penser : Utilisez une instruction de boucle pour imprimer le contenu suivant
*********
* ******
******
******
****
***
**
Conseil :
System.out.println("*"); un signe * sans sauts de ligne
System.out.print("*"); Imprimer un signe * sans sauts de ligne
System.out.println(); Saut de ligne
Combien de lignes sont imprimées ? Combien sont imprimés par ligne ?

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

L'expression Lambda sort de la boucle, des exemples de code spécifiques sont nécessaires en programmation, la structure de boucle est une syntaxe importante qui est souvent utilisée. Cependant, dans certaines circonstances, nous pouvons vouloir sortir de la boucle entière lorsqu'une certaine condition est remplie dans le corps de la boucle, plutôt que de simplement terminer l'itération en cours de la boucle. À l'heure actuelle, les caractéristiques des expressions lambda peuvent nous aider à atteindre l'objectif de sortir de la boucle. L'expression Lambda est un moyen de déclarer une fonction anonyme, qui peut définir une logique de fonction simple en interne. C'est différent d'une déclaration de fonction ordinaire,

Remarque : Cet article compare les boucles et la récursivité du point de vue du langage Go. Lors de l'écriture de programmes, vous rencontrez souvent des situations dans lesquelles une série de données ou d'opérations doivent être traitées de manière répétée. Pour y parvenir, nous devons utiliser des boucles ou de la récursivité. Les boucles et les récursions sont toutes deux des méthodes de traitement couramment utilisées, mais dans les applications pratiques, elles présentent chacune des avantages et des inconvénients, c'est pourquoi la situation réelle doit être prise en compte lors du choix de la méthode à utiliser. Cet article mènera une étude comparative des boucles et de la récursivité dans le langage Go. 1. Boucle Une boucle est un mécanisme qui exécute de manière répétée un certain morceau de code. Il existe trois principaux types de langage Go

Cet article expliquera en détail comment PHP renvoie toutes les valeurs d'un tableau pour former un tableau. L'éditeur pense que c'est assez pratique, je le partage donc avec vous comme référence. J'espère que vous pourrez gagner quelque chose après avoir lu cet article. . Utilisation de la fonction array_values() La fonction array_values() renvoie un tableau de toutes les valeurs d'un tableau. Il ne conserve pas les clés du tableau d'origine. $array=["foo"=>"bar","baz"=>"qux"];$values=array_values($array);//$values sera ["bar","qux"]Utilisation une boucle peut utiliser une boucle pour obtenir manuellement toutes les valeurs du tableau et les ajouter à un nouveau

Remplacement des appels récursifs dans les fonctions Java par itération En Java, la récursivité est un outil puissant utilisé pour résoudre divers problèmes. Cependant, dans certains cas, l’utilisation de l’itération peut s’avérer une meilleure option car elle est plus efficace et moins sujette aux débordements de pile. Voici les avantages de l'itération : Plus efficace puisqu'elle ne nécessite pas la création d'un nouveau stack frame à chaque appel récursif. Les débordements de pile sont moins susceptibles de se produire car l'utilisation de l'espace de pile est limitée. Méthodes itératives comme alternative aux appels récursifs : Il existe plusieurs méthodes en Java pour convertir des fonctions récursives en fonctions itératives. 1. Utiliser la pile L'utilisation de la pile est le moyen le plus simple de convertir une fonction récursive en fonction itérative. La pile est une structure de données dernier entré, premier sorti (LIFO), similaire à une pile d'appels de fonction. publicintfa

Interface Iterator L'interface Iterator est une interface utilisée pour parcourir les collections. Il fournit plusieurs méthodes, notamment hasNext(), next() et remove(). La méthode hasNext() renvoie une valeur booléenne indiquant s'il existe un élément suivant dans la collection. La méthode next() renvoie l'élément suivant de la collection et le supprime de la collection. La méthode Remove() supprime l'élément actuel de la collection. L'exemple de code suivant montre comment utiliser l'interface Iterator pour parcourir une collection : Listnames=Arrays.asList("John","Mary","Bob");Iterator

Tous les langages de programmation sont indissociables des boucles. Ainsi, par défaut, nous commençons à exécuter une boucle chaque fois qu’il y a une opération répétitive. Mais lorsqu’il s’agit d’un grand nombre d’itérations (millions/milliards de lignes), utiliser des boucles est un crime. Vous pourriez rester bloqué pendant quelques heures, pour vous rendre compte plus tard que cela ne fonctionne pas. C'est là que l'implémentation de la vectorisation en python devient très critique. Qu’est-ce que la vectorisation ? La vectorisation est une technique permettant d'implémenter des opérations de tableau (NumPy) sur des ensembles de données. En coulisse, il applique l'opération à tous les éléments du tableau ou de la série à la fois (contrairement à une boucle "for" qui opère une ligne à la fois). Nous utilisons ensuite quelques cas d'utilisation pour démontrer ce qu'est la vectorisation. Trouver la somme des nombres##Utilisez la boucle importtimestart

Comment gérer les erreurs d'imbrication de boucles PHP et générer les messages d'erreur correspondants Pendant le développement, nous utilisons souvent des instructions de boucle pour gérer des tâches répétées, telles que le parcours de tableaux et le traitement des résultats des requêtes de base de données. Cependant, lors de l'utilisation de l'imbrication de boucles, vous rencontrez parfois des erreurs, telles que des boucles infinies ou un trop grand nombre de niveaux d'imbrication. Ce problème peut entraîner une dégradation des performances du serveur, voire un crash. Afin de mieux gérer ces erreurs et de générer les messages d'erreur correspondants, cet article présentera quelques méthodes de traitement courantes et donnera des exemples de code correspondants. 1. Utilisez des compteurs pour

Différences : 1. for parcourt chaque élément de données via l'index, tandis que forEach parcourt les éléments de données du tableau via le programme sous-jacent JS ; 2. for peut terminer l'exécution de la boucle via le mot-clé break, mais forEach ne le peut pas ; .for peut contrôler l'exécution de la boucle en contrôlant la valeur de la variable de boucle, mais forEach ne peut pas ; 4. for peut appeler des variables de boucle en dehors de la boucle, mais forEach ne peut pas appeler des variables de boucle en dehors de la boucle ; est supérieur à forEach.
