JavaSE学习笔记 Day8

JavaSE学习笔记 Day8

[上一篇](https://blog.csdn.net/CHiN_951/article/details/134721029?spm=1001.2014.3001.5502)

---

---

···

6.5数组的应用

1、从键盘录入五个名字到数组中，遍历数组输出这五个名字
2、给定一个数组，求数组的最大值
3、给定一个数组，求数组的最小值
4、给定一个数组，求数组的平均值
5、给定一个数组，传入一个数字，如果在数组中存在这个数字，返回这个数字在数组中的下标，否则返回-1
6、思考题：在第一题的基础上。但是要保证五个名字不重复

public class Test01 {

//	从键盘录入五个名字到数组中，遍历数组输出这五个名字
	public static void main(String[] args) {
		Test01 t01 = new Test01();
		
		String[] names = t01.lrName();
		
//		统一的进行遍历输出
		for(int i = 0;i<names.length;i++) {
			System.out.println(names[i]);
		}
		for (String string : names) {
			System.out.println(string);
		}
	}
	
//	封装方法,功能:可以录入5个人的名字,返回结果为一个数组
	public String[] lrName() {
		Scanner input = new Scanner(System.in);
//		创建数组 引用类型数组创建之后,每个位置的默认值为null
		String[] names = new String[5];
//		使用数组进行改造 循环的为数组的每个位置进行赋值
		for(int i = 0;i<names.length;i++) {
			System.out.println("请输入第"+(i+1)+"个人的名字:");
			names[i] = input.next();
		}
//		将创建的names数组作为返回值给调用者
		return names;
	}
}

public class Test02 {

	public static void main(String[] args) {
		int[] arr = {1,2,3,54,6,7,124};
		Test02 t02 = new Test02();
		System.out.println(t02.getMax(arr));
		System.out.println(t02.getMin(arr));
		System.out.println(t02.getAvg(arr));
	}
	
//	最大值方法
	public int getMax(int[] arr) {
//		判断数组的长度是否为可用
		if(arr.length <= 0) {
//			异常之下不会执行,功能类似于return
			throw new RuntimeException("哥们,你数组中没有东西啊");
		}
//		定义最大值变量 拟定数组中的一个位置
		int max = arr[0];
//		使用循环进行数组的比较,去更换最值
		for(int i = 0;i<arr.length;i++) {
//			若定义的最大值表数值中的位置小
			if(max < arr[i]) {
//				更换最大值
				max = arr[i];
			}
		}
		return max;
	}
	
//	最小值方法
	public int getMin(int[] arr) {
		if(arr.length <= 0) {
			throw new RuntimeException("哥们,你数组中没有东西啊");
		}
		int min = arr[0];
		for(int i = 0;i<arr.length;i++) {
			if(min > arr[i]) {
				min = arr[i];
			}
		}
		return min;
	}
	
//	平均值方法
	public double getAvg(int[] arr) {
		if(arr.length <= 0) {
			throw new RuntimeException("哥们,你数组中没有东西啊");
		}
		int sum = 0;
		for(int i = 0;i<arr.length;i++) {
			sum += arr[i];
		}
		return sum / arr.length;
	}
}

6.6数组的扩容

6.6.1实现数组的扩容/缩容

数组的扩容/缩容
1.定义一个新数组,然后新数组的长度比原数组要大或者小
2.将原数组中的数据,拷贝到新数组中
3.将原数组的变量名指向新数组(使用新数组对原数组进行赋值)

public class Demo06 {
//	数组的扩容
	public static void main(String[] args) {
//		对arr1进行扩容
		int[] arr1 = {1,2,3,4,5};
//		1.定义新数组,新数组的长度比原数组长(扩容) 新数组的长度比数组短(缩容)
		int[] arr2 = new int[arr1.length + 3];//扩容3
		
//		2.将原数组中的数据添加到新数组中
		for(int i = 0;i<arr1.length;i++) {
			arr2[i] = arr1[i];
		}
		
//		3.将新数组赋值给原数组
		arr1 = arr2;
		
//		扩容以完成
		for (int i : arr1) {
			System.out.println(i);
		}
	}
}

6.6.2数组的拷贝

1.通过自定义的方法,将原数组中的数据拷贝到新数组中
2.System类中提供了拷贝方法
3.Arrays类中提供了拷贝方法

public class Demo07 {

//	System类的数组拷贝
	public static void main(String[] args) {
		int[] arr1 = {1,2,3,4,5};
		
		int[] arr2 = new int[arr1.length + 5];
		
		/*
		 *	src:原数组
		 *	srcPos:原数组开始拷贝的位置
		 *	dest:新数组/目标数组
		 *	destPos:目标的开始拷贝的位置
		 *	length:拷贝的长度,若比原数组的长度大,就会抛出越界异常
		 */
//		System.arraycopy(arr1, 0, arr2, 0, 6);
//		System.arraycopy(arr1, 0, arr2, 0, 5);
//		System.arraycopy(arr1, 0, arr2, 0, 4);
//		System.arraycopy(arr1, 2, arr2, 0, 3);
		System.arraycopy(arr1, 0, arr2, 3, 5);
		for (int i : arr2) {
			System.out.print(i+"\t");
		}
	}
}

import java.util.Arrays;//ctrl+shift+o

public class Demo08 {
//	Arrays进行数组拷贝
	public static void main(String[] args) {
		int[] arr1 = {1,2,3,4,5};

		/*
		 * original:原数组
		 * newLength:新数组的长度
		 * 返回值为新数组
		 */
		int[] arr2 = Arrays.copyOf(arr1, 10);
		
		for (int i : arr2) {
			System.out.print(i+"\t");
		}
	}
}

6.7冒泡排序算法

冒泡排序降序的思想
 将相邻的两个元素进行比较,若前一个元素比后一个元素大,则交换,否则不换

import java.util.Arrays;

public class Demo09 {
//	冒泡排序:降序从大到小 相邻的两个元素进行比较
	/**
	 * N个数字来排队
	 * 两两相比大靠前
	 * 外层循环N-1
	 * 内层循环N-1-i
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = {1,23,44,12,71};
		
//		外层控制轮数 其实多少轮都不重要,但是轮数越多效率越低
//		优化了比较的轮数
		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 temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		System.out.println(Arrays.toString(arr));//直接显示数组
	}
}

6.8多维数组

6.8.1二维数组

一维数组中的每个元素都是一个数据
二维数组中的每个元素都是一个一维数组

6.8.2二维数组的创建

动态初始化

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

注意:创建二维数组时,二维数组的长度必须指定,一维数组的长度可以不写,默认就是null

public class Demo10 {

//	二维数组
	public static void main(String[] args) {
		int[][] arr = new int[4][6];
		
		System.out.println("外层数组的长度"+arr.length);
//		arr[0] 是一个一维数组
		System.out.println(arr[0].length);
		System.out.println(arr[1].length);
		System.out.println(arr[2].length);
		System.out.println(arr[3].length);
		System.out.println(arr[0]);
		
//		二维数组直接访问具体元素
		System.out.println(arr[0][0]);
		
		arr[0][0] = 11;
		
		System.out.println(arr[0][0]);
		
		
		System.out.println("---------------------");
//		第二个长度不写就是说明内部的小数组没有进行初始化
		int[][] arr1 = new int[4][];
		System.out.println(arr1[0]);//null
		
		System.out.println("---------------------");
		int[] arr2[] = new int[4][4];
		int arr3[][] = new int[4][4];
	}
}

静态初始化

语法:
 数据类型[][] 数组名 = {
  {数据},
  {数据},
  {数据},
  {数据}
 };

//	二维数组的静态初始化
public static void main(String[] args) {
    int[][] arr = {
        {1,2,3,5},
        {1,2,3,5},
        {1,2,3,5},
        {2,1,3,5,7}
    };

    System.out.println(arr[3][4]);

    System.out.println(arr[0][0]);
}

6.8.3二维数组的遍历

public class Demo12 {
	public static void main(String[] args) {
		int[][] arr = {
				{1,2,3,5},
				{1,2,3,5},
				{1,2,3,5},
				{2,1,3,5,7}
		};
//		遍历二维数组
		for(int i = 0;i<arr.length;i++) {
//			遍历一维数组
			for(int j = 0;j<arr[i].length;j++) {
				System.out.print(arr[i][j] + "\t");
			}
			
			System.out.println();
		}
//		遍历二维
		for (int[] is : arr) {
//			遍历一维
			for (int i : is) {
				System.out.print(i + "\t");
			}
			System.out.println();
		}
	}
}

6.9变长参数

jdk1.5后引入的

语法: 数据类型…参数名

特点:
 1.变长参数只能作为方法的参数使用(形参),实参可以使用0或者多个执行对变长参数进行赋值
 2.变长参数只能为参数列表的最后一位,一个方法只能有一个变长参数
 3.方法中变长参数的处理按照数组对待
场景:不确定个数的情况

public class Demo13 {
	public static void main(String[] args) {
		Demo13 demo13 = new Demo13();
		
		int add = demo13.add(1,2);
		System.out.println(add);
		
		add = demo13.add(1,2,3);
		System.out.println(add);
		
		add = demo13.add(1,2,3,4);
		System.out.println(add);
//		1.变长参数的赋值可以使用数组进行
		int[] arr = new int[] {1,2,3,4};
		
		add = demo13.add(arr);
		System.out.println(add);
		
//		2.使用值列表直接赋值 无法为数组赋值的,变长参数的独有赋值方式
		add = demo13.add(1,2,3,4,5,5,6,7,78,8,1);
		System.out.println(add);
	}
	public int add(int a,int b) {
		return a + b;
	}
	public int add(int a,int b,int c) {
		return a + b + c;
	}
	public int add(int a,int b,int c,int d) {
		return a + b + c + d;
	}
//	多个数值的相加
	/*public int add(int[] arr) {
		int sum = 0;
		for (int i : arr) {
			sum += i;
		}
		return sum;
	}*/
//	和数组是一样处理的,但是赋值时有自己的独特方法
//	demo13.add(1,2,3,4,5,5,6,7,78,8,1);
	public int add(int...arr) {
		int sum = 0;
		for (int i : arr) {
			sum += i;
		}
		return sum;
	}
}

public class Demo14 {

	public int sum(int...arr) {
		int sum = 0;
		for (int i : arr) {
			sum += i;
		}
		return sum;
	}
//	变长只能有一个,并且只能在最后一位
	public void test01(String name,int...arr) {
		
	}
//	java中变长参数必须是最后一个参数
	/*public void test01(int...arr,String name) {
		
	}*/
	
	public static void main(String[] args) {
		Demo14 demo14 = new Demo14();
		
		System.out.println(demo14.sum());
		System.out.println(demo14.sum(1,2,3,4,5));
		int[] arr = {1,2,3,4};
//		变长参数可以使用数组赋值,不推荐这么使用
		System.out.println(demo14.sum(arr));
	}
}