Java基础——数组

 
 
运行结果：


 
 
 
 
 
2，二维数组的内存表示


 


对于 a 数组来说，它还是一个一维数组，这个一维数组的长度为 3，也就 是说，a 数组有三个元素。而 a[0],a[1],a[2]又各自记录了一个一维数组的地址。因此我们把 a 数组称为“一维数组的一维数组”，也就是二维数组。
3，不规则数组
除了普通的二维数组之外，Java 还支持不规则数组。举例来说，如果一个柜子有三个 抽屉，这个三个抽屉中并不一定每个抽屉都具有一样的大小，完全有可能第三个抽屉更 大，元素更多，而第一个抽屉相对就比较小。
int[][] a; //定义数组变量

a = new int[3][]; //先确定第一个维度，表明柜子里有三个抽屉 a = new int[][3]; //error!
a[0] = new int[3]; //上层的抽屉有三个元素

a[1] = new int[4]; //下一层有四个元素

a[2] = new int[5]; //最底层有五个元素
 
四，数组的常见算法
1，数组的扩容
首先，数组空间一旦分配完成之后，长度就不能改变了。因此，我们不能够直接在原 有数组的空间后面增加新的内存空间。我们可以采用以下方式，来增加数组的长度：

①、分配一个新的数组，新数组的长度比原有数组要大（比如长度是原有数组的两倍）

②、把原有数组中的数据，复制到新数组中。
 
package p5;
import java.util.Arrays;
public class TestArrayExpand{
	public static void main(String []args){
	int []a={1,2,3,4};//定义数组a，并显示初始化a
	int []b=new int[8];//定义数组b,并为b分配内存空间，
	a=expand(a);
	}
	public static int[] expand(int[]a){//扩充方法1
		int []b=new int[a.length*2];
		for(int i=0;i<a.length;i++){
			b[i]=a[i];
		
	}
	return b;
		
	}
	public static int []expand1(int []a){//扩充方法2
		int []b=new int [a.length*2];
		System.arraycopy(a,0,b,0,a.length);
		return b;
	}
	public static int []expand2(int []a){//扩充方法3
		
		return Arrays.copyOf(a,a.length*2);
	}
}
 
2，冒泡排序
在排序的过程中，相邻元素不停进行比 较和交换。在交换的过程中，大的元素沉向数组的末尾，小的元素走向数组的开头；这就好像在水里面：重的东西往下沉，而轻的东西往上浮起来。正因为这种排序方式很像水里 的气泡往上浮的过程，因此，这种排序方式被称为冒泡排序。
接下来，我们来写冒泡排序的代码。如果有五个元素，则需要进行 4 次循环，也就是 说，如果数组的长度是 a.length 的话，则需要进行 a.length-1 次循环。因此，外层循环如下：
for(int i = 0; i<a.length-1; i++){
		…
		}

内层循环稍有点复杂。我们让内层循环的循环变量为 j，则每次进行比较的时候，比较 的都是 a[j]和 a[j+1]这两个元素。那么 j的循环条件怎么写呢？

第 1 次循环，i 的值为 0，因为要排到最后一个，因此 j+1 最大值为 a.length，j 的最大值为 a.length-1； 
 
第 2 次循环，i的值为 1，j+1 的最大值为 a.length-1，j的最大值为 a.length-2； 
第 3 次循环，i的值为 2，j+1 的最大值为 a.length-2，j的最大值为 a.length-3；

由上面，我们可知，每次循环 j+1 的最大值，都是 a.length-i；而 j 的最大值，就是 a.length-i-1。 因此，内层循环条件如下：

for(int i = 0; i<a.length-1; i++){
	for(int j = 0; j<a.length–i-1; j++){
		比较 a[j]和 a[j+1]， 如果 a[j]比 a[j+1]大，则交换两个元素的值 13
		}
	}


进一步细化，代码为 

for(int i = 0; i<a.length-1; i++){ 
		for(int j = 0; j<a.length–i-1; j++){ 
			if(a[j] > a[j+1]){ 
				则交换 a[j]和 a[j+1]的值 
			} 
		} 
	}


如何交换两个变量的值呢？假设有两个变量 a = 5；b=4；要交换两个 a 和 b 的值，应该怎么做呢？

如果直接执行 a = b 的话，则 a 的值 5 就会被 b 的值覆盖。这样，a 有了 b 的值，但是 b 却无法获得 a 变量原来的值了。因此，为了交换两个变量的值，需要第三个变量参与。

首先，定义一个新变量 t； 然后，把 a 的值赋值给 t：t = a；

接下来，把 b 的值赋值给 a： a=b。这样会覆盖 a 原有的值，但是没关系，a 原有的值 已经被保存在 t 变量中了。

再接下来，把在 t 变量中保存的原有的 a 变量的值，赋值给 b。
 
示例代码：
package p5;
public class TestArraySort{
	public static void main(String[]args){
		int []data={5,4,2,1,3};//定义一个一维数组，并显示初始化数组
		int n=data.length;//定义变量n为数组长度，便于后面使用数组长度
		for(int i=1;i<n;i++){//冒泡排序必定是n-1次，i表示第几次冒泡排序
			for(int j=0;j<(n-i);j++){//归纳总结，从0开始data[j]与data[j+1]比较，比较n-i次
				if(data[j]>data[j+1]){
				int t=data[j];
				data[j]=data[j+1];
				data[j+1]=t;//data[j]与data[j+1]交换位置
				}
				
			}	
			
			
		}
		
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+" ");//遍历输出data[i]
		}
		System.out.println();//换行
		
	 	
	}
}
 运行结果：


 
3，选择排序
选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）
package p5;
public class TestArraySort{
	public static void main(String[]args){
		int []data={5,4,2,1,3};//定义一个一维数组，并显示初始化数组
		int n=data.length;//定义变量n为数组长度，便于后面使用数组长度
		for(int i=0;i<(n-1);i++){//选择排序
			for(int j=i+1;j<n;j++){
				if(data[i]>data[j]){
					int t=data[i];
					data[i]=data[j];
					data[j]=t;
				}
			}
			
		}
		
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+" ");//遍历输出data[i]
		}
		System.out.println();//换行
		
	 	
	}
}