JAVA---数组
一维数组本质上是一组相同类型的线性集合，当在程序需要处理一组数据，或者传递数据时，可以应用这种类型的数组。
创建一维数组：数组作为对象允许使用new关键字进行分配内存。在使用数组之前，必须首先定义数组变量所属类型。
1：int arr[]; //声明int型数组，数组中的每个元素都是int型。
String str[]; //声明string型数组，数组中的每个元素都是String型。
声明了数组只是给出了数组名字和元素的数据类型，要想真正使用数组，还要为它分配内存空间。在为数组分配内存时，必须指明数组的长度。
数组名字 =new 数组元素类型[数组元素的个数]; arr=new int[5];
数组是通过下标来区分数组中的不同元素，数组的下标是从0开始的。
2：声明数组的同时为数组分配内存。
数组元素类型 数组名=new 数组元素类型[数组元素的个数];
int month=new int[2];
初始化一维数组：
int arr=new int[]{1,3,2,5,8};
int arr={1,3,2,5,8};
eg:
public class GetDay(){
public static void main(String[]args){
int day=new int[]{31,28,30,31};
for(int i=0;i<day.length,i++){
System.out.println("day[i]");
}
}
}
二维数组的创建及使用
如果一维数组中的各个元素仍然是一个数组，那么它就是一个二维数组。二维数组常用于表示表中的信息以列和行的形式组织，第一个下标代表元素所在行，第二个下标代表元素所在的列。
二维数组可以看作是特殊的一维数组，因此，二维数组的创建同样有两种方式。
1：先声明，再用new运算符进行内存分配。
数组元素类型 数组名字[][];
数组元素类型 [][] 数组名字;
int arry[][];
同一维数组一样，二维数组在声明时也没有分配内存空间，同样要使用new关键字来分配内存，然后才可以访问每个元素。
对于高维数组，有两种为数组分配内存的方式：
（1）直接为每一维分配内存空间。
a=new int[2][4]
分别为每一维分配内存，
a=new int[2][];
a[0]=new int[2];;
a[1]=new int[3];
(2):声明的同时为数组分配内存
第二种方式同第一种实现的相同功能。使用方式为二维码数组分配内存时，首先指定最左边维数的内存，然后单独地给余下的维数分配内存。
二维数组初始化：
type arryname[][]={value1,value2.....valuen};
int arryname[][]={{1,2},{45,10}};
使用二维数组：
public class Matrix{
public static void main(String[]args){
int a[][]=new int[3][4];
for(int i=0;i<a.length;i++){
System.out.println(a[i][j]);
}
}
}
对于整型二维数组，创建成功之后系统会赋给数组中每个元素初始值0.
数组的基本操作：
1：遍历数组
遍历二维数组使用双层for循环。
public class Trap{
public static void main(String[]args){
int b[][]=new int[][]{{1},{2,3},{4,5,6}};
for(int k=0;k<b.length;k++){
for(int j=0;j<b[k].length;j++){
System.out.println(b[k][j]);
}
}
}
}
在遍历数组时使用foreach语句可能会更简单。
public class Tautog{
public static void main(String[]args){
int b[][]=new int[][]{{4,3},{1,2}};
System.out.println("数组中的元素是：");
for(int x[]:b){
for(int y[]:x){
if(x==b.length){
System.out.println(y);
}
else
System.out.println(e+"＼＂）；
｝
｝
｝
｝
填充替换数组元素
数组中的元素定义完成之后，可通过arry类中fill来对数组中的元素进行替换。该方法通过重载形式可完成任意类型的数组元素的替换。
fill(int a[],int value): a为要替换元素的数组，Value为要进行替换的数据。将指定的int值分给数组中的每一个元素。
import java.util.Arrays;
public class Swap{
public static void main(String[]args){
int arr[]=new int[5];
Array.fill(arr, 8);
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
fill(int []a,int fromIndex,int toIndex,int value); 该方法将指定的int值分配给指定范围中的每一个元素。如果fromIndex==toIndex,则填充范围为空。
import java.util.Arrays;
public class Displace{
public static void main(String[]args){
int arr[][]=new int[][]{45,12,2,10};
Array.fill(arr,1,2,8);
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
对数组进行排序：
通过Arrays类静态 sort()方法可以实现对数组的排序。sort()方法提供了多种重载形式，可以对任意类型的数组进行升序排序。
Array.sort(object)
import java.util.Arrays;
public class Taxis{
public static void main(String[]args){
int arr[]={23,42,12,8};
Arrays.sort(arr);
for(int i=0;i<arr.length;i++){
System.out.println(arr[i] );
}
}
}
上述实例是对整形数组进行排序。java中的string类型数组的排序算法是根据字典编排顺序排序的。因此数字排在字母前面，大写字母排在小写字母前面。
复制数组：
Arrays类的copyOf()方法与copyOfRange（） 方法可以实现对数组的复制，copyOf（）是复制数组至指定的长度，copyOfRange（）方法则将数组指定长度复制到一个新的数组中。
copyOf(arr,int newlength);
arr:要进行复制的数组； newlength：指复制后的长度。如果新数组的长度大于数组arr的长度，则用0进行填充（根据复制数组的类型来决定填充的值，整型数组决定用0来填充的，char型数组则使用null来填充）。如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取满足新数组长度为止。
eg:
import java.util.Arrays;
public class Cope{
public static void main(String[]args){
int arr[]=new int[]{23,42,12};
int newarr[]=Arrays.copyOf(arr,5);
for(int i=0;i<newarr.length;i++){
System.out.println(newarr[i]);
}
}
}
copyOfRange()方法： copyOfRange(arr,int fromIndex,int toIndex); arr:要进行复制的数组对象。fromIndex：指定开始复制数组的索引位置。fromIndex必须在0至整个数组长度之间。新数组包括索引fromIndex的元素。 toIndex：要复制范围的最后索引位置。可大于数组arr的长度。新数组不包括索引是toIndex的元素。
eg：
import java.util.Arrays;
public class Repeat{
public static void main(String[]args){
int arr[]=new int[]{23,42,12,84,10};
int newarr[]=Array.copyOfRange(arr,0,3);
for（int i=0;i<newarr.length;i++）{
System.out.println(newarr[i]);
}
}
}
}
数组查询
Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象，该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要，binarySearch（）方法有两种参数类型。
1：binarySearch（Object[]a.Object key）
a:要搜索的数组。key：要搜索的值。
如果key在数组中，则返回索引值，否则返回-1或“-”插入点，插入点是搜索要插入数组的那一点，即第一个大于此键的元素索引。
int arr[]=new int[]{4,25,10};
Arrays.sort(arr);
int index=Arrays.binarySearch(arr,0,1,8);
上面代码中的变量index的值的元素“8”在数组arr中索引在0~1内的索引位置。由于在指定范围并不存在元素“8”，Index的值是“-”（插入点）。如果对数组进行排序，元素“8”应该在25前面，因此插入点应是元素：25的索引位置“2”，即index的值为-2；
如果数组中的所有元素都小于指定的键值，则为a.length
(必须对数组进行排序，否则结果是不正确的）
eg:
import java.util.Arrays;
public class Example{
int a[]=new int[]{1,8,9,4,5};
Arrays.sort(a);
int index=Arrays.binarySearch(a,4);
System.out.println("4的索引位置是："+index);
}
}
返回值为：1
(2) binarySearch（Object[].a,int fromIndex,int toIndex,Object key）
a:要进行检索的数组 fromIndex：起始位置（包含） toIndex：结束位置（不包含） key：要搜索的元素
如果数组中所有的元素都小于指定的键值，则为toIndex.
如果指定的范围大于或等于数组的长度，则会报ArrayIndexOfBoundException异常
eg：
import java.util.Arrays;
public class Rakel{
public static void main(String[]args){
String str[]=new String[]{"ab","cd","ef","yz");
Arrays.sort(str);
int index=Arrays.binarySearch(str,0,2,"cd");
System.out.println（“cd的索引位置：”+index）;
}
}
数组排序算法
1：冒泡排序
冒泡排序的基本思想就是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移到数组前面，把较大的元素移到数组后面（即为交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。
eg：
public class BubbleSort{
public static void main(String[]args){
int arr[]={63,4,24,1,3,15};
BubbleSort soter=new BubbleSort();
soter.sort(arr);
}
public void sort(int[]arr){
for(int i=1;i<arr.length;i++){
for(int j=0;j<arr.length-i;j++){
if(arr[j]>arr[j+1]){
int a;
a=arr[j],arr[j]=arr[j+1],arr[j+1]=a;
}
}
}
showArray(arr);
}
public void showArray(int[]arr){
for（int x:arr）{
System.out.println(">"+x);
}
System.out.println();
}
}
运行结果：>1>3>15>24>63
直接选择排序：
基本思想：将指定排序位置与其他数组元素分别进行比较，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素于指定元素的顺序位置交换。
eg：
public class SelectSort{
public static void main(String[]args){
int arr[]={63,4,24,1,3,15};
SelectSort sorter=new SelectSort();
sorter.sort(arr);
}
public void sort(int[]arr){
for(int i=1;i<arr.length;i++){
int index;
for(int j=1;j<arr.length-i;j++){
index=0;
if(arr[j]>arr[index]){
index=i;
}
int temp=arr[arr.length-i];
arr[arr.length-i]=arr[index];
arr[index]=temp;
}
showArray(arr);
}
public void showArray(int[]arr){
for(int i:arr){
System.out.println(">"+i);
}
System.out.println();
}
}
反转排序
思路就是把数组最后一位与第一位替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换。
eg：
public class ReserverSort{
public static void main(String[]args){
int arr[]={10,20,30,40,50,60};
ReserverSort sorter=new ReserverSort();
sorter.sort(arr);
}
public void sort(int[]arr){
System.out.println("数组原有的内容：");
showArray(array);
int temp;
int len=arr.length;
for(int i=0;i<len/2;i++){
temp=arr[i];
arr[i]=arr[len-1-i];
array[len-1-i]=temp;
}
System.out.println("数组反转内容：");
showArray(arr);
}
public void showArray(int[]arr){
for(int i:arr){
System.out.print("\t"+i);
}
System.out.println();
}
}
i
