一,函数的相关知识点
1,函数也称为方法,函数是定义在类中的具有特定功能的一段代码块。函数之间不能相互包含,也就是不能再函数内部定义函数,但是函数之间可以相互调用。
基本格式:修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,...) {
语句;
return 返回值;
}
当返回值是void类型时,return语句可以省略。关于java中方法的使用,我的总结是多敲代码就自然而然的理解了,在所有的java程序中都离不开方法的使用,其好处是对功能进行了封装,可以重复使用某一个功能,提高代码的复用。只要记住基本格式,使用时自然不成问题。
2,关于函数的一个很重要知识点也就是函数的重载,函数的重载包括构造函数的重载和普通方法的重载。
函数的重载是指,函数的参数名相同,但是参数列表不同,参数列表包括参数类型和参数的个数不同。要特别注意的一点是,函数的重载与函数的返回值类型没有关系,当两个函数的返回值类型不同,参数列表也不相同的时候,这两个函数是重载的。当函数返回值类型不同,参数列表相同时,函数没有重载,并且这两个函数是不能共存的。
例子:给定函数:void show(int a,double b,char c) {} 判断下面那些函数与给定函数重载了。
(1),void show(int x,double y,char z) {} 没有,与给定函数相同
(2),int show(int a,char c,double b) {} 重载了,参数类型与给定函数参数类型不同,重载与返回值类型无关
(3),void show(int a,char c,double b) {} 重载了,重载与函数返回值类型无关
(4),boolean show(int a,char c) {} 重载了,参数个数不同,重载与返回值类型无关
(5),void show(int a) {} 重载了,参数个数不同
(6),int show(int a,double b,char c) {} 没有重载,参数列表相同,返回值类型与函数重载无关。该函数不能和给定函数共存。
二,数组的相关知识点
1,数组就是同一类型的数据的集合,可以看成是一个容器。数组中的每个元素都有各自的编号,并且编号是从0开始的。
2,数组的格式:
(1)元素类型[] 数组名 = new 数组名[数组长度]
示例:int[] arr = new int[5]
(2)元素类型[] 数组名 = new 数组名[] {元素,元素,元素,...}
示例:int[] arr = new int[] {1,2,3,4,5}
int[] arr = {1,2,3,4,5}
3,数组的基本特点:
(1)长度固定,一旦被创建它的长度就是不可改变的。
(2)元素类型必须是相同类型,不允许出现混合类型;
(3)数组中的元素可以是任何数据类型,包括基本数据类型和引用数据类型。
用类型,本身是在堆内存中的。(4)数组的变量属于引用类型,数组也可以看做是对象,数组中的每个元素相当于数组的成员,java中的对象时在对内存中的,因此数组无论是原始类型还是引
4,数组的常见操作:
(1)获取数组的最值,以最大值为例:
public class Demo1 {
public static void main(String[] args) {
int[] arr = new int[] {4,5,7,8,4,5,6};
int max = getMax(arr);
System.out.println(max);
}
private static int getMax(int[] arr) {
int max = arr[0];
for(int i=1;i<arr.length;i++) {
if(arr[i]>max) {
max = arr[i];
}
}
return max;
}
//使用重载可以获取double类型数组的最大值
private static double getMax(double[] arr) {
double max = arr[0];
for(int i=1;i<arr.length;i++) {
if(arr[i]>max) {
max = arr[i];
}
}
return max;
}
}
(2)对数组的选择排序:
public class SelectSort {
public static void main(String[] args) {
int[] arr = new int[] {4,5,7,8,4,5,6};
sop(arr);
sort(arr);
sop(arr);
}
//遍历排序
public static void sort(int[] arr) {
for(int i=0;i<arr.length;i++) {
for(int j=i+1;j<arr.length;j++) {
if(arr[j]<arr[i]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
//打印结果,用逗号隔开
public static void sop(int[] arr) {
for(int i=0;i<arr.length;i++) {
if(i!=arr.length-1)
System.out.print(arr[i] + ",");
else
System.out.println(arr[i]);
}
}
}
(3)数组的冒泡排序:
public class BubbleSort {
//冒泡排序的原理是相邻的两个元素进行比较,如果符合条件则换位
public static void main(String[] args) {
int[] arr = new int[] {4,5,7,8,4,5,6,10,18,3,4};
sop(arr);
sort(arr);
sop(arr);
}
//遍历排序
public static void sort(int[] arr) {
for(int i=0;i<arr.length-1;i++) {
for(int j=0;j<arr.length-i-1;j++) {
if(arr[j]>arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
//打印结果,用逗号隔开
public static void sop(int[] arr) {
for(int i=0;i<arr.length;i++) {
if(i!=arr.length-1)
System.out.print(arr[i] + ",");
else
System.out.println(arr[i]);
}
}
}
(4)数组的排序在实际开发中常用的是使用Arrays的静态方法,Arrays.sort(数组),可以实现排序。
(5)数组的查找法(普通查找和折半查找):
public class Search {
public static void main(String[] args) {
int[] arr = {4,5,7,8,9,11};
//System.out.println(commonSearch(arr,8));
System.out.println(binarySearch(arr,10));
}
//折半查找法
public static int binarySearch(int[] arr,int value) {
int start = 0;
int end = arr.length-1;
while(start<=end) {
int mid = (start+end)/2;
if(arr[mid]>value)
end = mid - 1;
else if(arr[mid]<value)
start = mid + 1;
else
return mid;
}
return start;
}
//普通查找方法
/*public static int commonSearch(int[] arr,int value) {
for(int i=0;i<arr.length;i++) {
if(arr[i] == value)
return i;
}
return -1;
}*/
}
(6)查表法实现进制之间的转换
class Converse
{
public static void main(String[] args)
{
//toBin(-6);
toBin(6);
//toHex(-60);
//toOcto(60);
}
/*
十进制-->二进制
*/
public static void toBin(int num)
{
trans(num,1,1);
}
/*
十进制-->八进制
*/
public static void toOcto(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)
{
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 ;
}
}
(7)将数组中所有的元素逆序,如:int[] arr = new int[] {2,5,4,1,3,4} 逆序后:{4,3,1,4,5,2}
public class Test2 {
public static void main(String[] args) {
int[] arr = new int[] {2,5,4,1,3,4};
sop(arr);
reverse(arr);
}
//将第一个元素与最后一个元素进行互换位置,然后将第一个元素角标增一,最后一个元素角标减一,循环交换,知道两角表相同循环结束
private static void reverse(int[] arr) {
for(int start=0,end=arr.length-1;start<end;start++,end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
sop(arr);
}
//遍历打印结果
private static void sop(int[] arr) {
for(int i=0;i<arr.length;i++) {
if(i != arr.length-1)
System.out.print(arr[i] + ",");
else
System.out.println(arr[i]);
}
}
}
三,二维数组的使用
1,二维数组可以理解为数组的数组,即在一维数组中存储的元素是一位数组。
2,格式:
(1)int[][] arr = new int[3][2]
含义是:定义了一个名称为arr的二维数组,二维数组中有3个一维数组,每一个一维数组有2个元素。
一维数组分别是:arr[0],arr[1],arr[2]
(2)int[][] arr = int[3][]
含义是:二维数组中有3个一维数组
一位数组的初始化值都默认为null
可以分别对这3个数组分别初始化:arr[0] = new int[3]; arr[1] = new int[2];int arr[2] = new int[5];