又是一个月过去了，学习 java 的进程在缓慢的进行。这一次学习了数组，里面的算法对初学者来说还是有点难度，所以我足足学了两遍，敲了两遍代码。
数组是同一种类型数据的集合。可以将它比作一个容器，当要操作的数据比较多的时候，可以先将期存入到数组中。好处是可以对这些数据进行编号。方便操作。容器是程序语言中非常重要的概念。计算机语言无非是为了操作数据。数据多了就需要存储。那么容器就成了最常用的要素。
数组常用的是一维数组和二维数组。还有三维四维，据说爱因斯坦才能四维，五维，咳咳~~。


我们写个简单的一维数组的例子：
先初始化：

int[] arr=new int[5];

再输出：

System.out.println(arr[0]);

这里是初始化一个最多为五个数的数组，可以输出的是 arr[0~4].
再分析下一维数组的内存。JVM 虚拟机的内存主要有四个区，栈区，堆区，静态区，代码区。主要是栈区和堆区。
栈区存放函数的参数值，局部变量的值等，在超过这个变量的作用域时就会被系统自动释放掉存在于 JVM 内存中的资源。
优点：存取速度比堆快
缺点：栈中的数据大小与生存周期是确定的，无灵活性。
堆区是存放由 new 创建的对象和数组，JVM 不定时的查看这个对象，如果没有引用指向这个对象就回收。
优点：可以动态分配 JVM 内存
缺点：要在运行时分配 JVM 内存，速度慢

以上说明了存放的位置，像 int[] arr=new int[5],其中 int[] arr 存放在栈区，new int[5] 存放在堆区。
接着是数组的算法，这个对于初学者来说有些难以理解，要多练习。
首先是数组的 length 属性，可以获取数组的长度，这个非常常用。还有一个就是给数组从小大排序：Arrays.sort(数组名)。

算法一：求最大值.思路是假设第一个是最大值，然后第一个跟第二个对比，要是第一个小于第二个，那么最大值就等于第二个。然后第二个再跟第三个第四个第五个第 i 个比。直到必出最大的，然后挑出来。

public class Max{
          public static void main(String[] args){
              Scanner in=new Scanner(System.in);
              int[] arr=new int[5];
              for(int i=0;i<arr.length;i++){
              System.out.println(“请输入第”+(i+1)+"个学生的成绩");
              arr[i]=in.nextInt();
}
             int max=arr[0];
             for(int i=0;i<arr.length;i++){
             if(max<arr[i]){
             max=arr[i];
}

}
System.out.println("");
}
}

算法二：数组复制。不能直接 arrB=arrA，而是要在 for 循环下=。

public class Copy{
          public static void main(String[] args){
              int[] arrA={1,2,3,4,5,6,7,8};
              int arrB=new int[arrA.length];
              for(int i=0;i<arr.length;i++){
                  arrB[i]=arrA[i];
}
              for(int i=0;i<arrA.length;i++){
                 System.out.println(arrB[i]);
}
}

算法三：数组查找。在数组中查找，主要是循环查找是否equals。

```java
public class Find{
          public static void main(String[] args){
              Scanner in=new Scanner(System.in);
              System.out.println("请输入你要找的学生的姓名：");
              String name=in.next();
              String[] arr={"张三","李四","王五"};
              boolean flag=false;
             for(int i=0;i<arr.length;i++){
               if(name.equals(arr[i])){
                  flag=true;
                    break;
}
}
               if(flag==true){
                       System.out.println("找到了");

}else{
                     System.out.println("查无此人");
}
}

算法四：数组插入。将一个值插入到 arr.length-1 的位置上去。因为数组是从 0 开始的。

public class Insert{
          public static void main(String[] args){
              Scanner in=new Scanner(System.in);
              int[] arr={23,44,56,33,53,77};
              System.out.println("请输入你要插入的值：");
              int num=in.next();
             arr[arr.length-1]=num;
             for(int i=0;i<arr.length;i++){
             System.out.println(arr[i]);
}
}

算法五：冒泡排序。用的是嵌套循环的方法，第 1 个数和第 2 个对比，第 1 个数要是比第 2 个大，那么它们进行替换。接着再对比第 2 个数第 3 个数，一直到第一轮比完，外嵌套循环比完一次，接着内嵌套循环比第二次，从第 2 个数开始往后对比。一直到外嵌套循环也比完，再进行输出。

public class maopao{
          public static void main(String[] args){
              int[] arr={23,44,56,33,53,77};
            for(int i=0;i<arr.length-1;i++){  
             for(int j=0;j<arr.length-1;j++){
                 if(arr[j]>arr[j+1]){
                    int t=arr[j];
                    arr[j]=arr[j+1];
                   arr[j+1]=t;
}
}
}
             for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
}
}
}

算法六：选择排序。冒泡排序是一次一次的比，选择排序是比完一个，就把第一轮比完的最大数挑出来，放在一旁，再进行第二轮对比。比一轮就少一个数。所以选择排序比冒泡排序效率更高。

public class xuanze{
          public static void main(String[] args){
              int[] arr={23,44,56,33,53,77};
            for(int i=0;i<arr.length-1;i++){  
             for(int j=i+1;j<arr.length;j++){
                 if(arr[j]>arr[j+1]){
                    int t=arr[j];
                    arr[i]=arr[j];
                   arr[j]=t;
}
}
}
             for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]); 
}
}
}

算法总算完了，接着是二维数组。



最后，for 循环结合数组的增强型 for 循环，在自动化常常会用到。。