之前关于数组的知识点都已经讲的很通透了，还不清楚的小伙伴可以看一下我之前的文章，保证焕然一新的感觉。

这一篇，咱们由浅入深，来手把手做一做小练习，带大家更加深入的理解数组的应用。

话不多说，咱们开始吧！

案例一

01 需求

:car:创建一个数组，用来存储1~100之间的偶数。

02 分析

:cake:下面来剖析一下这个问题。

这是一个很简单的入门练习，主要也是为了巩固之前学的基础知识点。

入门小白快来学，一步一步教你怎么做，思路是什么样的，那么，走起~

（1）用什么存储

说到存东西，就很容易想到拿一个容器去存，就有了变量和数组两个工具，变量呢只能存一个，而数组可以存一堆。

具体用变量还是数组来存，要看具体情况。

这里的需求，明确提出用数组来存储，那么就不用大费周章了。

（2）创建数组

既然用数组来存储，那么就需要创建一个数组啦。

创建数组，用来存储的是什么？是数字（偶数），int整数类型肯定够了。

所以我们先创建一个整数类型的数组，这里将数组取名为array。

int[] array;

（3）给数组赋值（初始化）

创建好了数组，接下来要赋值（初始化）。

初始化方式有两种，静态初始化和动态初始化。

用什么初始化好呢？

别急，咱们来试一试。

①如果用静态初始化，那就是这样来写：

int[] array=new int[]{2,4,6,8......};

哎呀，用静态初始化，这花括号里面的数字，好像有好多哎。

这样也太麻烦了吧！不好。

②如果用动态初始化，那就是这样来写：

int[] array=new int[???];

这个中括号里面写啥呢？写的是数组的长度。

数组的长度是多少？本题说了，存储1~100之间的偶数，那么肯定是50个啦。

这就好确定了，数组长度为50。

于是，就动态初始化好了一个数组：

int[] array=new int[50];

（4）如何往数组里存值

我们知道，动态初始化创建的数组，有长度，没有元素（都是默认值）。

这个数组创建好了，50个小格子里边，都是默认值0，不是我们想要的。

我们想要的是1~100之间的偶数。

所以我们现在要将1~100之间的偶数存入数组内。

怎么存呢？

①一般思路

按照一般思路，往数组里边存值，就可以一个一个存呀，就像这样：

array[0]=2;
array[1]=4;
array[2]=6;
...
...

这样写，比刚才的静态初始化还麻烦呢。

静态初始化是直接将所有数都用大括号括起来的，比这个还简单呢。

这种方法存，不好。

②进阶思路

那么就要想一想了，怎么快速又简单的将这些数字存储进数组。

观察发现，刚才我们一个一个地存进数组，都是重复一件事情啊。

重复一件事？

对啊，用循环呗！循环就是帮我们每次做一样的事情呀。

每次做一样的事情，而且事情还有规律，那必须用 循环呀！

什么规律？

看一下索引号，从0-49；偶数，从2-50。

（5）写循环结构

通过刚才的分析，我们可以通过循环，来帮助咱们完成存储这个繁琐的工作。

循环结构咋写呢？

这里咱们用for循环来演示，其他循环也是可以的啦。

①for循环要执行多少次？

要存储1~100之间的偶数，自然是要执行50次啦。

==所以for循环要执行50次。==

②50次从何时开始数？

那，从什么时候数50次？都可以的。从1-50是50次，从100-150也是50次。只要是50次就好。

既然都可以，从什么时候开始数比较方便呢？

==从0开始数比较方便。==

为啥呢？因为从0开始数，刚好和索引号对的上。（看到这里有的小伙伴可能还是不明白，往下看）

索引号也是从0开始的，那我们这里从0开始数，刚好可以共用一个变量呀。

这样的话，循环里的变量不光可以计数（就是控制循环次数），还可以当索引号使用！

省去一个变量岂不乐哉。（省去一个索引号变量）

③写循环三要素

根据上面的分析，for循环的大致框架（三要素）就明白了。

下面来写吧：

for(int i=0;i<50;i++){
    
}

注意，三要素的第二个，循环条件可以写i<50，也可以写i<=49。

都是50次，只不过一个有等于号一个没有。自己觉得哪个比较好写哪个，我这里觉得小于号比较清爽。

再注意一点，循环条件我们写的是i<50，这个50，可以用另一种方式表达。

怎么写呢？

数组长度是50，这里的控制条件就是i<50。

那么就可以将控制条件的50用数组长度（array.length）表示。

array.length中的.可以理解为中文里面的的，即：数组的长度。

具体写法如下，记着就好：

for(int i=0;i<array.length;i++){ //同样，控制条件还可以写i<=array.length-1 （加了等于号就要减一个）
    
}

④写循环体

循环体里面就是要写需要做的事情啦。

做啥事情？

往数组里面存值呀。

如何存值？之前在学数组的时候讲过基本操作，用索引号遍历，然后存值就好了。

array[?]=值;

中括号里边就是索引号，索引号的变化和咱们刚才的循环变量i变化一致。

那么这里就直接写i就好了。（现在是不是理解刚才让循环从0开始了，目的就是为了和索引号变化一致，省去一个变量）

后边的值写什么呢？

找一找后边的值和索引号之间的规律。（要学会找规律）

array[0]=2; -->  0*2+2=0
array[1]=4; -->  1*2+2=4
array[2]=6; -->  2*2+2=6
...
array[i]=?; -->  i*2+2=?

根据分析，结果显而易见。

后边的值用索引号（i）表示，就是2*i+2。

好啦，整体分析下来，这个循环结构就写好了。

合在一块就是这样：

for(int i=0;i<array.length;i++){
    array[i]=2*i+2;
}

:rainbow: 如果一上来把这个代码给大家，很多入门的小伙伴都会稀里糊涂，不知道怎么来的。

刚开始学写代码，得弄明白具体的每一步，如何来的，这样遇到其他类似问题，就可以自己解决啦。

我们学的是思路，并不是这个题目怎么写，看起来是简单，但弄明白具体每一步，具体的思路，就是一件不容易的事情。

加油，一步一步来。

（6）输出结果

其实，截止到上面的代码。就已经根据题目意思，将1-100之间的偶数存进数组里了。

这里，为了验证一下，数组里面的数，究竟是不是我们想要存进去的，那可以输出一下数组里面的数。

这个步骤不是必须的，只是想验证一下。

以后可以直接用这个数组干其他事，不用验证。

这不是刚学，不放心，就验证一下结果啦，也可以看看，刚才的思路对不对，数组里面的值是不是想要存的。

这里就用到学数组的时候，咱们说的，数组元素的遍历。

我们使用简单的加强for来遍历数组元素。

不知道的戳这里，在数组元素遍历第三点说过，具体位置:

再回到这个题目，具体遍历代码，很简单：

for(int v:array){ //用变量v来接收数组内的元素，冒号后边是要遍历的数组
    System.out.println(v);
}

03 代码及执行

（1）代码

根据上面的分析，就可以得到这样的代码，整合一块并加上头尾：

public class Test1{
    public static void main(String[] args){
        //1.创建一个数组
        int[] array=new int[50];
        //2.将1-100之间的偶数存入数组内
        for(int i=0;i<array.length;i++){
            array[i]=2*i+2;
        }
        //3.输出验证看一看
        for(int v:array){
            System.out.println(v);
        }
    }
}

大家可以自己分析，然后写出来。

很简单的代码，重要的是思路，思路！！！

写的多了，思考的就很快，很快就可以写出来。刚开始不要着急。

（2）执行结果

这里我还是用dos窗口执行代码。

太长了，你们自己去执行一下，这里放部分结果。

04 总结

最后总结一下。

本题，用到的知识点。

（1）创建一个数组

我们这个题，用动态初始化创建了一个数组。

具体用什么初始化呢？

• 如果元素个数比较少，用静态初始化。
• 如果元素个数很多而且有规律，用动态初始化，可以通过循环往数组里边放元素。
• 如果元素个数很多又没有规律，用静态初始化，因为没办法循环往数组里边放入元素。

一般，使用 动态初始化较多，因为比较灵活，可以通过循环的方法来往数组里面放值。

（2）用了两个循环

一个只为存值，另一个只为了输出看一看。

一个循环50次，两个循环就是100次。

可以不可以用一个循环搞定呢？

能不能一边放一边输出呢？就像这样：

public class Test1{
    public static void main(String[] args){
        //1.创建一个数组
        int[] array=new int[50];
        //2.将1-100之间的偶数存入数组内
        for(int i=0;i<array.length;i++){
            array[i]=2*i+2;
            System.out.println(array[i]);
        }
    }
}

可以一边存一边输出。

但是，如果放的值是正确的，这样写可以。

但如果，存放值的时候操作失误。

目前输出的值是对的，下一次再看就不对了。（存放时直接看结果可能由于存放操作失误，看时正确，之后就发生变化）

况且，存放的值不一定要拿出来看一看。

存放是一件事情，查看是另一件。以后可以只存不放出来看。

不用担心多了50次循环，因为这个循环只是暂时我们查看逻辑对不对的，用来检验一下的，以后是可以不写的。

一个循环尽量做一件事更好。

我们不光写代码，还要看哪个更加合理。

案例二

01 需求

:car:创建一个数组，用来存储1~100之间的奇数。

02 分析

:cake:下面来剖析一下这个问题。

很简单，和第一个案例类似，这里就不过多阐述了。多说显得冗余。

（1）创建数组并初始化

明显，用动态初始化创建数组。

数组里边存放int整数类型，就创建int[]类型的数组。

给数组取个名字，叫array2。

数组里面存放1-100之间奇数，有50个，那么数组长度就是50。

具体写法：

int[] array2=new int[50];

（2）用循环存值

这里就不再具体分析为啥用循环啦。

因为是动态初始化创建的数组，咱们要往数组里面存值，就要找到规律，用循环存。

<1> 三要素

for循环三要素：

①我们将循环变量i从0开始数，为了与索引变化一致，省去一个变量。（不懂的看上一个案例，很详细）

②循环经历50次，也就是数50次，50是数组长度（array.length）。

③一次循环之后变量加一（i++）。

for(int i=0;i<array2.length;i++){
    
}

<2> 循环体

for循环体：

往数组内存值。（索引变化和循环变量变化一致，都用i表示即可）

array2[i]=?;

怎么存，找规律。

array2[0]=1; -->  0*2+1=0
array2[1]=3; -->  1*2+1=3
array2[2]=5; -->  2*2+1=5
...
array2[i]=?; -->  i*2+1=?

很明显了。

循环体就是这样：

array2[i]=i*2+1;

< 3> 整合

整体的for循环就是这样：

for(int i=0;i<array2.length;i++){
    array2[i]=i*2+1;
}

（3）输出

来看看逻辑对不对，输出数组中的值看一看。

for(int v2:array2){ //用变量v2来接收数组内的元素，冒号后边是要遍历的数组array2
    System.out.println(v2);
}

03 代码及执行

（1）代码

加上头尾，整体代码如下：

public class Test2{
    public static void main(String[] args){
        //1.创建一个数组
        int[] array2=new int[50];
        //2.将1-100之间的奇数存入数组内
        for(int i=0;i<array2.length;i++){
            array2[i]=i*2+1;
        }
        //3.输出验证看一看
        for(int v2:array2){ //用变量v2来接收数组内的元素，冒号后边是要遍历的数组array2
            System.out.println(v2);
        }
    }
}

（2）执行结果

这里放出部分结果。