day09数组的排序&复制&二维数组

一.数组的排序

排序：数组是存储一组数据，这些数据是有顺序的。但是数值本身可能是无序的。可以通过算法来实现给数组进行排序，升序（数值从小到大），降序（数值从大到小）。

1.1.冒泡排序：Bubble Sort

原理：比较相邻的两个数，将较大的数，向后移动。长度减1

//核心代码
    int[] a = {12,44,3,5,35};
	for(int i = 1 ; i<a.length; i++){//控制轮数
        for(int j = 0; j<a.length-i; j++){
            if(a[j] > a[j+1]){
                //交换位置
            }
        }
    }

举例

public class TestBubbleSort {
	public static void main(String[] args) {
		int[] arr = {15,23,8,10,7};
		
		for(int i= 1; i<arr.length;i++){//控制轮数：i=1,2,3,4
			
			for(int j = 0;j < arr.length - i;j++){
				if(arr[j] > arr[j+1]){
					//交换位置
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}

		for(int i = 0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
}

1.2.选择排序（升序）

思路：（升序）：每次找一个基准值，定一个变量k表示较少的值的下标。每轮比较完后，都在基准值上放一个较小数。

//核心代码：
int[] a = {15,33,8,10,7};
for(int i = 0; i<a.length-1; i++){//控制比较轮数
    int k = i;
    for(int j = k+1; j<a.length; j++){
        if(a[k] > a[j]){
            k = j;
        }
    }
    //交换
    if(k != i){//基准值下标和变量相同，不用换位置
        int temp = a[k];
        a[k] = a[i];
        a[i] = temp;
    }
}

举例

public class TestSelectionSort {

	public static void main(String[] args) {
		int[] arr = { 15, 23, 8, 10, 7 };

		for (int i = 0; i < arr.length - 1; i++) {// i = 0,1,2,3,表示轮数

			int k = i;// 用于标记本轮中，要找的比较小的值。
			// 依次比较arr[k]
			for (int j = k + 1; j < arr.length; j++) {
				// 比较arr[k]和arr[j],如果arr[k]值大于arr[j]的值，将j赋值给k
				if (arr[k] > arr[j]) {
					k = j;
				}
			}

			// 交换arr[i]和arr[k]
			if (k != i) {
				int temp = arr[i];
				arr[i] = arr[k];
				arr[k] = temp;
			}
		}

		// 排序后，打印数组
		for (int e : arr) {
			System.out.println(e);
		}
	}
}

1.3.工具类:JDK提供好的类(Arrays)

Arrays.sort(a);//排序，给a排

import java.util.Arrays;
public class TestArrays {

	public static void main(String[] args) {
		//使用Arrays工具类提供的方法，进行排序
		int[] a = {15,23,8,10,7};		
		Arrays.sort(a);//排序，给a排
		
		for(int e:a){// 排序后，打印数组
			System.out.println(e);
		}
	}
}

二. 数组的复制

就是将一个数组的数据，复制到另一个数值中。

2.1方法一:自己通过循环依次复制

通过循环，依次复制，将原数组的数据，一个一个，复制到目标数组中

public class Test1Copy {

	public static void main(String[] args) {
		int[] a = {1,2,3};	
		int[] b = new int[10];
	
		for(int i=0;i<a.length;i++){
			b[i] =a[i];
		}
		
		for(int e :b){
			System.out.println(e);//1,2,3,0,0,0,0,0,0,0
		}
	}
}

2.2方法二:借助于Arrays类

copyOf(int[] 原始数组，int 新数组的长度)
Arrays类里方法：copyOf(原数组，新数组的长度)–>返回值是新数组

import java.util.Arrays;
public class Test2Copy {

	public static void main(String[] args) {
		int[] a = {1,2,3};
		/*
		 * copyOf(int[] 原始数组，int 新数组的长度)
		 * 返回值就是新的数组
		 */
		int[] c = Arrays.copyOf(a, 5);//int[] c = {1,2,3,0,0}
		for(int e:c){
			System.out.println(e);//1,2,3,0,0
		}	
	}
}

2.2方法三：借助于System类

System.arraycopy(src, srcPos, dest, destPos, length)
System类里的方法：arraycopy(原数组，原数组位置，新数组，新数组位置，拷贝的个数)

import java.util.Arrays;
public class Test3Copy {

	public static void main(String[] args) {
		/*
		 * arraycopy(src, srcPos, dest, destPos, length)
		 * 第一个参数：原始数组
		 * 第二个参数：从原始数组的哪个下标开始复制
		 * 第三个参数：目标数组
		 * 第四个参数：目标数组从哪个下标开始贴
		 * 第五个参数：拷贝几个数据
		 */
		int[] a = {1,2,3};
		int [] d = new int[10];
		System.arraycopy(a, 1, d, 5, 2);
		for(int e:d){
			System.out.print(e+"\t");//0,0,0,0,0,2,3,0,0,0
		}
	}
}

三. 二维数组

3.1 维度：dimension

数组：存储相同类型的一组数据。
一维数组：数组中存储的就是数据了。
二维数组：存储的是一组数组。本质也叫数组的数组。也叫矩阵：行和列的。

3.2 二维数组的创建语法

1.先声明，在创建
int[][] a = new int[3][4];//二维，一维一起创建

2.先创建二维数组，后创建一维数组
int[][] b = new int[3][];//只是创建了二维数组，但是一维还没创建
b[0] = new int[3];
b[1] = new int[4];
b[2] = new int[4];
3.声明，创建，赋值一起
int[][] c = {{},{},{}};
4.声明，创建，赋值一起
int[][] d = new int[][]{{},{},{}};

	int[][] arr1 = {{1,2,3},{4,5,6},{7,8,9,10}};
	
	System.out.println(arr1);//打印的是二维数组的地址
	System.out.println(arr1.length);//二维数组的长度-->二维数组中一维数组的个数
	System.out.println(arr1[0]);//二维数组的第一个元素-->第一个一维数组，地址
	System.out.println(arr1[0].length);//第一个一维数组的长度
	System.out.println(arr1[0][0]);//第一个一维数组的第一个元素