关于java数组的使用

关于java数组的使用

上一篇文章中我们学习了数组，数组的声明、创建、赋值、遍历数组、堆和栈的知识，本篇文章让我们了解以下数组的使用方法，和增强for循环的实例，反转数组等😀

可以结合之前学习过的for循环，可以更好的理解运用。

关于java的循环结构for循环

一、数组元素输出

首先我们先正常输出数组元素，也叫做循环遍历数组元素。

1、声明数组，给数组元素赋值。

2、使用for循环。

3、循环判断数组长度，array.length。

4、满足条件，迭代，再次执行循环。

public class test {
    public static void main(String[] args)
    {
        //数组元素遍历
        int[] arrays={1,2,3,4,5};

        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+"\t");
        }
    }
}

我们执行以下上述的代码，可以看到以下的运行结果。

1 2 3 4 5
    
进程结束.....

二、数组元素求和

1、声明数组，给数组元素赋值。

2、声明一个叫做总数的变量sum，初始化赋值为0。

3、使用for循环，具体的步骤在上一篇文章中有说明过，这里就不详细解释了关于java数组的声明和创建。

4、循环判断数组长度，array.length。

5、满足条件，迭代，再次执行循环。

public class test {
    public static void main(String[] args)
    {
        //数组元素遍历
        int[] arrays={1,2,3,4,5};
		int sum =0;
        for (int i = 0; i < arrays.length; i++) {
            sum+=arrays[i];
        }
        System.out.print(sum);
    }
}

我们执行以下上述的代码，可以看到以下的运行结果。

15

进程结束......

三、输出数组中最大值

1、声明数组，给数组元素赋值。

2、声明一个变量max，初始值为array[0]。

3、使用for循环。

4、使用if判断长度。

5、循环判断数组长度，array.length。

6、满足条件，迭代，再次执行循环。

public class test {
    public static void main(String[] args)
    {
        int[] arrays={1,2,3,4,5};//声明数组赋值
        
        int max=arrays[0];//声明最大值
        
        for (int i = 1; i < arrays.length; i++)//因为最大值初始化为[0],所以int i= 1
        {
            if (max<arrays[i])
            {
                max=arrays[i];
            }
        }
        System.out.println(max);
    }
}

我们来分解一下上面的代码😊

1、第一次进入循环，i = 1，i < 5，进入循环。

2、执行if语句，max=array[0]=1，1<array[1]，1<2，结果为true

3、执行if中的语句，max=array[1]=2。

4、迭代，i++=i+1=1+1=2，往下继续循环，知道最大值为止。

5、我们执行以下上述的代码，可以看到以下的运行结果。

5

进程结束......

四、反转数组

1、我们把上面说到的第一种情况，封装成方法🤔

public class test {
    public static void main(String[] args)
    {
        int[] arrays={1,2,3,4,5};
        
        printArrays(arrays);

    }
    
    //遍历元素方法
    public static void printArrays(int[] arrays)
    {
        for (int i = 0; i < arrays.length; i++) 
        {
            System.out.print(arrays[i]+"\t");
        }
    }
}

我们执行以下上述的代码，可以看到以下的运行结果。

1 2 3 4 5

进程结束......

2、我们再来写一个反转数组的方法，反转数组其实就是，数组元素倒序。

这个可能会比较难理解，可以通过代码断点编译跟踪看步骤，也可以自己去反复思考深入理解一下😀。

如果大家忘记了方法，可以回去看看之前的文章来回顾以下😊关于java方法的定义

public class test {
    public static void main(String[] args)
    {
        int[] arrays={1,2,3,4,5};
        
        //printArrays(arrays);
        int[] reverse=reverse(arrays);//声明反转数组变量，给方法传参，返回给变量。
        printArrays(reverse);//用遍历方法输出出来。

    }
    
    //遍历元素方法
    public static void printArrays(int[] arrays)
    {
        for (int i = 0; i < arrays.length; i++) 
        {
            System.out.print(arrays[i]+"\t");
        }
    }
    
    //反转数组方法
    public static int[] reverse(int[] arrays)
    {
        int[] result = new int[arrays.length]; //我们先创建一个数组，名字为结果。
        
        for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) 
        {
            result[j]=arrays[i];
        }
        
        return result;//最后返回这个结果
    }
}

看这个代码比较复杂，我们来进行以下拆解。

1、我们先创建一个数组，名字为结果，用于传参数后返回一个值。

2、使用for循环，我们为结果result也进行初始化，长度等于传入参数数组长度减少1。

• 我们上面传入的参数是arrays，长度为5。

• int[] result = new int[arrays.length];  //result:[0,0,0,0,0]  result是从0-4
  

• j = result.length -1 =4 i=0

• 所以 result[4] = arrays[0] =1

• 于是result变为了[0,0,0,0,1]

• for (int i = 0,j=result.length-1; i < arrays.length; i++,j--)  //result:[0,0,0,0,1] 
  

• 通过迭代，i ++ = 1 j – = 3

• result[3] = arrays[1] =2

• 于是result变为了[0,0,0,2,1]

3、以此类推，最后result变成[5,4,3,2,1]，返回给变量。

4、我们刚刚定义了遍历数组的方法，所以直接用遍历数组的方法来输出结果。

5 4 3 2 1

进程结束......

五、增强for循环

• 我们也可以用for each 方法（在前面文章中提到过）来输出数组，但是这个方法是没有下标的。

public class Demo 
{
    public static void main(String[] args)
    {
        int[] arrays={1,2,3,4,5};
        //JDK1.5 没有下标
        for (int array : arrays) 
        {
            System.out.print(array+"\t");
        }
    }
}

我们执行以下上述的代码，可以看到以下的运行结果。

1 2 3 4 5

进程结束......

以上就是数组的用法，大家要去深入一下，可能不是很好理解，要反复观看，反复跟断点去理解，养成一个Dubug的好习惯💪。