打印循环换行_Java之循环结构及数组

循环结构

for循环

for（条件初始化;条件判断;条件变化）{
重复执行的代码；
}
for循环的执行流程:
1.条件初始化
2.条件判断
3.不满足条件结束循环,满足条件执行,执行循环体语句
4.条件变化
从第二次循环开始,条件初始化就不执行了

//循环 
        //打印10次,我是最帅的!!!
        int sum=0;
        for(int i=1;i<=10;i++){  //i可以用来控制循环次数,可以用来在循环体中当做数据使用,这个数据是可变的
            System.out.println("我是最帅的!!!"+i);  
            sum+=i;
        }
        for(int i=1;i<=10;i++){  
            System.out.println("我是最帅的!!!"+i);

for循环是非常灵活的。下面来给一些题目

//1.求1-100的和,求1-100的偶数和,求1-100的奇数和
        int sum=0; //所有数的和
        int sum1=0 ; //所有偶数和
        int sum2=0 ; //所有奇数和
        for(int i=1;i<=100;i++){
            sum+=i; //所有数的和
            if(i%2==0){//当判断i除以2的余数为0即i为偶数时
                sum1+=i;//累加
            }else{//否则其余即奇数累加
                sum2+=i;
            }
        }
//也可以这样将变化条件直接+=2；
        sum2=0;
        for(int i=1;i<=100;i+=2){
            sum2+=i; //所有偶数的和
        }
//2.求5的阶乘  5! 5*4*3*2*1 
        for(int i=1;i<6;i++){
            i = i*i;
        }

/*3打印水仙花数。
提示：水仙花数指一个三位整数，其各位数的立方和等于该数本身。
例如：153=1*1*1 + 5*5*5 + 3*3*3
*/
//重复的拿出每一个3位数,都要通过同样的逻辑进行判断---循环
        for(int i=100;i<=999;i++){  
            //难点再取各个位数的值

            int a=i/100%10;//百位  678/100=6.78再÷10取余（=0……6）为6//注意转为int取整
            int b=i/10%10;//十位  678/10=67.8再÷10取余（=6……7）为7
            int c=i%10;//个位   678%10取余（=67……8）为8
            if(a*a*a + b*b*b + c*c*c==i){
                System.out.println("水仙花数"+i);
            }
        }
//*******请找出[100，300]之间能被5整除的所有数，每行输出8个数
        int count=0;//这里需要计数器，很重要。灵活应用
        for(int i=100;i<=300;i++){
            if(i%5==0){//判断是否能被5整除
                System.out.print(i+" ");
                count++;//每进行上面一次循环则自增1
                if(count==8){//当计数器达到8次则换行
                    System.out.println();
                    count=0;//***要将计数器返回0；从零开始下一行的计数
                }
            }
        }
/请找出[100，300]之间能被5整除的所有数，每行输出8个数且中间有“，”最后一位没有
//思维，上面例子是1+“ ”，反向思考，这次我们将“，”+1；第一个数i也有逗号怎么办，来个判断，当打印第一个数，否则就打印“，”+i；
        count=0;
        for(int i=100;i<=500;i++){
            if(i%5==0){
                if(count==0){//计数为1时
                    System.out.print(i);//输出  i
                }else{
                    System.out.print(","+i);//否则输出  ，i
                }
                count++;
                if(count==8){//计数到8时，换行
                    System.out.println();
                    count=0;//计数器清零
                }
            }
        }

while循环

循环结构:
条件循环
条件初始化;
while(条件判断){ 循环体语句; 条件变化; }

注意:能够使用for循环的都能使用while,可以互相转换

确定循环次数|变量变化区间 -->推荐使用for

条件不需要我们声明,变化也不需要我们声明 -> 推荐使用while

int i=1;  //条件初始化  主方法中的作用域
        while(i<=100){
            System.out.println(i);//打印1-100
            i++; //条件变化
        }
        System.out.println(i);

do……while（）

do..while与while之间的区别:
do..while 无论是否满足条件都至少执行一次
while: 先判断,满足才执行,不满足结束
do..while:先执行,后判断,判断满足条件继续下一次执行,不满足条件结束 java //条件初始化; do{ 语句体; 条件变化; }while//(条件判断);

boolean flag=false;
        while(flag){//这里赋值布尔变量
            System.out.println("我是while..false");//编译成功但不打印
        }

        do{
            System.out.println("我是do..while..false");//打印出
        }while(false);

==死循环：for(;;){执行语句；}==

==while(true){执行语句；}==

break和continue的区别

break:
作用: 结束,终止
应用场景: switch语句,循环中
continue:
作用: 结束本次循环,直接进入到下一次循环中
应用场景: 循环中

//打印1~10之间的数,遇到3或者3的倍数,则敲桌子
        for(int i=1;i<=10;i++){
            if(i%3==0){
                System.out.println("敲桌子...");
                continue;//跳出本次循环进行下一轮循环
            }
            System.out.println(i);
        }

//打印50~100之间,前5个能被5整除的数
        int count=0; //计数器
        for(int i=50;i<=100;i++){
            if(i%5==0){
                System.out.println(i);
                count+=1;//计数器+1
                if(count==5){//当计数器计数到5时
                    break;//结束循环
                }
            }


//随机5个彩票中间号码 ,要求每一个彩票中间号码不能重复  [1~19]
        int num1=(int)(Math.random()*(19-1+1)+1);
        int num2=(int)(Math.random()*(19-1+1)+1);
        int num3=(int)(Math.random()*(19-1+1)+1);
        int num4=(int)(Math.random()*(19-1+1)+1);
        int num5=(int)(Math.random()*(19-1+1)+1);//5个[1~19]随机数
        while(true){ //当进循环时候不确定一共会执行多少次,可以选择使用while..true,在内部进行判断决定循环的结束
            //num2与num1不相等 
            if(num2==num1){ //如果相等
              num2=(int)(Math.random()*(19-1+1)+1);//重新生成
            }else{//如果不等
                break;//结束
            }
        }
        while(num3==num2 || num3==num1){
            num3=(int)(Math.random()*(19-1+1)+1);
        }
        while(num4==num3 || num4==num2 || num4==num1){
            num4=(int)(Math.random()*(19-1+1)+1);
        }
        while(num5==num4 || num5==num3 || num5==num2 || num5==num1){
            num5=(int)(Math.random()*(19-1+1)+1);
        }
        System.out.println("num1="+num1+",num2="+num2+",num3="+num3+",num4="+num4+",num5="+num5);

==***双重循环嵌套==

双重循环嵌套
for(条件初始化;条件判断;条件变化){
//代码
for(条件初始化;条件判断;条件变化){
//代码
}
//代码
} 外层循环执行一次,内层循环执行一轮(从开始到结束)

/*1.打印
            * * * * *
            * * * * *
            * * * * *
            * * * * *
            * * * * *
        */
        //用计数器方式当打印到第五行时换行
        /*
        int count=0;
        for(int i=1;i<=25;i++){
            System.out.print("* ");
            count++;
            if(count==5){
                System.out.println();
                count=0;
            }
        }
        */
            //循环嵌套
        //外层循环  控制行数  i 1~5
        for(int i=1;i<=5;i++){
            //列  j 1~5
            for(int j=1;j<=5;j++){ 
                System.out.print("* ");
            }
            //换行
            System.out.println();
        }
/*2.打印
            * * * * *
            *       *
            *       *
            *       *
            * * * * *
        */
//分析可以看到规律第一行最后一行以及第一列最后一列都有“*”，其他都是“ ”；
        for(int i=1;i<=5;i++){
            //列  j 1~5
            for(int j=1;j<=5;j++){ 
                if(i==1 || i==5 || j==1 || j==5){//当第一行最后一行以及第一列最后一列
                    System.out.print("* ");//打印"* "
                }else{
                    System.out.print("  ");
                }
            }
            //换行
            System.out.println();
        }
/*3.打印
            *           
            * *         
            * * *   
            * * * *     
            * * * * *   
        */
//发现规律每一列和每一行的*相同；
        for(int i=1;i<=5;i++){
            for(int j=1;j<=i;j++){//该列*数<=行数，当*=行数跳出
                System.out.print("* ");
            }
            //换行
            System.out.println();
        }

        /*4.
            *           
            * *         
            *   *       
            *     *     
            * * * * *   
        */
//发现规律每一行的末尾（i=j）和第一列，最后一行都打印为*，其他为“ ”
        for(int i=1;i<=5;i++){
            for(int j=1;j<=i;j++){
                if(i==5||j==1||j==i){//当判断每一行的末尾（i=j）和第一列，最后一行
                    System.out.print("* ");
                }else{
                    System.out.print("  ");
                }   
            }
            //换行
            System.out.println();
        }
/*5.输出下列数值列表

         1    10    100     1000
         2    20    200     2000
         3    30    300     3000
         4    40    400     4000
         5    50    500     5000
        */
//发现规律，第i行的第j+1列都是j列的10倍，这里领过运用for循环不要将他的变化规则局限于j++；这里变化是十倍递增；
        for(int i=1;i<=5;i++){
            for(int j=1;j<=1000;j*=10){//递增为j = j*10；
                System.out.print(i*j+"t");
            }
            System.out.println();
        }

java //九九 乘法表 for(int i=1;i<=9;i++){ for(int j=1;j<=i;j++){ System.out.print(j+"*"+i+"="+j*i+"t"); } System.out.println(); }

MATH类：数学相关的类

不需要导包
在java.lang下的类不需要导包
可以直接通过类名.功能名字去使用 Math.random() 产生随机数 [0,1) 随机小数 随机小数 [min,max)某个范围内的随机小数 Math.random()(max-min)+min
math.round(数据) 四舍五入*/
double num=Math.random();
System.out.println(num); // 产生随机数 [0,1)
//[min,max) 随机整数
[1,5) 之间的随机整数 int num2=(int)(Math.random()*(5-1)+1); //注意整体括号将double强制转化为int
System.out.println(Math.round(1.59));//四舍五入得到1.6

数组

数组的特点:
1.引用数据类型,容器
2.一个数组中的多个数据数据类型一致|相同
3.长度一旦确定不可改变
4.数组中的数据是有序的(索引|下标)
索引|下标:
​ 从0开始,依次+1
数组的长度:
​ 数组名.length
数组的声明: []
数据类型[] 数组名; --推荐使用
数据类型 数组名[];
数据类型 : 指明数组中存放的每一个数据的类型
数组的初始化:
1.动态初始化:先根据数据的长度创建一个数组,但是没有赋值,确定数据的时候再赋值
数据类型[] 数组名 = new 数据类型[长度n];
数组中的数据没有赋值存在默认值:
整数0 小数0.0 字符串null 字符型' ' 布尔型false
2.静态初始化:创建的同时赋值
数据类型[] 数组名 = new 数据类型[]{值1,值2,值3...};
数据类型[] 数组名 = {值1,值2,值3...}; --简略写法,不够灵活,但是简单
数组的遍历: 从前到后拿到每一个数据
1.普通for循环
遍历索引->循环变量i控制数组的索引
2.增强for循环 | for..each
for(数据类型 变量名: 数组名|容器名){
变量代表数组中的每一个数据(非索引) }

//数组的声明:
        int[] arr1;
        String arr2[];

        //动态初始化
        arr1= new int[3];
        //获取值
        System.out.println(arr1.length);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);//打印结果为000.没赋值默认为0
        double[] arr3={1.1,2.2,3.3,4.4,5.5};
        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);
        System.out.println(arr3[3]);
        System.out.println(arr3[4]);
        //System.out.println(arr3[5]);//ArrayIndexOutOfBoundsException 数组索引越界异常（因为数组长度只有5位）
//遍历1 普通for
    for(int i=0;i<=arr2.length-1;i++){
        System.out.println(arr2[i]);
    }
    //for..each
    for(String s : arr2){
        System.out.println(s);
    }