数组的 创建 使用 遍历 排序（sort） 比较（equals） 复制（copyOf（）和copyOfRang（）） 扩容 删除 查找（ binarySearch）方式

数组的 创建 使用 遍历 排序（sort） 比较（equals） 复制（copyOf（）和copyOfRang（）） 扩容 删除 查找（ binarySearch）方式

创建
遍历数组
排序数组（sort）
数组比较（equals）
数组复制（copyOf（）和copyOfRang（））
删除数组方法
扩容数组方法
查找数组元素（ binarySearch）
数组各个类型的初值

byte	int	short	long	bouble	float	boolean	char	Obiect
0	0	0	0	0.0	0L	false	'\u0000\ ’	null

数组的实质：

数组是一个变量，是一块连续的存储空间。只能存储相同类型的数据。数组名称 是连续空间的首地址。数组是引用类型。
注：
1.在声明数组时，必须声明大小 存储是连续的。
2.长度一旦确定，在运行过程中不可以改变。（但可以扩容）

数组的创建和使用：

创建:

//      方法1
//      在声明数组时，必须声明大小 存储是连续的
        //声明一个长度为10的整型变量，长度一旦确定，在运行过程中不可以改变。
        int[] a=new int[10]; //下标（索引）是0-9
        int[] a1=new int[]{1,3,2,3,1,2,3,2,3};
        int a2[]=new int[3];
        //方法2,推荐
        int[] b={1,3,2,3,1,2,3,2,3,2,3};
        //不需要new 也不需要指定长度,定义数组并赋值
        int[] c={};//长度为0的数组与null不相同

使用：

遍历数组（循环）：

规则：因为数组的下标从0开始，所以数组的最后一个元素的下标是数组的长度-1。所以当遍历数组时，只需要让 i <b.length 就行。

int[] b={1,2,3,4,5,6,7,8};
for (int i = 0; i <b.length ; i++) {//b.length获取数组的长度
            System.out.print(b[i]+"\t");//“\”t是空格
            //数组的下标，从零开始。b[0]对应的是数组中第一个数据
        }

遍历排序（sort）：

规则：

字符串String类型数组的排序算法是根据字典编排顺讯排序的，因此数字排在字母前面，大写字母排在小写字母前面。

String[] d={"1","21","2","a","g","F","小"};
        Arrays.sort(d);
        System.out.println();
        System.out.print("打印排序后的数组：");
        for (int i = 0; i <d.length ; i++) {
            System.out.print( d[i]+"\t");
        }

比较（String与实数 整型之间的区别）：

规则：

当数组的类型是整数和实数类型时：

        //比较整个数组，相等返回true ，
        //不相等（若元素一样，位置不同也不相等）返回false。
        int[] e={23,4,3,5,1,37,56,1,2};
        int[] e1={53,1,4,3,5,45,3,15};
        int[] e2={23,4,3,5,1,37,56,1,2};
        System.out.println("数组比较1："+Arrays.equals(e1,e));
        System.out.println("数组比较1："+Arrays.equals(e2,e));
        //比较元素
        //整型和实数类型之间元素比较，用==比较
        System.out.println("元素比较："+(e[0]==e1[0]));//false
        System.out.println("元素比较："+(e[0]==e2[0]));//true

当类型是字符串（String）类型时：
规则：使用equals进行比较

        String[] str={"y","n","n","m"};
        String[] str1={"y","n","n"};
        System.out.println("字符串数组比较"+str.equals(str1));//false
        System.out.println("字符串数组元素比较"+str[0].equals(str1[0]));//true

复制数组（copyOf（）和copyOfRang（））：

copyOf（）规则：复制数组至指定长度。
copyOf（数组名称，int newlength）
数组的名称：要复制的数组
int newlength：int型常量，指的是从下标从0开始到newlength-1之间元素。

int[] copyArr={1,21,2,1,2,1};
        int[] newCopyArr=Arrays.copyOf(copyArr,3);//复制下标0-2的元素
        System.out.print("copyOf复制：");
        for (int i = 0; i <newCopyArr.length ; i++) {
            System.out.print(newCopyArr[i]+"\t");
        }

copyOfRange规则：复制数组至指定长度。
copyOfRange（arr，int forIndex，int toIndex）
arr：数组名称
int forIndex：指定开始赋值数组的索引位置。必须在从0开始至整个数组的长度之间。新数组包括索引是forIndex的元素。
toIndex：要复制范围的最后索引位置。可大于数组arr的长度，新数组不包括索引是toIndex的元素。

int[] copyArr1={1,21,2,1,2,1};
        int[] newCopyOfRange=Arrays.copyOfRange(copyArr1,0,4);
        System.out.print("copyOfRang复制：");//下一行
        for (int i = 0; i < newCopyOfRange.length ; i++) {
            System.out.print(newCopyOfRange[i]+"\t");
        }

扩容数组方法：

第一种：

//扩容数组
      //使用系统类实现拷贝数据功能
        //第一个参数:原始数组
        //第个参数: 原始数组起始位置
        //第三个参数:扩容的数组
        //第四个参数:扩容数组的起始位置
        //第五个参数:扩容的长度
        int[] oldArr={121,2,12,12,1,2};
        int[] newArr=new int[oldArr.length*2];//创建一个长度是oldArr数组长度2倍的数组
        System.arraycopy(oldArr,0,newArr,0,oldArr.length);
        //把old数组从下标0开始复制，复制长度是oldArr的长度。复制给newArr下标也是从0开始
        oldArr=newArr;//让旧数组等于新数组
        System.out.print("oldArr：");
        for (int i = 0; i <oldArr.length ; i++) {
            System.out.print(oldArr[i]+"\t");
        }

第二种：

int[] oldArr1={12,1,5,1,2,5};
        int[] newArr1=new int[oldArr1.length*2];
        System.out.print("\n第二种扩容方法遍历出的结果：");//”\n“切换到下一行
        for (int i = 0; i <oldArr1.length ; i++) {
            newArr1[i]=oldArr1[i];//遍历oldArr1并把值给oldArr2
        }//遍历完就把所有的的复制给了newArr2
        oldArr1=newArr1;//
        for (int i = 0; i <oldArr1.length ; i++) {
            System.out.print(oldArr1[i]+"\t");
        }

删除数组某一元素的方法：

int[] Arr={3,51,31,53,13,5};
        System.out.println(Arrays.toString(Arr));
        Scanner input=new Scanner(System.in);
        System.out.print("请输入要删除的的下标数组：");
        int num=input.nextInt();
        int[] newArr=new int[Arr.length-1];
        for (int i = 0; i <newArr.length ; i++) {
            //以下是输入的下标小于或者等于原数组的长度
            if(i<num){//复制小于输入下标之前的元素
                newArr[i]=Arr[i];
            }else{// 复制大于输入下标之后的元素
                newArr[i]=Arr[i+1];
            }
        }

数组查询元素方法

规则：对于一个没有顺序的数组，必须进行排序后才能查找其中的值。

//        不指定范围查找：
//        binarySearch（Object[]a,Object key）：
//        a:要搜索的数组。
//        key：要搜索的值。
        int index=Arrays.binarySearch(binaryArr,12);
        int index1=Arrays.binarySearch(binaryArr,3);
        System.out.println("\n第一个查找："+index);//查找成功返回值在数据中的索引值。
        System.out.println("第二个查找："+index1);//没有查找到返回-1
//        指定范围查找：
//        binarySearch（Object[]a,int fromIndex，int toIndex，Object key）：
//        a:要搜索的数组。
//        fromIndex：指定范围的开始处索引（包含）
//        toIndex：指定范围的结束处索引。（不包含）
//        key：要搜索的值。
        int index2=Arrays.binarySearch(binaryArr,2,5,4);
        System.out.println("指定范围内查找："+index2);
        //如果指定范围大于或者等于数组的长度，则会报ArrayIndexOutOfBoundsException异常