java里的for（java里的否则是什么）

今天给各位分享java里的for的知识，其中也会对java里的否则是什么进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、java中for循环的几种写法2、java for循环用法3、for在java里怎么用4、java中for是什么意思5、java中for的作用

java中for循环的几种写法

以下为for循环的几种写法：

/***

方法一：最普通的不加思考的写法

* p*优点：较常见，易于理解

* p* 缺点：每次都要计算list.size()*/

for (int i = 0; i list.size(); i++) {

System.out.println(list.get(i));

}

/***

方法二：数组长度提取出来

* p* 优点：不必每次都计算

* p* 缺点：

1、m的作用域不够小，违反了最小作用域原则

2、不能在for循环中操作list的大小，比如除去或新加一个元素*/

int m = list.size();

for (int i = 0; i m; i++) {

System.out.println(list.get(i));

}

/***

方法三：数组长度提取出来

* p* 优点：

1、不必每次都计算

2、所有变量的作用域都遵循了最小范围原则

* p* 缺点：

1、m的作用域不够小，违反了最小作用域原则

2、不能在for循环中操作list的大小，比如除去或新加一个元素*/

for (int i = 0, n = list.size(); i n; i++) {

System.out.println(list.get(i));

}

/***

方法四：采用倒序的写法

* p* 优点：

1、不必每次都计算

2、所有变量的作用域都遵循了最小范围原则

* p* 缺点：

1、结果的顺序会反

2、看起来不习惯，不易读懂

* p* 适用场合：与显示结果顺序无关的地方：比如保存之前数据的校验*/

for (int i = list.size() – 1; i = 0; i–) {

System.out.println(list.get(i));

}

/***

方法五：Iterator遍历

* p* 优点：简洁

* p* 缺点：*/

for (IteratorString it = list.iterator(); it.hasNext();) {

System.out.println(it.next());

}

/*** 方法六：

jdk1.5新写法

* p* 优点：简洁结合泛型使用更简洁*

p* 缺点：jdk1.4向下不兼容*/

for (Object o : list) {

System.out.println(o);

}

java for循环用法

Java for循环的几种用法详解

本文非常适合初学Java的程序员，主要是来了解一下Java中的几种for循环用法，分析得十分详细，一起来看看。

J2SE 1.5提供了另一种形式的for循环。借助这种形式的for循环，可以用更简单地方式来遍历数组和Collection等类型的对象。本文介绍使用这种循环的具体方式，说明如何自行定义能被这样遍历的类，并解释和这一机制的一些常见问题。

在Java程序中，要“逐一处理”――或者说，“遍历”――某一个数组或Collection中的元素的时候，一般会使用一个for循环来实现（当 然，用其它种类的循环也不是不可以，只是不知道是因为for这个词的长度比较短，还是因为for这个词的含义和这种操作比较配，在这种时候for循环比其 它循环常用得多）。

对于遍历数组，这个循环一般是采取这样的写法：

清单1：遍历数组的传统方式

/* 建立一个数组 */

int[] integers = {1， 2， 3， 4};

/* 开始遍历 */

for (int j = 0; j integers.length; j++) {

int i = integers[j];

System.out.println(i);

}

而对于遍历Collection对象，这个循环则通常是采用这样的形式：

清单2：遍历Collection对象的传统方式

/* 建立一个Collection */

String[] strings = {“A”， “B”， “C”， “D”};

Collection stringList = java.util.Arrays.asList(strings);

/* 开始遍历 */

for (Iterator itr = stringList.iterator(); itr.hasNext();) {

Object str = itr.next();

System.out.println(str);

}

而在Java语言的最新版本――J2SE 1.5中，引入了另一种形式的for循环。借助这种形式的for循环，现在可以用一种更简单地方式来进行遍历的工作。

1、 第二种for循环

不严格的说，Java的第二种for循环基本是这样的格式：

for (循环变量类型 循环变量名称 : 要被遍历的对象) 循环体

借助这种语法，遍历一个数组的操作就可以采取这样的写法：

清单3：遍历数组的简单方式

/* 建立一个数组 */

int[] integers = {1， 2， 3， 4};

/* 开始遍历 */

for (int i : integers) {

System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */

}

这里所用的for循环，会在编译期间被看成是这样的形式：

清单4：遍历数组的简单方式的等价代码

/* 建立一个数组 */

int[] integers = {1， 2， 3， 4};

/* 开始遍历 */

for (int 变量名甲 = 0; 变量名甲 integers.length; 变量名甲++) {

System.out.println(integers[变量名甲]); /* 依次输出“1”、“2”、“3”、“4” */

}

这里的“变量名甲”是一个由编译器自动生成的不会造成混乱的名字。

而遍历一个Collection的操作也就可以采用这样的写法：

清单5：遍历Collection的简单方式

/* 建立一个Collection */

String[] strings = {“A”， “B”， “C”， “D”};

Collection list = java.util.Arrays.asList(strings);

/* 开始遍历 */

for (Object str : list) {

System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */

}

这里所用的for循环，则会在编译期间被看成是这样的形式：

清单6：遍历Collection的简单方式的等价代码

/* 建立一个Collection */

String[] strings = {“A”， “B”， “C”， “D”};

Collection stringList = java.util.Arrays.asList(strings);

/* 开始遍历 */

for (Iterator 变量名乙 = list.iterator(); 变量名乙.hasNext();) {

Object str = 变量名乙.next();

System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */

}

这里的“变量名乙”也是一个由编译器自动生成的不会造成混乱的名字。

因为在编译期间，J2SE 1.5的编译器会把这种形式的for循环，看成是对应的传统形式，所以不必担心出现性能方面的问题。

不用“foreach”和“in”的原因

Java采用“for”（而不是意义更明确的“foreach”）来引导这种一般被叫做“for-each循环”的循环，并使用“:”（而不是意义 更明确的“in”）来分割循环变量名称和要被遍历的对象。这样作的主要原因，是为了避免因为引入新的关键字，造成兼容性方面的问题――在Java语言中， 不允许把关键字当作变量名来使用，虽然使用“foreach”这名字的情况并不是非常多，但是“in”却是一个经常用来表示输入流的名字（例如 java.lang.System类里，就有一个名字叫做“in”的static属性，表示“标准输入流”）。

的确可以通过巧妙的设计语法，让关键字只在特定的上下文中有特殊的含义，来允许它们也作为普通的标识符来使用。不过这种会使语法变复杂的策略，并没有得到广泛的采用。

“for-each循环”的悠久历史

“for-each循环”并不是一个最近才出现的控制结构。在1979正式发布的Bourne shell（第一个成熟的UNIX命令解释器）里就已经包含了这种控制结构（循环用“for”和“in”来引导，循环体则用“do”和“done”来标识）。

2、防止在循环体里修改循环变量

在默认情况下，编译器是允许在第二种for循环的循环体里，对循环变量重新赋值的。不过，因为这种做法对循环体外面的情况丝毫没有影响，又容易造成理解代码时的困难，所以一般并不推荐使用。

Java提供了一种机制，可以在编译期间就把这样的操作封杀。具体的方法，是在循环变量类型前面加上一个“final”修饰符。这样一来，在循环体 里对循环变量进行赋值，就会导致一个编译错误。借助这一机制，就可以有效的杜绝有意或无意的进行“在循环体里修改循环变量”的操作了。

清单7：禁止重新赋值

int[] integers = {1， 2， 3， 4};

for (final int i : integers) {

i = i / 2; /* 编译时出错 */

}

注意，这只是禁止了对循环变量进行重新赋值。给循环变量的属性赋值，或者调用能让循环变量的内容变化的方法，是不被禁止的。

清单8：允许修改状态

Random[] randoms = new Random[]{new Random(1)， new Random(2)， new Random(3)};

for (final Random r : randoms) {

r.setSeed(4); /* 将所有Random对象设成使用相同的种子 */

System.out.println(r.nextLong()); /* 种子相同，第一个结果也相同 */

}

3. 类型相容问题

为了保证循环变量能在每次循环开始的时候，都被安全的赋值，J2SE 1.5对循环变量的类型有一定的限制。这些限制之下，循环变量的类型可以有这样一些选择：

循环变量的类型可以和要被遍历的对象中的元素的类型相同。例如，用int型的循环变量来遍历一个int[]型的数组，用Object型的循环变量来遍历一个Collection等。

清单9：使用和要被遍历的数组中的元素相同类型的循环变量

int[] integers = {1， 2， 3， 4};

for (int i : integers) {

System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */

}

清单10：使用和要被遍历的Collection中的元素相同类型的循环变量

Collection String strings = new ArrayList String();

strings.add(“A”);

strings.add(“B”);

strings.add(“C”);

strings.add(“D”);

for (String str : integers) {

System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */

}

循环变量的类型可以是要被遍历的对象中的元素的上级类型。例如，用int型的循环变量来遍历一个byte[]型的数组，用Object型的循环变量来遍历一个Collection String（全部元素都是String的Collection）等。

清单11：使用要被遍历的对象中的元素的上级类型的循环变量

String[] strings = {“A”， “B”， “C”， “D”};

Collection String list = java.util.Arrays.asList(strings);

for (Object str : list) {

System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */

}

循环变量的类型可以和要被遍历的对象中的元素的类型之间存在能自动转换的关系。J2SE 1.5中包含了“Autoboxing/Auto-Unboxing”的机制，允许编译器在必要的时候，自动在基本类型和它们的包裹类（Wrapper Classes）之间进行转换。因此，用Integer型的循环变量来遍历一个int[]型的数组，或者用byte型的循环变量来遍历一个 Collection Byte，也是可行的。

清单12：使用能和要被遍历的对象中的元素的类型自动转换的类型的循环变量

int[] integers = {1， 2， 3， 4};

for (Integer i : integers) {

System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */

}

注意，这里说的“元素的类型”，是由要被遍历的对象的决定的――如果它是一个Object[]型的数组，那么元素的类型就是Object，即使里面装的都是String对象也是如此。

可以限定元素类型的Collection

截至到J2SE 1.4为止，始终无法在Java程序里限定Collection中所能保存的对象的类型――它们全部被看成是最一般的Object对象。一直到J2SE 1.5中，引入了“泛型（Generics）”机制之后，这个问题才得到了解决。现在可以用Collection T来表示全部元素类型都是T的Collection。

for在java里怎么用

格式：

for (initialization;condition;increment)statement;

其中：

initialization是for循环的初始部分，它用来设置循环控制变量，并制初值；

condition是条件判断部分，由该条件判断的真假决定for循环合时推出；

increment是增量部分，每执行一次循环后，由增量部分决定循环控制的变化情况；

（这三部分必须用分号隔开）

statement称为for循环的循环体，它可以是一条语句也可以是一个语句块。

执行步骤：

首先执行初始化部分，然后执行条件判断部分，若条件为真，则执行for循环的statement语句，

当循环的statement语句执行完后执行增量部分，然后再执行条件判断部分，为真，则继续执行

循环，否则执行for循环后面的语句。

例：for (i=1;i=10;i++)sytem.out.println(i);

1.当初始化、条件判断、增量三部分为空时，就实现了一种无限循环：

for( ; ; )statement;

但实际中，这样的无限循环往往并不是真的让它无限执行下去，只要在statement中在合适的条件下执行

break语句就可以跳出循环体。

2.无循环体的for循环，此时不提供statement：

for(t=0;tsome_value;t++);

这种循环一般用来产生时间延迟。

3.JAVA语言不支持逗号运算符，但在循环初始化和增量两部分 允许采用逗号，这样也就可以使用由逗号

隔开多个表达式，从而在for循环中模拟了逗号运算符的功能，但注意，条件判断部分必须是一个值为 布尔

型的表达式：

int i；

string s；

for （i=0,s=”testing”;

(i10(s.length()=1);

i++,s=s.substring(1)

{

system.out.println(s)

}

4.JAVA的for循环允许在初始化部分零食说明局部循环变量：

for(int i =0;imy_array.length;i++)

system.out.println(” a [ ” + i + “]= “+my_array[i]);

用这种方法定义的零食循环变量的作用域只在for循环体内，换句话说，它们的作用域在for循环体、

初始化、条件测试和增量中有效，在定义他们的循环外使用的有相同名字的变量不会受这些临时的

循环变量的影响。

注意 ：JAVA语法只允许程序员在初始化部分要么定义多个由逗号隔开的表达式，要么定义具有相同

类型的由逗号隔开的多个变量，但不能混用。

int j=3;

fot (int =0, j=0;ij;i++,j–)

system.out.println(“k=”+i*j);

system.out.println(“j=”,j);

在for循环的初始化部分说明了 i 和 j 两个循环变量，并将他们的值设置为0，在循环外，使用了一个

与循环变量 j 相同的变量，但 for 循环对 j 的值没有影响，屏幕上输出的 j 值还是3.

java中for是什么意思

for是控制循环的关键字。

这样解释比较容易理解，看下面的伪代码

for every int named i in group (1~10) do

{

printf(“%d”, i);

}

翻译一下:

定义一个范围（group）1~10，然后其中逐个赋值给int i，然后执行括号里面的printf(“%d”, i);

再写正式代码

for(int i=1; i=10; i++) //i初始值是1，i的最大值是10 ，i每一次+1

{

printf(“%d”, i);

}

java中for的作用

Java中 for是控制循环的关键字

for(int i = 0; i 10; i++){

System.out.println(“这是个for循环：” + i);

}

关于java里的for和java里的否则是什么的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。