数据元素类型决定了数组的数据类型。
使用new为数组分配内存时，整数型数组中各个元素中的值为0；
int arr[]; arr=new int[5];声明的同时为数组分配内存空间：
int arr[]=new int[10] 初始化一维数组两种方式：
int arr[]=new int[]{1,2,3,4,5}; int arr1[]={2,3,4}; 使用一维数组例1：在主方法中创建int型数组，实现各个月的天数输出；
public class Getday { public static void main(String[] args){ int day[]={31,28,31,30,31,30,31,31,30,31,30,31}; for(int i=0;i<12;i++){ System.out.println((i+1)+"月有"+day[i]+"天"); } } }先声明，再用new运算符进行内存分配：
int arr[][]; arr=new int[2][3];也可以为每一维分配内存：
int a[][]; a=new int[2][]; a[0]=new int[2]; a[1]=new int[3];声明内存的同时为数组分配内存。
二维数组初始化 int arr[][]={{12,34,12},{23,56,45}}; 使用二维数组例2：输出一个3行4列且所有元素为0的矩阵。
public class Output { public static void main(String[] args){ int arr[][]=new int[3][4]; for(int i=0;i<arr.length;i++){ for(int j=0;j<arr[i].length;j++){ System.out.print(arr[i][j]); } System.out.println(); } } }结果：
123 45 6 填充替换数组元素（1）fill(int[] a,int value)
a：要进行元素替换的数组；
value：要存储数组中所有元素的值；
例3：创建一维数组，通过fill进行填充，最后将数组中的元素输出；
import java.util.Arrays;//导入java.util.Arrays类 public class Output { public static void main(String[] args) { int arr[] = new int[3];//创建一维数组 Arrays.fill(arr, 8);//fill函数进行填充 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }结果：
8 8 8（2）fill(int[] a,int formIndex,int toIndex,int value)
a：要填充的数组；
formIndex：填充第一个元素索引（包含）；
toIndex：填充最后一个元素（不包含）；
value：要存储所有元素中的值；
例4：创建一维数组，通过fill进行填充，最后将数组中的元素输出；
import java.util.Arrays;//导入java.util.Arrays类 public class Output { public static void main(String[] args) { int arr[]=new int[]{1,2,34,5}; Arrays.fill(arr,2,3,6);//一位数组36替换为6； for(int i=0;i<arr.length;i++){ System.out.println("第"+(i+1)+"元素是"+arr[i]); } } }结果：
第1元素是1 第2元素是2 第3元素是6 第4元素是5 对数组进行排序通过Arrays类的静态sort（）方法可以进行实现数组的排序，可以对任意数组进行升序排列。
Arrays.sort(object);例5：创建一维数组，将数组排序后输出。
import java.util.Arrays;//导入java.util.Arrays类 public class Output { public static void main(String[] args) { int arr[]=new int[]{1,2,34,5}; Arrays.sort(arr); for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); } } }结果：
1 2 5 34 复制数组（1）copyOf(arr,int newlength)
arr：要进行复制的数组；
newlength：int型常量，指复制后新数组的长度，如果新数组长度大于数组arr长度，则用0进行补充。如果新数组长度小于数组arr长度，满足截取长度即可。
import java.util.Arrays; public class Cope { public static void main(String[] args) { int arr[] = new int[]{1, 2, 3, 4}; int newarr[]=Arrays.copyOf(arr, 5); for (int i = 0; i < newarr.length; i++) { System.out.println(newarr[i]); } } }结果：
1 2 3 4 0（2）copyOfRange(arr,int formIndex,int toIndex)
arr：要进行复制数组对象；
formIndex：开始复制指定数组位置；
toIndex：要复制范围的最后索引位置；
import java.util.Arrays; public class Cope { public static void main(String[] args) { int arr[] = new int[]{1, 2, 3, 4}; int newarr[]=Arrays.copyOfRange(arr,0,3);//包括arr[0]、arr[1]、arr[2]； for (int i = 0; i < newarr.length; i++) { System.out.println(newarr[i]); } } }结果：
1 2 3 数组查询（1）binarySearch(Object[] a,Object key)
a：要搜索的数组；
key：要搜索的值；
如果key包含在数组中，则返回索引值；否则返回-1或“-”；
import java.util.Arrays; public class Text { public static void main(String[] args){ int arr[]=new int[]{1,2,3,4,5}; int Index=Arrays.binarySearch(arr,4); System.out.println("4的索引位置为："+Index); } }结果：
4的索引位置为：3（2）binarySearch(Object[] a,int formIndex,int toIndex,Object key)
a：要进行检索的数组；
formIndex：指定范围的开始处索引；
toIndex：指定范围的结束出索引；
key：要搜索的元素；
import java.util.Arrays; public class Text { public static void main(String[] args){ int arr[]=new int[]{1,2,3,4,5}; int Index=Arrays.binarySearch(arr,0,4,4); System.out.println("4的索引位置为："+Index); } }
结果：
4的索引位置为：3基本思想：对比相邻的元素值，如果满足条件就交换值，把较小的元素移动到数组前面，把大的元素移动到数组后面。
实例：{34,56,67,23,12,4}运用冒泡排序进行操作；
public class BubbleSort { public static void main(String[] args){ int arr[]=new int[]{34,56,67,23,12,4}; for(int i=1;i<arr.length;i++){ for(int j=0;j<arr.length-i;j++){ if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } for(int k=0;k<arr.length;k++){ System.out.print(arr[k]+" "); } } }结果显示：
4 12 23 34 56 67基本思想：将指定排序位置与其它数组元素分别对比，如果满足条件就交换元素值。
public class SelectSort { public static void main(String[] args){ int arr[]=new int[]{34,56,67,23,12,4}; int Index; for(int i=1;i<arr.length;i++){ Index=0; for(int j=1;j<=arr.length-i;j++){ if(arr[j]>arr[Index]){ Index=j; } } int temp=arr[arr.length-i]; arr[arr.length-i]=arr[Index]; arr[Index]=temp; } for(int k=0;k<arr.length;k++){ System.out.print(arr[k]+" "); } } }结果显示：
4 12 23 34 56 67基本思想：把最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，依次类推。
public class ReverseSort { public static void main(String[] args){ int arr[]=new int[]{34,56,67,23,12,4}; System.out.print("反转排序前的数组为："); for(int i=0;i<arr.length;i++){ System.out.print(arr[i]+" "); } System.out.println(); int temp; int n=arr.length; for(int i=0;i<n/2;i++){ temp=arr[i]; arr[i]=arr[n-1-i]; arr[n-1-i]=temp; } System.out.print("反转排序后的数组为："); for(int j=0;j<arr.length;j++){ System.out.print(arr[j]+" "); } } }结果显示：
反转排序前的数组为：34 56 67 23 12 4 反转排序后的数组为：4 12 23 67 56 34
