Java中的循环笔记整理(必看篇)

一、循环的类型:

1、for循环

class For{
  public static void main(String[] args) {
    System.out.println("Hello World!");
    System.out.println("Hello World!");
    System.out.println("Hello World!");
    System.out.println("Hello World!");
    System.out.println("我是分隔符~~~~~~~~~~~~~~~~~~~~~~~~");
    for(int i = 0; i < 4; i++){
      System.out.println("Hello World!");
    }
  }
}

运行结果:

2、while() {}

class TestWhile {
  public static void main(String[] args) {
    //100以内的偶数的输出
    int i = 1;
    int sum = 0;
    while(i <= 100){
      if(i % 2 == 0){
      System.out.println(i);
      sum += i;
      }
      i++;
    }
    System.out.println(sum);
    //System.out.println(i);
  }
}

运行结果:

3、do{}while()

class DoWhile{
  public static void main(String[] args) {
    int i = 1;
    do{
      if(i % 2 == 0){
        System.out.print(i + "\t");
      }
      i++;
    }while(i <= 100);
  }
}

运行结果:

二、格式:

所有的循环结构都必须包含以下4部分:

     1、初始化条件;

    2、循环条件;

    3、迭代条件;

    4、循环体;

1、for循环格式:

/*
所有的循环结构都必须包含以下4部分:
1、初始化条件;
2、循环条件;
3、迭代条件;
4、循环体;
在这段代码中与格式的对应关系为:
1、初始化条件 = int i = 0;
2、循环条件 = i < 4;
3、迭代条件 = i++;
4、循环体 = System.out.println("Hello World!");
*/
class For{
  public static void main(String[] args) {
    for(int i = 0; i < 4; i++){
      System.out.println("Hello World!");
    }
  }
}

2、while循环格式:

/*
所有的循环结构都必须包含以下4部分:
1、初始化条件;
2、循环条件;
3、迭代条件;
4、循环体;
在这段代码中与格式的对应关系为:
1、初始化条件 = int i = 1;int sum = 0;;
2、循环条件 = i <= 100;
3、迭代条件 = i++;
4、循环体 = if语句;
*/
class TestWhile {
  public static void main(String[] args) {
    //100以内的偶数的输出
    int i = 1;
    int sum = 0;
    while(i <= 100){
      if(i % 2 == 0){
      System.out.print(i +"\t");
      sum += i;
      }
      i++;
    }
    System.out.print(sum);
  }
}

3、do{4 3}while(2);

/*
所有的循环结构都必须包含以下4部分:
1、初始化条件;
2、循环条件;
3、迭代条件;
4、循环体;
在这段代码中与格式的对应关系为:
1、初始化条件 = int i = 1;
2、循环条件 = i <= 100;
3、迭代条件 = i++;
4、循环体 = if语句;
*/
class TestDoWhile{
  public static void main(String[] args) {
    int i = 1;
    do{
      if(i % 2 == 0){
        System.out.println(i);
      }
      i++;
    }while(i <= 100);

    int j = 10;
    do{
      System.out.println(j);
      j++;
    }while(j<10);

    while(j < 10){
      System.out.println(j);
      j++;
    }
  }
}

注意:

1、不同的循环结构之间可以相互转换;

2、while和do-while的区别:do-while程序至少会执行一次;

三、嵌套循环:

说明:循环结构中还可以声明循环;让内层循环结构整体充当外层循环的循环体;若外层循环执行m次,内层循环执行N次,整个程序执行m*n次。

可以理解为外层循环控制行数,内层循环控制列数;

例:

class TestFor2 {
  public static void main(String[] args) {
    for(int j = 0;j < 4;j++){//外层循环控制行数
      for(int i = 0;i < 5;i++){//内层循环控制列数
        System.out.print("*");
      }
      System.out.println();
    }
  }
}

运行结果:

练习题

1、九九乘法表

class TestJiuJiu {
  public static void main(String[] args) {
    for(int i = 1;i <= 9;i++){
      for(int j = 1;j <= i;j++){
        System.out.print(i + "*" + j + "=" + i*j + "\t");
      }
    System.out.println();
    }
  }
}

运行结果:

2、输出100内的质数(两种方法实现)

第一种:

class TestPrimeNumber {
  public static void main(String[] args) {
      boolean flag = false;
      long start = System.currentTimeMillis();
      for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历
      //如何判断i是否为一个质数
      for(int j = 2;j <= Math.sqrt(i);j++){
        if(i % j == 0){
          flag = true;
          break;
        }
      }
      if(!flag){
        System.out.println(i);
      }
      flag = false;
    }
    long end = System.currentTimeMillis();
    System.out.println("所花费的时间为:" + (end - start));
  }
}

运行结果:由于数据过多,这里使用运营时间来表示

第二种:这种方式主要是为了显示运行的效率,这里也是使用运行时间来表示。

class TestPrimeNumber1 {
  public static void main(String[] args) {
      //boolean flag = false;
      long start = System.currentTimeMillis();
      l:for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历
      //如何判断i是否为一个质数
      for(int j = 2;j <= Math.sqrt(i);j++){
        if(i % j == 0){
          //flag = true;
          //break;
          continue l;
        }
      }
      //if(!flag){
        //System.out.println(i);
      //}
      //flag = false;
    }
    long end = System.currentTimeMillis();
    System.out.println("所花费的时间为:" + (end - start));
  }
}

运行结果:

四、无限循环

当需要使用无限循环时,将循环的循环条件修改为true即可(代码格式请参考第二部分),但是需要注意的是,在无限循环结果内部一定要提供循环的终止条件(使用break关键字)否则程序将无限制的执行下去,形成死循环;

五、break和continue:

1、break:

  1、使用在swich-case结构或者循环结构中;

  2、在循环结构中,一旦执行到break,就跳出当前循环。

2、continue:

  1、使用在循环结构中;

  2、在循环结构中,一旦执行到continue就跳出当次循环;

3、在嵌套循环中,可以使用带标签的break和continue。

  例:

class TestPrimeNumber1 {
  public static void main(String[] args) {
      //boolean flag = false;
      long start = System.currentTimeMillis();
      l:for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历
      //如何判断i是否为一个质数
      for(int j = 2;j <= Math.sqrt(i);j++){
        if(i % j == 0){
          //flag = true;
          //break;
          continue l;
        }
      }
      //if(!flag){
        //System.out.println(i);
      //}
      //flag = false;
    }
    long end = System.currentTimeMillis();
    System.out.println("所花费的时间为:" + (end - start));
  }
}

注意:请注意第5行代码(l:for(int i = 2;i <= 100000;i++))以及第11行代码(continue l;),在第五行代码前边写了一个l:的标签,然后在第11行代码处进行调用,如果程序执行到这里会自动跳出此循环,然后从第五行开始执行;

六、数组:

1、定义:相同数据类型的数据的组合。

不使用数组的定义方式: 

int i1 = 1;
int i2 = 2;
int i3 = 3;

使用数组的定义方式:

1、静态初始化:在声明并初始化数组与给数组相应的元素赋值操作同时进行;

int[] scores = new int[]{72,90,59};

2、动态初始化:在声明并初始化数组与给数组相应的元素赋值操作分开进行;

int[] scores1 = new int[3];

socres1[0] = 72;

socres1[1] = 90;

socres1[2] = 59;

2、数组的初始化问题(以下的初始化为错误的初始化方式):

String[] names = new String[5]{"AA","BB","CC"}

int i = new int[10];

int i = new int[];

注意:不管是动态初始化还是静态初始化,一定要在创建的时候就指明数组的长度;

3、数组的引用:

1、通过数组下角标的方式来进行引用;下角标从0开始到n-1结束,其中n为数组的长度。

2、数组的长度通过length属性来调用;

代码

3、如何遍历数组:使用循环来进行遍历

for(int i = 0,i < scores1.length;i++){

System.out.println(scores1[i]);

}

代码展示:

public class TestArray {
  public static void main(String[] args){
    int i1;
    i1 = 12;
    boolean b = true;
    //1.如何定义一个数组
    //1.1数组的声明
    String[] names;
    int[] scores;
    //1.2初始化
    //第一种:静态初始化:初始化数组与给数组元素赋值同时进行。
    names = new String[]{"张三","李四","王五"};
    //第二种:动态初始化:初始化数组与给数组元素赋值是分开进行的;
    scores = new int[4];
    //2.如何调用相应的数组元素:通过数组元素的下角标的方式来调用。
    //下角标从0开始,到n-1结束。其中N表示的是数组的长度。
    scores[0] = 87;
    scores[1] = 89;
    scores[3] = 98;
    //3。数组的长度:通过数组的length属性。
    System.out.println(names.length);
    System.out.println(scores.length);
    //4.如何遍历数组元素
//    System.out.println(names[0]);
//    System.out.println(names[1]);
//    System.out.println(names[2]);
    for(int i = 0;i < names.length;i++){
      System.out.println(names[i]);
    }
  }
}

以上这篇Java中的循环笔记整理(必看篇)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • 深入理解java中for和foreach循环

    •for循环中的循环条件中的变量只求一次值!具体看最后的图片 •foreach语句是java5新增,在遍历数组.集合的时候,foreach拥有不错的性能. •foreach是for语句的简化,但是foreach并不能替代for循环.可以这么说,任何foreach都能改写为for循环,但是反之则行不通. •foreach不是java中的关键字.foreach的循环对象一般是一个集合,List.ArrayList.LinkedList.Vector.数组等. •foreach的格式: for(元素类

  • Java中的两种for循环介绍

    复制代码 代码如下: package com.zxd.test; import java.util.List; import org.hibernate.HibernateException; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; import com.zxd.bea

  • Java for循环的几种用法分析

    J2SE 1.5提供了另一种形式的for循环.借助这种形式的for循环,可以用更简单地方式来遍历数组和Collection等类型的对象.本文介绍使用这种循环的具体方式,说明如何自行定义能被这样遍历的类,并解释和这一机制的一些常见问题. 在Java程序中,要"逐一处理"――或者说,"遍历"――某一个数组或Collection中的元素的时候,一般会使用一个for循环来实现(当然,用其它种类的循环也不是不可以,只是不知道是因为for这个词的长度比较短,还是因为for这个词

  • java新特性之for循环最全的用法总结

    1. 增强for概述 增强for循环,也叫Foreach循环,用于数组和容器(集合类)的遍历.使用foreach循环遍历数组和集合元素时,无需获得数组和集合长度,无需根据索引来访问数组元素和集合元素,大大提高的效率,代码也简洁不少. 2. Oracle官网的解释 So when should you use the for-each loop? Any time you can. It really beautifies your code. Unfortunately, you cannot

  • java List循环与Map循环的总结

    java  List循环与Map循环的总结 做了一下list和map的总结,没有什么技术含量,就全当复习了一下api. 测试环境是在junit4下,如果没有自己写一个main方法也是一样的. 首先是List的三种循环: @Test public void ForListTest() { List<String> list = new ArrayList<String>(); list.add("1"); list.add("2"); list

  • Java中的循环笔记整理(必看篇)

    一.循环的类型: 1.for循环 class For{ public static void main(String[] args) { System.out.println("Hello World!"); System.out.println("Hello World!"); System.out.println("Hello World!"); System.out.println("Hello World!"); Sy

  • Linux shell脚本输出日志笔记整理(必看篇)

    1.日志方法简介: #日志名称 log="./upgrade.log" #操作日志存放路径 fsize=2000000 #如果日志大小超过上限,则保存旧日志,重新生成日志文件 exec 2>>$log #如果执行过程中有错误信息均输出到日志文件中 #日志函数 #参数 #参数一,级别,INFO ,WARN,ERROR #参数二,内容 #返回值 function zc_log() { #判断格式 if [ 2 -gt $# ] then echo "parameter

  • 基于java中的流程控制语句总结(必看篇)

    程序的结构分类: 顺序结构:按照写代码的顺序 一次执行 选择结构:根据条件的不同有选择的执行不同的代码 循环结构:在一定条件下 反复执行某一片代码 选择结构: 也叫分支结构 根据条件的不同,有选择的执行某一片代码 ,Java提供了两种 if结构 switch结构 if分为三种格式: if的第一种格式 if(条件){ 语句块 } 执行流程: 先判断条件, 如果为真 则语句块执行,否则 语句块不执行 代码演示: public static void main(String[] args) { Sys

  • Java中的对象流总结(必看篇)

    Java中可以通过对象流将一个序列化的对象保存到硬盘中,或者硬盘中读取一个对象.对象流的存储和读取包含以下几点内容: 1.所保存的对象必须实现Serializable接口. 2. 所保存的对象的属性也必须实现Serializable接口. 3. 最好要给该对象提供一个版本号,private static final long serialVersionId. 下面是一个对象流存储和读取一个对象的流程图: class Person implements Serializable { //实现序列化

  • Java基本语法笔记(菜鸟必看篇)

    一.关键字&标识符 1.关键字:被Java语言赋予了特殊含义,用作专门用途的字符串(单词): 2.保留字:现有Java版本尚未使用,但以后版本可能会作为关键字使用.自己命名时要避免使用这些保留字: 3.标识符:凡是自己可以起名字的地方都叫标识符: 4.标识符命名规则(必须遵守): 1.由26个英文字母大小写,0-9,_或$组成: 2.数字不可以开头: 3.不可以使用关键字以及保留字,但能包含关键字以及保留字: 4.Java中严格区分大小写,长度无限制: 5.标识符不能包含空格: 5.Java中的

  • Java中jqGrid 学习笔记整理——进阶篇(二)

    相关阅读: Java中jqGrid 学习笔记整理--进阶篇(一) 本篇开始正式与后台(java语言)进行数据交互,使用的平台为 JDK:java 1.8.0_71 myEclisp 2015 Stable 2.0 Apache Tomcat-8.0.30 Mysql 5.7 Navicat for mysql 11.2.5(mysql数据库管理工具) 一.数据库部分 1.创建数据库 使用Navicat for mysql创建数据库(使用其他工具或直接使用命令行暂不介绍) 2. 2.创建表 双击打

  • JavaWeb学习笔记分享(必看篇)

    自定义列表 <dl></dl>:表示列表的范围 **在里面 <dt></dt>:上层内容 **在里面 <dd></dd>:下层内容 有序列表 <ol></ol>:有序列表的范围 --属性 type:设置排序方式,1(默认),a,i.. **在ol标签里面 <li>具体内容</li> 无序列表 <ul></ul>:无序列表的范围 --属性 type:circle(空

  • java异常和错误类总结(必看篇)

    java异常和错误类总结 最近由于考试和以前的面试经常会遇到java当中异常类的继承层次的问题,弄得非常头大,因为java的异常实在是有点多,很难记下来,今天正好查了一些资料整理下来,希望对自己和大家有点帮助.最开始的时候习惯用笔记本(手写的纸质的本子)记笔记,后来发现查阅的时候不是很方便,而且速度比较慢.后来改用notepad开始记,感觉效果挺棒,简单易用,没有花哨的东西.但是也有它的缺点,比如版式的整理,不能加入一些图片(往往图片特别是一些大纲是非常好的记忆学习方法)等等,于是尝试用mark

  • Javascript基础学习笔记(菜鸟必看篇)

    什么是变量? 变量是用于存储信息的容器 变量的声明 语法: var 变量名 变量名 = 值; 变量要先声明再赋值 变量可以重复赋值 变量的命名规则 变量必须以字母开头: 变量也能以$和_符号开头(不过我们不推荐这么做): 变量名称对大小写敏感(a和A是不同的变量). 语句 语句以一个分号结尾:如果省略分号,则由解析器确定语句的结尾. 有个好的编码习惯,都要以 ; 结尾 数据类型 在JavaScript中,一段信息就是一个值(value).值有不同的类型,大家最熟悉的类型是数字.字符串(strin

  • Java final 修饰符知识点总结(必看篇)

    final从字面上理解含义为"最后的,最终的".在Java中也同样表示出此种含义. final可以用来修饰变量(包括类属性.对象属性.局部变量和形参).方法(包括类方法和对象方法)和类. 1. final修饰类: final修饰类即表示此类已经是"最后的.最终的"含义.因此,用final修饰的类不能被继承,即不能拥有自己的子类. 如果视图对一个已经用final修饰的类进行继承,在编译期间或发生错误. 2. final修饰方法: final修饰的方法表示此方法已经是&

随机推荐