第五章总结 数组

数组的声明

数组元素类型 数组名字[]；

数组元素类型[] 数组名字；

分配内存

数组名 = new 数组元素类型[数组长度]

分配内存同时设置初始值

数组名 = new 数组元素的类型[]{值1，值2，...，值n}

数组元素赋值

数组名[索引] = 值；

使用一维数组

例5.1

public class Ba {//新建类
	public static void main(String[] args) {//主方法
		int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};//创建并初始化一维数组
		for(int i = 0;i < day.length;i++) {//利用循环将信息输出
			System.out.println((i + 1)+"月有"+ day[i] + "天");//输出每月的天数
		}
		// TODO Auto-generated method stub
	}
}

结果：

错误：

数组下标越界：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 12 out of bounds for length 12

at Ba.main(Ba.java:5)

避免下标越界的方法：

public class Ba {//新建类
	public static void main(String[] args) {//主方法
		int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};//创建并初始化一维数组
		for(int i = 0;i < day.length;i++) {//利用循环将信息输出
			System.out.println((i + 1)+"月有"+ day[i] + "天");//输出每月的天数
		}
		// TODO Auto-generated method stub
	}
}

例4.8

public class Repetition {//新建类
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = new int[] {5,13,96};//一维整型数组
		//for循环遍历数组
		for(int i = 0;i < arr.length; i++) {
			int temp = arr[i];
			System.out.println(temp);//输出遍历出的元素值
		}
//foreach循环
		for(int temp : arr){
		System.out.println(temp);
		}
	}
}

二维数组的声明：

数组元素类型 数组名字[][]；

数组元素类型[][] 数组名字；

二维数组分配内存：

数组名 = new 数组元素类型[行数][列数]

二维数组分配内存同时设置初始值

数组名 = new 数组元素的类型[][]{{值1，值2，...}，{}，...，{}}};

二位数组元素赋值

数组名[行号] = {值1，值2，...}；

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

使用二维数组

例5.2

public class Bb {//创建类
	public static void main(String[] args) {//主方法
		int a[][] = new int [3][4];//定义二维数组
		for(int i = 0;i < a.length;i++) {
			for(int j = 0;j < a[i].length;j++) {//循环遍历数组中的每个元素
				System.out.print(a[i][j]);//将数组中的元素输出
			}
			System.out.println();//输出空格
		}
				// TODO Auto-generated method stub
	}
}

 输出结果：

遍历数组

例5.3

public class Btrap {//创建类
	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 c=0;c<b[k].length;c++) {//循环遍历二维数组中的每个元素
				System.out.print(b[k][c]);//将数组中的元素输出
			}
			System.out.println();//输出空格
		}
		// TODO Auto-generated method stub
	}
}

输出结果

 

例5.4

public class Bc {//创建类
	public static void main(String[] args) {//主方法
		int arr2[][] = {{4,3},{1,2}};//定义二维数组
		System.out.println("数组中的元素是:");//提示信息
		int i = 0;//外层循环计数器变量
		for(int x[] : arr2){//外层循环变量为一维数组
			i++;//外层计数器递增
			int j = 0;//内层循环计数器变量
			for(int e : x) {//循环遍历每一个数组元素
				j++;//内层计数器递增
				if(i == arr2.length &&j == x.length) {//判断变量时二维数组中的最后一个元素
					System.out.print(e);//输出二维数组的最后一个元素
				}else//如果不是二维数组中的最后一个元素
					System.out.print(e +"、");//输出信息
			}
		}
				// TODO Auto-generated method stub
	}

}

输出结果：

填充替换数组排序

替换数组：

Arrays.fill(数组名，值);

替换数组部分元素：前改后不改

Arrays.fill(数组名，前索引，后索引，值)；

例5.5

import java.util.Arrays;//导入java.util.Arrays类
public class Bd {//创建类
	public static void main(String[] args) {//主方法
		int arr[] = new int[5];//创建int型数组
		Arrays.fill(arr,8);//使用同一个值对数组进行填充
		for(int i = 0;i < arr.length;i++) {//循环遍历数组中的元素
			System.out.println("第" + i + "个元素是:" + arr[i]);//将数组中的元素依次输出
		}
		// TODO Auto-generated method stub
	}
}

输出结果

例5.6

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

 输出结果

对数组进行排序

数组元素排序：

Arrays.sort（数组名）；

例5.7

	import java.util.Arrays;//导入java.util.Arrays
	public class Bh {//创建类
	public static void main(String[] args) {//主方法
int arr[] = new int[] {23,42,12,8};//声明数组
Arrays.sort(arr);//将数组进行排序
for(int i = 0;i < arr.length;i++) {//循环遍历排序后的数组
	System.out.println(arr[i]);//将排序后数组中的各个元素输出
}
		// TODO Auto-generated method stub
	}
}

 输出结果

 

例5.8

	import java.util.Arrays;//导入java.util.Arrays类
	public class Bf {//创建类
	public static void main(String[] args) {//主方法
int arr[] = new int[] {23,42,12};//定义数组
int newarr[] = Arrays.copyOf(arr,5);//复制数组arr
for(int i = 0;i < newarr.length;i++) {//循环遍历赋值后的新数组
	System.out.println(newarr[i]);//将新数组输出
}
		// TODO Auto-generated method stub
	}
}

输出结果

复制数组

复制数组元素：空位补0，溢出去掉

新数组名 = Arrays.copyof(旧数组名，新数组长度)；

复制数组部分元素：前在后不在

新数组名 = Arrays.copyOfRange(旧数组名，前索引，后索引）；

例5.9

	import java.util.Arrays;//导入java.util.Arrays
	public class Bg {//创建类
	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]);//将新数组中的每个元素输出
}
		// TODO Auto-generated method stub
	}
}

 输出结果

 

查询数组

查询数组元素：先排序再查询

索引 = Arrays.binarySearch(数组名，元素);

查询数组元素：先排序再查询，前含后不含

索引 = Arrays.binarySearch(数组名，前索引，后索引，元素);

例5.10

import java.util.Arrays;//导入java.util.Arrays类
public class Bi {//创建类
	public static void main(String[] args) {//主方法
		int ia[] = new int[]{1,8,9,4,5};//定义int型数组ia
		Arrays.sort(ia);//将数组进行排序
		int index= Arrays.binarySearch(ia,4);//查找数组ia中元素4的索引位置
			System.out.println("4的索引位置是：" + index);//将索引输出
		}
		// TODO Auto-generated method stub
	}

输出结果

 例5.11

import java.util.Arrays;//导入java.util.Arrays类
public class Bj {//创建类
	public static void main(String[] args) {//主方法
		String str[] = new String[]{"ab","cd","ef","yz"};//定义String型数组str
		Arrays.sort(str);//将数组进行排序
		int index = Arrays.binarySearch(str,0,2,"cd");//在指定范围内搜索元素“cd”的索引位置
			System.out.println("cd的索引位置是：" + index);//将索引输出
		}
		// TODO Auto-generated method stub
	}

输出结果

数组排序算法

冒泡排序

例5.12 

 

public class Bzwd12 {//创建类
	public static void main(String[] args) {//主方法
		int[] array = {63,4,24,1,3,15};//创建一个数组，元素是乱序的
		Bzwd12 sorter = new Bzwd12();//创建冒泡排序类的对象
		sorter.sort(array);//调用排序方法，对数组排序
	}
	
	public void sort(int[] array) {
		for(int i = 1 ;i < array.length;i++) {
			for(int j = 0;j < array.length - i;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 i : array) {//遍历数组
			System.out.print(">"+i);//输出每个数组元素值
		}
		System.out.println();
	}
}

输出结果

 例5.13

public class Bzwd13 {//创建类
	public static void main(String[] args) {//主方法
		int[] array = {63,4,24,1,3,15};//创建一个数组，元素是乱序的
		Bzwd13 sorter= new Bzwd13();//创建直接排序类的对象
		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;
					}
				}
				//交换在位置array。length-i和index（最大值）上的两个数
				int temp = array[array.length -i];//把第一个元素值保存到临时变量中
				array[array.length - i] = array[index];//把第二个元素值保存到第一个元素单元中
				array[index] = temp;//把临时变量（第一个元素原值）保存到第二个元素单元中
			}
			showArray(array);//输出直接选择排序后的数组元素
		}
		
		public void showArray(int[] array) {
			for(int i:array) {//遍历数组
				System.out.print(">"+i);//输出每个数组元素值
			}
			System.out.println();
		}
	}

输出结果