Java boucle constructions - pour, tandis que et à faire ... tout
déclarations de programme structure séquentielle ne peut être effectuée une fois. Si vous souhaitez effectuer la même opération plusieurs fois ,, vous avez besoin d'utiliser une structure en boucle.
Java a trois structure de boucle principale:
- tandis que la boucle
- boucle do ... while
- pour la boucle
Introduit un tableau amélioré est principalement utilisé pour la boucle Java5.
tandis que la boucle
tandis que la boucle est le plus fondamental, sa structure est:
while( 布尔表达式 ) {
//循环内容
}
Tant que l'expression booléenne est vrai, l'expérience de la boucle a été mis en œuvre.
Exemples
public class Test {
public static void main(String args[]) {
int x = 10;
while( x < 20 ) {
System.out.print("value of x : " + x );
x++;
System.out.print("\n");
}
}
}
Les exemples ci-dessus les résultats compilés sont les suivants:
value of x : 10 value of x : 11 value of x : 12 value of x : 13 value of x : 14 value of x : 15 value of x : 16 value of x : 17 value of x : 18 value of x : 19
boucle do ... while
Pour le compte de tout, si la condition est pas satisfait, il ne peut pas entrer dans la circulation. Mais parfois, nous avons besoin, même si les conditions ne sont pas remplies, mais aussi d'effectuer au moins une fois.
faire ... tout en boucle et en boucle est similaire, sauf que, boucle do ... while exécutera au moins une fois.
do {
//代码语句
}while(布尔表达式);
Note: l'expression booléenne après que le corps de la boucle, de sorte qu'un bloc d'instructions avant la détection expression booléenne a été effectuée. Si l'expression booléenne est évaluée à true, le bloc de déclaration est exécutée jusqu'à ce que l'expression booléenne est évaluée à false.
Exemples
public class Test {
public static void main(String args[]){
int x = 10;
do{
System.out.print("value of x : " + x );
x++;
System.out.print("\n");
}while( x < 20 );
}
}
Les exemples ci-dessus les résultats compilés sont les suivants:
value of x : 10 value of x : 11 value of x : 12 value of x : 13 value of x : 14 value of x : 15 value of x : 16 value of x : 17 value of x : 18 value of x : 19
pour la boucle
Alors que toute la structure de la boucle peut être utilisée pendant ou faire ... tout en montrant, mais Java fournit une autre déclaration - pour la circulation, donc une partie de la structure cyclique plus facile.
Le nombre de cycles effectués pour un déterminé avant de l'exécuter. La syntaxe est la suivante:
for(初始化; 布尔表达式; 更新) {
//代码语句
}
Le respect de la boucle a la description suivante:
- Le premier à effectuer la procédure d'initialisation. Vous pouvez déclarer un type, mais vous pouvez initialiser une ou plusieurs variables de contrôle de boucle peuvent également être instruction vide.
- Ensuite, la valeur détectée de l'expression booléenne. Si cela est vrai, le corps de la boucle est exécutée. Si elle est fausse, la boucle se termine, le début de la mise en œuvre de la déclaration suivante de la boucle.
- Après l'exécution d'une boucle, la variable de contrôle de boucle mise à jour.
- expression booléenne nouveau détectée. Boucle exécute la procédure ci-dessus.
Exemples
public class Test {
public static void main(String args[]) {
for(int x = 10; x < 20; x = x+1) {
System.out.print("value of x : " + x );
System.out.print("\n");
}
}
}
Les exemples ci-dessus les résultats compilés sont les suivants:
value of x : 10 value of x : 11 value of x : 12 value of x : 13 value of x : 14 value of x : 15 value of x : 16 value of x : 17 value of x : 18 value of x : 19
Java améliorée pour la boucle
Java5 pour l'introduction d'un réseau majeur de renforcer la boucle for.
Java amélioré pour la syntaxe de la boucle est le suivant:
for(声明语句 : 表达式)
{
//代码句子
}
Avertissement déclaration: déclarer une nouvelle variable locale, et le type de la variable doit correspondre au type d'éléments du tableau. Son champ d'application est limité au bloc de boucle, sa valeur à ce moment est égale à la valeur de l'élément de tableau.
Expression: L' expression est le nom du tableau à accéder, ou la méthode qui renvoie la valeur du tableau.
Exemples
public class Test {
public static void main(String args[]){
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
System.out.print("\n");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
System.out.print( name );
System.out.print(",");
}
}
}
Les exemples ci-dessus les résultats compilés sont les suivants:
10,20,30,40,50, James,Larry,Tom,Lacy,
pause mot-clé
briser principalement utilisé dans les boucles ou de passer des déclarations, utilisées pour sauter hors de l'ensemble du bloc.
sortir de la boucle la plus interne, et la boucle continue à exécuter l'instruction suivante.
grammaire
briser l'utilisation est la structure de boucle très simple dans un communiqué:
break;
Exemples
public class Test {
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
break;
}
System.out.print( x );
System.out.print("\n");
}
}
}
Les exemples ci-dessus les résultats compilés sont les suivants:
10 20
continuer mots-clés
continuer pour toute structure de contrôle en boucle. Le rôle est de permettre au programme de sauter immédiatement à l'itération suivante de la boucle.
Dans une boucle, instruction continue provoque le programme saute immédiatement pour mettre à jour les déclarations.
Dans tout ou faire ... tout en boucle, le programme saute immédiatement aux phrases du juge des expressions booléennes.
grammaire
poursuivre le corps de la boucle est une déclaration simple:
continue;
Exemples
public class Test {
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
continue;
}
System.out.print( x );
System.out.print("\n");
}
}
}
Les exemples ci-dessus les résultats compilés sont les suivants:
10 20 40 50