Java初级·数组

最新推荐文章于 2024-07-27 18:29:13 发布

DateBegin

最新推荐文章于 2024-07-27 18:29:13 发布

阅读量761

点赞数

本文链接：https://blog.csdn.net/DateBegin/article/details/102807193

版权

JAVA数组

java语言中提供的数组是用来存储固定大小的同类型元素，相当于一个容器。

你可以声明一个数组标量，如number[100]来替代直接声明100个独立变量，number1，number2.。。

1.声明数组变量

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dateType[] arrayName;//首选的方法
或
 dateType  array[];//效果相同，但不是首选方法。

2.创建数组

Java语言使用new 操作符来创建数组，语法如下：

arrayName =new dateType[arraySize]

一、使用dataType[ arraySIze]创建了一个数组。

二、把新创建的数组的引用赋值给变量 arrayRefVar。

数据变量的声明，和创建数组可以用一条语句完成，如下所示

dataType[] arrayName =new dataType[arraySize]

另外，你还可以使用如下的方式创建数组。

dataType[] arrayName= {value0,value1,....valueN}

数组的元素是通过索引访问的，数组索引从0开始，所以索引值从0到arrayRefVar length-1.

实例

下面是语句首先声明了一个数组变量myList，接着创建了一个包含10个double类型元素的数组，并且把它的引用赋值给myList 变量

public class 数组{
	public static void main(String[] args) {
		//数组大小
		int size=10; 
		//定义数组
		double[] myList=new double [size];
		myList[0] = 5.6;
	      myList[1] = 4.5;
	      myList[2] = 3.3;
	      myList[3] = 13.2;
	      myList[4] = 4.0;
	      myList[5] = 34.33;
	      myList[6] = 34.0;
	      myList[7] = 45.45;
	      myList[8] = 99.993;
	      myList[9] = 11123;
	   // 计算所有元素的总和
	      double total=0;
	      for (int i = 0; i <size; i++) {
			total+=myList[i];
		}
	      System.out.println("总和为；"+total);
	}
}

3.数组的特点

1.数组是一个容器。

2.数组也是一个变量，必须满足先声明再赋值再使用。

3.数组是引用数据类型，不可以存放数值，必须存放地址。地址想要获取，必须由系统分配内存空降，并且随机分配地址。

4.数组中每一个元素的数据类型可以是八大基本数据类型，同时也可以是引用数据类型。

堆区的特点

堆区中每个变量都有默认值
byte short int long 默认值0
float double 默认值是0.0
char默认值’\u0000’ 就是一个空字符
boolean默认值 false
引用类型默认值 null
2，凡是new 出来的东西都在堆区开辟空间，堆区开辟的空间都会有地址值
3.在堆区中的对象，一旦使用完毕之后，不会立刻消失，会等待垃圾回收器空闲的时候自动回收

课间教学代码

public class ArrayDemo01 {
	public static void main(String[] args) {
		// 1.声明数组
		// int i = 19;
		int[] arr = null;
		// arr = 0x0001;
		// arr = new int[3];
		System.out.println(arr); // [I@7852e922  直接输出数组名，输出的是地址。  想要输出数组里面的元素，则是 arr[i];
		System.out.println(arr[0]); // 0
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		// System.out.println(arr[3]); // java.lang.ArrayIndexOutOfBoundsException
		// System.out.println(arr[-3]);
		
		arr[0] = 100;
		arr[1] = 200;
		arr[2] = 300;
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		
		// 启动垃圾回收器
		System.gc();
		// 通知垃圾回收期执行回收垃圾的方法
		System.runFinalization();
		// 但是显示回收不一定起作用
		
	}
}

	public class ArrayDemo01 {
	public static void main(String[] args) {
		// 1.声明数组
		// int i = 19;
		int[] arr = null;
		// arr = 0x0001;
		// arr = new int[3];
		System.out.println(arr); // [I@7852e922
		System.out.println(arr[0]); // 0
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		// System.out.println(arr[3]); // java.lang.ArrayIndexOutOfBoundsException
		// System.out.println(arr[-3]);
	arr[0] = 100;
	arr[1] = 200;
	arr[2] = 300;
	System.out.println(arr[0]);
	System.out.println(arr[1]);
	System.out.println(arr[2]);
	
	// 启动垃圾回收器
	System.gc();
	// 通知垃圾回收期执行回收垃圾的方法
	System.runFinalization();
	// 但是显示回收不一定起作用
	
}

在这里插入图片描述
[

开发中最常见的两个异常

1.数组越界

产生原因：访问了不在0到数组的长度范围内的索引。

解决办法：检查索引范围。

2.空指针异常

产生原因：对象没有分配地址，就直接方位了对象。

解决办法；给对象分配地址，一个字new

4.数组初始化

两种方式

1，静态初始化：在处水花的同时不需要指定数组的大小，但是要指定元素的数值，由系统根据元素的个数去计算数组的长度。

格式1：

数据类型[ ] 数组名=new 数据类型[ ]{

元素一，元素二。。}

格式二：

数据类型[ ] 数组名={ 1，2.。}

2.动态初始化：在初始化的同时指定数组的大小，不指定元素数组，由用户在后期来动态指定，系统会默认分配初始值

分配的规则：

bye short int long 默认值0

float double 默认值 0.0

char 默认值 ‘\u0000’ 就是一个空字符

boolean 默认值 false

引用类型默认值 null

下面的图片描绘了数组myList。这里myList数组里有10个double元素，的下表从0到9.

javaæ•°ç»„ç»“æž„è¯´æ˜Ž

处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者For-Each 循环。

示例

public class 数组 {
	public static void main(String[] args) {
		double[] myList = { 1.9, 2.9, 3.4, 3.5 };
		// 打印所有的数组元素
		for (int i = 0; i < myList.length; i++) {
			System.out.println(myList[i] + "");
		}
		// 计算所有元素的总和
		double total = 0;
		for (int i = 0; i < myList.length; i++) {
			total += myList[i];
		}
		System.out.println("Total is " + total);
		// 查找最大元素
		double max = myList[0];
		for (int i = 0; i < myList.length; i++) {
			if (myList[i] > max)
				max = myList[i];
		}
		System.out.println("max is " + max);
	}
}

5.数组的遍历

// 数组的遍历
public class ArrayDemo03 {
	public static void main(String[] args) {
		int[] arr = {11,22,33,44,55,66};
		// double[] arr = {11.2,22.3,44.3};
	
		printArray(arr);

	}
	
	/*
	 * 功能: 输出数组中的每一个元素
	 * 参数类型: int[] arr
	 * 返回值类型: void
	 * 方法名: printArray
	 */
	public static void printArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}


}

/*
 * 有一个数列：8, 4, 2, 1, 23, 344, 12		
 * 	A   循环输出数列的值。
	B   求数列中所有数值的和。
	C   求出最大值。
	D   将数组倒置并输出
	E   数组查找 猜数游戏：从键盘中任意输入一个数据，
	判断数列中是否包含此数。提高: 并且返回找到的数在数组中的索引
	F   数组排序 	【不写  八大排序】
 */
public class ArrayDemo05 {
	public static void main(String[] args) {
		int[] arr = {8, 4, 2, 1, 23, 344, 12};
		printArray(arr);
		System.out.println("==================");
		System.out.println("数列的和为: " + getSum(arr));
	}
	
	/*
	 * 功能: 循环输出数列的值
	 * 参数列表: int[] arr
	 * 返回值类型: void
	 * 方法名: printArray
	 */
	public static void printArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	
	/*
	 * 功能: 求数列中所有数值的和。
	 * 参数列表: int[] arr
	 * 返回值类型: int
	 * 方法名: getSum 
	 */
	public static int getSum(int[] arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum;
	}
}

6.值传递和引用传递

/*
 * 值传递和引用传递 【************】
 * 10
 * 15
 * 15
 * 传递: 实参赋值给形参
 * 
 * 形参可以是八大基本数据类型和引用数据类型
 * 
 * 值传递针对的是形参是八大基本数据类型
 * 引用传递针对的是形参是引用数据类型
 * 
 * 值传递本质传递的是数值本身,引用传递传递的地址值
 * == 比较基本数据类型比较的是 数值
 * 	     比较引用数据类型比较的是 地址值
 */
public class ArrayDemo06 {
	public static void main(String[] args) {
		/*int a = 10;
		System.out.println("main方法中a的值: " + a);
		change(a);
		System.out.println("main方法中调用change方法后a的值: " + a);*/
		
		int[] arr = new int[]{ 11, 22, 33 };
		System.out.println("main方法中数组arr每一个元素的值: " + Arrays.toString(arr));
		
		changeArr(arr);
		System.out.println("main方法经过方法调用后中数组arr每一个元素的值: " + Arrays.toString(arr));
		
	}
	
	public static void change(int a) {
		a += 5;
		System.out.println("change方法的a的值: " + a);
	}
	
	public static void changeArr(int[] arr) {
		arr[1] = 666;
		System.out.println("changeArr方法中数组每一个元素的值: " + Arrays.toString(arr));
	}
}

值传递原理

在这里插入图片描述

引用数据传递原理

在这里插入图片描述

/*
 * 值传递本质传递的是数值本身,引用传递传递的地址值
 * == 比较基本数据类型比较的是 数值
 * 	     比较引用数据类型比较的是 地址值
 * 
 * 多个引用指向同一个堆区空间的问题
 * 如果多个引用指向同一个堆区的空间,
 * 那么任何一个引用如果修改了堆区的内容,那么必然会影响到所有的引用
 */
public class ArrayDemo07 {
	public static void main(String[] args) {
		int[] arr = { 11, 22, 33 };
		int[] arr2 = { 44, 55, 66 };
		int[] arr3 = arr;
		
		System.out.pri ntln(Arrays.toString(arr));
		System.out.println(Arrays.toString(arr2));
		System.out.println(Arrays.toString(arr3));
		
		arr[1] = 666;
		System.out.println(Arrays.toString(arr)); // [11, 666, 33]
		System.out.println(Arrays.toString(arr2)); // [44, 55, 66]
		System.out.println(Arrays.toString(arr3)); // [11, 666, 33]
	}
}

For-Each 循环

JDK1.5引进了一种新的循环类型，被称为For-Each循环或者加强型循环，它能在不使用下标的情况下遍历数组。

语法格式如下；

for（type element:array）{

System.out.println(element);

}

实例

该实例用来显示数组myList中的所有元素：

public class Array{
	public static void main(String[] args) {
	double[] myList={1.9,2.9,3.4,3.5};
	//打印所有数组元素
	for(double element:myList){
		System.out.println(element);
	}
	}
}

数组作为函数的参数

数组可以作为参数传递给方法。

例如，下面的例子就是一个打印int数组中元素的方法。

public class Practice06 {
	public static void main(String[] args) {
	double[] myList={1,2,5,6};
	printArray(new int[]{3, 1, 2, 6, 4, 2});
	
	}
	public static void printArray(int[] array){
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]+" ");
		}
	}
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维，其每个元素都是一个一维数组，比如：

String str[][]=new String [3][4];

多维数组的动态初始化（以二维数组为例）

1.直接为每一维分配空间，格式如下：

7.排序算法

八大排序算法：冒泡选择插入堆希尔快速排序归并排序基数排序

冒泡排序

1、相邻两个元素进行比较，前面的数大于后面的数，交换两个数。

2.第一个比较了 arr.length -1趟

3.每一趟比上一趟少比较一次。

public class BubbleSort {
	public static void main(String[] args) {
		int[] arr = {24, 59, 80, 55, 13};
		System.out.println("原始数据: " + Arrays.toString(arr));
	for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j+1]) {
					int temp = 0;
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		System.out.println("冒泡排序后: " + Arrays.toString(arr));
	}
}

插入排序

insertion Sort

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描。找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素做不向后挪位，为最新元素提供插入空间。

1.从第一个元素开始，该元素可以认为已经被排序

2.取出下一个元素，在已排序的元素序列中从后向前扫描

3如果该元素（已排序）大于新元素，将该元素移到下一位置。

4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

5.将新元素插入到该位置后

6.重复步骤2~5

public class InsertSort {
	public static void main(String[] args) {
		int[] arr = {69, 24, 15, 31, 13};
		
		System.out.println("排序前: " + Arrays.toString(arr));
		
		for (int i = 1; i < arr.length ; i++) {
			for (int j = 0; j < i; j++) {
				if (arr[i] < arr[j]) {
					int temp = 0;
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		System.out.println("排序后: " + Arrays.toString(arr));
	}
}

选择排序

1.将制定的元素依次和后面的每一个元素进行比较

2.一共比较了arr.length-1 趟

每一趟比上一趟少比较一次，并且比较的数值等于上一次的起始位置+1

public class SelectSort {
	public static void main(String[] args) {
		int[] arr = {44, 89, 100, 77, 33};
		
		System.out.println("原始数据: " + Arrays.toString(arr));
	for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
					int temp = 0;
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		System.out.println("选择排序后: " + Arrays.toString(arr));
	}
}

8.foreach

foreach是设计使用来简化遍历的

格式：

for（元素类型元素变量名：数组/集合）{

使用元素变量名直接访问元素

}

public class  foreach {
	public static void main(String[] args) {
		int[] arr = {25, 66, 88, 77, 64};
		
		// 普通for遍历
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		System.out.println("=================");
		for (int i : arr) {
			System.out.println(i);
		}
	}
}

9.可变参数

为什么需要学习可变参数？针对多个参数的类型一致个数不同的情况。

定义格式：

形参类型…参数名

可变参数的特点：

1.可变参数的本质还是数组，参数的类型一致，个数不一致。

2.可变参数的… 的位置在数据类型和变量名之间

3.可变参数必须出现在参数列表的最后。

public class ArrayDemo09 {
	public static void main(String[] args) {
		System.out.println(add(10, 20));
		System.out.println(add(10, 20, 30));
		System.out.println(add(10, 20, 30, 40));
		System.out.println(add());
	}
	
	// 计算两个数的和
	/*public static int add(int a, int b) {
		return a + b;
	}*/
	
	// 计算三个数的和
	/*public static int add(int a, int b, int c) {
		return a + b + c;
	}*/
	
	public static int add(int... args) {
		// System.out.println("可变参数方法被调用了...");
		// System.out.println(args); // [I@7852e922
		int sum = 0;
		for (int i : args) {
			sum += i;
		}
		return sum;
	}
	
	// 计算多个int类型和一个double类型的和
	public static int add(double a, int... args) {
		// System.out.println("可变参数方法被调用了...");
		// System.out.println(args); // [I@7852e922
		int sum = 0;
		for (int i : args) {
			sum += i;
		}
		return sum;
	}
}

10.Array工具类

Array工具类：针对数组操作的工具类，方便操作数组

在不使用API调用的情况下实现排序

利用Arrays.copyOf或者System.arraycopy

可以实现对数组的任意文职的任意元素进行增加和删除

数组作为容器增加和删除的效率低

查询和修改效率非常高【索引】

数组的本质就是一种数据结构

栈队列堆哈希表链表二叉树。。。

public class text {//arrays.工具类
	
		public static void main(String[] args) {
			int [] arr={52,86,35,32,64,21};
			//遍历
			//Arrays.toString(arr); 这样无法直接输出的哦！！
			System.out.println(Arrays.toString(arr));
			
			//排序
			Arrays.sort(arr);
			System.out.println("排序后为"+Arrays.toString(arr));
			
			//二分法查找
			Arrays.binarySearch(arr, 52);//也是不能输出的
			System.out.println(Arrays.binarySearch(arr, 52));
			
			//数组的拷贝
			//第一个参数表示要拷贝的数组源
			//第二个表示数组长度
			//Arrays.copyOf(original, newLength)
			int [] newArr=  Arrays.copyOf(arr, arr.length+1);//此处length可以设置，为新数组的长度。
			System.out.println("拷贝后的数组"+Arrays.toString(newArr));
			
			/*
			 *数组拷贝
			 *src：需要拷贝的源数组
			 *srcPos：源数组的拷贝的起始索引
			 *dest：需要拷贝的目标数组
			 *destPos：需要拷贝的目标数组的起始索引
			 *length：从源数组中拷贝爱多少个长度的目标索引
			*/
			//System.arraycopy(src, srcPos, dest, destPos, length);
	
	}
}

本节习题

1.已知如下数组
Int[] arr = {44,77,88,99,100,22};
完成如下操作:
A 循环输出数列的值并按照如下格式输出。arr[44,77,88,99,100,22]
B 求数列中所有数值的和
C 求出最小值。
D 将数组倒置并输出
E 查找（要求使用二分法查找和基本查找）
F 数组
排序要求使用至少两种排序算法

public class Prc01 {
	public static void main(String[] args) {
		// A 循环输出数列的值并按照如下格式输出。arr[44,77,88,99,100,22]
		int[] arr = { 44, 77, 88, 99, 100, 22 };
		System.out.println("倒置前" + Arrays.toString(arr));
		// B 求数列中所有数值的和
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		System.out.println("所有数值的和为：" + sum);
		// C 求出最小值。
		System.out.println("最小值为：" + min(arr));
		// D 将数组倒置并输出
		inversion(arr);
		System.out.println("倒置后：" + Arrays.toString(arr));
		// E 查找（要求使用二分法查找和基本查找）
		// 基本查找
		int numb = 99;
		for (int k = 0; k < arr.length; k++) {
			if (numb == arr[k]) {
				System.out.println("该数在数组数列中！，他的索引是" + k);
				return;
			}
		}
		System.out.println("该数不在数组数列中！");
		
	}
	
	public static int min(int[] array) {
		int min = array[0];
		for (int i = 1; i < array.length; i++) {
			if (array[i] < min) {
				min = array[i];
			}
		}
		return min;
	}

	public static void inversion(int[] array) {
		for (int j = 0; j < array.length / 2; j++) {
			int tem = 0;
			tem = array[j];
			array[j] = array[array.length - 1 - j];// 此处要记得加上 -j 对应不同倒置的元素
			array[array.length - 1 - j] = tem;
		}
	}
}

public class   {//arrays.工具类
	
		public static void main(String[] args) {
			int[] arr= {44,77,88,99,100,23};
			//二分法查询 见鬼了测试23就是把不行
			//System.out.println(binArray(arr, 44));
			Scanner input=new Scanner(System.in);
			System.out.println("请输入要查询的数");
			int n=input.nextInt();
			int index=Arrays.binarySearch(arr, n);
			if (index >= 0) {
				System.out.println("该数在数组数列中，它的索引为"+index);
			}else{
				System.out.println("该数不在该数组数列中！");
			}
		}
		public static int binArray(int[] array,int sum){
	
			int min=0;
			int max=array.length-1;
			int mid=(min+max)/2;
			while(sum!=array[mid]){
				if (sum>array[mid]) {
					//在右边找
					min=mid+1;
				}
				if (sum<array[mid]) {
					//在左边找
					max=mid-1;
				}
				if (min>max) {
					return -1;
				}
				mid=(min+max)/2;
			}
			return mid;
		}	
	}

public class     {
	
		public static void main(String[] args) {
		int [] arr={44,77,88,99,100,22};
		System.out.println(Arrays.toString(bubbleArray(arr)));
		System.out.println("-------------------");
		System.out.println(Arrays.toString(selectSort(arr)));
		}
		// 冒泡排序	
		public static int[] bubbleArray(int [] array){
			for (int i = 0; i < array.length-1; i++) {
				for (int j = 0; j < array.length-1-i; j++) {
					if (array[j]>array[j+1]) {
						int tem=array[j];
						array[j]=array[j+1];
						array[j+1]=tem;
					}
				}
			}
			return array;
		}
		//选择排序
		public static int[] selectSort(int[] array){
			
			for (int j = 0; j < array.length-1; j++) {
				for (int i =j+ 1; i < array.length; i++) {
					if (array[j]>array[i]) {
						int tem=array[i];
						array[i]=array[j];
						array[j]=tem;
					}
				}
			}
			return array;
		}
	}

2.现有一个数组,要求对数组进行倒置并且按照如下格式输出
Int[] arr = {11,22,33,44,55,66,77}
输出结果77-66-55-44-33-22-11

public class   {
	public static void main(String[] args) {
		int[] arr={11,22,33,44,55,66,77};
		System.out.println(Arrays.toString(arr));
		
		System.out.println(printArray(inversion(arr)));
	}
	public static int[] inversion(int[] arr){
		for (int i = 0; i < arr.length/2; i++) {
			int tem=arr[i];
			arr[i]=arr[arr.length-i-1];
			arr[arr.length-i-1]=tem;
		}
		return arr;
	}
	public static String printArray(int [] arr){
		String result="";
		for (int i = 0; i < arr.length; i++) {
			
			if (i==0) {
				result= ""+arr[i];
			}else{
				result += "-"+arr[i];
			}
		}
		return result;
	}
}

3.现在有如下的一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;
要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：
int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5} ;

//第一种思路：把原数组中不等于0的元素，赋值到新的数组的元素位中。
public class     {
	public static void main(String[] args) {
		int oldArr[] = { 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
		System.out.println("新的数组为" + Arrays.toString(removeZeroFromArrray(oldArr)));
	}

	public static int[] removeZeroFromArrray(int[] array) {
		int length = 0;
		for (int i = 0; i < array.length; i++) {
			if (array[i] != 0) {
				length++;
			}
		}
		int[] newArray = new int[length];
		int index = 0;
		for (int i = 0; i < array.length; i++) {
			if (array[i] != 0) {
				newArray[index] = array[i];
				index++;
			}
		}
		return newArray;
	}
}

//第二种思路，直接移除
public class     {
	static int[] arr;
	public static void main(String[] args) {
		//int [] arr ={ 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
		//int []arr=new int[]{ 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
		arr=new int[]{ 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
		for (int i = 0; i < arr.length; i++) {
			if (arr[i]==0) {
				remove(i);
				i--;
			}
		}
		System.out.println(Arrays.toString(arr));
	}
	public static void remove(int index) {
		int[] newArr = new int[arr.length - 1];
		System.arraycopy(arr, 0, newArr, 0, index);
		System.arraycopy(arr, index+1, newArr, index, arr.length - index - 1);
		arr = newArr;
	}
	}

4.现在给出两个数组
数组A：1,7,9,11,13,15,17,19
数组B：2,4,6,8,10
编写一个方法实现将两个数组合并成一个新的数组c，并且按照升序排序

public class      {
	public static void main(String[] args) {
		int [] arrA={1,7,9,11,13,15,17,19};
		int [] arrB={2,4,6,8,10};
		int [] arrC={12,24,16};
		System.out.println(Arrays.toString(mergeArray(arrA,arrB,arrC)));
	}
	public static int[] mergeArray(int[]...args){
		int totalLength=0;
		for (int[] arr : args) {
			totalLength+=arr.length;
		}
		int[] totalArray=new int [totalLength];
		int destp=0;
		for (int[] arr : args) {
			System.arraycopy(arr, 0, totalArray, destp, arr.length);
			destp+=arr.length;
		}
		sortArray(totalArray);
		return totalArray;
	}
	public static int[] sortArray(int[] arr){
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if (arr[i]>arr[j]) {
					int tem=arr[i];
					arr[i]=arr[j];
					arr[j]=tem;
				}
			}
		}
		return arr;
	}
}

5.定义
一个数组来存储12个学生的成绩{72,89,65,58,87,91,53,82,71,93,76,68}，统计各成绩等级（90分以上为‘A’，80_{89分为‘B’，70}79分为‘C’，60~69分为‘D’，60分以下为E）学生人数，并将其放入到数组count中，其中：count[0]存E级的人数，count[1]存D级的人数，……，count[4]存A级的人数。

public class   {
	public static void main(String[] args) {
		int[] arr = {72,89,65,58,87,91,53,82,71,93,76,68};
		
		int[] count = new int[5];
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] >= 90 && arr[i] <= 100) {
				count[4]++;
			} else if (arr[i] >= 80 && arr[i] <= 89) {
				count[3]++;
			} else if (arr[i] >= 80 && arr[i] <= 89) {
				count[3]++;
			} else if (arr[i] >= 70 && arr[i] <= 79) {
				count[2]++;
			} else if (arr[i] >= 60 && arr[i] <= 69) {
				count[1]++;
			} else if (arr[i] >= 0 && arr[i] < 60) {
				count[0]++;
			}
		}
		
		System.out.println(Arrays.toString(count));
	}
}

6、编写顺序查找的方法public static int[] ordinalSearch(int data[],int key)，要求该方法返回一个数组（如果key存在，数组中各元素的值分别为关键字key在原数组data中的各下标；如果key不存在，则返回一个长度为1的数组，数组元素为-1）。
基本过程思路：
（1）先扫描数组data，统计数组中key的个数n；
（2）如果n为0，直接返回一个数组元素为－1的数组；否则的话定义一个数组int index[]=new int[n]，再扫描数组data，把数组中值为key的各个元素的下标保存到数组index中，最后返回数组index】

public class   {
	public static void main(String[] args) {
		int[] date = { 11, 34, 32, 32, 44, 44, 55, 64, 45, 32 };
		Scanner input = new Scanner(System.in);
		System.out.println("请输入要查找的数");
		int numb = input.nextInt();
		System.out.println(Arrays.toString(ordinalSearch(date, numb)));
	}

	public static int[] ordinalSearch(int array[], int key) {
		int n = 0;
		for (int i = 0; i < array.length; i++) {
			if (key == array[i]) {
				n++;
			}
		}
		if (n == 0) {
			// int[]arr=new int[]{-1};
			return new int[] { -1 };
		} else {
			int[] indexArr = new int[n];
			int index = 0;
			for (int i = 0; i < array.length; i++) {
				if (key == array[i]) {
					indexArr[index] = i;
					index++;
				}
			}
			return indexArr;
		}
	}
}

7、编写一个方法public static int[][] dyadicArraySort(int a[][])，能够实现对一个二维数组a进行升序排列，要求整个二维数组中最小的值为a[0][0]，然后依次是a[0][1]，a[0][2]….，a[1][0]，a[1][1]……，使用一个无序的二维数组对你编写的方法进行检验。
（基本思想：在方法体中，先将二维数组转换为一个一维数组，然后对一维数组进行排序，排好序后再将一维数组中的各个元素依次搬到二维数组中）

public class     {
	public static void main(String[] args) {
		int[][] arr = { { 1, 7, 9, 11, 13, 15, 17, 19, 9 }, { 2, 4, 6, 8, 10 }, { 12, 24, 16 } };
		mergeArray(arr);//二维转一维并排序
		disArray(mergeArray(arr), arr);// 一维转二维
		printArray(arr);//打印

	}

	// 二维转一维+排序；
	public static int[] mergeArray(int[]... arrs) {
		//统计总长度
		int totalLength = 0;
		for (int[] arr : arrs) {
			totalLength += arr.length;
		}
		int[] mergeArray = new int[totalLength];
		int destp = 0;
		for (int[] arr : arrs) {
			System.arraycopy(arr, 0, mergeArray, destp, arr.length);
			destp += arr.length;
		}
		Arrays.sort(mergeArray);
		return mergeArray;
	}

	// 一维转二维
	public static void disArray(int[] arr, int[][] a) {
		int index = 0;
		for (int i = 0; i < a.length; i++) {
			System.arraycopy(arr, index, a[i], 0, a[i].length);
			index += a[i].length;
		}
	}
	//输出
		public static void printArray(int[][] arr) {
			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();
			}
		}
}