讲解Java基础知识:如何学好for循环嵌套
来源:凤凰网河北
随着近期招聘市场上Java岗位的异常火爆，更多的准从业者为了能够成功就业，选择了与Java相关的培训或自学。而在学习中不免碰到一些疑难...... 随着近期招聘市场上Java岗位的异常火爆，更多的准从业者为了能够成功就业，选择了与Java相关的培训或自学。而在学习中不免碰到一些疑难问题，比如for循环的嵌套，如果搞不懂，很可能会影响到后面的学习。对此，传智播客济南校区特意针对这个知识点做了详细的解答，便于初学者或自学者掌握。　　下面，我们就开始对for循环嵌套进行详细的解答：　　首先，我们发现使用for循环可以方便的遍历一维数组中的元素。因为一维数组只有一个索引是变化的，我们用变量i表示索引，让它从0-3 变化，就得到了数组的所有元素。　　那么我们如何遍历二维数组呢?按照传智播客教学的传统思路我们先来分析一下。我们发现二维数组的大括号内还有一层大括号，这说明数组中还有数组。也就是说二维数组中的元素是一维数组。　　当我们根据一维数组的逻辑去输出二维数组arr的0号元素的时候：我们发现arr[0] 输出的结果是一个地址值。我们按照一维数组遍历方式看看：不出所料，里面存的是两个地址值。这也证明了二维数组中的元素其实是一维数组。我们通过一个变量i是无法既表示二维数组的索引，又表示一维数组的索引的。　　因此我们还需要一个变量，也就还需要再引入for循环的嵌套。先得到里面的一维数组再遍历这个一维数组得到里面的整数。我们按照思路用了i 和j 两个变量表示二维和一维的两个索引，但是! 7 去哪了??为什么结果只输出了1 2 3 4 5 6 ?　　在传智播客上课时老师经常会跟学员说遇到bug不要慌。这里，请注意看图片中黄色的地方。我们j 的取值范围是0 到arr[0].leagth 那么arr[0].length等于几?它表示的是二维数组中0索引元素的长度，也就是第一个数组的长度，也就是{1,2,3}这个数组的长度，它的长度是3。但是我们发现第二个数组比第一个一维数组长，那么我们遍历第二个数组的时候就不能还按照长度3去遍历了。也就是说这个范围应该是变化的。好，我们来改一下：只需要轻轻一改我们就完美的打印出了所有的整数元素。大功告成!这里我们需要注意的就是内层循环和外出循环到底是管的什么。　　案例驱动，多敲多练是传智播客推荐的学习方法。下面有两段代码，自学或初学者可以看代码思考输出结果，先自己分析，然后运行验证一下，看看是不是如你所想。　　1 ：java程序开发之数组解析
数组的概述
* A: 数组的概述
* a:数组的需求
现在需要统计某公司员工的工资情况，例如计算平均工资、最高工资等。假设该公司有50名员工，用前面所学的知识完成，
那么程序首先需要声明50个变量来分别记住每位员工的工资，这样做会显得很麻烦.
* b:数组的概述
数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。
06数组的定义
* A：数组的定义
数据类型[] 数组名 = new 数据类型[元素个数或数组长度];
int[] x = new int[100];
* c:要点说明
1)数据类型: 数组中存储元素的数据类型
2) [] 表示数组的意思
3) 变量名 自定义标识符
4) new 创建容器关键字
5)数据类型: 数组中存储元素的数据类型
6)[] 表示数组的意思
7)元素个数,就是数组中,可以存储多少个数据 (恒定, 定长)
数组是一个容器: 存储到数组中的每个元素,都有自己的自动编号
自动编号,最小值是0, 最大值,长度-1
自动编号专业名次, 索引(index), 下标, 角标
访问数组存储的元素,必须依赖于索引, 公式 数组名[索引]
提供一个属性,操作索引的
数组的一个属性,就是数组的长度, 属性的名字 length
使用属性: 数组名.length 数据类型 int
数组的最小索引是0, 最大索引数组.length-1
08数组的内存
* A: 数组的内存
* int[] // 声明一个int[]类型的变量
* x = new int[100]; // 创建一个长度为100的数组
* 接下来，通过两张内存图来详细地说明数组在创建过程中内存的分配情况。
* 第一行代码 int[] 声明了一个变量x，该变量的类型为int[]，即一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值
* 第二行代码 x = new int[100]; 创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x来引用数组，这时内存中的状态会发生变化
09使用索引访问数组的元素
* A: 使用索引访问数组的元素
* 组中有100个元素，初始值都为0。数组中的每个元素都有一个索引(也可称为角标)，要想访问数组中的元素可以通过&x[0]、x[1]、&&、x[98]、x[99]&的形式。
* 需要注意的是，数组中最小的索引是0，最大的索引是&数组的长度-1&
10数组的length属性
* A: lenth属性
* a 在Java中，为了方便我们获得数组的长度，提供了一个length属性，在程序中可以通过&数组名.length&的方式来获得数组的长度，即元素的个数。
* b 求数组的长度
public class ArrayDemo01 {
public static void main(String[] args) {
int[] // 声明变量
arr = new int[3]; // 创建数组对象
System.out.println(&arr[0]=& + arr[0]); // 访问数组中的第一个元素
System.out.println(&arr[1]=& + arr[1]); // 访问数组中的第二个元素
System.out.println(&arr[2]=& + arr[2]); // 访问数组中的第三个元素
System.out.println(&数组的长度是：& + arr.length); // 打印数组长度
11为数组的元素赋值
* A: 为数组的元素赋值
* a: 如果在使用数组时，不想使用这些默认初始值，也可以显式地为这些元素赋值。
* 赋值过的元素已经变为新的数值,没有赋值的元素默认初始化的数值
public class ArrayDemo02 {
public static void main(String[] args) {
int[] arr = new int[4]; // 定义可以存储4个整数的数组
arr[0] = 1; // 为第1个元素赋值1
arr[1] = 2; // 为第2个元素赋值2
// 下面的代码是打印数组中每个元素的值
System.out.println(&arr[0]=& + arr[0]);
System.out.println(&arr[1]=& + arr[1]);
System.out.println(&arr[2]=& + arr[2]);
System.out.println(&arr[3]=& + arr[3]);
数组的定义_2
* A: 定义数组格式2
* a: 数组初始化
动态初始化 : 在定义数组时只指定数组的长度，由自动为元素赋初值的方式称作动态初始化。
1、类型[] 数组名 = new 类型[长度];
int[] arr = new int[4];
静态初始化: 在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。
2、类型[] 数组名 = new 类型[]{元素，元素，&&};
int[] arr = new int[]{1,2,3,4};
3、类型[] 数组名 = {元素，元素，元素，&&};
int[] arr = { 1, 2, 3, 4 };
13遍历数组
* A:遍历数组
* 在操作数组时，经常需要依次访问数组中的每个元素，这种操作称作数组的遍历
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
// 使用for循环遍历数组的元素
for (int i = 0; i & arr. i++) {
System.out.println(arr[i]); // 通过索引访问元素
上述代码中，定义一个长度为5的数组arr，数组的角标为0~4。由于for循环中定义的变量i的值在循环过程中为0~4，因此可以作为索引，依次去访问数组中的元素，并将元素的值打印出来
14数组中常见的异常
* A: 数组操作中,常见的两个异常
数组的索引越界异常
空指针异常
public class ArrayDemo_4{
public static void main(String[] args){
//数组的索引越界异常
//int[] arr = {5,2,1};
//数组中3个元素,索引 0,1,2
//System.out.println(arr[3]);//java.lang.ArrayIndexOutOfBoundsException: 3
//空指针异常
int[] arr2 = {1,5,8};
System.out.println(arr2[2]);
arr2 = // arr2 不在保存数组的地址了
System.out.println(arr2[2]);//java.lang.NullPointerException
15数组最值
* A: 数组获取最值的原理思想
* 定义数组的第一个元素arr[0]为最大值;循环arr数组,判断如果有比arr[0] 大的就交换,直到arr数组遍历完毕,那么arr[0]中就保存了最大的元素
16数组获取最值代码实现
* A: 代码实现
public class ArrayDemo05 {
public static void main(String[] args) {
int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定义一个数组
int max = arr[0]; // 定义变量max用于记住最大数，首先假设第一个元素为最大值
// 下面通过一个for循环遍历数组中的元素
for (int x = 1; x & arr. x++) {
if (arr[x] & max) { // 比较 arr[x]的值是否大于max
max = arr[x]; // 条件成立，将arr[x]的值赋给max
System.out.println(&max=& + max); // 打印最大值
17二维数组的定义
* A 二维数组的作用
* 要统计一个学校各个班级学生的考试成绩，又该如何实现呢？
* 这时就需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组。
* B 定义格式
* a 第一种定义格式:
* int[][] arr = new int[3][4];
* 上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组
* b 第二种定义格式
* int[][] arr = new int[3][];
* 第二种方式和第一种类似，只是数组中每个元素的长度不确定
* c 第三种定义格式
* int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
* 二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}
18二维数组元素的访问
* A: 二维数组的访问
class ArrayDemo08 {
public static void main(String[] args){
//定义二维数组的方式
int[][] arr = new int[3][4];
System.out.println( arr );
System.out.println(&二维数组的长度: & + arr.length);
//获取二维数组的3个元素
System.out.println( arr[0] );
System.out.println( arr[1] );
System.out.println( arr[2] );
System.out.println(&打印第一个一维数组的元素值&);
System.out.println( arr[0][0] );
System.out.println( arr[0][1] );//访问的为二维数组中第1个一维数组的第2个元素
System.out.println( arr[0][2] );
System.out.println( arr[0][3] );
System.out.println(&打印第二个一维数组的元素值&);
System.out.println( arr[1][0] );
System.out.println( arr[1][1] );
System.out.println( arr[1][2] );
System.out.println( arr[1][3] );
System.out.println(&打印第三个一维数组的元素值&);
System.out.println( arr[2][0] );
System.out.println( arr[2][1] );
System.out.println( arr[2][2] );
System.out.println( arr[2][3] );
19二维数组内存图
* A: 二维数组内存图
* 举例:int[][] arr = new int[3][2];
* 外层数组长在内存开辟连续的3个大的内存空间,每一个内存空间都对应的有地址值
* 每一个大内存空间里又开辟连续的两个小的内存空间.
20二维数组的定义和访问
* A: 二维数组的定义和访问
* int[][] arr = new int[3][]; 不推荐
* int[][] arr = {{1,2,4},{4,7},{0,9,3}};
* B: 二维数组的访问
举例:int[][] arr = {{1,2,4},{5,8,7},{0,9,3}};
想要打印数组中7这个元素需要先找到大的元素索引{5,7} 索引为2 ,在找7在{5,7}中的索引2
那么结果为 arr[2][2] 第一个[2]代表大数组中{5,8,7}这个元素索引
第二个[2]代表{5,8,7}中7元素的索引
二维数组的遍历
* A:二维数组遍历
int[][] arr = {{1,2,4},{4,7},{0,9,3}};
先使用for循环遍历arr这个二维数组,得到每一个元素为arr[i]为一维数组
再外层for循环中嵌套一个for循环遍历每一个一维数组arr[i],得到每一元素
* B:举例:遍历二维数组
public class ArrayArrayDemo_2{
public static void main(String[] args){
int[][] arr = { {1,2,3},{4,5},{6,7,8,9},{0} };
//外循环,遍历二维数组
for(int i = 0 ; i & arr.i++){
//内循环,遍历每个一维数组 arr[0] arr[1] arr[i]
for(int j = 0 ; j & arr[i]. j++){
System.out.print(arr[i][j]);
System.out.println();
* C:二维数组累加求和
class ArrayDemo09 {
public static void main(String[] args){
int[][] arr2 = { {1,2},{3,4,5},{6,7,8,9,10} };
int sum2 = 0;
for (int i=0; i for (int j=0; j //System.out.println(arr2[i][j])
sum2 += arr2[i][j];
System.out.println(&sum2= &+ sum2);I am trying to create an array of arrays of arrays etc..., except I don't know how many nested levels deep it needs to be until runtime.
Depending on the input, I might need either int[], int[][], int[][][][][][], or anything else. (For context, I am trying to construct an N-dimensional grid for a cellular automaton, where N is passed as a parameter.)
I don't have any code for you because I have no idea
I suspect is not possible at all using just arrays. Any help, or alternative solutions, would be appreciated.
解决方案 You could do this with an Object[], limiting its members to either Object[] or int[].
For example, here's an array that goes three levels deep in one part, and two levels deep in another:
Object[] myarray = new Object[] {
new Object[] { new int[] { 1, 2 },
new int[] { 3, 4 }},
new int[] { 5, 6 }
After you've created it, you may want to access members. In your case, you know the depth N up front, so you know at what depth to expect an Object[] and at what depth to expect an int[].
However, if you didn't know the depth, you could use reflection to determine whether a member is another Object[] level or a leaf int[].
if ( myarray[0] instanceof Object[] ) {
System.out.println("This should print true.");
Here's a sketch [untested so far, sorry] of a method that access a member of an array of known depth, given an array of indices. The m_root member can be an Object[] or an int[]. (You could relax this further to support scalars.)
public class Grid {
private int m_
private Object m_
public int get( int ... indices ) {
assert( indices.length == m_depth );
Object level = m_
for ( int i = 0; i + 1 & m_ ++i ) {
level = ((Object[]) level)[ indices[i] ];
int[] row = (int[])
return row[ indices[m_depth - 1] ];
本文地址： &
我想创建数组等数组的数组...，但我不知道深，它需要多少嵌套级别要到运行时。根据输入，我可能需要为 INT [] ， INT [] [] ， INT [] [] [] [] [] [] ，或其他任何东西。 （对于背景下，我想构造一个 N维网作为一个细胞自动机，其中N是作为参数传递。）我没有任何code你，因为我不知道如何去这一点;我怀疑是根本不可能只使用数组。任何帮助，或者替代性解决方案，将AP preciated。解决方案 您可以用一个Object []做到这一点，限制其成员任一对象[]或INT []。例如，下面是在另一个深藏在三个级别中的一部分，以及两个深层次的数组： 对象[] myArray的=新的对象[] {
新的对象[] {新INT [] {1，2}，
新的INT [] {3,4}}，
新的INT [] {5,6}
}; 您已经创建了它之后，你可能会想访问的成员。在你的情况，你知道精度N前面，所以你知道在什么深度，期待一个Object []和在什么深度，期待一个int []。不过，如果你不知道深浅，你可以使用的反射的确定成员是否是另一个对象[]级别或叶INT []。 如果（myArray的[0] INSTANCEOF对象[]）{
的System.out.println（“这应该打印正确的。”）;
编辑： 下面是一个草图[未经考验到目前为止，对不起]访问已知深度的数组成员的方法，给定指数的数组。该m_root成员可以是一个Object []或int []。 （你可以进一步放宽此支持标量）。 公共类网{
私人诠释m_
私有对象m_
公众诠释的get（INT ...指数）{
断言（indices.length == m_depth）;
对象级= m_
对（INT I = 0; i + 1的＆下; m_depth ++ⅰ）{
级=（（对象[]）电平）[指数[Ⅰ]];
INT []行=（INT []）的水平;
返回行[指数[m_depth
本文地址： &
扫一扫关注IT屋
微信公众号搜索 “ IT屋 ” ，选择关注
与百万开发者在一起
(window.slotbydup = window.slotbydup || []).push({
id: '5828425',
container: s,
size: '300,250',
display: 'inlay-fix'
Oracle Database12c性能优化攻略/
5G移动缓存与大数据:5G移动缓存、通信与计算的融java 嵌套循环的问题_百度知道
java 嵌套循环的问题
java 嵌套循环的问题这个图片红圈的逻辑是什么
我理解的是两个循环结果是一样的 但是实际循环不是这样 我理解不到 老司机教育我一下
我有更好的答案
chs是随机生成的字符数组，input是你输入的，这个循环的作用是判断两个字符串中有几个字母是相同的，相同的字母在第几位，两个for循环的，并不是同一个数组看不明白可以debug看一下运行过程
我的意思是介绍一下第二次判断相等的过程
采纳率：59%
来自团队：
有句话这样讲：尽信书不如无书；代码不管是从什么地方来的，但是计算机科学是客观的，在同一组循环里，两个if()语句的判断条件一样，肯定结果也是一样的，这个不用怀疑什么。大胆的给你老师指出来就行了，说不定是给你们的考验。还有一种情况就是，代码写错了，我看注释。我看注释，如果判断位置，就直接判断 if(i==j),你图片的两个都是判断字符是否相同的。如果改为if(input[i]==chs[j]){result[1]++;if(i=j){result[0]++;}}返回的参数：第一个数值为比较的两个字符数组 位置相同，字符相同的个数 ,第二个为两个数组字符重复的个数满意，请采纳！
双层循环嵌套双层if 没看懂要干嘛，内层if不多余嘛
做两个char数组字符位置相同判断和对比字符是否有相同字母判断
字符位置相同和相同字母？。。。不是一个意思嘛？就是两个数组相同下标的元素内容相同
char1[i]==char2[i]本身就是下标和内容都相同
里面循环层下标会变啊
上面判断字母相同我明白 但是第二个是判断相同字母和相同位置对等 代码写的却和判断第一个一模一模我就不明白了
你给他去掉试试，感觉多余
两个if都在每层循环啊，下标一样的啊
试过了对的 这是老师的案例
我发下源代码
为您推荐：
其他类似问题
您可能关注的内容
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。JavaSE基础：数组JavaSE基础：数组一个java码农百家号数组与方法数组按照使用可以分为一维数组/二维数组/多维数组.1.数组的概述数组是相同数据类型的有序集合数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成.其中,每个数据称作一个数组的元素,每个数组元素可以通过一个索引(或者下标)来访问它们.数组的三个特点:数组的长度是确定的. 数组当被创建时,它的大小就是不可以改变的.数组元素必须是相同类型,不允许出现混合类型数组中的元素可以是任何数据类型,包括基本数据类型和引用数据类型2.一维数组(1) 声明方式方式一.方式二.简写方式.(2) 数组中元素的表示方法数组的声明以及简单输出.对于数组的访问采用"数组名称[索引或者下标]"的方式,索引从0开始计数,假设程序中取出的内容超过了这个下标范围,例如:score[3]程序运行会存在以下的异常错误提示信息:.提示的内容为数组索引超出绑定的异常(经常说的数组越界异常),这个是未来你们初学者经常出现的问题,请引起重视.此外,我们发现以上的程序运行的结果的内容都是"0",这是因为声明的数组是整型数组.默认初始化数据:数组元素相当于对象的成员变量,默认值跟成员的规则是一样的,重点记忆!系统将按照如下规则分配初识值:数组元素的类型是基本类型中的整数类型(byte,short,int和long),则数组元素的值为0数组元素的类型是基本类型中的浮点类型(float,double),则数组元素的值为0.0数组元素的类型是基本类型中的字符类型(char),则数组元素的值为'\u0000'(空格)数组元素的类型是基本类型中的布尔类型(boolean),则数组元素的值为false数组元素的类型是引用数据类型(类,接口和数组),则数组元素的值为null为数组中的元素赋值并进行输出声明整型数组,长度为5,通过for循环赋值1,3,5,7,9的数据.数组长度的取得..(3) 数组的初始化方式动态初始化之前练习的就是使用的动态初始化方式.静态初始化..(4) 课堂练习已知一个字符数组char[] letterArray = new char[26],请动态初始化数据为A~Z.请求数组中最大和最小值.对整数数组按照由小到大的顺序进行排序.(5) 数组的问题数组一定要初始化吗?在之前我们说在使用Java数组之前必须要先初始化数组(即在使用数组之前,必须先创建数组).实际上,如果真正掌握了Java数组中的分配机制,那么可以完全换一个方式来初始化数组.始终记住:Java的数组变量只是引用类型的变量,它并不是数组对象本身,只是让数组变量指向有效的数组对象,程序中即可使用该数组变量.既然数组内容可以进行引用传递,那么就可以把数组作为方法中的参数,而如果一个方法想接收参数,则对应的参数类型必须是数组使用方法接收数组.使用方法修改数组的内容.3.二维数组之前定义的数组只有一个"[]",表示一维数组,如果有两个"[]"就是二维数组,其实本质上不存在多维数组的概念,其实就是一维数组中有嵌套了数组而已一维数组表格表示索引12345数据102030405060二维数组表格表示int[3][6]索引1234534567811020305040602111222333444555666二维数组的定义动态初始化数据类型[][] 数组名 = new 数据类型[行数][列数];静态初始化数据类型[][] 数组名 = new 数据类型[[]{{值1,值2},{值1,值2,值3...},{值1...}};遍历二维数组.4.Java新特性对数组的支持(1) 可变参数在调用一个方式,必须根据方法的定义传递指定的参数,但是在JDK1.5之后产生了新的概念--可变参数(即方法中可以接收的参数不再是固定的,而是随着需要传递的)a.可变参数的定义格式.方法中传递可变参数之后, 实际上参数是以 数组 的形式保存下来的,关键点b.使用可变参数定义的方法.代码分析:通过main方法里的调用，可以看出来这个可变参数既可以是没有参数（空参数），也可以是不定长的。看到这里估计都能明白，这个不定长的参数其实和数组参数挺像的。事实上，也确实是这么回事儿。编译器会在悄悄地把这最后一个形参转化为一个数组形参，并在编译出的class文件里作上一个记号，表明这是个实参个数可变的方法。请看代码：.c.发现问题问题1:看看是不是这个可变参数就是数组类参数？.问题2:可变参数能否接收数组呢?.错误的示例代码.代码分析:通过这两端代码可以看出来,[重点知识]可变参数是兼容数组类参数的，但是数组类参数却无法兼容可变参数!问题3:可变参数可以放置在形参中的任意位置吗?.代码分析:可变参数类型必须作为参数列表的最后一项，而不能放在定长参数的前面。问题4:重载方法的优先级问题?.代码分析:控制台的数据结果为: 22222这里需要记住：能匹配定长的方法，那么优先匹配该方法。含有不定参数的那个重载方法是最后被选中的。留在最后的一句话: main方法的参数就是一个数组类型的，那么它其实也是可以改成不定参数类型d.可变参数的总结只能出现在参数列表的最后；... 位于变量类型和变量名之间，前后有无空格都可以;调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。如果一个是两个方法是重载，一个是可变参数，一个是固定参数，然后我们调用方法如果故常长度的能满足，那么有优先调用固定长度的，###(2) foreach输出数组的输出一遍都会使用for循环,但是在JDK1.5后为了方便数组的输出,提供了foreach的语法,格式如下.简单示例代码.扩展说明:可以反编译class文件,我们会看到增强(加强)for循环的语法结构为:.本文由百家号作者上传并发布，百家号仅提供信息发布平台。文章仅代表作者个人观点，不代表百度立场。未经作者许可，不得转载。一个java码农百家号最近更新：简介:方便大家学习交流java作者最新文章相关文章}