黑马程序员_java基础学习笔记03_函数以及数组知识

------- android培训、java培训、期待与您交流！ ----------

一 函数

(1)函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。
(2)函数的格式
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…) {
执行语句;
return 返回值;
}
public static int add(int a,int b)//a = 3,b =5
A：修饰符 后面会重点讲。public static
B：返回值类型 这个特定的功能完成后，需要返回一个结果。这个地方就是返回结果的型。
C：函数名 为了方便使用这个函数，给它起个名字。这个名字要符合标识符命名规则。
D：参数类型 形式参数的数据类型
形式参数 自定义的接收方
实际参数 发出方add(3,5)
E：执行语句 那么这个语句是由多条语句组成。
F：return 这个功能执行完以后，需要有一个返回值，那么这个值有关键字return带回。
(3)函数的特点
A：一般函数只有被调用后，才执行。
B：void 表示没有返回。在这个函数的结尾可以不写return。
其实jvm会自动的结尾处加上return;
(4)如果定义自己的函数 两个明确
A：明确该功能的结果 其实就是该功能的返回类型。
B：明确该功能的参数 其实就是明确该功能中是否需要未知内容(形式参数)参与运算。
   明确未知内容的类型和个数。
(5)函数的重载
A：函数名相同，参数列表不同。
   参数类型不同:int add(int i)void add(double d)
   参数个数不同:add(int a,int b);add(int a,int b,int c)
   参数顺序不同:print(String name, int age)//参数顺序不同的重载是可以存在的,但是没有  什么实际意义
 print(int age,String name)
B：特点：与返回值类型无关，只看参数列表。
C：好处：便于阅读，优化程序设计。

二 数组

1.同一种类型数据的集合。其实数组就是一个容器。int[] arr = new int[5];
A：只要是容器，就得重点掌握。
2.数组的好处
int[] arr = new int[5];
arr[3] = 10;
A：可以自动给数组中的元素从0开始编号，方便操作这些元素。
3.数组的定义格式
A：当不明确数组中的元素时
举例 int[] arr = new int[3];//动态初始化
arr[0] = 3;
B：当明确数组中的元素时
举例 int[] arr = new int[]{1,2,3,4,5};//静态初始化
     int[] arr = {1,2,3,4,5};

4.什么时候使用数组？
A：当要操作的同种数据类型的数据是多个的时候，你就得想着先把这些数据用数组进行存储。
5.内存图
A：栈 
存储的是局部变量(在函数中定义的变量)。
变量被使用完后，立即自动释放。
B：堆 
存储的是实体(数组和对象)。
实体：new出来的东西，可以存放很多数据的东西。
      class定义一个类。
堆内存数据的特点
每个实体都有内存地址
堆内存中的变量都有默认初始化值
int --> 0
double --> 0.0
boolean --> false
char --> '\u0000' 空字符，unicode编码。 
当实体不在被使用的时候，会在jvm空闲的时候，
通过java垃圾回收机制使其自动释放。
C：方法区 后面讲。
D：本地方法区 调用是Windows系统底层资源，我们不用考虑。
E：寄存器 和CPU相关。我们不用考虑。
6.操作数组最常见的问题
A：当你访问到数组中的最后一个元素时，还想继续访问，这个时候，会发生角标越界异常。
ArrayIndexOutOfBoundsException
举例 int[] arr = new int[3];
      System.out.println(arr[3]);
B：当数组不在指向某个实体时，你还继续访问，就会发生空指针异常。
NullPointerException
举例 int[] arr = new int[3];
      arr = null;
      System.out.println(arr[1]);
7.常见的数组的操作
记住：对数组的操作，一定要从角标入手。
A：遍历操作 
数组的属性：length 数组的长度。
格式：数组名.length
for (int x=0;x < arr.length ;x++ )
System.out.println("arr["+x+"]="+ arr[x]);
B：获取最值
获取最大值
public static void main(String[] args) {
int[] arr = {3,2,1,4,5,6};
//int x = getMax(arr);
//System.out.println(x);
}
public static int getMax(int[] arr){
int max = arr[0];
//i从1开始，因为第一个数不用跟自己比
for(int x=1; x<arr.length; x++) {
if(arr[x]>max) {
max = arr[x];
}
}
return max;
}
获取最小值
public static int getMin(int[] arr) {
int min = arr[0];

//i从1开始，因为第一个数不用跟自己比
for(int i=1; i<arr.length; i++) {
if(arr[i]<min){
min = arr[i];
}
}
return min;
}
C：排序(选择和冒泡都还没有讲,大家可以先看一下)
int[] arr = {66,55,44,33,22,11};
选择排序
原理：如果拿0角标上的元素依次和后面的元素进行比较，
                     第一次内循环结束后，最小值出现在了0角标位置。
arr[0]与arr[1-5]比了五次
arr[1]与arr[2-5]比了四次
arr[2]与arr[3-5]比了三次
arr[3]与arr[4-5]比了二次
arr[4]与arr[5]比了一次
你就想想我们是如何打星星
*****
****
***
**
*
arr[x]与arr[y]比较
数组长度是6
for (int x = 0;x < arr.length - 1;x++){
for (int y = x + 1;y < arr.length;y++){
if (arr[x] > arr[y]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
int[] arr = {66,55,44,33,22,11};
冒泡排序
原理：两个相邻元素进行比较，第一次比较完以后，最大值出现在了最大角标处。
第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4],arr[4]与arr[5],比了五次
第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比了四次
第三次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比了三次
第四次:arr[0]与arr[1],arr[1]与arr[2]比了二次
第五次:arr[0]与arr[1]比了一次
for (int x = 0;x < arr.length - 1; x++){
//-1防止角标越界
//-x为了提高效率
for (int y = 0;y < arr.length - 1 - x;y++){//6
if (arr[y] > arr[y+1]){
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
D：传递参数
调用的时候，传递是基本类型的值的时候，形参改变对实参没有任何影响。
调用的时候，传递是引用类型的地址的时候，形参改变对实参有直接影响。

8.数组初始化过程
<1> 主函数进栈,然后在main()中有一个数组的引用arr
<2> 在堆内存中开辟空间，分配内存地址值
<3> 在堆内存中建立数组对象，并进行默认初始化
<4> 如果有显示初始化值的,对它进行显示初始化
<5> 将内存地址赋给栈内存中的arr变量

数组排序还有一种较快的方法,即快速排序

public class quiksort {
	static int count = 0;

	public static void main(String[] args) {
		int values[] = { 5, 4, 8, 3, 7, 2, 1, 9, 0, 6 };

		qsort(values, 0, (values.length - 1));

		System.out.printf("\n\n排序后的结果是：");
		for (int i = 0; i < values.length; i++) {
			System.out.printf("%d ", values[i]);
		}
	}

	public static void qsort(int values[], int left, int right) {
		int tmp = 0;

		System.out.printf("\n这个是第%d次排序的结果：", count);
		count++;
		for (int i = 0; i < values.length; i++) {
			System.out.printf("%d ", values[i]);
		}

		if (left < right) {
			tmp = partition(values, left, right);
			qsort(values, left, tmp);
			qsort(values, tmp + 1, right);
		}
	}

	public static int partition(int values[], int left, int right) {
		int i = 0, j = 0;
		int key = 0, tmp = 0;
		if (null == values) {
			return 0;
		}

		i = left;
		j = right;
		key = values[left];

		// 这个while循环可以实现排序的第一步：分组
		while (i < j) {
			while (values[j] > key) {
				--j;
			}
			tmp = values[i];
			values[i] = values[j];
			values[j] = tmp;

			while (values[i] < key) {
				i++;
			}
			tmp = values[i];
			values[i] = values[j];
			values[j] = tmp;
		}
		return i;
	}
}

9. 数组的操作

(1)查找
A：无序数组
int[] arr = {33,22,11,44,55,66};
public static int getIndex(int[] arr,int key) {
for (int x = 0;x < arr.length;x++){
if (key == arr[x]){
return x;
}
}
return -1;
}
B：有序数组 二分查找
数组长度是6,最大角标值是5
public static int getIndex(int[] arr,int key) {
int min = 0;
int max = arr.length-1;
int mid = (min + max)/2;
while (key != arr[mid]){
if (key > arr[mid]){
min = mid + 1;
}else if (key < arr[mid]){
max = mid - 1;
}
if (min > max){
return -1;
}
mid = (min + max)/2;
}
return mid;
}

(2)数组反转
要求:给一个数组让其反转,而并不是反过来遍历
public static void main(String[] args) {
int[] arr = {3,2,1,5,4,6};//6,4,5,1,2,3;
revArray(arr);
System.out.println(print(arr));
}
//定义反转的方法,经过分析我们发现需要对调的角标是两个变化的变量
//第一次让头角标和尾角标对调,然后让头角标自增,尾角标递减再对调
public static void revArray(int[] arr) {
//int start = 0;
//int end = arr.length-1;
for (int start=0,end = arr.length-1;start<end ;start++, end--){
//角标值每变化一次就对调一次
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}

}
//把数组转换成字符串输出,因为任何数据类型与字符串用+想连接都会产生新的字符串
int [] arr = {6,5,4,3,2,1};
public static String arrToString(int[] arr) {
String str = "[";
for (int x = 0; x < arr.length; x++){
if (x != arr.length - 1) {
str = str + arr[x] + ", ";//[6, 5, 
}else {
str = str + arr[x] +"]";
}
}
return str;
}

10.二维数组

(1)int[][] arr = new int[3][2];arr[1][0]
A：定义了名称为arr的二维数组
B：二维数组中有3个一维数组
C：每一个一维数组中有2个元素
D：一维数组的名称分别为arr[0], arr[1], arr[2]
arr[0][0] arr[0][1]
arr[1][0] arr[1][1]
arr[2][0] arr[2][1]
arr:二维数组名
arr[1]:二维数组中的第二个一维数组名
arr[1][1]:二维数组中的第二个数组的第二个元素
E：给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
(2)格式2：int[][] arr = new int[3][];
A: 二维数组中有3个一维数组
B: 每个一维数组都是默认初始化值null
C: 可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[5];
arr[2] = new int[7];
(3)int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};arr[2].length
A：二维数组有3个一维数组。
B：第一个一维数组有3个元素
   第二个一维数组有2个元素
   第三个一维数组有4个元素
(4)二维数组的遍历
int[][] arr2 = new int[2][3];
public static void printArray2(int[][] arr2){
for(int i=0; i<arr2.length; i++){
for(int j=0; j<arr2[i].length; j++){
System.out.print(arr2[i][j]+" ");
}
System.out.println();
}
}
(5)二维数组的应用
求一年的销售总额。
public static void printArray2(int[][] arr2){
int sum = 0;
for(int i=0; i<arr2.length; i++){
for(int j=0; j<arr2[i].length; j++){
sum = sum + arr[i][j];
}
System.out.println("sum =" + sum);
}
}