java04循环结构，数组

1. 数组
   JAVA中，程序 = 算法 + 数据结构；
   前面学习的if、if-else、switch、循环解决的都是流程问题，即算法问题。
   所谓数据结构，简单说就是把数据按照特定的某种结构来保存，设计合理的数据结构是解决问题的前提。数组就是最基本的一种数据结构。

1.1什么是数组
数组是多个相同类型数据的组合，实现对这些数据的统一管理

1.2数组的定义
数组的声明
1. 数据类型[] 数组名 = new 数据类型[length];
a) int[] ary = new int[3];
2. 数据类型 数组名[] = new 数据类型[length]
int ary[] = new int[3];

数组的初始化
   int[] ary = new int[3];

   程序在执行时，会先对数组的元素进行默认初始化

默认初始化：对数组的元素进行赋值。

Java中的数据类型：
   基本数据类型 – 8种
   引用数据类型
数组元素的类型是int:0

默认初始值是多少取决于元素的类型：
如果是整数数值型：0
如果是浮点类型：0.0
boolean ：false
char:\u0000

引用类型：null

初始化：
i. int[] ary = {1,2,3,4};

数组的访问
    访问长度:
        int[] ary = new int[2];
        int[] ary = {1,2,3};
    访问元素：
        数组的线性特性 – 有序：

所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素（“一个跟一个”）
可以通过元素所在位置的顺序号（下标）做标识来访问每一个元素（下标从0开始，最大到元素个数-1）
遍历数组：
案例：
1. 遍历数组元素，正序输出
int[] ary = {12,323,5,3,5,7,67,8,765};
//对数组的遍历 - 正序输出
for(int i=0;i

public class GetMaxElementDemo {
public static void main(String[] args) {
     int[] ary = new int[10];
     //对数组的每个元素赋值
     for(int i=0;i<ary.length;i++){
         ary[i] = (int)(Math.random()*100);
     }
     //数组的内容输出
     for(int i=0;i<ary.length;i++){
         System.out.print(ary[i]+" ");
     }

     //去数组中的最大值
     int max = ary[0];
     for(int i=1;i<ary.length;i++){
         //比较
         max = max<ary[i]?ary[i]:max;
     }
     System.out.println("最大值是："+max);
}

}

1.3 数组的复制

    要求：有2个int数组
         int[] ary1 = {1,2,3};
         int[] ary2 = new int[5];
         现要求ary1中1-2下标的元素复制到ary2的0-1位置，如何实现？



    1.System.arrayCopy

-arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Src: 源数组
SrcPos:从源数组的此下标开始复制
Dest:目标数组
destPos：目标数组的下标，将内容从此位置开始复制
length:从源数组指定下标开始复制长度为n个元素

   思考：
     length的值偏小或偏大

public class ArrayCopyDemo {
public static void main(String[] args) {
int[] ary1 = {1212,3,45,5,654};
int[] ary2 = new int[10];

// //要求将数组1中的内容复制到数组2从2下标开始
// System.arraycopy(ary1, 0, ary2, 2, ary1.length);
// //打印数组2中的内容
// for(int i=0;i

 int[] ary = {12,43,5,34,6,7,2,76};
      //找最大值
      int max = 0;
      for(int i=0;i<ary.length;i++){
         max =  max<ary[i]?ary[i]:max;
      }
      System.out.println("最大值是："+max);

      //对数组进行扩容
     ary =  Arrays.copyOf(ary, ary.length+1);
     //将最大值赋给扩容后的数组的最后一个元素
     ary[ary.length-1] = max;

     System.out.println(Arrays.toString(ary));
     //ary打印
//       for(int i=0;i<ary.length;i++){
//           System.out.print(ary[i]+" ");
//       }




}
}    

1.4数组的排序
所谓排序，是指将数组元素按照从小到大或从大到小的顺序重新排列；
对于元素较多的数组，排序算法的优劣至关重要；一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣；
常用的排序算法有：冒泡排序、选择排序等。

冒泡排序：
- 比较相邻的元素，如果违反最后的排序准则，则交换
- 比较时既可以采用”下沉”的方式（降序），也可以采用”上浮”的方式（升序）

2.案例：
1. 用冒泡排序将数组中的最大值选出

    2.对一个数组进行升序排列

 public static void main(String[] args) {
     int[] ary = {23,45,7,4,8,98,4,7,65,35};
     //i控制冒泡排序的次数
     for(int i=0;i<ary.length-1;i++){
         //j代表比较元素的下标
         for(int j=0;j<ary.length-1-i;j++){
             //两两比较
             if(ary[j]>ary[j+1]){
                 int tmp = 0;
                 tmp = ary[j];
                 ary[j] = ary[j+1];
                 ary[j+1] = tmp;
             }
         }
     } 

     //数组已经排序好了
     System.out.println(Arrays.toString(ary));
}

}   

/*
* 0 最大下标 8 j