黑马程序员——Java基础___函数、数组

最新推荐文章于 2024-05-05 13:57:09 发布

1992zyj

最新推荐文章于 2024-05-05 13:57:09 发布

阅读量456

点赞数

分类专栏：黑马程序员技术博客文章标签： java 黑马程序员函数数组编程

本文链接：https://blog.csdn.net/u012191003/article/details/43459509

版权

黑马程序员技术博客专栏收录该内容

11 篇文章 0 订阅

订阅专栏

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

一、函数

1.1函数的定义

什么是函数？

函数就是定义在类中的具有特定功能的一段独立小程序。

函数也称为方法。

函数的格式：

修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2,....)
{

执行语句;

return 返回值;

}

说明：

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

return：用于结束函数。

返回值：该值会返回给调用者。

1.2函数的特点

(1).定义函数可以将功能代码进行封装。

(2).便于对该功能进行复用。

(3).函数只有被调用才会被执行。

(4).函数的出现提高了代码的复用性。

(5).对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

注意：

(1).函数中只能调用函数，不可以在函数内部定义函数。

(2).定义函数时，函数的结果应该返回给调用者，交由调用者处理。

1.3、函数的应用

两个明确：

(1).明确要定义的功能最后的结果是什么？

(2).明确在定义该功能的过程中，是否需要未知内容参与运算？

例:

需求：定义一个功能，得到两个整数中较大的那个。

分析：

该功能的运算结果是两个整数中较大的那个，也就是得到一个整数（int）。

实现该功能需要两个未知的整数参与（两个参与int a，int b）。

函数代码：

int getMax(int a,int b){

int max;//用来存储较大的那个数。

if(a>b){

max=a;

}

else{

max=b;

}

return max;

}

1.4、函数的重载

重载的概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

重载的特点：与返回值类型无关，只看参数列表（参数个数、参数类型）。

重载的好处：方便于阅读，优化了程序设计。

重载示例：

//返回两个整数中较大的那个

int getMax(int a,int b){

return a>b?a:b;

}

//返回两个小数中较大的那个

float getMax(float a,float b){

return a>b?a:b;

}

//返回三个整数中最大的那个

int getMax(int a,int b,int c){

int max1,max2;

max1=a>b?a:b;

max2=b>c?b:c;

return max1>max2?max1:max2;

}

二、数组

2.1、数组的定义

概念：同一种类型数据的集合。其实数组就是一个容器。

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

定义数组格式：

格式1： 元素类型[] 数组名= new 元素类型[元素个数或数组长度];

示例：int[] arr = new int[10]。

格式2：元素类型[] 数组名= new 元素类型[]{元素，元素，……};

示例：int[] arr = new int[]{2,5,1,7}; 可以这样简写：int[] arr = {2,5,1,7};

2.2、内存结构

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一

片区域都有特定的处理数据方式和内存管理方式。

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：

(1). 数组和对象，通过new建立的实例都存放在堆内存中。

(2).每一个实体都有内存地址值。

(3).实体中的变量都有默认初始化值。

(4).实体不在被使用，会在不确定的时间内被垃圾回收器回收。

数组的内存结构：

2.3、遍历数组

这里需要用到数组的一个属性：length，该属性可以直接获取数组中的元素个数。

使用方式：数组名.length;结果是一个整数（int）。

示例代码：

class ArrayDemo
{
	public static void main(String[] args) 
	{
		int[] arr = new int[]{5,1,10,11,7,88,66};//定义数组，并进行静态初始化。
		for(int i=0; i<arr.length; i++)	      //这里的arr.length就是获取arr这个数组的元素个数。	
		{
			System.out.println("arr["+i+"]="+arr[i]+";");
		}
	}
}

2.4、数组操作常见问题

(1).数组脚标越界异常(ArrayIndexOutOfBoundsException)。

原因：访问到了数组中的不存在的脚标。

例如：int [] arr = new int [5];System.out.println(arr[5]);

注意：数组元素中最大角标是：元素个数-1，因为数组角标是从0开始的。

(2).空指针异常(NullPointerException)。

原因：定义的数组引用没有指向实体，却在操作实体中的元素。

例如：int[] arr = null;System.out.println(arr[0]);

注意：以上错误都是在运行时出现的。

2.5、数组常见操作

获取最值(最大值，最小值)

场景：有一群小朋友，这群小朋友都有自己的学号（1、2、...n），想知道谁最高？老师这么做：

(1).所有小朋友都先站在右边。

(2).老师一开始假设1号小朋友最高，让他站到中间。

(3).接着让2号小朋友和1号小朋友比看谁高，比完后：高的站中间，矮的站左边。

(4).接着让3号小朋友和中间(上一次比较后高的那个)的小朋友比，比完后：高的站中间，矮的站左边。

(5).后面依次让4号、5号、..n号小朋友和中间的小朋友比，比完后：高的站中间，矮的站左边。

(6).最后当右边的小朋友都比完时，站在中间的就是最高的。

同样的道理，如果想知道谁最矮，比较后让矮的站中间就可以。

根据这个原理获取数组中的最大值

//该函数根据给定的数组返回数组中的最大值
public static int getMax(int[] arr)
{

int max = arr[0];

for(int x=1; x<arr.length; x++)

{

if(arr[x]>max)

max = arr[x];

}

return max;

}

获取数组中的最小值

//该函数根据给定的数组返回数组中的最小值
public static int getMax(int[] arr)
{

int min = arr[0];

for(int x=1; x<arr.length; x++)

{

if(arr[x]<min)

min = arr[x];

}

return max;

}

排序--选择排序

过程：

(1).将0角标的元素依次和0角标后面的元素比较，如果0角标的元素值比后面的大，交换位置，最终0角标保存的是最小值。

(2).将1角标的元素依次和1角标后面的元素比较，如果1角标的元素值比后面的大，交换位置，最终1角标保存的是第2小值。

(3).这样依次比较后就得到从小到大的排序的数组。

图解：这里的图是第一轮比较得到最小值，后面的过程类似，图就不画了。

这样一轮比较后就在0角标位置得到数组的最小值。

下面看代码实现

class ArrayDemo3 
{
	public static void main(String[] args)
	{
		int[] arr = {5,1,6,4,2,8,9};
		//打印排序前的数组。
		printArray(arr);
		//进行排序
		selectSort(arr);
		//打印排序后的数组：
		printArray(arr);
			
	}
	/*
	定义功能，实现数组排序。
	核心部分是双重for循环，第一次内循环结束在0角标位置得到最小值，
	第二次内循环结束在1角标位置得到第二小值。。。最终得到一个从小到大排序的数组。
	*/
	public static void selectSort(int[] arr)
	{
		for (int x=0; x<arr.length-1 ; x++)
		{
			for(int y=x+1; y<arr.length; y++)
			{
				if(arr[x]>arr[y])
				{
					swap(arr,x,y);
				}
			}
		}
	}
	//定义功能，用于交换数组中两个元素的值。
	public static void swap(int[] arr,int a,int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

	//定义功能，用于打印数组。
	public static void printArray(int[] arr)
	{
		System.out.print("[");
		for(int x=0; x<arr.length; x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+", ");
			else
				System.out.println(arr[x]+"]");
		}		
	}
}

注意：上面的排序结果是从小到大的，如果要从大到小排序，原理完全类似，只需要稍微改动。

改动部分：

public static void selectSort(int[] arr)
{

for (int x=0; x<arr.length-1 ; x++)

{

for(int y=x+1; y<arr.length; y++)

{

if(arr[x]<arr[y])//只需要把这里的大于号改成小于号就能实现从大到下排序。

{

swap(arr,x,y);

}

}

排序--冒泡排序

过程：

(1).相邻的两个元素比较，如果符合条件就交换位置。一轮比较后最值就在最后位。

注意：符合条件根据需求而定。如果要从小到大排：前面比后面大时交换位置；从大到小排：前面比后面小时交换位置。

(2).还是相邻的两个元素比较，不过最后面已经是最值的不用比较。这一轮比较得到第二大（或第二小）值。

(3).这样依次比较就得到排序号的数组。

代码实现

class ArrayDemo4
{
	public static void main(String[] args)
	{
		int[] arr = {5,1,6,4,2,8,9};
		//打印排序前的数组。
		printArray(arr);
		//进行排序
		bubbleSort(arr);
		//打印排序后的数组：
		printArray(arr);
			
	}
	public static void bubbleSort(int[] arr)
	{
		for(int x=0; x<arr.length-1; x++)
		{									
			for(int y=0; y<arr.length-x-1; y++)//-x的作用是从后面较少需要比较的元素，-1的作用是避免角标越界。
			{
				if(arr[y]>arr[y+1])//如果这里的大于号改成小于号，排序结果就是从大到小。
				{
					swap(arr,y,y+1);
				}
			}
		}
	}
	//定义功能，用于交换数组中两个元素的值。
	public static void swap(int[] arr,int a,int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

	//定义功能，用于打印数组。
	public static void printArray(int[] arr)
	{
		System.out.print("[");
		for(int x=0; x<arr.length; x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+", ");
			else
				System.out.println(arr[x]+"]");
		}		
	}
}

查找--折半查找

猜数字游戏大家应该都玩过，规则这样的：A给定一个1-100之间的随机整数，B来猜，每猜一次A会给出提醒说

大了、小了、还是猜对了。

如果随便猜可能要猜几十次，比较高效的猜法是：先猜50，如果大了猜25，如果小了猜75；看图：

注意：折半查找要保证数组已经是有序的

折半查找代码实现：

/*
折半查找应用：查找某个元素在数组中出现的位置。
*/
class ArrayDemo5
{
	public static void main(String[] args) 
	{
		int[] arr = {1,10,22,56,8,7,32,100};
		//测试：查找32在数组中的位置。
		int index1 = halfSearch(arr,32);
		System.out.println("index1="+index1);
		//测试：查找110在数组中的位置。
		int index2 = halfSearch(arr,110);
		System.out.println("index2="+index2);
		
	}
	/*
	折半查找:提高效率，但是必须要保证该数组是有序的数组。
	返回某元素在数组中的位置（角标），如果没有这个元素返回-1。
	*/
	public static int halfSearch(int[] arr,int key)
	{
		int min = 0,max = arr.length-1,mid;

		while(min<=max)
		{
			mid = (max+min)>>1;

			if(key>arr[mid])
				min = mid + 1;
			else if(key<arr[mid])
				max = mid - 1;
			else
				return mid;
		}
		return -1;
	}
}

三、进制转换

进制转换方法前面已经介绍过了参考：http://blog.csdn.net/u012191003/article/details/43241593。这里

说怎么用代码实现。

十进制转二进制

class ArrayDemo6
{
	public static void main(String[] args) 
	{
		toBin(10);
	}
	/*
	十进制-->二进制
	*/
	public static void toBin(int num)
	{
		int[] arr = new int[30];
		/*
		arr数组用于存储余数，但不知道有多少个，只能把数组长度定义的较大些。
		如果需要转换的十进制数较小就会造成资源浪费。
		*/
		int x = 0;
		while(num>0)
		{
			arr[x] = num%2;
			num = num / 2;
			x++;
		}
		for(int i=x-1;i>=0;i--){
			System.out.print(arr[i]);
		}
		
	}
}

优化：利用StringBuffer存储数据；利用StringBuffer的reverse方法反转数据。

class ArrayDemo7
{
	public static void main(String[] args) 
	{
		toBin(10);
	}
	/*
	十进制-->二进制
	*/
	public static void toBin(int num)
	{
		StringBuffer sb = new StringBuffer();
		while(num>0)
		{
			sb.append(num%2);//有一个余数就添加一个
			num = num / 2;
		}
		System.out.println(sb.reverse());
	}
}

十进制转十六进制

class ArrayDemo8 
{
	public static void main(String[] args) 
	{
		toHex(60);
	}
	
	/*
	十进制-->十六进制。
	*/
	public static void toHex(int num)
	{

		StringBuffer sb = new StringBuffer();

		for(int x=0; x<8; x++)//一个整数（int）4个字节，共32位。一次右移4位，需要8次。
		{
			int temp = num & 15;
			if(temp>9){  //如果大于9就用十六进制对应的字母来表示。
				sb.append((char)(temp-10+'A'));
			}
			else{
				sb.append(temp);
			}
			num  = num >>> 4;
		}
		System.out.println(sb.reverse());

	}
}

1992zyj

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——Java基础___函数、数组

-------android培训、java培训、期待与您交流！ ----------一、函数1.1函数的定义什么是函数？函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。函数的格式：修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2,....){执行语句;
复制链接

扫一扫