1. 函数
什么是函数？
•函数就是定义在类中的具有特定功能的一段独立小程序。
•函数也称为方法。
函数的格式：
•修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2， )
{
执行语句;
return返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该值会返回给调用者。
函数的特点：
定义函数可以将功能代码进行封装
便于对该功能进行复用
函数只有被调用才会被执行
函数的出现提高了代码的复用性
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
注意：
•函数中只能调用函数，不可以在函数内部定义函数。
•定义函数时，函数的结果应该返回给调用者，交由调用者处理。
怎么使用函数：
明确要定义的功能最后的结果是什么？明确函数的返回值类型
明确在定义该功能的过程中，是否需要未知内容参与运算；明确函数的参数列表(参数的类型和参数个数)
函数的重载
2. 数组
数组的定义：
数组的静态初始化：Int[] arr = new int[]{3,5,1,7}
二维数组
内存结构：
格式1： int[][] arr= new int[5][3];
以上格式表示定义了名称为arr的二维数组。有5个一维数组，每一个一维数组中有3个元素。一维数组的名称分别为arr[0],arr[1],arr[2]…arr[4]。
arr[0][1] = 20: 给第一个一维数组1脚标位赋值为20
格式2： int[][] arr= new int[3][];
以上格式代表该数组有3个一位数组，每个一维数组的列数(元素个数)还没有确定
如：
class Test
{
publicstaticvoid main(String[] args) throws Exception
{
int [][]i = newint[3][];
i[0] = newint[1];
i[1] = newint[2];
i[2] = newint[3];
sop("二维数组的长度为："+i.length);
sop("二维数组第一维的长度为："+i[0].length);
sop("二维数组第二维的长度为："+i[1].length);
sop("二维数组第三维的长度为："+i[2].length);
}
publicstaticvoid sop(Object obj)
{
System.out.println(obj);
}
}
格式3：int[][] arr = {{1,2,3},{2,3,4,5}};
每一个一维数组中具体元素都初始化了。
注：一种特殊定义写法：int[]x,y[]; x是一维数组，y是二维数组。
数组是引用数据类型，初始化的值为null;例如：arr[0][1]=null;
数组内存结构：
栈内存：数据使用完毕就会自动释放；（局部变量，函数都在栈内存）；
堆内存：存放实体(数组和对象)，会默认初始化值；数据使用完后是通过Java的垃圾回收机制清除的(当堆内存中的数据没有被使用的时候jvm会自动把垃圾数据从内存中清除)。
清空数组： arr=null;
数组的常见问题:
ArrayIndexOutOfBoundsException: 3:操作数组时，访问到了数组中不存在的角标。
NullPointerException:空指针异常：当引用没有任何指向值为null的情况，该引用还在用于操作实体。
怎么操作数组？
1. 获取最值：
初始化任一元素：
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_2(int[] arr)
{
int max = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[max])
max = x;
}
return arr[max];
}
2. 排序：
选择排序:
让第一个数（a）和其他剩余的数字（b）进行比较，如果a>b就进行交换，第一轮结束后，在进行第二轮---第三轮--第四伦，以此类推
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])
{
/*
int temp = arr[x];
arr[x] = arr[y];
arr[y]= temp;
*/
swap(arr,x,y);
}
}
}
}
冒泡排序：
此方法如意阅读，但是效率不好，因为堆内存的元素要进行换位。
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])
{
/*
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
*/
swap(arr,y,y+1);
}
}
}
}
Arrays.sort(数组名):
java中已经定义好的排序方式,开发中使用该方法(util包的)。
开发中不这样做，这样做的目的是提高算法能力，面试能力。
3. 折半查找（二分查找）:
方法1:
与从头到尾查找相比,提高效率，但是必须要保证该数组是有序的数组
public static int halfSearch_2(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;
}
方法2:
Arrays.binarySearch(数组名,元素);//java提供好的一个进行折半查找的功能。开发时使用这个。
练习：
有一个有序的数组，想要将一个元素插入到该数组中，
还要保证该数组是有序的。如何获取该元素在数组中的位置。
public static int getIndex_2(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 min;
}
4. 获取十进制à二进制的值
利用StringBuff容器：只能算正数
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer();
while(num>0)
{
//System.out.println(num%2);
sb.append(num%2);
num = num / 2;
}
System.out.println(sb.reverse());
}
StringBuffer类的appendf方法：
StringBuffer sb = new StringBuffer(“abc”);
sb.append(true);
方法的作用是追加内容到当前StringBuffer对象的末尾，类似于字符串的连接。调用该方法以后，StringBuffer对象的内容也发生改变。
reverse方法：
该方法的作用是将StringBuffer对象中的内容反转，然后形成新的字符串。例如：
StringBuffer sb = new StringBuffer(“abc”);
sb.reverse();
经过反转以后，对象sb中的内容将变为”cba”。
利用数组(查表法)：正数，负数都可以算
public static void toBin(int num)
{
//定义二进制的表。
char[] chs = {'0','1'};
//定义一个临时存储容器。
char[] arr = new char[32];
//定义一个操作数组的指针
int pos = arr.length;
while(num!=0)
{
int temp = num & 1;
arr[--pos] = chs[temp];
num = num >>> 1;
}
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]);
}
}
5. 十进制->十六进制
利用StringBuff容器：
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for(int x=0; x<8; x++)
//4个二进制位=1个十六进制位。一个INT数据类型是32位，总共要右移8次，取得8个十六进制数。
{
int temp = num & 15;
if(temp>9)
//System.out.println((char)(temp-10+'A'));
sb.append((char)(temp-10+'A'));
else
//System.out.println(temp);
sb.append(temp);
num = num >>> 4;
}
System.out.println(sb.reverse());
}
利用数组(查表法)：
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for(int x=0; x<8; x++)
//4个二进制位=1个十六进制位。一个INT数据类型是32位，总共要右移8次，取得8个十六进制数。
{
int temp = num & 15;
if(temp>9)
//System.out.println((char)(temp-10+'A'));
sb.append((char)(temp-10+'A'));
else
//System.out.println(temp);
sb.append(temp);
num = num >>> 4;
}
System.out.println(sb.reverse());
}
6. 进制转换优化(将共性内容抽取出来)
/*
十进制-->二进制
*/
public static void toBin(int num)
{
trans(num,1,1);
}
/*
十进制-->八进制
*/
public static void toBa(int num)
{
trans(num,7,3);
}
/*
十进制-->十六进制
*/
public static void toHex(int num)
{
trans(num,15,4);
}
public static void trans(int num,int base,int offset)
{
if(num==0)//0不用参与计算了，直接结束
{
System.out.println(0);
return ;
}
char[] chs = {'0','1','2','3'
,'4','5','6','7'
,'8','9','A','B'
,'C','D','E','F'};
char[] arr = new char[32];
int pos = arr.length;
while(num!=0)
{
int temp = num & base;
arr[--pos] = chs[temp];
num = num >>> offset;
}
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]);
}
return ;
}
453
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
