java的数组

作用：存储相同类型的一组数组，相当于一个容器，存放数据的。对同种数据类型集中存储、管理、便于遍历

数组类型：就是数组中存储的数据的类型

特点：数组中的所有元素必须属于相同的数据类型，数组中所有元素在内存中连续存储的。数组本身也是一种引用类型，数组名只是引用，指向堆中创建的数组对象，该对象保存一组其他引用或直接值。

一、数组的声明和创建：告诉系统数据类型是什么？

1.语法：

　　数据类型[] 数组名;

2.数据的创建： 为数组分配内存空间（堆中分配）（数组名指向堆中）

　　 new 操作符的使用

3.声明并创建数组

　　数据类型[] 数组名 = new 数据类型[大小];

4.数据特点：

• 数组又一个字段length，表示此数组对象可以存储多少元素即数组长度；length不是实际保存的元素个数。
• “[]”语法是访问数组对象成员的唯一方式
• 对象数据保存的是引用，基本类型数组直接保存基本类型的值
• 新生成的数组对象，其中所有的引用自动初始化为null，基本类型数组成员有各自默认值（数值型自动初始化为0，字符型为（char）0，不二星为false。

5.数组的初始化

• 为数组中的成员一一赋值

6.数组赋值的两种方式

• 边声明边赋值（静态初始化）

int[] score = {66,77,88,99}

　　int[] score =new int[]{66,77,88,99}

• 动态的获取（从键盘录入）信息并赋值

int[] score = new int[3];
Scanner input = new Scanner(System.in);
for(int i=0;i<3;i++){
      score[i]=input.nextInt();
}

• 综合赋值和遍历

import java.util.Scanner;

public class Arrays {

    public static void main(String[] args){

        int[] array = new int[3];
        System.out.println(array[0]);
        System.out.println(array.length);
        //对数组中的元素进行赋值，通过下标进行赋值
        array[0]=1;
        array[2]=3;
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        //通过for循环遍历数组
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }

        //创建数组的同时做初始化
        int[] array1 = {10,20,30};
        for(int i=0;i<array.length;i++){
            System.out.println(array1[i]);
        }

        //通过Scanner赋值
        int[] score = new int[3];
        Scanner input = new Scanner(System.in);
        for(int i=0;i<3;i++){
            score[i]=input.nextInt();
        }

        for(int i=0;i<array.length;i++){
            System.out.println(score[i]);
        }
    }
}

二、数据的查找

//线性查找法：从头开始一直找，直到找到为止，返回数组的下标，找不到返回-1
    public static int linearSearch(){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入你要查找到的数：");
        int string =input.nextInt();
        int[] arrry= {20,10,5,30,35,25,40,50};

        for(int i = 0;i<arrry.length;i++){
            if(arrry[i]==string){
                return i;
            }else{
                continue;
            }
        }
        return -1;
    }

//2分查找法,原理就是一切为2，中间位置和想要查找的数做比较，比中间数大，那么要后面一半，比中间数小，要前一半，以此类推
    //找到返回下标，找不到返回-1
    public static void binarySearch(){
        int[] arrry= {20,21,22,30,35,36,40,50,51,52,53,54,55,67};
        Scanner input = new Scanner(System.in);
        int number =input.nextInt();
        System.out.println("请输入你要查找到的数：");
        int index = -1; //保存找到数的下标，没有找到返回-1
        int start = 0;
        int end = arrry.length-1;
        int middle ;
        while(start<=end){
            //找到中间下标对应的元素值
            middle = (start+end)/2;
            if(number==arrry[middle]){
                index = middle;
                break;
            }

            //如果被查找的数大于中间数，去掉左边一部分
            if(number>arrry[middle]){
                start = middle+1;
            }

            //如果被查找的数小于中间数，去掉右边一部分
            if(number<arrry[middle]){
                end = middle-1;
            }
        }

        if(index==-1){
            System.out.println("没有找到");
        }else{
            System.out.println("找到:"+index);
        }
    }

三、数组的排序

//冒泡排序
//工作原理，相邻两个元素比较大小，若第一个大于第二个，那么交换位置，此时的第二个再去和第三个比较，以此类推，一轮会得到一个最大的数，然后进行第二轮，那么比前面一轮少比较一次
public static void bubbleSort(){
        int[] arrry= {20,10,5,30,35,25,40,50};
        //N个数比较，轮数为N-1次
        for(int i=0;i<arrry.length-1;i++){
            //每一轮比较的次数 N-1-i
            for(int j=0;j<arrry.length-i-1;j++){
                //比较相邻的两个，大的往后排
                if(arrry[j]>arrry[j+1]){
                    int temp;
                    temp = arrry[j];
                    arrry[j]=arrry[j+1];
                    arrry[j+1]=temp;
                }
            }
        }

        //把排好的顺序输出
        for(int i=0;i<arrry.length;i++){
            System.out.print(arrry[i]+",");
        }
    }

4个数比较了3轮，那么n个数比较n-1轮