数组 排序和查找

一，数组

　　1.数组介绍

　　数组可以存放多个同一类型的数据，数组也是一种数据类型，是引用类型，　　即：数组就是一组数据

　　2.数组的使用

　　　　数组定义：  数据类型    数组名[ ] = new 数据类型[ 大小]

　　　　int a [] = new int [5] ;  创建一个数组 ，名字是a, 存放5个  int

　　　　说明  ：这是定义数组的一种方法  　　

　　　　

public class Array01 {
    public static void main(String[] args) {
        int[] a = new int[5]; //第一种定义  动态分配方式
        double scores[] ; //声明数组，  这时 scores  是 null
        scores = new double[5]; //  分配内存空间，可以存放数据
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) { //循环输入
            System.out.println("请输入第" + (i+1) + "元素");
            scores[i] = scanner.nextDouble();
        }
        for (int i = 0; i < scores.length; i++) { //遍历输出
            System.out.println("输出第" + (i+1) + "的值是" + scores[i]);
        }
    }
}

　　　　静态初始化

　　　　初始化数组  语法： 数据类型   数组名[] ={元素值，元素值，........}

　　　　例如： int a[] = {2,5,68}

　　3. 数组使用注意事项和细节

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

　　　　2）数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型，但是不能混用

　　　　3）数组创建后，如果没有赋值，有默认值

　　　　　　int o ,short 0 , byte o , float 0.0      double 0.0      char  \u0000           boolean false       String    null

　　　　4)使用数组的步骤    1. 声明数组并开辟空间     2.给数组各个元素赋值         3. 使用数组

　　　　5）数组的下标是从  0 开始的

　　　　6）数组下标必须在指定范围内使用 ，否则报 下标越界异常    例如          int [] arr=new int[5];  则有效下标为 0-4

　　　　7）数组属引用类型，数组型数据是对象（object ) 

　　　　举例   创建一个 char 类型的 26 个元素的数组，分别 放置'A'-'Z' 。   使用 for 循环访问所有元素并打印出来。提示：char 类型 数据运算 'A'+2 -> 'C'

public class ArrayExercise01 {
    public static void main(String[] args) {
        char[] chars = new char[26];
        for (int i = 0; i < chars.length; i++) {//输入
            chars[i] = (char)('A'+i);
        }
        for (int i = 0; i < chars.length; i++) {  //输出
            System.out.println(chars[i]);
        }
    }
}

　　　　第二个举例

　　　　　　//请求出一个数组 int[]的最大值 {4,- 1,9, 10,23} ，并得到对应的下标。

                     //思路分析

             //1. 定义一个 int 数组 int[] arr = {4,- 1,9, 10,23};

          //2.  假定 max = arr[0]  是最大值 , maxIndex=0;
          //3.  从下标 1  开始遍历 arr ，  如果 max <  当前元素，说明 max  不是真正的
         //    最大值,  我们就 max=当前元素; maxIndex=当前元素下标
        //4.  当我们遍历这个数组 arr 后 , max 就是真正的最大值，maxIndex 最大值
        //      对应的下标

public class ArrayExercise02 {
    public static void main(String[] args) {
        int[] arr ={4,- 1,9, 10,23};
        int max = arr[0];//假定第一个元素就是最大值
        int maxIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]){  //如果 max <  当前元素
                max = arr[i];    //把 max  设置成 当前元素
                maxIndex = i;
            }
        }
        //当我们遍历这个数组 arr 后 , max 就是真正的最大值，maxIndex 最大值下标
        System.out.println("max=" + max + " maxIndex=" + maxIndex);
    }
}

　　4 ， 数组的赋值机制

　　　　1）基本数据类型赋值，这个值就是具体的数据  ，而且互相不影响    int  n1 = 2;      int   n2 = n1;

　　　　2) 数组在默认情况下是引用传递，赋的值是地址

　　　看一张图  分析数组赋值的内存图

 

 　　5， 数组拷贝

　　　　将 int[] arr1 = { 10,20,30};  拷贝到 arr2 数组,  要求数据空间是独立的.

　　　　

public class ArrayCopy {
    public static void main(String[] args) {
        int[] arr1 = {10, 20 ,30}; //定义数组1
        int[] arr2 = new int[arr1.length];  //创建一个新数组
        for (int i = 0; i < arr1.length; i++) {  //遍历数组1 并且把数组1赋值给数组2
            arr2[i] = arr1[i];
        }
        arr2[0] = 100; // 改变数组2 对数组一没影响
        for (int i = 0; i < arr1.length; i++) {  //遍历数组1
            System.out.println(arr1[i]);
        }
        for (int i = 0; i < arr2.length; i++) {   //遍历数组二
            System.out.println(arr2[i]);
        }
    }
}

　　6. 数组反转

　　　　

//arr    { 11,22,33,44,55,66}         {66, 55,44,33,22, 11}
public class ArrayReverse {
    public static void main(String[] args) {
        //思路分析  1.一共交换三次   2.  每次交换时，对应的下标 是 arr[i]  和 arr[arr.length - 1 -i]
        int[] arr = { 11,22,33,44,55,66};
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = arr[i];
            arr[i] =temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

　　　　方式二 逆向排序

　　　　

//arr    { 11,22,33,44,55,66}         {66, 55,44,33,22, 11}
public class ArrayReverse02 {
    public static void main(String[] args) {
        int[] arr = { 11,22,33,44,55,66};
        int[] arr2 = new int[arr.length]; //创建要给新数组
        for (int i = arr.length -1 , j = 0; i >= 0; i--,j++) { //建议增加一个循环变量 j -> 0 -> 5
            arr2[j] = arr[i]; // 2.  逆序遍历 arr ,将 每个元素拷贝到 arr2 的元素中(顺序拷贝)
        }
        arr = arr2; //3.让 arr指向 arr2 数据空间,此时 arr 原来的数据空间就没有变量引用会被当做垃圾，销毁
        for (int i = 0; i < arr.length; i++) {  //遍历
            System.out.println(arr[i]);
        }
    }
}

　　7. 数组 添加和扩容

　　　　1.定义一个数组   2.定义一个新数组 3.遍历数组赋给新数组   4新数组指向数组   5 数组扩容完成

//1)    原始数组使用静态分配 int[] arr = { 1,2,3}
//2)    增加的元素 4 ，直接放在数组的最后 arr = { 1,2,3,4}
public class ArrayAdd {
    public static void main(String[] args) {
        int[] arr= {1,2,3,4};
        int[] arr2 = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[i];
        }
        arr2[arr.length] = 4;
        arr = arr2;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr2[i]);
        }

    }
}