4.Java基础之数组&排序问题

数组

---

1. 定义:

• 数组是用来存储相同性质的数据的集合

2. 特点：

• 存储的是批量数据，数组是引用类型
• 下标也叫索引，数组中的下标从0开始，最大长度=下标-1
• 可以定义任意数据类型的数组
• 数组一旦创建成功,长度不可更改
• length属性是数组的固有属性,用来获取数组的长度----使用形式:数组名.length

3. 声明用法：

• 数组类型[] 数组名;
• 数据类型 数组名;

4. 数组的赋值:

• 数组名 = new 数据类型[存储数据的个数];
• 存放长度=数组中数据的个数

5. 使用数组存储数据

• 数组名[下标] = 值;

6. 获取数组中的数据

• 数组名[下标];

public class TestArray {
	public static void main(String[] args){
		System.out.println("-----------------");
		int a = 10;
		System.out.println(a);
		//声明并赋值一个数组
		int arr2[] = new int[1];
		System.out.println(arr2);//内存首地址[I@15db9742
		
		String str = "哈哈";
		System.out.println(str);
		
		/*
		 * 数组创建的第二种形式,直接初始化赋值
		 * 语法格式:数据类型[] 数组名={值1,值2...};
		 *
		 */
		String[] names={"如花","翠花"};
		System.out.println(names[1]);
		//System.out.println(names[2]);//符合语法,但是执行过程中会超出数组界限
		
		/*
		 * 数组创建的第三种形式
		 * 语法格式:数据类型[] 数组名 = new 数据类型[]{值1,值2...}
		 * 
		 */
		String[] names2=new String[]{"小明","小红","小黑"};
		System.out.println(names2[1]);
		System.out.println("----------------");
		/*数组的遍历*/
		for(int i=0;i<names2.length;i++){
			System.out.println(names2[i]);
		}
		System.out.println("----------------");
		/*
		 * foreach遍历数组,增强for循环
		 * 自动打开和关闭的功能
		 * 数组数据取完,自动结束循环
		 * 
		 * */
		for(String name:names2){
			System.out.println(name);
		}
	}
}

---

数组的缺省值

public class TestArray2 {
	public static void main(String[] args){
		/*
		 * 数组的缺省值
		 * byte[]		0
		 * short[]		0
		 * int[]		0
		 * long[]		0
		 * 
		 * float[]		0.0
		 * double[]		0.0
		 * 
		 * char[]		unicode下的一个空格
		 * 
		 * boolean[]	false	
		 * 
		 * String[]		null
		 */
		//byte[] bytes = new byte[0];
		byte[] bytes = new byte[1];
		System.out.println(bytes[0]);
		short[] shorts = new short[1];
		System.out.println(shorts[0]);
		
		float[] floats=new float[1];
		System.out.println(floats[0]);
		
		char[] chars = new char[1];
		System.out.println(chars[0]+"哈哈");
		System.out.println(" 哈哈");
		System.out.println("\u0000哈哈");
		
		boolean[] bool = new boolean[1];
		System.out.println(bool[0]);
		
		String[] strs = new String[1];
		System.out.println(strs[0]);
		
		String str = "";		//有地没盖房子
		String str2 = null;		//连地都没有
	}
}

---

冒泡排序

public class BubbleSort {
	public static void main(String[] args){
		/*
		 * 冒泡排序:
		 * 	降序
		 * 	升序
		 */
		int[] arr = {100,54,23,48,98,12,46,31};
		//升序排序
		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 c = arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=c;
				}
			}
		}
		//遍历数组
		for(int i:arr){
			System.out.println(i+" ");
		}
	}
}

---

插入排序

public class InsertSort {
	public static void main(String[] args) {
		/*
		 * 插入排序
		 */
		int[] arr = { 100, 54, 23, 48, 98, 12, 46, 31 };
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j > 0; j--) {
				if (arr[j - 1] > arr[j]) {
					int c = arr[j];
					arr[j] = arr[j - 1];
					arr[j - 1] = c;
				} else {
					break;
				}
			}
		}

		for (int i : arr) {
			System.out.print(i + " ");
		}
	}
}

---

选择排序

public class SelectSort {
	public static void main(String[] args){
		/*
		 * 选择排序
		 * 
		 */
		int[] arr = { 100, 54, 23, 48 };
		//先确定，选择的下标范围
		for(int i=0;i<arr.length-1;i++){
			int min = i;//i下标就是最小值对应的下标
			//参与比较的数值的下标，从i+1开始到length-1
			for(int j=i+1;j<arr.length;j++){//确定j的取值范围
				if(arr[min]>arr[j]){
					min=j;//若比arr[min]小,则将j下标赋值给min下标
				}
			}
			//让min和i的位置进行交换，前提是min!=i
			if(i!=min){
				int c = arr[i];
				arr[i] = arr[min];
				arr[min]=c;
			}
		}
		for (int i : arr) {
			System.out.println(i+" ");
		}
	}
}

---

二分查找法

public class Search {
	public int binarySearch(int[] array,int num){
		int min=0,max=array.length-1;
		while(min<=max){
			int mid = (min+max)/2;
			if(num<array[mid]){
				max=mid-1;
			}else if(num==array[mid]){
				return mid;
			}else{
				min=mid+1;
			}
		}
    	return -1;
	}
	public static void main(String[] args) {
		int[] array = {24,13,61,58,49,82,11};
		Arrays.sort(array);
		Search search = new Search();
		System.out.println(search.binarySearch(array,30));
	}
}   

---

除0

public class DelectZero {
	public static void main(String[] args){
		 int[] a={1,2,1,2,1,2,1,2,0,2,0,0,0,0,0};
		 int num = 0;//记录0项个数
		 //遍历a数组
		 for (int i : a) {
			if(i==0){
				num++;
			}
		}
		 int[] b = new int[a.length-num];//确定b的长度
		 //将数组a中的非零项赋值给数组b
		 int index = 0;//代表b的下标
		 for (int i : a) {
			if(i!=0){
				b[index]=i;
				index++;
			}
		}
		 //遍历数组b
		 for (int i : b) {
			System.out.print(i+" ");
		}
	}
}

---

数组反转

public class InversionArray {
	public static void main(String[] args){
		//不创建新数组完成数组反转
		int[] a={1,2,3,4,5};
		//确定遍历数组a的范围为(a.length-1)/2	
		for(int i=0;i<(a.length-1)/2;i++){//除2的目的是为了防止二次换位
			int c = a[i];
			a[i] = a[a.length-1-i];
			a[a.length-1-i] = c;
		}
		for(int i:a){
			System.out.print(i+" ");
		}
	}
}

---

合并数组

public class CombinArray {
	public static void main(String[] args){
		int[] a={1,3,5};
		int[] b={2,4,6};
		int flag=a.length+b.length;
		int[] c = new int[flag];
		for(int i=0;i<flag;i++){
			if(i<3){
				c[i]=a[i];
			}else{
				c[i]=b[i-3];
			}
		}
		for (int i : c) {
			System.out.print(i+" ");
		}
	}
}

---

二位数组

1. java本身不支持多维数组,使用一维数组的嵌套,到达任意维度

2. 语法格式

数据类型[][]  数组名 [= new 数据类型[二维数组的长度][]];

public class TwoDimensionalArray {
	public static void main(String[] args){
		/*
		 * 二维数组
		 * 	嵌套的一维数组
		 */
		int[][] arr = new int[3][2];//这个二维数组的长度是3,里面存放的是长度为2的一维数组
		
		int[][] arr2 = new int[3][];//这个二维数组的长度为3
		//arr2[0] = new int[2];
		arr2[0] = new int[]{1,2,3};
		arr2[1] = new int[3];
		arr2[2] = new int[100];
		//无论是多少维度的数组,数据都是在一维数组中存放
		arr[1][1] = 100;
		
		//直接初始化赋值
		int[][] arr3 = {{1},{2,3},{4,5,6}};
		System.out.println(arr[2][1]);
		
		//初始化数组,并赋值
		int[][] arr4 = new int[][]{{2,3},{4,5,6}};
		System.out.println(arr4[1][0]);
	
		//遍历二维数组
		for(int i = 0;i<arr4.length;i++){
			//arr4[i]是一维数组
			for(int j=0;j<arr4[i].length;j++){
				System.out.println("arr4["+i+"]["+j+"]="+"arr4["+arr4[i][j]+"]");
			}
		}
		//使用foreach遍历
		for(int[] i:arr4){
			for(int j:i){
				System.out.println(j);
			}
		}
	}
}