3、函数和数组

函数

定义函数的格式：

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
{
执行语句;
return 返回值;

}

特殊情况：
功能没有具体的返回值。
这时return的后面直接用分号结束。
返回值类型怎么体现呢？因为没有具体值，所以不可以写具体的数据类型。
在java中只能用一个关键字来表示这种情况。关键字是：void.

总结：没有具体返回值时，返回值类型用void来表示。
注意：如果返回值类型是void，那么函数中的return语句可以省略不写。

函数重载

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

数组

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

定义数组

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

格式二：元素类型[] 数组名 = { 元素1，元素2，元素3.....}

内存的划分

1、寄存区

2、本地方法区

3、方法区

4、栈内存：储存的都是局部变量，而且变量所属的作用域一旦结束，该变量就自动释放。

5、堆内存：储存的是数组和对象，凡是new的都建立在堆内存中，其特点有：a、每个实体都有首地址值。b、堆内存中的每个变量都有默认初始化值，根据类型的不同而不同。c、垃圾回收机制。

对数组最基本的操作就是存和取，核心思想就是对角标的操作。

数组排序练习

选择排序和冒泡排序

//数组排序练习，主要练习选择排序和冒泡排序
class  PaiXuText
{
	public static void main(String[] args) 
	{
		int[] arr = { 23, 45, 123, -87, 9, -45};
		System.out.print("选择排序演示\r\n	未排序前数组	");
		printArray(arr);
		xuanZe_2(arr);
		System.out.print("	排序后数组	");
		printArray(arr);
		
		int[] arr2 = { 23, 45, 123, -87, 9, -45};
		System.out.print("冒泡排序演示\r\n	未排序前数组	");
		printArray(arr2);
		maoPao(arr2);
		System.out.print("	排序后数组	");
		printArray(arr2);
	}

	//选择排序是将第一个数依次与后面数相比较，将最小值存于第一个元素上，再类推第二个数，最后以小到大排序。
	public static void xuanZe( int[] arr){

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

<span style="white-space:pre">	</span>//性能优化后的方法，考虑到数组排序的性能问题</span>

<span style="white-space:pre">	</span>public static void xuanZe_2( int[] arr){

<span style="white-space:pre">		</span>for (int i = 0; i < arr.length - 1 ; i ++ )
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>int num = arr[i];
<span style="white-space:pre">			</span>int index = i;
<span style="white-space:pre">		</span>for (int j = i + 1; j < arr.length ; j ++ )
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>if (num > arr[j])
<span style="white-space:pre">			</span>{
<span style="white-space:pre">				</span>num = arr[j];
<span style="white-space:pre">				</span>index = j;
<span style="white-space:pre">			</span>}
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>if (index != i)
<span style="white-space:pre">			</span>swap(arr,i,index);
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>}
	//冒泡排序，是相邻的两个元素比较，把大的元素往后面移，直至数组内从小到大排序
	public static void maoPao(int[] arr)
	{
		for (int i = arr.length - 1; i > 0 ; i -- )
		{
			for (int j = 0; j < i ; j ++ )
			{
				if (arr[j] > arr[j+1])
					swap(arr, j, j+1);
			}
		}
	}

</pre><pre name="code" class="java">	//定义一个互换数组元素的函数
	public static void swap(int[] arr, int i, int j){
	
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = 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] + " ]");
		}
	}
}

运行结果为

数组常见功能：查找

查表法进制转化练习

class  ArrayText
{
	public static void main(String[] args) 
	{
		toHax(60);
		toBinary(60);
		toOctal(60);
	}
	
	//16进制
	public static void toHax(int num)
	{
		getChange(num, 15, 4);
	}

	//二进制
	public static void toBinary(int num)
	{
		getChange(num, 1, 1);
	}

	//八进制
	public static void toOctal(int num)
	{
		getChange(num, 7, 3);
	}
	//进制转化
	public static void getChange(int num, int base, int offset)
	{
		if (num == 0)
		{
			System.out.print('0');
			return ;
		}
		char[] arr = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
		char[] arr2 = new char[8];
		int pos = arr2.length;
		while(num != 0)
		{
			int x = num&base;
			arr2[--pos] = arr[x];
			num = num >>> offset;
		}
		for (int x = pos; x < arr2.length ; x ++ )
		{
			System.out.print(arr2[x]);
		}
		System.out.println();
	}
}

结果为