Java语言基础-方法的重载设计(overload)-数组-数组的遍历-多 维数组-排序算法(冒泡排序)-选择排序

方法的重载设计(overload):

---

重载方法的定义是在同一个类中，某方法允许存在一个以上的同名方法，只要它们的参数列表不同即可。
方法重载的作用：屏蔽了同一功能的方法由于参数不同所造成方法名称不同。
方法重载判断原则：
两同：同类中，方法名相同；
不同：方法参数列表不同（参数类型、参数个数、参数顺序）
只要参数类型,参数个数,参数顺序有一个不同,参数列表就不同.

class Demo {
	static int getnum(int x, int y) {
		return x + y;
	}

	static double getnum(double a, double b) {
		//参数列表 参数类型不同
		return a + b;
	}

}

方法重载和方法的返回值类型无关，只是要求返回值类型一致。

数组

---

什么是数组?一组数据,一堆数据:
所谓数组，是在程序设计中，为了处理方便，把具有相同类型的若干变量按有序的形式组织起来的一种数据形式。这些按一定顺序排列的同类型数据的集合称为数组。而数组中的每一个数据称之为数组元素，数组中的元素以索引来表示其存放的位置，索引从0开始，步长是1.

基本数据类型

基本数据类型有八种:byte,short,int,long,float,double,char,boolean

引用数据类型: 类,接口,数组.

数组的定义

变量的定义:
数据类型 变量名; 如: int age;

数组的定义:

方式1: 数组元素的类型[] 数组名;int[] ages; 可以吧int[]看成是一种数据类型,int类型的数组类型.

方式2:数组元素的类型 数组名[]; int ages[];
但是数组必须先初始化才能使用,初始化表示在内存中分配空间;

数组的初始化(两种方式):

静态初始化:

语法:
数组元素类型[] 数组名 = new 数组元素类型[]{元素1,元素2,元素3,…};

举例:
int[] nums = new int[]{1,3,5,7,9};

简单写法,必须声明之后,立刻初始化,不能先声明后初始化:int[] nums = {1,3,5,7,9};

无论，以哪种方式初始化数组，一旦初始化完成，数组的长度就固定了，不能改变，除非重新初始化。也就是说数组是定长的。
数组是定长的: 数组一旦初始化成功,数组中的元素个数就已经固定了,不能更改,如果需要更改,只能重新做初始化.

int [] num = {1,2,3};
System.out.println(num.length);

那我们如何吧新数组赋值进去呢?

public class Test {
public static void main(String[] args) {
	
	int [] num = {1,2,3};//定义一个int类型的数组
	System.out.println(num.length);//打印数组的长度 3
	num = new int[]{2,3,4}; //new在内存中开辟新空间存放新的数组
	System.out.println(num);
	}
}

动态初始化

动态初始化语法:
语法:

数组元素类型[] 数组名 = new 数组元素类型[ length ];

比如:
int[] ages = new int[100];

当我们事先知道,需要存储哪一些数据的时候,选用静态初始化.
当我们事先不知道,需要存储哪些数据的时候,只能使用动态初始化.

数组的遍历:

使用for循环遍历:

    public class Test {
	public static void main(String[] args) {
		
	int[] num = {1,3,4};
	for(int i = 0;i<=num.length;i++){
			System.out.println(num[i]);//打印数组内的索引i
		}
	}
}

其实在java1.5的开始,java提供了一种新的语法:增强for循环(foreach):

语法:

for(数组元素类型 变量 : 数组名)

{

循环体

}

public class Test {
	public static void main(String[] args) {
		
	int[] num = {1,3,4};
//	for(int i = 0;i<=num.length;i++){
//			System.out.println(num[i]);//打印数组内的索引i
//		}
	//增强for循环
	for (int a : num) {
		System.out.println(a);
	}
	}
}

其实我们通过反编译可以发现,foreach其实就是个语法糖,提升了代码的效率,但是功能可以却没有for循环那么强大;

如果迭代数组元素,而不关心数组的索引的时候,首选使用foreach.

多维数组

如果现在有多个数组,我想把多个数组保存在一个集合中,此时我又应该如何完成?

int[] arr1 = {1,2,3};

int[] arr2 = {4,5};

int[] arr3 = {6};

把上述的每个数组都作为一个元素,那么此时元素的类型为:int[].

多维数组语法:

//数组元素类型[] 数组名;
int[][]  arr = new int[][]   {

	arr1 ,arr2,arr3
	
};

int[][]  arr = new int[][]   {

	{1,2,3} ,
	
	{4,5},
	
	{6}
	
};

二维数组的初始化操作:
静态初始化:

int[][]  arr = new int[][]   {
	{1,2,3} ,
	{4,5},
	{6}
};

动态初始化:

int[][]  arr = new int[3][5] ;创建一个长度为3的二维数组,每一个元素(一维数组)的长度为5.

int[][]  arr = new int[0][5] 

排序算法(冒泡排序):

什么是冒泡排序呢？
你可以这样理解：（从小到大排序）存在10个不同大小的气泡，由底至上地把较少的气泡逐步地向上升，这样经过遍历一次后，最小的气泡就会被上升到顶（下标为0），然后再从底至上地这样升，循环直至十个气泡大小有序。

在冒泡排序中，最重要的思想是两两比较，将两者较少的升上去

冒泡排序最坏情况的时间复杂度是O(n²)

for(int time = 1;time<=arr.length-1;time ++){
	for(int i = 1;i<=arr.length - time; i++)
	{
		if(arr[i-1]>arr[i]){
			swap(arr,i-1);
		}
	}
}

选择排序

选择排序(Selection Sort)：
基本思路：选择某个索引位置的元素，然后和后面元素依次比较，若大于则交换位置，经过第一轮比较排序后可得出最小值，然后使用同样的方法把剩下的元素逐个比较即可。
可以看出选择排序，第一轮会选出最小值，第二轮会选出第二小的值，直到最后。
第一轮从arr[0]和后面元素相比较，第二轮从arr[1]和后面的元素相比较，依次类推。N个数要进行N-1轮。选择排序每一轮只进行一次交换，相对于冒泡排序效率高一些。

static void selectSort(int[] arr) {
	for (int times = 0; times < arr.length - 1; times++) {
		int minIndex = times;
		for (int i = times + 1; i < arr.length; i++) {
			if (arr[i] < arr[minIndex]) {
				minIndex = i;
			}
		}
		swap(arr, times, minIndex);
	}
}