第十一天

• 一维数组

 * 数组
 *     相同类型数据的有序集合
 * 
 * 数组:存储多个数据
 * 变量:一个数据
 * 
 * 注意:
 *     1.数组是定长的
 *     2.数组中数据类型是统一的
 *     3.数组是有序的,每个数据都有一个下标值(索引),索引都是唯一的
 *     3.数组是一个对象
 * 
 * 数组的索引|下标
 *     下标从0开始,最后一个数据下标为length-1
 *  数组名字[下标]  ---获取设置
 * 
 * 数组的长度
 *     length 数组的长度
 * 
 * 数组的声明:
 *     1.数据类型[]  变量名;
 *     2.数据类型     变量名[];  ---不推荐使用
 *     数据类型:可以为引用|基本
 *     [] : 数组
 *     变量名 : 引用
 * 
 * 数组的定义:
 *     静态初始化:
 *         数据类型 [] 变量名 ={值1,值2,值3...};
 *         数据类型 [] 变量名 =new 数据类型[]{值1,值2,值3...};--不推荐
 *         
 *     动态初始化:
 *         数据类型 [] 变量名 = new 数据类型[长度];
 * 
 *     遍历数组:
 *         1.for
 *         2.增强for循环

public class ArrDemo1 {
	public static void main(String[] args) {
		// 动态初始化
		String[] arr1 = new String[4];
		// String默认值是null
		System.out.println("根据下标获取数组中数据:" + arr1[3]);
		System.out.println("获取数组长度:" + arr1.length);
		// 设置值
		arr1[0] = "余攀";
		arr1[1] = "郁钟敏";
		arr1[2] = "宋吉";
		arr1[3] = "夏昆";

		// 遍历数组1---for循环
		for (int i = 0; i < arr1.length; i++) {
			System.out.println("arr1[" + i + "]=" + arr1[i]);
		}
		
		//静态初始化1
		int []arr2={1,2,3,4};
		for (int i = 0; i < arr2.length; i++) {
			System.out.println("arr2[" + i + "]=" + arr2[i]);
		}
		
		//静态初始化2
		char []arr3=new char []{'a','b','c'};
		
		/*
		 * 遍历数组2---增强for循环:foreach
		 * for(数据类型 迭代元素:数组名|容器名){
		 * 		迭代元素:具体的元素,不再是索引
		 * 		循环体;
		 * }
		 */
		for(char ch:arr3){
			System.out.println(ch);
		}

	}
}

• Java传参

 * java传参:
 *         基本数据类型是值传递
 *         引用数据类型是地址传递
 * 
 * 注意:String 类型是特殊的

public class ParameterDemo2 {
	public static void main(String[] args) {
		int a = 50;
		System.out.println(change(a));// 100
		System.out.println(a);// 50

		int[] arr1 = { 5, 4, 3 };
		int[] arr2 = change(arr1);
		System.out.println(arr2[2]);// 5
		System.out.println(arr1[2]);// 5

		String str = "变身前";
		System.out.println(change(str));// 变身后
		System.out.println(str);// 变身前
	}

	// 改变参数的值
	public static int change(int a) {
		a = 100;
		return a;
	}

	public static int[] change(int[] arr) {
		arr[2] = 5;
		return arr;
	}

	public static String change(String str) {
		str = "变身后";
		return str;
	}
}

• 可变参数

 * 可变参数:(方法  (形参))
 *         当你参数个数不确定的时候,可以使用可变参数
 *             1.在形参列表的最后位置
 *             2.  ...表示可变参数,写在数据类型和参数名之间
 *             3.编译器会为可变参数隐式定义数组,所以使用可变参数的时候,要使用操作数组的方式

public class ParaTest4 {
	public static void main(String[] args) {
		getSum(1, 2, 3, 4, 5);
		test1("hello", 11, 9, 8);
		User u = new User("张三", 18);
		test2(12, u);
	}

	// 求int类型数据的和
	public static void getSum(int a, int c, int... b) {
		int sum = 0;
		for (int i : b) {
			// System.out.println(i);
			sum += i;
		}
		sum = sum + a + c;
		System.out.println(sum);
	}

	public static void test1(String a, int c, int... b) {
		for (int i : b) {
			System.out.println(i);
		}
	}

	public static void test2(int a, Object... obj) {
		if (obj[0] instanceof User) {
			User u = (User) obj[0];
			System.out.println(u.name);
		}

	}
}

class User {
	String name;
	int age;

	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
}

• 数组异常

 * 使用数组的时候会遇到的异常:
 *         1.ArrayIndexOutOfBoundsException数组越界异常
 *             会产生月结异常的情况:
 *                     1)下表超出范围
 *                     2)下标为负数
 *         2.NullPointException 空指针异常
 *             当引用赋值为null是会出现空指针异常

public class ExceptionTest3 {
	public static void main(String[] args) {
		int[] arr = { 5, 4, 3, 2, 1 };
		System.out.println(arr.length);
		// System.out.println(arr[-1]);// ArrayIndexOutOfBoundsException

		arr = null;
		System.out.println(arr[1]);// NullPointException
	}
}

 

• 二维数组

 * 二维数组
 *         数组中的数组
 * 
 * 定义:
 *         数据类型 [] [] 变量名 = {{1,2},{3,4,5,},{1}};
 *         数据类型 [] 变量名 [] = new 数据类型 [3][2];//第二维每一个长度限定为2
 *         数据类型 [] 变量名 [] = new 数据类型 [3][];
 *                 变量名 [0] = new 数据类型[长度];
 *                 变量名 [1] = new 数据类型[长度];
 *                 变量名 [2] = new 数据类型[长度];
 *         数据类型[][] 变量名=new 数据类型[][]{{1,2,3},{4,5}};
 * 
 * 遍历二维数组:
 *         双层    for循环|增强for循环--foreach

public class DoubleArr5 {
	public static void main(String[] args) {
		// 1
		int[][] arr1 = { { 1, 2 }, { 3, 4, 5, }, { 1 } };
		System.out.println(arr1[1][1]);
		// 2
		double[] arr2[] = new double[3][2];
		System.out.println(arr2[1][1]);
		// 3
		char arr3[][] = new char[3][];
		arr3[0] = new char[2];
		arr3[0][0] = 'c';
		arr3[0][1] = 'b';
		// 4
		int[][] arr4 = new int[][] { { 1, 2, 3 }, { 4, 5 } };

		// 遍历
		for (int i = 0; i < arr4.length; i++) {
			for (int j = 0; j < arr4[i].length; j++) {
				System.out.println(arr4[i][j]);
			}
		}
		System.out.println("-------------");
		for (int[] i : arr4) {
			for (int j : i) {
				System.out.println(j);
			}
		}
	}
}

 

• 排序

• 选择排序

     * 12,7,0,6,-32
     * 选择排序  升序                                                比较的数本身自己i        被比较数的开始 i+1~length-1      比较次数
     * 第一轮:-32,7,8,6,12        int min=0  存放最小数据的索引位置        0        i            0+1 ~ length-1            4==length-1
     * 第二轮:-32    ,0,7,6,12                                            1                    1+1 ~ length-1            3==length-2
     * 第三轮:-32,0,6,7,12                                                2                    2+1 ~ length-1            2
     * 第三轮:-32,0,6,7,12                                                3                    3+1 ~ length-1            1
     * 一轮交换一次 确定最小的放在最前面          5个数比较了4轮

	/*
	 * 选择排序:(小数先出来) 每个数和后面的数比较,找出最小值
	 */
	public static void selectSort(int[] arr) {
		// 最小数的索引 ---默认第一个为最小
		int min = 0;
		for (int i = 0; i < arr.length; i++) {
			// 每轮比较数本身是最小的
			min = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[min]) {
					min = j;
				}
			}
			// 交换位置---将最小元素放在每轮的最前端
			if (min != i) {
				int temp = arr[min];
				arr[min] = arr[i];
				arr[i] = temp;

			}
		}
		System.out.println(Arrays.toString(arr));
	}
}

 

• 冒泡排序

    /*12,7,0,6,-32
     * 冒泡排序  降序
     *     相邻两位数                        j变量   从0开始  到   length-2
     *     第一轮:12,7,0,6,-32             j与 j+1    [0,3]   < length-1-0      1  
     *  第二轮:12,7,6,0,                           [0,2]   < length-1-1        2
     *  第三轮:12,7,6,                           [0,1]   < length-1-2     3
     *  第四轮:12,7,                               [0]     < length-1=3        4

	/*
	 * 冒泡排序:(大数先出来) 相邻两个数比较,如果前面的数大于后面的数, 就交换位置.
	 */
	public static void bubbleSort(int[] arr) {
		// 外层循环控制轮数
		for (int i = 0; i < arr.length; i++) {
			// -1 是前面数的下标要加一, -i是每轮从第i 个开始
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] < arr[j + 1]) {// 可以是> ,可以是<
					int temp = arr[j + 1];
					arr[j + 1] = arr[j];
					arr[j] = temp;
				}
			}
		}
		System.out.println(Arrays.toString(arr));
	}

 

• Arrays工具类

* 1.Arrays.equals()

         * 先判断两个数组的length是否相等,
         * 如果相等,再比内容,
         * 如果不相等,直接返回false

* 2.Arrays.sort()  升序

* 3.Arrays.binarySearch(数组,元素)

         * 二分法查找   
         *         到第一个参数数组中查找是否存在第二个参数,
         *         如果有返回索引,如果没有返回(-(插入点) - 1)
         * 无序数列要求先排序

* 4.数组 copyOf(原数组,新数组长度)

* System类中的静态方法:static void    arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

         *  src:原数组
         *  srcPos:原数组从哪一个索引开始拷贝
         *  dest: 目标数组
         *  destPos:拷贝到目标数组的索引位置
         *  length:拷贝的个数
        从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

import java.util.Arrays;

/*
 * Arrays工具类,用来操作数组
 */
public class ArraysDemo8 {
	public static void main(String[] args) {
		/*
		 * 1.Arrays.equals() 
		 * 先判断两个数组的length是否相等,
		 * 如果相等,再比内容,
		 * 如果不相等,直接返回false
		 */
		String[] arr1={"hello","shsxt"};
		String[] arr2={"hello","shsxt"};
		System.out.println(arr1.equals(arr2));//false----Object中的方法
		System.out.println(Arrays.equals(arr1, arr2));//true
		
		//2.Arrays.sort()  升序
		int[] arr3 = {12,5,4,1,0,6};
		Arrays.sort(arr3);
		for (int i : arr3) {
			System.out.print(i+" ");
		}
		System.out.println("--------");
		
		////根据Unicode表中的值
		String[] arr4={"美国","日本","中国"};
		Arrays.sort(arr4);
		for(String i:arr4){
			System.out.print(i+" ");
		}
		System.out.println();
		System.out.println((int)'中');
		System.out.println((int)'日');
		System.out.println((int)'美');
		System.out.println("--------");
		
		/*
		 * 3.Arrays.binarySearch(数组,元素)
		 * 二分法查找   
		 * 		到第一个参数数组中查找是否存在第二个参数,
		 * 		如果有返回索引,如果没有返回(-(插入点) - 1)
		 * 无序数列要求先排序
		 */
		System.out.println(Arrays.binarySearch(arr3, 4));
		System.out.println("--------");
		
		/*
		 * 4.数组 copyOf(原数组,新数组长度)
		 * 0 1 4 5 6 12 ---> [0, 1, 4, 5, 6, 12, 0]
		 */
		int [] newArr = Arrays.copyOf(arr3, 7);
		System.out.println(Arrays.toString(newArr));
		
		/*
		 * System类中的静态方法:static void	arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
		 * 	src:原数组
		 * 	srcPos:原数组从哪一个索引开始拷贝
		 *  dest: 目标数组
		 *  destPos:拷贝到目标数组的索引位置
		 *  length:拷贝的个数
		从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
		 */
		System.out.println();
		System.out.println("----------------");
		int[] last=new int[5];
		System.arraycopy(arr3, 2, last, 3, 2);
		for(int i:last){
			System.out.print(i+" ");
		}
	}
}