语句的循环和数组

1.循环结构

1.for循环

公式：for(初始条件;判断条件;循环增量/减量){
            java代码
        }

含义：初始条件--决定循环的开始
           判断条件--决定循环的结束
           循环增量/减量--控制初始条件值
        执行过程:
        先执行初始条件，再执行判断条件，
        判断条件的结果为true,执行{java代码}，接下来执行循环增量/减量，接着执行判断条件
        判断条件的结果为false,循环结束

public  class  For{
public  static  void  main(String  args[]){

//循环输出1-5的整数
for(int a=1;a<=5;  a++){
       System.out.println("a=="+a);

}
//循环输出5-1的整数
for(int a=5;a>=1;  a--){
       System.out.println("a=="+a);
}

 //计算一个1-5的整和

int  n=0;
for(int a=1;a<=5;  a++){
       n=n+a;
}
System.out.println("n=="+n);
//第一次n=0    a=1           得到的n=n+a=0+1=1
//第二次n=1    a=a++=2  得到的n=n+a=1+2=3
//第三次n=3    a=a++=3  得到的n=n+a=3+3=6
//第四次n=6    a=a++=4  得到的n=n+a=6+4=10
//第五次n=10  a=a++=5  得到的n=n+a=10+5=15

2.while循环

公式：while(判断条件){
            java代码
            【循环增量/减量的条件】
        }

执行过程:
        先执行判断条件，
            判断条件结果为true时，执行{java代码}，继续执行判断条件，
            判断条件结果为false时，结束循环
        注意1:初始条件定义在while循环的格式之外。
        注意2:把循环增量/减量的条件写在{java代码.....最后一句}

//循环输出1-5的整数
int  a=1;
while(a<=5){   
        System.out.println("a=="+a);
        a++;
 }

//循环输出5-1的整数

int  b=5;
while(b>=1){   
        System.out.println("b=="+b);
        b--;
 }

//求和1-5
int  d=0;
int  c=1;
while(c<=5){   
        d=d+c;
        c++;
}
System.out.println("d=="+d);

3.do....while循环

公式：do{
           java代码
        }while(判断条件);

执行过程:
        先执行{java代码}，再执行判断条件，
            判断条件的结果为true，继续执行{java代码}，接着执行判断条件
            判断条件的结果为false,结束循环
        注意1:初始条件定义在do...while循环的格式之外。
        注意2:把循环增量/减量的条件写在{java代码.....最后一句}

//循环输出1-5的整数
int a=1;
do{      
    System.out.println("a=="+a);
    a++;
        }
while(a<=5);

//循环输出5-1的整数
int b=5;
do{      
    System.out.println("b=="+b);
    b--;
        }

//求和1-5
int  c=1;
int d=0;
do{  d=d+c;
   c++;
}
while(c<=5  );
System.out.println("d=="+d);

三者的区别：

for循环有定义循环增量/减量具体位置，
while和do{}while()循环，没有定义循环增量/减量具体位置，往往都是自己定义在循环体中的最后一句

for循环需要明确循环次数    
while和do{}while()循环不需要考虑循环次数

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

//计算程序
import  java.util.Scanner;
public  class Test1{
public  static  void  main(String  orgs[]){
//创建输入对象
Scanner  input=new  Scanner(System.in);
boolean  flag=true; //控制循环持续执行
while(flag){
//得到第一个运算数字
System.out.println("请输入一个运算数字:");
int  num1=input.nextInt();
//得到一个运算符号
System.out.println("请输入一个运算运算符号:");
String  op=input.next();
//得到第二个运算数字
System.out.println("请输入第二个个运算数字:");
int  num2=input.nextInt();
//计算结果；
switch(op){
case"+":System.out.println(num1+"+"+num2+"="+(num1+num2));break;
case"-":System.out.println(num1+"-"+num2+"="+(num1-num2));break;
case"*":System.out.println(num1+"*"+num2+"="+(num1*num2));break;
case"/":System.out.println(num1+"/"+num2+"="+(num1/num2));break;
case "@":flag=false;break;
default:System.out.println("无法计算");break;
}
}
}
}

4.break语句与continue语句的用法和区别
    break语句---循环中就表示中断循环的执行
    如果循环是嵌套的，那么break语句出现在那一层就中断那一次的循环。

     ---switch中表示结束switch的执行

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

例如：

public  class Test2{
public  static  void  main(String  orgs[]){
/*
int  i=1;
do{
System.out.println("i=="+i);
}while(i<0);
*/
//把上面的do...while格式转换成while
int  i=1;
while(i<0){
System.out.println("i=="+i);

}
}
}

Java中的数组：

1.什么是数组

相同数据类型的数据

按照顺序

复合数据类型

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

格式:数据类型  数组名称[]; / 数据类型  []数组名称;（中括号的位置不一样）
        数组的定义与变量的定义相似，只是需要”[]”与变量区分，因此上”[]”就是数组的标志。
     名称的前面/后面出现一个“[]”就是一维数组，有两个”[][]”就是二维数组，两个以上就是多维数组

3.如何创建一个数组

    创建数组的本质就是确定数组的具体存储空间。
    格式:
        1.先定义，后创建
            定义: 数据类型  数组名称[]; / 数据类型  []数组名称;
            创建: 数组名称 = new 数据类型[指定的存储空间];
            指定的存储空间的数据值是int型
        2.定义+创建
            数据类型  数组名称[]=new 数据类型[指定的存储空间];
            数据类型  []数组名称=new 数据类型[指定的存储空间];

//int  intarray[]=new int[4];
//char  chararray[]=new char[4];

4.如何为一维数组赋值？
        1.逐个赋值---就是挨个为数组的每一个存储空间存放数据值。[需要数组的下标]
     数组的下标--因为数组是按照顺序保存数据，此时每一个存储空间就有一个顺序的编号，维持        数组数据顺序的编号就是下标。通过可以通过下标得到具体的数据存储空间。下标从0开始。              第一个存储空间的下标是0，依次类推。
          格式: 数组名称[下标] =  数据值;

chararray[0]=111;
chararray[1]=222;
chararray[2]=333;
chararray[3]=444;

几个下标就可以赋几个值，赋值从0开始。

          注意:当保存在数组中的数据超过数组指定的存储空间就是会出错。                        java.lang.ArrayIndexOutOfBoundsException: 
        
        2.直接赋值---就是在创建数组的时候将数据值保存到数组中。
            2.1  数据类型  数组名称[]=new 数据类型[]{数据值1，数据值2，...，数据值n};
                 //创建数组的时候不能指定存储空间
            2.2  数据类型  数组名称[]={数据值1，数据值2，...，数据值n};

//直接赋值；
int  intarray[]=new int[4]{111,222,333,444};
long  longarray[]=new long[]{555,666,777,888};

int  intarray[]={111,222,333,444};

long  longarray[]={555,666,777,888};

5.如何从一维数组中取值？
        只要我们能够得到数组的存储位置，就可以得到数组中的数据值
        格式:数组名称[下标]

System.out.println(intarray[0]);//111
System.out.println(intarray[1]);//222
System.out.println(longarray[0]);//555
System.out.println(longarray[1]);//666
System.out.println(longarray[3]);//888

6.一维数组的length属性
        如果数组通过直接赋值的方式创建，那么length属性就表示元素个数。
        如果数组通过定义创建的方式创建，那么length属性就表示创建数组是给出的空间大小，与数组的元素个数无关

System.out.println(longarray.length);//4,4表示直接赋值的元素个数

double  dou[]=new  double[4];
System.out.println(dou.length);//4，数组中没有值，输出的4与元素无关，代表的是空间大小。

直接赋值length代表元素个数，定义赋值length代表空间大小。

7.循环遍历一维数组

System.out.println(dou.length);//4
String names[]={"zhang","wang","li","zhao"};
for(int i=0;i<names.length;i++){
System.out.println(names[i]);
}
int  intarray[]=new int[]{555,666,777,888};
for(int  i=0;i<intarray.length;i++){
System.out.println(intarray[i]);
}

输出：

zhang
wang
li
zhao
555
666
777
888

//while循环遍历数组
        int j=0;
        while(j<names.length){
            System.out.println("while--"+names[j]);
            j++;
        }
        //do...while循环遍历数组
        int k=0;
        do{
            System.out.println("do...while--"+names[k]);
            k++;
        }while(k<names.length);

8.如何定义一个二维数组

格式: 数据类型  数组名称[][]；
         数据类型  [][]数组名称；

9.如何创建一个二维数组？
    二维数组可以保存一个类似表格一样的数据，所以我们可以认为二维数组就是一个表格。    
    1.先定义，后创建

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

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

   int [][]arrtest2;

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

arrtest1=new int[2][3];
    2.定义+创建
           数据类型  数组名称[][] = new 数据类型[表格行][行中的列];

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

char [][]charr=new char[2][5];

10.如何为二维数组赋值？
        1.逐个赋值---就是挨个为数组的每一个存储空间存放数据值。

        arrtest1[0][0]=100;
        arrtest1[0][1]=200;
        arrtest1[0][2]=300;
        arrtest1[1][0]=400;
        arrtest1[1][1]=500;
        arrtest1[1][2]=600;  
        2.直接赋值---就是在创建数组的时候将数据值保存到数组中。

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

    11.如何从二维数组中取值？
        只要我们能够得到数组的存储位置，就可以得到数组中的数据值。
        格式:数组名称[行][列]；

System.out.println(charr1[1][3]);

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

        System.out.println(charr1.length);

13.循环遍历二维数组---使用双层循环结构，外层控制行，内层控制列
        for(int i=0;i<charr1.length;i++){
            for(int s=0;s<=4;s++){
                System.out.println(charr1[i][s]);
            }
        }

增强for循环
        for(char carr[]:charr1){
            for(char value:carr){
                System.out.println("增强---"+value);
            }
        }

14.认识Arrays类【数组的帮助类】
        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)返回数组的字符串形式

        //认识Arrays类【数组的帮助类】
        //Arrays类位于java.util包中，主要包含了操纵数组的各种方法
        char chartest[]={'h','e','l','l','o'};
        //void Array.sort(Object[] array) 对数组按照升序排序
        Arrays.sort(chartest);
        for(char value:chartest){
                System.out.println("Arrays---"+value);
            }

    }
}

15.数组的内存结构

 数组的内存结构不同。