数组及其使用

数组

• 数组是相同类型数据的有序集合

package array;

public class Dome01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
int[] nums;//1.定义

nums=new int[10];//开辟10个空间
//3.给数组元素中赋值
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
nums[5]=6;
nums[6]=7;
nums[7]=8;
nums[8]=9;
nums[9]=10;
//计算所有数的和
int sum=0;
//计算数组长度：arrays.Lnegth
for(int i=0;i<nums.length;i++)
{
	sum=sum+nums[i];

}
System.out.println(sum);
	}
	

}

---

内存分析

package array;

public class Demo02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//静态初始化
		int[] a= {1,2,3,4,5,6,7,8};
		System.out.println(a[0]);
		//动态初始化
		int[] b=new int[10];
		b[0]=10;
		System.out.println(b[0]);
		}

}

ArrayIndexOutOfBoundsException ：数组下标定义越界

---

数组使用

package array;

public class Demo03 {
	public static void main(String[] args) {
		int[] array= {1,2,3,4,5};
		//打印全部数组元素
		for(int i=0;i<array.length;i++)
		{
			System.out.println("=========");
		}
			//计算所有元素和
			int sum=0;
			for(int i=0;i<array.length;i++) {
				sum += array[i];
				System.out.println("sum"+sum);
				System.out.println("=========");
			
			}
			//查找最大元素
			int max=array[0];
			for(int i=1;i<array.length;i++) {
				if(array[i]>max) {
					max=array[i];
				}
			}
			System.out.println("max="+max);
		}
}

package array;

public class Demo04 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
int[] arrays= {1,2,3,4,5};
//没有下标
/**for(int array:arrays) {
	System.out.println(array);
}*/
 int[] reverse=reverse(arrays);
 printArray(reverse);
	}
	//打印数组
	public static void printArray(int[] arrays) {
		for(int i=0;i<arrays.length;i++) {
			System.out.print(arrays[i]+" ");
		}
	}
//反转数组
	public static int[] reverse(int[] arrays) {
		int[] result=new int[arrays.length];
		//反转的操作
		for (int i=0,j=result.length-1;i<arrays.length;i++,j--) {
			result[j]=arrays[i];
		}
		return result;
	}
	
}

---

多维数组

package array;

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

---

冒泡排序

package array;

import java.util.Arrays;

public class Demo06 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
int [] a= {1,2,3,4,5,33,55,23,53,5};
int[] sort=sort(a);//调用完我们子写的排序方法以后，返回一个排序后的数组
  System.out.println(Arrays.toString(sort));
	}
//冒泡排序
public static int[] sort(int[] array) {
	int temp=0;
	//外层循环，判断走多少次
	for(int i=0;i<array.length-1;i++) {
		//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
		for(int j=0;j<array.length-1-i;j++) {
			if(array[j+1]>array[j]){//从小到大只需要变换一下符号
				temp=array[j];
				array[j]=array[j+1];
				array[j+1]=temp;
			}
		}
	}
	return array;
}
}

时间复杂度O(n2)

package array;

import java.util.Arrays;

public class Demo06 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
int [] a= {1,2,3,4,5,33,55,23,53,5};
int[] sort=sort(a);//调用完我们子写的排序方法以后，返回一个排序后的数组
  System.out.println(Arrays.toString(sort));
	}
//冒泡排序
public static int[] sort(int[] array) {
	int temp=0;
	//外层循环，判断走多少次
	for(int i=0;i<array.length-1;i++) {
		boolean flag=false;//通过flag标识位减少没有意义的比较
		//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
		for(int j=0;j<array.length-1-i;j++) {
			if(array[j+1]>array[j]){//从小到大只需要变换一下符号
				temp=array[j];
				array[j]=array[j+1];
				array[j+1]=temp;
				flag=true;
			}
		}
		if(flag==false) {
			break;
		}
	}
	return array;
}
}
//优化

---

稀疏数组

//五子棋
package array;

public class Demo07 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//1.创建一个二维数组 11*11 0：没有棋子，1：黑棋 2：白棋
		int[][]array1=new int[11][11];
		array1[1][2]=1;
		array1[2][3]=2;	
		//输出原始数组
		System.out.println("输出原始的数组");
		for(int[] ints:array1) {
			for(int anInt:ints) {
				System.out.print(anInt+"\t");
			}
			System.out.println();
		}
		//转换为稀疏数组
		//获取有效值的个数
		int sum=0;
		for(int i=0;i<11;i++) {
			for(int j=0;j<11;j++) {
				if(array1[i][j]!=0) {
					sum++;
				}
			}
		}
		System.out.println("有效值的个数"+sum);
		//2.创建一个稀疏数组的数组
		int[][] array2=new int[sum+1][3];
		
		array2[0][0]=11;
		array2[0][1]=11;
		array2[0][2]=sum;
		//遍历二维数组，将非零的值，存放在稀疏数组中
		int count=0;
		for(int i=0;i<array1.length;i++) {
			for(int j=0;j<array1[i].length;j++) {
				if(array1[i][j]!=0) {
					count++;
					array2[count][0]=i;
					array2[count][1]=j;
					array2[count][2]=array1[i][j];
				}
			}
		}
				//输出稀疏数组
		System.out.println("稀疏数组");
		for(int i=0;i<array2.length;i++) {
			System.out.println(array2[i][0]+"\t"
		+array2[i][1]+"\t"
		+array2[i][2]+"\t");
		
		}
		System.out.println("=========");
		System.out.println("还原");
		//1.读取稀疏数组
		int[][] array3=new int[array2[0][0]][array2[0][1]];
		//2.给其中的元素还原它的值
		for(int i=1;i<array2.length;i++) {
			array3[array2[i][0]][array2[i][1]]=array2[i][2];
				
		}
		//3.打印
		System.out.println("输出还原的数组");
		for(int[] ints:array3) {
			for(int anInt:ints) {
				System.out.print(anInt+"\t");
			}
			System.out.println();
		}
		
	}

}