第六章 数组

1. 数组是具有相同数据类型的一组数据的集合,使用new关键字为数组分配内存时，整数数组中各个元素的初始值都为0
2. 声明一维数组同时分配内存：数组元素类型 数组名字=new 数组元素类型[数组元素的个数]
3. 初始化一维数组：

int arr[]=new int[]{1,2,3,4,5,6}
int arr2[]={1,2,3,4,5,6}

1. 二维数组的创建

声明二维数组：数组元素类型 数组名字[];
分配内存:（1）直接为每一维分配内存空间a=new int[2][4]
(2)分别为每一维分配内存

a=new int[2][];
a[0]=new int[2];
a[1]=new int[3];
```![这里写图片描述](https://img-blog.csdn.net/20150924165355105)
二维数组的初始化：eg：int my[][]={{1,2}{3,2}}

遍历数组：获取数组中的每个元素
![这里写图片描述](https://img-blog.csdn.net/20150924165825290)

![这里写图片描述](https://img-blog.csdn.net/20150924165844976)

填充替换数组元素

 1. fill(int[] a ,int value),语法也是这样，（a是要进行元素替换的数组，value是要存储数组中所有元素的值）




<div class="se-preview-section-delimiter"></div>

import java.util.Arrays;
public class Swap {

public static void main(String[] args) {
    // TODO 自动生成的方法存根
    int arr[]=new int[5];
    Arrays.fill(arr, 8);
    for(int i=0;i<arr.length;i++){
        System.out.println("第“+”i个元素"+arr[i]);

    }
}

}

 1. fill(int[] a ,int fromIndex,int toIndex,int value):该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromIndex（包括）一直到索引toIndex（不包括）
 ```
import java.util.Arrays;
public class Displace {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        int arr[]=new int[]{45,12,2,10};
        Arrays.fill(arr, 1, 2, 8);
        for(int i=0;i<arr.length;i++){
            System.out.println("第"+"i"+"个元素"+arr[i]);
        }
    }

}




<div class="se-preview-section-delimiter"></div>

排序
sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法：Arrays.sort(object)

import java.util.Arrays;
public class Displace {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        int arr[]=new int[]{45,12,2,10};
        Arrays.sort(arr);
        for(int i=0;i<arr.length;i++){
            System.out.println("第"+"i"+"个元素"+arr[i]);
        }
    }

}





<div class="se-preview-section-delimiter"></div>

结果为2,10,12,45
数字排在字母前面，大写字母排在小写字母前面

复制数组

1. copyOf()方法，语法copyOf(arr,int newlength)(newlength:int型常量，指复制之后的新数组的长度，如果新数组的长度大于数组arr的长度，则用0填充（根据复制数组类型来决定填充的值，整型数组用0填充，char型数组则用null填充）；如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个长度截取至满足新数组长度为止)
2. copyOfRange()方法，语法copyOfRange（arr，int fromIndex,int toIndex）(arr要进行复制的数组对象)

import java.util.Arrays;
public class Repeat{
    public static void main(String[] args){
        int arr[]=new int[]{23,42,12,84,10};
        int newarr[]=Arrays.copyOfRange(arr,0,3);
        for(int i=0;i<newarr.length;i++){
        System.out.println(newarr[i]);
}
}
}




<div class="se-preview-section-delimiter"></div>

数组查询

1. bingSearch（Object[] a,Object key）(key要搜索的值)（如果key包含在数组中，则返回搜索值的索引，否则返回-1或插入点（“-”））（必须要在进行此调用之前对数组进行排序（sort（）方法））
2. binarySearch（Object[] a ,int fromIndex,int toIndex,Object key）

int arr[]=new int[]{4,25,10};
Arrays.sort(arr);
int intdex=Arrays.binarySearch(arr,0,1,8);
上述代码中变量index的值是元素8在arr中索引在0~1内的索引位置，index的值为2

冒泡排序，

数组查询

 1. bingSearch（Object[] a,Object key）(key要搜索的值)（如果key包含在数组中，则返回搜索值的索引，否则返回-1或插入点（“-”））（必须要在进行此调用之前对数组进行排序（sort（）方法））
 2. binarySearch（Object[] a ,int fromIndex,int toIndex,Object key）

int arr[]=new int[]{4,25,10};
Arrays.sort(arr);
int intdex=Arrays.binarySearch(arr,0,1,8);
上述代码中变量index的值是元素8在arr中索引在0~1内的索引位置，index的值为2

冒泡排序，

public class Bubblesort {

public static void main(String[] args) {
    // TODO 自动生成的方法存根
    int[] array={63,4,24,1,3,15};
    Bubblesort sorter=new Bubblesort();
    sorter.sort(array);


}
public void sort(int[] array){
    for(int i=1;i<array.length;i++){
    for (int j = 0; j < array.length-1; j++) {
        if (array[j]>array[j+1]) {
            int temp=array[j];
            array[j]=array[j+1];
            array[j+1]=temp;

        }
        }
    }
        showArray(array);

}
        public void showArray(int array[]){
            for(int j:array){
                System.out.print(">"+j);
            }
            System.out.println();
        }


}

结果为>1>3>4>15>24>63

直接选择排序：将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，（交换次数少）

public class SeclectSort{

public static void main(String[] args) {
    // TODO 自动生成的方法存根
    int[] array={63,4,24,1,3,15};
    SeclectSort sorter=new SeclectSort();
    sorter.sort(array);


}
public void sort(int[] array){
    int index;
    for(int i=1;i<array.length;i++){
        index=0;
    for (int j = 1; j <= array.length-i; j++) {
        if (array[j]>array[index]) {
            index=j;
        }
        int temp=array[array.length-i];
        array[array.length-i]=array[index];
        array[index]=temp;
        }
    }
        showArray(array);

}
        public void showArray(int array[]){
            for(int j:array){
                System.out.print(">"+j);
            }
            System.out.println();
        }


}

“`