一维数组

　　　　　　　　一维数组
一、数组的作用和类型
1.作用
　　A.存储 相同数据类型 的一组数据
　　B.对同类型数据进行集中管理，比如储存和遍历
2.数组类型
　　A.数组的类型就是数据中存储的数据的类型
　　B.数据本身是个对象（对象属于引用数据类型）
注意：
　　A.数组中的所有元素属于相同的数据类型
　　B.数组中所有元素在内存中连续存储
特点：数组本身也是一种引用类型
　　A.数组名只是引用，指向堆中创建的数组对象，该对象保存一组其它引用或直接值

 

 

二、声明、创建数组
1.数组的声明
　　A.告诉系统数据类型是什么
　　B.语法： 数据类型[] 数组名；
2.数组的创建
　　A.为数组分配内存空间
　　　　a.new操作符的使用
3.声明并创建数组
　　数据类型[] 数组名 = new 数据类型[大小]；
　　列：int[] arry = new int[3];
4.数组的特点
　　A.数组有一个字段length，表示此数组对象可以存储多个元素即数组长度；length不是实际保存的元素个数
　　B.“[]”语法是访问数组对象成员的唯一方式
　　C.对象数组保存的是引用，基本类型数组直接保存基本类型的值
　　D.新生成的数组对象，其中所有的引用自动化初始化为null；基本类型数组成员有各自默认值（数值型自动初始化为 0，字符型为（char）0，布尔型为false，float/double型为0.0）

三、初始化数组
1.数组的初始化
　　A.为数组中的成员一一赋值
2.数组赋值的两种方式
　　A.边声明边赋值（静态初始化）
　　　　int[] score = {66,77,88};
　　　　int[] score = new int[]{66,77,88};
　　B.动态地获取（从键盘录入）信息并赋值
　　　　int[] score = new int[3];
　　　　Scanner input = new Scanner(System.in);
　　　　for(int i=0 ;i<3;i++){
　　　　score[i] = input.nextInt();
　　　　}

四、常用数组排序算法

1.冒泡排序法
　　工作原理：比较相邻的元素。如果第一个比第二个大，就交换它们两个。对每一对响铃元素做同样的工作，从开始第一对到结尾的最后一对。最后的元素应该会是最大的数。针对除了最后一个元素以外所有的原色重发以上的步骤。直到没有任何一对数字需要比较。

总结：N个数，比较N-1轮，每轮比较N-1-i次。　　

代码示例：

package com.sanlianxueuan;

public class Demo7 {

    /**
     * 冒泡排序
     */
    public static void main(String[] args) {
        int [] array = {1,5,3,2,6,7,9,13,54,20};
        //N个数比较的论数N-1；
        for (int i=0;i<array.length-1;i++){
            //每一轮比较的次数N-1-i次；
            for(int j=0;j<array.length-1-i;j++){
                //比较相邻的两个数，小的往前靠，大的往后移
                if(array[j]>array[j+1]){
                    //两个数做交换，通过设置临时变量
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] =temp;
                }
            }
        }
        //把排好序的数组输出
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
    }

}

2.选择排序法：
　　工作原理：首先在为排序序列中找到最小元素，存放到排序序列的其实位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。以此类推，直到所有元素觉排序完毕。

代码示例：

package com.sanlianxueuan;

public class Demo8 {

    /**
     * 选择排序
     */
    public static void main(String[] args) {
        int [] array = {1,5,3,2,6,7,9,15,54,82};
        int min = 0;  //保存最小元素值的下标
        //N个数进行N-1轮的比较
        for(int i=0;i<array.length-1;i++){
            min = i; //以第一个数为最小值
            //查找最小数在数组中的下标
            for(int j=i+1;j<array.length;j++){
                if(array[min] > array[j]){
                    min = j;
                }
            }
            //如果第i个最小的数位置不在i上，则进行交换
            if(i != min){
                int temp = array[i];
                array[i] = array[min];
                array[min] = temp;
            }    
         }
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
    }

}

总结：N个数，比较N-1轮

3.插入排序法：
　　工作原理：它是通过构建有序序列，对于未排序数据，在已排序列中从后向前扫描，找到相应位置并插入。从后向前扫描过程中，需要反复吧已排序元素逐步向后挪位，为最新元素提供插入空间。

 代码示例：

package com.sanlianxueuan;

public class Demo9 {

    /**
     * 插入排序
     */
    public static void main(String[] args) {
        int [] array = {20,25,15,42,36,16,12};
        for(int i=1;i<array.length;i++){
            int temp = array[i];
            //把下标保存起来
            int j=i;
            while(j>0&&temp<array[j-1]){
                //上面的数覆盖下面的数
                array[j] = array[j-1];
                j--;
            }
            array[j]=temp; //插入数据
        }
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
    }

}

五、常用数组查找算法
1.线性查找法：
　　工作原理：它又称之为顺序查找。在一列给定的值中进行搜索，从一端开始注意查询每个元素，知道返回所需元素的过程。
　　例：A.查找指定的数在数组中出现的位置，找到返回下标，找不到返回-1；
　　　　B.求数组中的最大值，最小值

代码示例：

package com.sanlianxueuan;

import java.util.Scanner;

public class Demo4 {

    /**
     * 查找指定的数在数组中出现的位置，找到返回下标，找不到返回-1；
     */
    public static void main(String[] args) {
        int[] array = {10,20,80,60,50,90,70,30};
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个数:");
        int number = input.nextInt();
        int index =-1;   //保存找到的数所在数组中的下标，找不到等于-1；
        for(int i=0;i<array.length;i++){
            if(number == array[i]){
                index = i+1;
                break;
            }
        }
        
        if(index != -1){
            System.out.println("你要查找的数在第"+index+"位");
        }else{
            System.out.println("你要查找的数不在该数组内");
        }
            
    }
        

}

2.二分法查找：-----针对的是有序的数据
　　工作原理：它又称之为折半查找法。讲数组中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置将数组分成前、后两个子数组，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子数组，否则进一步查找后一子数组。重复以上过程知道找到或者找不到为止。

代码示例：

package com.sanlianxueuan;

import java.util.Scanner;

public class Demo6 {

    /**
     * 二分法查找
     */
    public static void main(String[] args) {
        int [] array ={1,2,3,4,5,6,7,8,9,18,49,87,90};
        System.out.println("请输入要查找的数：");
        Scanner input = new Scanner(System.in);
        int number = input.nextInt();
        int index = -1;   //保存找到数所在数组中的下标，找不到等于-1
        int start = 0;   //起始下标
        int end = array.length-1;  //终止下标
        int middle;
        while(start<end){
            //找到中间下标所对应的元素值
            middle = (start+end)/2;
            if(number == array[middle]){
                index = middle+1;
                break;
            }
            //假如要查找的那个数大于中间比较的那个数
            //去掉左边的数
            if(number > array[middle]){
                start = middle+1;
                
            }
            //保留左边的数，去掉右边的数
            if(number < array[middle]){
                end = middle - 1;
                
            }
        }
        if(index != -1){
            System.out.println("要找的数在"+index+"位");
        }
        
        if(index == -1){
            System.out.println("not find");
        }

    }

}

六、Arrays类使用
java的jdk中提供了一个Arrays工具类，此类专门为程序员操作数组提供了很多专有的方法，通过方法的调用可以对数组进行复制、排序、比较、查找元素等功能。

 代码示例：

package com.sanlianxueuan;

import java.util.Arrays;

public class Demo10 {

    /**
     * Array类的引用
     */
    public static void main(String[] args) {
        int [] arraySrc1 = {1,3,4,5,6,2};
        //拷贝数组
        //参数说明：第一个是要拷贝的数组名，第二个是数组的长度
        int [] arrayDes1 = Arrays.copyOf(arraySrc1, 10);
        for(int i=0; i<arrayDes1.length;i++){
            System.out.print(arrayDes1[i]+" ");
        }
        
        System.out.println("
*******************");
        //拷贝指定数组中的指定范围内的数据
        //参数说明：第一个是要拷贝的数组，第二个是要拷贝的起始位置下标，第三个是拷贝结束的数组下标
/*        注意：数组的长度是第三个参数-第二个参数*/
        int [] arrayDes2 = Arrays.copyOfRange(arraySrc1, 2, 4);
        for(int i=0; i<arrayDes2.length;i++){
            System.out.print(arrayDes2[i]+" ");
        }
        //数组的比较
        System.out.println("
*******************");
        int [] arraySrc2 = {1,3,5,6,2};
        boolean flag = Arrays.equals(arraySrc1, arraySrc2);
        System.out.println(flag);
        
        //数组的填充
        System.out.println("
*******************");
        int [] arrayDes3 = new int[10];
        //Arrays.fiil(arrayDes3,10);
        //参数说明：第一个参数是要填充的数组，第二个是要填充的起始位置，
        //第三个是要填充的终止位置，第四个是要填充的数
        Arrays.fill(arrayDes3,1,5, 10);
        for(int i=0; i<arrayDes3.length;i++){
            System.out.print(arrayDes3[i]+" ");
        }
        
        //对数组进行排序
        System.out.println("
*******************");
        Arrays.sort(arraySrc1);
        for(int i=0; i<arraySrc1.length;i++){
            System.out.print(arraySrc1[i]+" ");
        }
        
        //二分法查找
        System.out.println("
*******************");
        int index = Arrays.binarySearch(arraySrc1, 5);
        System.out.println(index);
        
        //使用System这个类的方法来拷贝数组
        System.out.println("
*******************");
        int [] arrayDes5 = new int [10];
        System.arraycopy(arraySrc1, 0, arrayDes5, 2, 5);
        for(int i=0; i<arrayDes5.length;i++){
            System.out.print(arrayDes5[i]+" ");
        }
    }

}