JavaSE-06数组

数组

数组也是数据类型，是引用类型。数组就是一组数据，存储一组类型相同的变量。

数组定义

• 数据类型[] 数组名 ={数据1,数据2,...}; 静态初始化

• 数据类型[] 数组名 = new 数据类型[大小]; 动态初始化

可以先定义名称，在new内存空间。

• 数据类型[] 数组名； 数组名 = new 数据类型[大小]; 动态初始化

public class Array01{

	//main方法
	public static void main(String[] args){

		double[] hens = {1 , 2 , 3.5 , 4 , 5 };
		int[] ns = new int[5];
    //可以用for循环赋值初始化
        ns[0] = 1;
        ns[1] = 2;
        ns[2] = 3;
        ns[3] = 4;
        ns[4] = 5;	

        //数组的引用a[i]，数组下标从0开始
        for(int i = 0; i < hens.length; i++){
        	System.out.println("第" + (i+1) + "个数组元素" + hens[i]);
        	// System.out.println("第" + (i+1) + "个数组元素" + ns[i]);
        }
		
	}
}
/*
1.数组内存放的数据的数据类型必须相同。包括基础类型和引用类型，不能混用。
2.数组创建后，如果没有赋值，有默认值。
        int 0;short 0;byte 0;long 0;
        float 0.0;double 0.0;char \u0000;
        boolean false;String null;
3.下标必须在指定范围内使用，否则会爆越界异常。
        如：int [] arr = new int[5]; 有效下标 0-4
*/

//基本类型变量1赋值给变量2，过程中是值传递，变量1的值改变，不影响变量2
//数组类型变量1赋值给变量2，过程中是引用传递（类似C的指针），变量1的值改变，变量2跟着改变。此时数组拷贝实现如下:

public class ArrayCopy{

	//main方法
	public static void main(String[] args){
		int[] arr1 = {10,20,30};
		int[] arr2 = new int[arr1.length];

		for(int i = 0; i < arr2.length; i++){
			arr2[i] = arr1[i];
		}


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

	}
}

数组添加

动态添加元素，新建一个数组，大小在原先的数组长度上加1，把旧的数据赋给新的数组，在增加一个数据，在把新的数组赋值给旧的数组。

public class ArrayAdd{

	//main方法
	public static void main(String[] args){
		int[] arr1 = {10,20,30};
		int[] arr2 = new int[arr1.length+1];

		for(int i = 0; i < arr1.length; i++){
			arr2[i] = arr1[i];
		}
		arr2[arr2.length - 1] = 40;

		arr1 = arr2;

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

	}
}

数组缩减

public class ArrayReduce{

	//main方法
	public static void main(String[] args){
		int[] arr1 = {10,20,30};
		int[] arr2 = new int[arr1.length-1];

		for(int i = 0; i < arr2.length; i++){
			arr2[i] = arr1[i];
		}

		arr1 = arr2;

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

	}
}

排序

将多个数据按照指定的顺序进行排列的过程。

• 内部排序：将数据加载到内存中排序。交换式排序法、选择式排序、插入式排序。
• 外部排序：数据量太多，无法全部加到内存中排序。借助外部存储进行排序。合并排序法、直接合并排序法。

冒泡排序

冒泡排序（Bubble Sorting），从下标较大的元素开始确定，从待排数组第一位开始依次比较相邻元素的值，若发现逆序则交换。

public class BubbleSort{

	//main方法
	public static void main(String[] args){
		int[] arr1 = {24,69,80,57,13};
		int temp = 0;
    //一共排序 arr1.length-1 轮
		for(int i = 0; i < arr1.length-1; i++){
      //每一轮排序，确定一个位置，从末尾开始
			for(int j = 0; j < arr1.length-1-i; j++){
				if(arr1[j] > arr1[j+1]){
					temp = arr1[j];
					arr1[j] = arr1[j+1];
					arr1[j+1] = temp;
				}
			}
		}
			

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

	}
}

查找

java中有2种查找。

• 顺序查找：一个个比较。

• 二分查找（后面学习在记录）：有序数组，先和中间的数比较，判断大小，选择左边还是右边的部分继续选中位数查找。

顺序查找

import java.util.Scanner;
public class SeqSearch{

	//main方法
	public static void main(String[] args){
		String[] names = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};

		Scanner myScanner = new Scanner(System.in);

		System.out.println("请输入名字：");

		String findName = myScanner.next();
		int index = -1;
		for(int i = 0; i < names.length; i++){
			if(findName.equals(names[i])){
				System.out.println("数组中存在：" + findName + "下标为" + i);
				index = i;
				break;
			}
		}
		if(index == -1){
			System.out.println("数组中不存在：" + findName);
		}
		
	}
}

多维数组

二维数组：一维数组内的元素还是一维数组，三维以此类推。

public class Array02{
    public static void main(String[] args) {
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        System.out.println(ns.length); // 3
      	System.out.println(ns[0].length); //4
      	System.out.println(ns[0][0]); //1
      
      	for (int i =0; i < ns.length; i++){
      		for(int j = 0; i < ns[i].length; j++){
      			System.out.println(ns[i][j]);
      		}
      	}
      	
    }
}

数组定义

	数据类型[][] 数组名 ={一维数组1,一维数组2,...};  静态初始化
	数据类型[][] 数组名 = new 数据类型[大小][大小];    动态初始化

可以先定义名称，在new内存空间。
	数据类型[][] 数组名；  数组名 = new 数据类型[大小][大小];   动态初始化
  
列数不固定
 	数据类型[][] 数组名 = new 数据类型[大小][]; //列数写大小
	然后对每一个行的列单独开辟空间;

public class TwoDimensionalArray01{

	//main方法
	public static void main(String[] args){
		//开辟二维空间
		int[][] arr = new int[3][];
		//开辟一维空间
		for(int i =0; i < arr.length; i++){
			arr[i] = new int[i+1];

			//赋值
			for(int j = 0; j < arr[i].length; j++){
				arr[i][j] = i + 1;
			}

		}

		//输出
		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();
		}

	}
}

杨辉三角

public class YangHui {

	//main方法
	/*
	1
	1 1
	1 2 1
	1 3 3 1
	1 4 6 4 1
	1 5 10 10 5 1
	1 6 15 20 15 6 1
	1 7 21 35 35 21 7 1
	1 8 28 56 70 56 28 8 1
	1 9 36 84 126 126 84 36 9 1
	*/

	//首尾为1 中间的等于上一行的此列和前一列数的和 yanghui[i][j] = yanghui[i-1][j] + yanghui[i-1][j-1]
	public static void main(String[] args){
		int[][] yanghui = new int[10][];
		for(int i = 0; i < yanghui.length; i++){
			//定义一维数组空间
			yanghui[i] = new int[i+1];

			for(int j = 0; j < yanghui[i].length; j++){
				if( j == 0 || j == yanghui[i].length - 1){
					yanghui[i][j] = 1;
				}else{
					yanghui[i][j] = yanghui[i-1][j] + yanghui[i-1][j-1];
				}
			}
			
		} 

		for(int i = 0; i < yanghui.length; i++){
			for( int j = 0; j < yanghui[i].length; j++){
				System.out.print(yanghui[i][j] + " ");
			}
			System.out.println();
		}
				
	}
}

三维数组

三维数组就是二维数组的数组。

int[][][] ns = {
    {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    },
    {
        {10, 11},
        {12, 13}
    },
    {
        {14, 15, 16},
        {17, 18}
    }
};