教学日志：javaSE-数组

一、一维数组

import java.util.Scanner;
/*
	数组：存储一组相同数据类型的有序集合。
		特点：
			1、数组中的元素必须是同一种数据类型，可以是基本数据类型，也可以是引用数据类型
			2、获取数组元素需要使用下标来获取，下标范围[0,length-1]
			3、数组在定义的时候必须指定大小，并且一旦指定大小之后是不能修改的
			4、数组中的元素是有序集合，这个有序指的不是大小排序，指的按照插入的先后顺序

		使用：
			1、声明数组
			2、分配空间
			3、赋值
			4、数组操作

*/

public class ArrayDemo{
	public static void main(String[] args){
		//声明数组
		/*int[] array;
		//分配空间（申请空间）
		array = new int[5];
		//赋值
		array[0] = 0;
		array[1] = 1;
		array[2] = 2;
		array[3] = 3;
		array[4] = 4;
		//array[5] = 5;   //数组越界异常Exception
		//数组操作
		System.out.println(array[0]);*/

		//数组常见的几种写法：
		//1、声明并分配空间
		/*int[] arr1 = new int[5];
		int [] arr2 = new int[5];
		int arr3[] = new int[5];
		//2、声明并赋值
		int[] arr4 = new int[]{1,2,3,4,5};
		//3、声明并初始化
		int[] arr5 = {10,20,30,40,50};*/

		/*
		//计算5位同学的平均成绩
		Scanner sc = new Scanner(System.in);
		//定义一个数组存储5位同学的成绩
		int[] arr = new int[5];
		//定义变量存储总成绩
		int sum = 0;
		for(int i = 0; i < arr.length ;i++){
			System.out.print("请输入第"  + (i+1) + "位同学的成绩：");
			arr[i] = sc.nextInt();
			sum += arr[i];
		}
		System.out.println(arr.length + "位同学的平均成绩是：" + ((double)sum/arr.length));*/

		//int[] arr1 = {1,2,3,4,5};  //声明并初始化的写法必须在一行写完

		/*int[] s = new int[10];
		int[] s1 = new int[10];
		int[] s2= new int[10];
		int[] s3 = new int[10];
		int[] s4 = new int[10];
		int[] s5 = new int[10];
		int[] s6 = new int[10];
		int[] s7 = new int[10];
		int[] s8 = new int[10];
		int[] s9 = new int[10];
		System.out.println(s);
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s4);
		System.out.println(s5);
		System.out.println(s6);
		System.out.println(s7);
		System.out.println(s8);
		System.out.println(s9);*/

		//int a;
		//System.out.print(a);  //报错，a没有引用地址

		/*
			数组元素的默认初始化：
				数组在定义的时候，每个数组元素都会有默认值，系统会根据数组元素数据类型默认进行初始化工作
				int: 0
				boolean: false
				String: null

		*/
		/*int[] arr1 = new int[5];
		System.out.println(arr1[3]);
		String[] arr2 = new String[5];
		System.out.println(arr2[0] + "--" + arr2[1] + "--" +arr2[2] + "--" +arr2[3] + "--" +arr2[4]);*/

		//数组中的属性length
		int[] arr1 = new int[10];
		System.out.println(arr1.length);

	}
}

一、二维数组和数组拷贝

/*
    二维数组：数组中的每一个元素又是一个一维数组
              多维数组不必是规则矩阵

*/

public class TwoArray{
    public static void main(String[] args){
        /*int[] array = new int[5];
        //定义二维数组
        int[][] array2 = new int[3][];

        array2[0] = new int[2];
        array2[1] = new int[3];
        array2[2] = new int[4];

        //为一维数组中的每个元素赋值
        array2[0][0] = 1;
        array2[0][1] = 2;

        array2[1][0] = 10;
        array2[1][1] = 20;
        array2[1][2] = 30;

        array2[2][0] = 100;
        array2[2][1] = 200;
        array2[2][2] = 300;
        array2[2][3] = 400;

        //遍历数组
        for(int i = 0;i<array2.length;i++){
            for(int j = 0;j<array2[i].length;j++){
                System.out.print(array2[i][j] + "\t");
            }
            System.out.println();
        }*/

        //数组拷贝
        /*String[] s = {"Mircosoft","IBM","Sun","Oracle","Apple"};
        String[] sBak = new String[6];
        System.arraycopy(s,0,sBak,2,s.length);
        for(int i=0;i<sBak.length;i++){
            System.out.print(sBak[i]+" ");
        }*/
        System.out.println();
        int[][] intArray = {{1,2},{1,2,3},{3,4}};
        int[][] intArrayBak = new int[3][];
        System.arraycopy(intArray,0,intArrayBak,0,intArray.length);
        intArrayBak[2][1] = 100;
        for(int i = 0;i<intArrayBak.length;i++){
            for(int j =0;j<intArrayBak[i].length;j++){
                System.out.print(intArrayBak[i][j]+" ");
            }
            System.out.println();
        }
    }
}

三、main方法形参String[] args

public class ArgsDemo{
    public static void main(String[] args){
        for(int i = 0;i <args.length;i++){
            System.out.print("args[" + i + "]=" + args[i] + "\t");
        }
    }
}

四、数组排序

import java.util.Arrays;
/*
数组也是数据结构中的一种实现，存储数据的时候很多时候都需要使用数组
    常见的数据结构：
        线性表
        非线性表
        树
        图
        队列
        堆
        栈

数组一般会考算法：
    面试需求：
        1、手写某种算法
            冒泡排序
            选择排序
            插入排序
            快速排序
        2、排序算法的时间复杂度（空间复杂度）
            时间复杂度是衡量一个数据结构是否合适的衡量标准
        3、排序算法的稳定性
            算法执行之前各元素的位置和执行之后的位置是否发生变化

*/

public class ArraySort{
    public static void main(String[] args){
        int[] array = {1,3,5,7,2,8,6,9,4};
        //冒泡排序
        /*for(int i = 0; i <array.length; i++){
            for(int j = 0; j <array.length - 1- i;j++){
                //判断前面的数大于后面的数，就需要交换位置
                if(array[j] > array[j+1]){
                    //前后位置交换
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }*/

        //选择排序
        /*for(int i = 0; i<array.length; i++){
            //记录下来假定是最小的值的位置
            int index = i;
            //从前往后找比参照数更小的数，然后进行标记，后面的数再比较大小，从这个从新标记的位置比起
            for(int j = i;j<array.length;j++){
                if(array[j] < array[index]){
                    index = j;
                }
            }
            //交换位置，把小的数往前放，大数往后放
            int temp = array[index];
            array[index] = array[i];
            array[i] = temp;
        }*/

        //使用Arrays类中的sort方法进行排序
        Arrays.sort(array);

        //遍历数组
        for(int i = 0; i<array.length;i++){
            System.out.print(array[i] + "\t");
        }

    }
}

五、数组作业

1.数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。

public class Test {
	// 思路：遍历数组时当有值与输入字符串相同时使用一个boolean记录状态
	public static void main(String[] args) {
		String[] strArr = new String[10];
		strArr[0] = "java";		strArr[1] = "html";
		strArr[2] = "sql";		strArr[3] = "android";
		strArr[4] = "javascript";		strArr[5] = "ruby";
		strArr[6] = "c";
		strArr[7] = "c++";
		strArr[8] = ".net";
		strArr[9] = "ios";
		Scanner scanner = new Scanner(System.in);
		System.out.print("请输入需要查找的计算机编程语言:");
		String inputStr = scanner.next();
		boolean flag = false;
		for (String string : strArr) {
			if (string.equals(inputStr)) {
				flag = true;
			}
		}
		if (flag) {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
	}
}

2.获取数组最大值和最小值操作：利用Java的Math类的random()方法，编写函数得到0到n之间的随机数，n是参数。并找出产生50个这样的随机数中最大的、最小的数，并统计其中>=60的有多少个。
提示：使用 int num=(int)(n*Math.random());获取随机数

public class Test {
	public static void main(String[] args) {
		//创建一个长度为50的，每个元素在0-100之间的数组
		int[] arr = getArray(100);
		//遍历数组
		printArr(arr);
		//获取最大值和最小值
		int min = getMin(arr);
		int max = getMax(arr);
		System.out.println("数组中最大值：" + max + "\t数组中最小值：" + min);
		//统计其中大于等于60的元素个数
		int count = count(arr,60);
		System.out.println("数组中大于或等于60的数有:" + count + " 个");
	}
	//遍历数组
	private static void printArr(int[] arr) {
		System.out.println("输出数组元素");
		for(int i=0;i<arr.length;i++){
			if(i%10 ==0){
				System.out.println();
			}
			System.out.print(arr[i]+"\t");
		}
	}
	//获取数组最大值
	private static int getMax(int[] arr) {
		int max = arr[0];
		for(int i=1;i<arr.length;i++){
			if(max<arr[i]){
				max = arr[i];
			}
		}
		return max;
	}
	//获取数组最小值
	private static int getMin(int[] arr) {
		int min = arr[0];
		for(int i=0;i<arr.length;i++){
			if(min>arr[i]){
				min = arr[i];
			}
		}
		return min;
	}
	// 创建数组 并且初始化50个数据
	public static int[] getArray(int n) {
		int arr[] = new int[50];
		for (int i = 0; i < 50; i++) {
			arr[i] = (int) (n * Math.random());
		}
		return arr;
	}
	// 统计数组中大于等于60的数量的方法 思路：使用一个int值计数
	public static int count(int[] arr,int elem) {
		int count = 0;
		for (int i : arr) {
			if (i >= elem) {
				count++;
			}
		}
		return count;
	}
}

3.数组逆序操作：定义长度为10的数组，将数组元素对调，并输出对调前后的结果。

思路：把0索引和arr.length-1的元素交换，把1索引和arr.length-2的元素交换…..

只要交换到arr.length/2的时候即可。

public class Test{
	public static void main(String[] args) {
		//定义一个数组，并进行静态初始化。
		int[] arr = {12,98,50,34,76,87,90,34,67,80};
		//逆序前
		System.out.println("逆序前：");
		printArr(arr);
		//逆序后
		System.out.println("逆序后：");
		reverseArr(arr);
		printArr(arr);
	}
	public static void reverseArr(int[] arr) {
		for(int x=0; x<arr.length/2; x++) {
			int temp = arr[x];
			arr[x] = arr[arr.length-1-x];
			arr[arr.length-1-x] = temp;
		}
	}
	//遍历数组
	public static void printArr(int[] arr) {
		System.out.print("[");
		for(int x=0; x<arr.length; x++) {
			if(x == arr.length-1) { //这是最后一个元素
				System.out.println(arr[x]+"]");
			}else {
				System.out.print(arr[x]+", ");
			}
		}
	}
}

4.合并数组操作：现有如下一个数组：   int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}   要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为： int newArr [] ={1,3,4,5,6,6,5,4,7,6,7,5}

思路： 确定出不为0的个数，这样可以开辟新数组；从旧的数组之中，取出内容，并将其赋给新开辟的数组。

public class Test {
	public static void main(String[] args) {
		int oldArr[] = { 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
		int newArr[] = selectArr(oldArr);
		for (int i : newArr) {
			System.out.print(i+" ");
		}
	}
	// 去掉数组中值为0的元素的方法
	public static int[] selectArr(int[] arr) {
		// 1.计算数组中元素不为0的个数
		int count = 0;
		for (int i : arr) {
			if (i != 0) {
				count++;
			}
		}
		// 2.创建一个新数组,长度为count
		int newArr[] = new int[count];
		// 3.复制不为0的元素到新数组中
		int size = 0;
		for (int i : arr) {
			if (i != 0) {
				newArr[size++] = i;
			}
		}
		return newArr;
	}
}

5.二分法查找操作：使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。

分析：二分法查找的前提是数组有序。

假如有一组数为3，12，24，36，55，68，75，88要查给定的值24.可设三个变量front，mid，end分别指向数据的上界，中间和下界，mid=（front+end）/2.　　

1. 开始令front=0（指向3），end=7（指向88），则mid=3（指向36）。因为mid>x，故应在前半段中查找。
2. 令新的end=mid-1=2，而front=0不变，则新的mid=1。此时x>mid，故确定应在后半段中查找。
3. 令新的front=mid+1=2，而end=2不变，则新mid=2，此时a[mid]=x，查找成功。
4. 如要查找的数不是数列中的数，例如x=25，当第三次判断时，x>a[mid]，按以上规律，令front=mid+1，即front=3，出现front>end的情况，表示查找不成功。

public class BinarySearch {
	public static void main(String[] args) {
		int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		System.out.println(searchLoop(array, 9));
	}
	/**
	 * 循环二分查找，返回第一次出现该值的位置
	 * @param array 已排序的数组
	 * @param findValue   需要找的值
	 * @return 值在数组中的位置，从0开始。找不到返回-1
	 */
	public static int searchLoop(int[] array, int findValue) {
		// 如果数组为空，直接返回-1，即查找失败
		if (array == null) {
			return -1;
		}
		// 起始位置
		int start = 0;
		// 结束位置
		int end = array.length - 1;
		while (start <= end) {
			// 中间位置
			int middle = (start + end) / 2;
			// 中值
			int middleValue = array[middle];
			if (findValue == middleValue) {
				// 等于中值直接返回
				return middle;
			} else if (findValue < middleValue) {
				// 小于中值时在中值前面找
				end = middle - 1;
			} else {
				// 大于中值在中值后面找
				start = middle + 1;
			}
		}
		// 返回-1，即查找失败
		return -1;
	}
		}

6.二维数组遍历求和操作：用二重循环求出二维数组b所有元素的和：

int[][] b={{11},{21,22},{31,32,33}}

public class Test {
	public static void main(String[] args) {
		int sum=0;
		int[][] b={{11},{21,22},{31,32,33}};
		for(int i=0;i<b.length;i++){
			for(int j=0;j<b[i].length;j++){
				sum += b[i][j];
			}
		}
		System.out.println(sum);
	}
}

7.生成一百个随机数，放入数组，然后排序输出。

public class Test {
	public static void main(String[] args) {
		//1.生成100个随机数的数组
		int []arr = createArr();
		//2.从小到大排序
		arr = sortArr(arr);
		//3.打印
		printArr(arr);
	}
	//生成100个随机数的方法
	public static int[] createArr(){
		int []arr = new int[100];
		for(int i=0;i<arr.length;i++){
			arr[i]= (int) (100*Math.random());
		}
		return arr;
	}
	//对数组进行排序的方法
	public static int[] sortArr(int arr[]){
		int temp;
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j <= i; j++) {
				if (arr[i] < arr[j]) {
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		return arr;
	}
	//数组遍历输出打印的方法
	public static void printArr(int []arr){
		for(int i:arr){
			System.out.println(i);
		}
	}
}

8.题目：输入某年某月某日，判断这一天是这一年的第几天？

分析：以3月5日为例，先把前两个月的加起来，然后再加上5天即本年第几天，特殊情况，闰年且输入月份大于3需考虑多加一天。可定义数组存储1-12月各月天数。

public class Test {
	public static void main(String[] args) {
		Scanner scanner1 = new Scanner(System.in);
		System.out.print("输出今年是第几年");
		int year = scanner1.nextInt();
		System.out.print("输出今年是第几月");
		int month = scanner1.nextInt();
		System.out.print("输出今年是第几日");
		int day = scanner1.nextInt();
		int daynum = 0; // 天数
		//一年365天
		int[] month1 = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,30, 31 };
		//闰年366天
		if (year % 400 == 0 && year % 100 != 0 || year % 100 == 0) {
			month1 = new int[] { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31,30, 31 }; // 闰年里的每个月的天数
		}
		//判断这一天是第几天
		for (int index = 1; index <= month; index++) {
			if (index == 1) {
				daynum = day;
			} else {
				daynum += month1[index - 2];
			}
		}
		System.out.println("这一天是这一年的第" + daynum + "天！");
	}
}

9.使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。使用递归实现

public class BinarySearch {
	public static void main(String[] args) {
		int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		System.out.println(searchRecursive(array, 0, array.length - 1, 20));
	}
	/**
	 * 执行递归二分查找，返回第一次出现该值的位置	 *
	 * @param array  已排序的数组
	 * @param start 开始位置
	 * @param end 结束位置
	 * @param findValue  需要找的值
	 * @return 值在数组中的位置，从0开始。找不到返回-1
	 */
	public static int searchRecursive(int[] array, int start, int end,
			int findValue) {
		// 如果数组为空，直接返回-1，即查找失败
		if (array == null) {
			return -1;
		}
		if (start <= end) {
			// 中间位置
			int middle = (start + end) / 1;
			// 中值
			int middleValue = array[middle];
			if (findValue == middleValue) {
				// 等于中值直接返回
				return middle;
			} else if (findValue < middleValue) {
				// 小于中值时在中值前面找
				return searchRecursive(array, start, middle - 1, findValue);
			} else {
				// 大于中值在中值后面找
				return searchRecursive(array, middle + 1, end, findValue);
			}
		} else {
			// 返回-1，即查找失败
			return -1;
		}
	}
}

10.数组A：1，7，9，11，13，15，17，19；数组b：2，4，6，8，10

两个数组合并为数组c，按升序排列。 要求：使用Arrays类的方法快速实现。

public class Test {
	public static void main(String[] args) {
		int data1[] = new int[] { 1, 7, 9, 11, 13, 17, 19 };
		int data2[] = new int[] { 2, 4, 6, 8, 10 };
		int newArr[] = concat(data1, data2);
		print(newArr);
		Arrays.sort(newArr);
		print(newArr);
	}
	public static int[] concat(int src1[], int src2[]) {
		int len = src1.length + src2.length; // 新数组的大小
		int arr[] = new int[len]; // 新数组
//		int count = 0;
//		for (int i : src1) {
//			arr[count++] = i;
//		}
//		for (int i : src2) {
//			arr[count++] = i;
//		}
		// 还可以通过系统的方法拷贝数组
		 System.arraycopy(src1, 0, arr, 0, src1.length); // 拷贝第一个数组
		 System.arraycopy(src2,0,arr,src1.length, src2.length); //拷贝第二个数组
		return arr;
	}
	public static void print(int[] temp) {
		for (int x = 0; x < temp.length; x++) {
			System.out.print(temp[x] + "、");
		}
		System.out.println();
	}
}