Java数组章节总结

一维数组

1、创建、

在Java中，数组的声明有两种方式：

1、数组元素类型 数组名[];     例如；int array1[];
2、数组元素类型[] 数组名;    例如；int[] array2;

在Java中对数组的使用是通过下标来进行的，通过对有效下标来进对数据的操作。

int[] arr=new int[10];
arr[0];	//访问第一个元素
arr[1]; //访问第二个元素
···
arr[9]; //访问最后一个元素

 2、数组的使用

使用一维数组输出1~12月每个月的天数

package yahu;
public class wuhu {
 
	public static void main(String[] args) {
 		//创建并初始化一维数组，如此进行数组的初始化后，系统会自动的计算数组的长度
		int d[]=new int [] {
				31,28,31,30,31,30,31,31,30,31,30,31
		};
		//利用循环输出信息
		for(int i=0;i<12;i++) {
			//输出每月天数
			System.out.println((i+1)+"月有"+d[i]+"天");	//使用下标访问数组中的元素
		}
	}
}
 

 二维数组

定义，如果一维数组中的各个元素仍是一个数组，那么它就是二维数组

1、创建 

二维数组数据类型 数组名=new 二维数组数据类型(且与前面的一致)[行数][列数];
例如：int[][] arr=new int[3][4];    //声明了一个3行4列，数据类型为int类型的二维数组

二维数组的初始化 

数组名[行号] [列号]=值；

2、二维数组的使用

 
package wuhu;
public class yahu{
 
	public static void main(String[] args) {
		int a[][]=new int[3][4];//定义一个3行4列的二维数组
		
		//遍历数组
		for(int i=0;i<a.length;i++) {
			//.length是数组长度
			for(int j=0;j<a[i].length;j++) {
				System.out.print(a[i][j]);//输出
			}
			//换行
			System.out.println();
		}
	}
}

 运行结果

3、Arrays类方法的使用

在使用Arrays类中的方法前，都需要提前包 

1. fill(int[ ] a,int value)

a：要进行元素替换的数组
value：指定的数据值

package yahu;
import java.util.Arrays;//导入类
 
public class wuhu {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int arr[]=new int [5];	//创建数组
		Arrays.fill(arr, 8);	//使用同一个值填充数组
		//遍历数组
		for (int i=0;i<arr.length;i++) {	
			System.out.println("第"+i+"个元素是"+arr[i]);
		}
	}
}

 

 2. fill(int[ ] a,int fromIndex,int toIndex,int value)

package yahu;
import java.util.Arrays;//导入类
 
public class wuhu {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int arr[]=new int [] {45,12,5,10};	//定义并初始化数组
		Arrays.fill(arr,1,2, 8);	//使用fill方法替换数组指定范围内的元素
		//遍历数组
		for (int i=0;i<arr.length;i++) {
			System.out.println("第"+i+"个元素是"+arr[i]);
		}
	}
}

 

3.copyOf(int[ ] arr,int newlength) 

package yahu;
import java.util.Arrays;//导入类
 
public class wuhu {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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]);
		}
	}
}

4.copyOfRange(arr,int fromIndex,int toIndex) 

package yahu;
import java.util.Arrays;//定义类
 
public class wuhu {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int arr[]=new int [] {23,42,12,84,10};	//定义数组
		int newarr[]=	Arrays.copyOfRange(arr,1,4);	//复制数组到新数组
		//遍历数组
		for (int i=0;i<newarr.length;i++) {
			System.out.println(newarr[i]);
		}
	}
}

数组的操作

1.sort(object)

2.binarySearch(Object[ ] a,Object key)

在a数组中查询key的下标位置，并且返回该下标。

package yahu;
import java.util.Arrays;//导入类
 
public class wuhu {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int arr[]=new int [] {1,8,9,4,5};//定义数组
		Arrays.sort(arr);//对数组进行排序
		int i=Arrays.binarySearch(arr, 4);//找到数组中元素4的值
		System.out.println("4的索引位置是"+i);//输出
	}
}

 

3.指定区间内查询

左闭右开区间，查找的返回包括前索引，但是不包括后索引。

 

 
package yahu;
import java.util.Arrays;//导入类
 
public class wuhu {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String arr[]=new String []{"ab","cd","ef","yz"};//定义string型数组
		Arrays.sort(arr);//排序
		int i=Arrays.binarySearch(arr,1,3,"cd");//在指定范围内搜索元素cd的索引位置
		System.out.println("cd的索引位置是："+i);//输出
	}
 
}

4.冒泡排序 

 
package yahu;
public class wuhu {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int []arr= {63,4,24,1,3,15};//定义数组
		h soter=new h();//创建冒泡排序的对象
		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 temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
		showArray(arr);//输出
	}
	public void showArray(int[]arr) {
		for(int i:arr) {
			System.out.print(">"+i);
			
		}System.out.println();
	}
}

5.直接排序 

 
package yahu;
public class wuhu {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int []a= {64,4,24,1,3,15};//定义数组
		int d;//最大值
		for(int i=1;i<a.length ;i++) {//外循环，要轮几次
			d=0;//初始化
			for(int j=1;j<a.length-i;j++) {//比大小
				if(a[j]>a[d]) {//最大值转换
					d=j;
				}
			}
			int t=a[a.length-i];//将索引赋给临时变量t
			a[a.length-i]=a[d];//将最大值放到已经空掉的索引内，达到交换的目的
			a[d]=t;//将之前索引的值赋给临时变量
		}
		for(int i:a) {//遍历数组
			System.out.print(">"+i);
		
	}
}

 6.反转排序

public class recursion {
    public static void main(String[] args) {
        int[] array=new int[]{1,2,3,4,5,6,7,8,9};

        System.out.println("原数组：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"  ");
        }
        System.out.println();

        int left=0;
        int right=array.length-1;

        while(left < right){
            int temp=array[left];
            array[left]=array[right];
            array[right]=temp;
            ++left;
            --right;
        }
        System.out.println("倒排后：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"  ");
        }
        System.out.println();
    }
}