devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

4.Java循环语句和数组_javafor循环数组

作者：从前慢现在也慢 | 2024-03-14 11:00:57

赞

踩

javafor循环数组

一、循环结构---重复运行

1.for循环

 结构：for(初始条件;判断条件;循环增量/减量){

                           java代码

                       }

              初始条件--决定循环的开始

              判断条件--决定循环的结束

              循环增量/减量--控制初始条件值

              执行过程:

              先执行初始条件，再执行判断条件，

              判断条件的结果为true,执行{java代码}，接下来执行循环增量/减量，接着执行判断条件

              判断条件的结果为false,循环结束。

            1. 循环输出1-10的整数

  1. public class ForDemo{
  2.            public static void main(String args[]){
  3.            // 循环输出1-10的整数
  4.             for(int i=1;i<=10;i++){
  5.                      System.out.println("i="+i);
  6.                           } 
  7.            }
  8. }

         2.循环输出20-1的整数

  1. public class ForDemo{
  2.  
  3.            public static void main(String args[]){
  4.  
  5.            //循环输出20-1的整数
  6.  
  7.            for(int j=20;j>=1;j--){
  8.  
  9.                      System.out.println("j="+j);
  10.  
  11.                      }
  12.  
  13.            }
  14.  
  15. }

       3.计算1-15的整数和

  1. public class ForDemo{
  2.  
  3.            public static void main(String args[]){
  4.  
  5.            //计算1-15的整数和
  6.  
  7.                 int sum=0;
  8.  
  9.            for( int k=1;k<=15;k++){
  10.  
  11.                       sum=sum+k;
  12.  
  13.                 }
  14.  
  15.                     System.out.println("sum="+sum);
  16.  
  17.            }
  18.  
  19. }

2.while循环

结构：while(判断条件){

                     java代码;

              }

              执行过程:

                  先执行判断条件，判断条件结果为true时，执行{java代码}，再执行增量/减量条件，继续执行判断条件，判断条件结果为false时，结束循环

              注意1:初始条件定义在while循环的格式之外。

              注意2:把循环增量/减量的条件写在java代码.....最后一句

            1.循环输出1-10的整数

  1. public class WhileDemo{
  2.  
  3.            public static void main(String args[]){     
  4.  
  5.            //循环输出1-10的整数
  6.  
  7.            int i=1;
  8.  
  9.            while(i<=10){
  10.  
  11.            System.out.println("i="+i);
  12.  
  13.            i++;
  14.  
  15.          }
  16.  
  17.      }
  18.  
  19. }

         2.循环输出20-1的整数

  1. public class WhileDemo{
  2.  
  3.            public static void main(String args[]){   
  4.  
  5.            //循环输出20-1的整数
  6.  
  7.            int j=20;
  8.  
  9.            while(j>=1){
  10.  
  11.            System.out.println("j="+j);
  12.  
  13.             j--;
  14.  
  15.           }
  16.  
  17.      }
  18.  
  19. }

        3.计算1-15的整数和

  1. public class WhileDemo{
  2.  
  3.            public static void main(String args[]){  
  4.  
  5.            //循环输出1-10的整数和
  6.  
  7.            int k=1;
  8.  
  9.            int sum=0;
  10.  
  11.            while(k<=10){
  12.  
  13.                  sum=sum+k;
  14.  
  15.                  k++;
  16.  
  17.             }
  18.  
  19.            System.out.println( "sum="+sum);
  20.  
  21.       }
  22.  
  23. }

3.Do……Whlie循环

结构：

do{

               java代码;

         }while(判断条件);

执行过程:

              先执行{java代码}，再执行判断条件，

              判断条件的结果为true，继续执行{java代码}，接着执行判断条件

              判断条件的结果为false,结束循环

              注意1:初始条件定义在do...while循环的格式之外。

              注意2:把循环增量/减量的条件写在{java代码.....最后一句}

        1.循环输出1-10的整数

  1. public class DoWhileDemo{
  2.  
  3.            public static void main(String args[]){ 
  4.  
  5. int i=1;
  6.  
  7.            do{
  8.  
  9.            System.out.println("i="+i);
  10.  
  11.            i++;             
  12.  
  13.              }while(i<=10);
  14.  
  15.       }
  16.  
  17. }

        2.循环输出20-1的整数

  1. public class DoWhileDemo{
  2.  
  3.            public static void main(String args[]){ 
  4.  
  5. int j=20;
  6.  
  7.            do{
  8.  
  9.            System.out.println("j="+j); 
  10.  
  11.             j--;
  12.  
  13.             }while(j>=1);   
  14.  
  15.       }
  16.  
  17. }

         3.计算1-15的整数和

  1. public class DoWhileDemo{
  2.  
  3.        public static void main(String args[]){
  4.  
  5.            int k=1;
  6.  
  7.            int sum=0;
  8.  
  9.            do{
  10.  
  11.            sum=sum+k;
  12.  
  13.             k++;
  14.  
  15.             }while(k<=15);
  16.  
  17.            System.out.println("sum="+sum);
  18.  
  19.       }
  20.  
  21. }

     4.三者区别

        For循环有定义循环增量/减量的具体位置；While循环和Do…while循环没有定义循环增量/减量的具体位置，往往都是自己定义在循环体中的最后一句。for循环需要明确循环次数while和do……while循环不需要考虑循环次数

        while循环与do……while循环的区别，while循环先判断后执行，do……while循环先执行后判断，初始判断条件的结果为false的时候，do……while循环会比while多执行一次循环体。

例1：无限循环，可以任意终止

  1. import java.util.Scanner;
  2.  
  3. public  class  Test1{
  4.  
  5.        public  static  void  main(String  args[]){
  6.  
  7.               //创建输入对象
  8.  
  9.               Scanner  input=new Scanner(System.in);
  10.  
  11.               boolean  flag=true; //控制循环持续执行
  12.  
  13.               while(flag){
  14.  
  15.               //得到第一个运算数字
  16.  
  17.               System.out.println("请输入第一个运算数字:");
  18.  
  19.               int  num1=input.nextInt();
  20.  
  21.               //得到一个运算符号
  22.  
  23.               System.out.println("请输入一个运算符号:");
  24.  
  25.               String  op=input.next();
  26.  
  27.               //得到第二个运算数字
  28.  
  29.               System.out.println("请输入第二个运算数字:");
  30.  
  31.               int  num2=input.nextInt();
  32.  
  33.               //计算结果
  34.  
  35.               switch(op){
  36.  
  37.                case "+":System.out.println(num1+"+"+num2+"="+(num1+num2));break;
  38.  
  39.                case "-":System.out.println(num1+"-"+num2+"="+(num1-num2));break;
  40.  
  41.                case "*":System.out.println(num1+"*"+num2+"="+(num1*num2));break;
  42.  
  43.                case "/":System.out.println(num1+"/"+num2+"="+(num1/num2));break;
  44.  
  45.                case "@":flag=false;break;
  46.  
  47.                default:System.out.println("输入有误无法计算");break;
  48.  
  49.               }
  50.  
  51.          }
  52.  
  53.      }
  54.  
  55. }

输出演示：

  1. 请输入第一个运算数字:
  2.  
  3. 1
  4.  
  5. 请输入一个运算符号:
  6.  
  7. -
  8.  
  9. 请输入第二个运算数字:
  10.  
  11. 4
  12.  
  13. 1-4=-3
  14.  
  15. 请输入第一个运算数字:
  16.  
  17. 3
  18.  
  19. 请输入一个运算符号:
  20.  
  21. +
  22.  
  23. 请输入第二个运算数字:
  24.  
  25. 3
  26.  
  27. 3+3=6
  28.  
  29. 请输入第一个运算数字:
  30.  
  31. 6
  32.  
  33. 请输入一个运算符号:
  34.  
  35. *
  36.  
  37. 请输入第二个运算数字:
  38.  
  39. 9
  40.  
  41. 6*9=54
  43. 请输入第一个运算数字:
  44.  
  45. 1
  46.  
  47. 请输入一个运算符号:
  48.  
  49. @
  50.  
  51. 请输入第二个运算数字:
  52.  
  53. 3
  54.

    5.break语句

break语句---循环中就表示中断循环的执行。

如果循环是嵌套的，那么break语句出现在那一层就中断那一次的循环。

例：

  1. public  class  BreakDemo{
  2.  
  3.            public  static  void  main(String  args[]){
  4.  
  5.               for(int i=1;i<=10;i++){
  6.  
  7.                      if(i==5){
  8.  
  9.                                    break;
  10.  
  11.                             }
  12.  
  13.                      for(int j=1;j<=10;j++){
  14.  
  15.                             System.out.println("i=="+i+",j=="+j);
  16.  
  17.                      }
  18.  
  19.               }
  20.  
  21.        }
  22.  
  23. }     

     6.continue语句

continue语句--往往出现在循环中表示结束当前循环，继续下一次循环执行。

例：

  1. public  class  ContinueDemo{
  2.  
  3.        public  static  void  main(String  args[]){
  4.  
  5.               //continue语句--往往出现在循环中表示结束当前循环，继续下一次循环执行
  6.  
  7.               for(int i=1;i<=10;i++){
  8.  
  9.                      if(i==5){
  10.  
  11.                             continue;
  12.  
  13.                      }
  14.  
  15.                      System.out.println("i=="+i);
  16.  
  17.               }
  18.  
  19.        }
  20.  
  21. }

二、数组

      1.什么是数组？

为了能够一次性保存一组数据，所以才有了数组。相同数据类型的数据按照顺序组成的复合数据类型就是数组。

      2.如何定义一个一维数组？

格式：两种都可

数据类型  数组名称[ ]

数据类型  [ ]数组名称

数组的定义与变量的定义相似，只是需要”[ ]”与变量区分，因此上”[ ]”就是数组的标志。名称的前面/后面出现一个“[ ]”就是一维数组，有两个”[ ][ ]”就是二维数组，两个以上就是多维数组。

      3.创建一个一维数组

①先定义，后创建, 指定的存储空间的数据值是int型

定义：数据类型  数组名称[ ] /   数据类型  [ ]数组名称

创建：数组名称=new 数据类型[指定存储空间]

②定义+创建同时

      数据类型 数组名称[ ]=new 数据类型[指定存储空间]

      数据类型 [ ]数组名称=new 数据类型[指定存储空间]  

    4.如何为一维数组赋值？

①逐个赋值---挨个为数组的每一个存储空间存放数据值。【需要数组的下标】

格式：数组名称[下标]=数据值；

注意:当保存在数组中的数据超过数组指定的存储空间就是会出错。

    下标从0开始

例：

  1. import java.util.Arrays;
  2.  
  3. public  class  ArrayDemo{
  4.  
  5.             public  static  void  main(String  args[]){
  6.  
  7.              //定义+创建数组
  8.  
  9.              int intarray1[]=new int[4];
  10.  
  11.              char chararray1[]=new char[5];
  12.  
  13.             //逐个赋值
  14.  
  15.              intarray1[0]=123;
  16.  
  17.              intarray1[1]=456;
  18.  
  19.              intarray1[2]=276;
  20.  
  21.              intarray1[3]=672;
  22.  
  23.             //注意:当保存在数组中的数据超过数组指定的存储空间就是会出错。
  24.  
  25.             //java.lang.ArrayIndexOutOfBoundsException: 4
  26.  
  27.             // intarray1[4]=832;
  28.  
  29.        }
  30.  
  31. }

②直接赋值---在创建数组的时候将数据值保存到数组中

格式1：数据类型 数组名称[ ]=new 数据类型[ ]{数据值1,数据值1,数据值3…数据值n}

      创建数组的时候不能指定存储空间

例：int intarray2[ ]=new int[ ]{23,34,45,56};

char chararray2[ ]=new char[ ]{'h','e','l','l','o'};

格式2：数据类型  数组名称[]={数据值1，数据值2，...，数据值n};

    5.如何从一维数组中取值

取值格式:数组名称[下标]

System.out.println(intarray2[3]); //56

System.out.println(chararray2[4]); //o

例：

  1. import java.util.Arrays;
  2.  
  3. public  class  ArrayDemo{
  4.  
  5.             public  static  void  main(String  args[]){
  6.  
  7.              //定义+创建数组
  8.  
  9.              int intarray1[]=new int[4];
  10.  
  11.              char chararray1[]=new char[5];
  12.  
  13.             //逐个赋值
  14.  
  15.              intarray1[0]=123;
  16.  
  17.              intarray1[1]=456;
  18.  
  19.              intarray1[2]=276;
  20.  
  21.              intarray1[3]=672;
  22.  
  23.             //注意:当保存在数组中的数据超过数组指定的存储空间就是会出错。
  24.  
  25.             //java.lang.ArrayIndexOutOfBoundsException: 4
  26.  
  27.             // intarray1[4]=832;
  28.  
  29.             //直接赋值
  30.  
  31.             int intarray2[]=new int[]{23,34,45,56};
  32.  
  33.             char chararray2[]=new char[]{'h','e','l','l','o'};
  34.  
  35.             //数组取值格式:数组名称[下标]
  36.  
  37.            System.out.println(intarray2[3]); //56
  38.  
  39.            System.out.println(chararray2[4]); //o
  40.  
  41.        }
  42.  
  43. }

      6.一维数组的length属性

如果数组通过直接赋值的方式创建，那么length属性就表示元素个数。

如果数组通过定义创建的方式创建，那么length属性就表示创建数组是给出的空间大小，与数组的元素个数无关

例：        

  1.            //如果数组通过直接赋值的方式创建，那么length属性就表示元素个数
  2.  
  3.           System.out.println(intarray2.length);//4
  4.  
  5.           //如果数组通过定义创建的方式创建，那么length属性就表示创建数组是给出的空间大小
  6.  
  7. //比如我创建数组空间大小4，但我只赋值了一个
  8.  
  9.            double douarray[]=new double[5];
  10.  
  11.            douarray[0]=5.2;
  12.  
  13.            System.out.println(douarray.length);//5

      7.循环遍历一维数组

比如:

  1. import java.util.Arrays;
  2.  
  3. public  class  ArrayDemo{
  4.  
  5. public  static  void  main(String  args[]){
  6.  
  7.  //循环遍历一维数组
  8.  
  9. String names[]={"张三","李四","王五"};
  10.  
  11.  //for循环
  12.  
  13.  for(int i=0;i<names.length;i++){
  14.  
  15.   System.out.println("for--"+names[i]);
  16.  
  17.        }
  18.  
  19. //while循环遍历数组
  20.  
  21.               int j=0;
  22.  
  23.               while(j<names.length){
  24.  
  25.               System.out.println("while--"+names[j]);
  26.  
  27.               j++;
  28.  
  29.               }
  30.  
  31.               //do...while循环遍历数组
  32.  
  33.               int k=0;
  34.  
  35.               do{
  36.  
  37.               System.out.println("do...while--"+names[k]);
  38.  
  39.            k++;
  40.  
  41.                    }while(k<names.length);
  42.  
  43. //增强的for循环--jdk1.5新增的内容
  44.  
  45.           //for(数据类型 变量名称:数组){  变量名称==数组中的每一个数据值}
  46.  
  47. for(String name:names){
  48.  
  49.                      System.out.println("增强的for循环--"+name);
  50.  
  51.               }
  52.  
  53.     }
  54.  
  55. }

      8.定义一个二维数组

格式：数据类型  数组名称[][]；       int arrtest1[][];

          数据类型  [][]数组名称；       int [][]arrtest2;

二维数组可以保存一个类似表格一样的数据，所以我们可以认为二维数组就是一个表格。

      9.创建二维数组

①先定义后创建，

                    int arrtest1[][];

                arrtest1=new int[2][3];

或者定义+创建，同一维处理方法

数据类型  数组名称[][] = new 数据类型[表格行][行中的列];

数据类型  [][]数组名称 = new 数据类型[表格行][行中的列];

②赋值

逐个赋值：

              arrtest1[0][0]=100;

              arrtest1[0][1]=200;

              arrtest1[0][2]=300;

              arrtest1[1][0]=400;

              arrtest1[1][1]=500;

              arrtest1[1][2]=600;

直接赋值：

格式：  

      ①数据类型 数组名称[][]=new 数据类型[][]{

              {数据值1,数据值2,数据值3…},

              {数据值1,数据值2,数据值3…}

          };

   如char charr2[][]=new char[][]{{'h','e','l','l','o'},{'w','o','r','l','d'}};

      ②数据类型 数组名称[][]={

            {数据值1,数据值2,数据值3…},

            {数据值1,数据值2,数据值3…}

     };

如char charr1[][]={{'h','e','l','l','o'},{'w','o','r','l','d'}};

      10.如何从二维数组中取值

只要我们能够得到数组的存储位置，就可以得到数组中的数据值。

格式:数组名称[行][列]；

System.out.println(charr1[0][1]);//e

      11.二维数组的length属性---行数

System.out.println(charr1.length);//2

      12.循环遍历二维数组

使用双层循环结构，外层控制行，内层控制列

①for循环  

  1.     for(int m=0;m<charr1.length;m++){
  2.  
  3.               for(int n=0;n<=4;n++){
  4.  
  5.               System.out.println(charr1[m][n]);
  6.  
  7.            }
  8.  
  9. }

②增强for循环 

  1.   for(char hhh[]:charr1){
  2.  
  3.          for(char value:hhh){
  4.  
  5.          System.out.println("增强for循环---"+value);
  6.  
  7.       }
  8.  
  9. }

③while循环 

  1.  //while循环
  2.  
  3.    int z=0;
  4.  
  5.    while(z<2){
  6.  
  7.           int k=0;
  8.  
  9.           while(k<=4){
  10.  
  11.                System.out.println("while循环---"+charr1[z][k]);
  12.  
  13.                k++;
  14.  
  15.              }
  16.  
  17.         z++;
  18.  
  19.      }

      13.认识Array类【数组的帮助类】

Arrays类位于java.util包中，主要包含了操纵数组的各种方法；

       Arrays常用函数（都是静态的)；

1.void Array.sort(Object[ ] array)

对数组按照升序排序；

2.void Array.sort(Object[ ] array, int from, int to)

       对数组元素指定范围进行排序（排序范围是从元素下标为from,到下标为to-1的元素进行排序）

3.Arrays.fill(Object[] array,Object object)

可以为数组元素填充相同的值

4.Arrays.fill(Object[] array,int from,int to,Object object)

对数组的部分元素填充一个值,从起始位置到结束位置，取头不取尾

5.Arrays.toString(Object[] array)

返回数组的字符串形式

例：

  1. import java.util.Arrays;
  2.  
  3. public  class  ArrayDemo2{
  4.  
  5.             public  static  void  main(String  args[]){
  6.  
  7.          //排序前
  8.  
  9.            System.out.println("排序前");
  10.  
  11.            int array1[]={5,2,0,8,6,1,4};
  12.  
  13.           //使用增强for循环输出
  14.  
  15.           for(int num:array1){
  16.  
  17.                     System.out.println(num);
  18.  
  19.                }
  20.  
  21.            System.out.println("按升序排序");
  22.  
  23.            //void Array.sort(Object[] array)   对数组按照升序排序；
  24.  
  25.            Arrays.sort(array1);
  26.  
  27.            for(int num:array1){
  28.  
  29.                     System.out.println(num);
  30.  
  31.                }
  32.  
  33.          //对指定元素范围进行排序
  34.  
  35.          System.out.println("对指定2,0,8,6,进行排序");
  36.  
  37.          int array2[]={5,2,0,8,6,1,4};
  38.  
  39.          Arrays.sort(array2,1,5);
  40.  
  41.            for(int num:array2){
  42.  
  43.                     System.out.println(num);
  44.  
  45.                }
  46.  
  47.          //对数组填充相同的值
  48.  
  49.          System.out.println("-------------");
  50.  
  51.          char array3[]={'w','o','r','l','d'};
  52.  
  53.          for(char charnum:array3){
  54.  
  55.                    System.out.println(charnum);
  56.  
  57.              }
  58.  
  59.           System.out.println("对数组填充相同的值");
  60.  
  61.          Arrays.fill(array3,'a');
  62.  
  63.           for(char charnum:array3){
  64.  
  65.                    System.out.println(charnum);     //aaaaa 
  66.  
  67.                }
  68.  
  69.           System.out.println("对数组部分位置填充一个值，从起始位置到结束位置，取头不取尾");
  70.  
  71.           char array4[]={'w','o','r','l','d'};
  72.  
  73.           Arrays.fill(array4,1,3,'a');
  74.  
  75.           for(char charnum:array4){
  76.  
  77.                    System.out.println(charnum);   //waald   
  78.  
  79.                }
  80.  
  81.          //返回数组的字符串形式
  82.  
  83.          System.out.println("-----------");
  84.  
  85.          String str1[]={"张三","李四","王五"};
  86.  
  87.          for(String strnum:str1){
  88.  
  89.                  System.out.println(strnum); 
  90.  
  91.                 }
  92.  
  93.           System.out.println("返回数组的字符串形式如下");
  94.  
  95.           String newString=Arrays.toString(str1);
  96.  
  97.            System.out.print(newString);  //[张三, 李四, 王五]      
  98.  
  99.       }
  100.  
  101. }

输出为：

  1. 排序前
  2. 5
  3. 2
  4. 0
  5. 8
  6. 6
  7. 1
  8. 4
  9. 按升序排序
  10. 0
  11. 1
  12. 2
  13. 4
  14. 5
  15. 6
  16. 8
  17. 对指定2,0,8,6,进行排序
  18. 5
  19. 0
  20. 2
  21. 6
  22. 8
  23. 1
  24. 4
  25. -------------
  26. w
  27. o
  28. r
  29. l
  30. d
  31. 对数组填充相同的值
  32. a
  33. a
  34. a
  35. a
  36. a
  37. 对数组部分位置填充一个值，从起始位置到结束位置，取头不取尾
  38. w
  39. a
  40. a
  41. l
  42. d
  43. -----------
  44. 张三
  45. 李四
  46. 王五
  47. 返回数组的字符串形式如下
  48. [张三, 李四, 王五]

      14.数组的内存结构

  

基本类型与复合数据类型的区别：

1.存在位置不同：基本类型存放是在栈中，复合数据类型存在栈和堆中；

2.在内存在存在的形式不同：基本类型在内存中是存放的真实值，复合类型在栈存放的是地址，堆中存放的是真实值。

练习题：

1.下列一维数组定义正确的是（ BD）。

A.x=6;int num[x];    错，存储空间必须是int型，x没有定义

B.final int x=6;float a[x];    对的

C.final float x=6;int b[x];    存储空间必须是int型

D.final int x=6;int c[x];     对的

2.下列一维数组定义错误的是（B ）。

A.char chararray3[]=new char[]{'a','b','c','d','e'};     对的

B.char []chararray3=new char[5]{'a','b','c','d','e'};    错，创建数组的时候不能指定存储空间

C.char chararray4[]={'h','e','l','l','o'};      对的

D.char []chararray4={'h','e','l','l','o'};      对的

3.以下数组定义中，正确的是（A ）。

A. int a[2][]={1,2,3,4,5};      第三行是一维的

B. int a[][2]={{0},{}};       第三列是一维的

C. int a[2][2]={{1,2},{3}};  第三行第三列，应该是一个数

D. int a[][]={1,2,3,4};      二维数组，明显不对

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/233704?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号