java语句及数组知识总结

来源：互联网发布：mac上好用的手绘软件编辑：程序博客网时间：2024/05/22 11:39

循环结构：

While（条件表达式）{执行语句}

do{执行语句}while（条件表达式）

区别在于：不论条件是否满足，do while都会至少执行一次

for(初始化表达式；循环条件表达式；循环的操作表达式){执行语句}

for和while的小区别：

1、变量有自己的作用域，对于for来讲，如果将控制循环的增量定义在for循环中，只能在语句内有效

2、可以互换，如果需要定义循环增量，用for更为合适

嵌套循环：

for…for嵌套

打印

***

****

*****和99乘法表

代码实现：

class ForForTest

{

public static void main(String[] args)

{

for(int x=0;x<5;x++)

{

for(int y=5-x;y<=5;y++)

{

System.out.print("*");

}

System.out.println();

}

System.out.println("---------------------------------");

for(int x=1;x<10;x++)

{

for(int y=1;y<=x;y++)

{

System.out.print(y+"*"+x+"="+x*y+"\t");

}

System.out.println();

}

流程控制语句：break（switch语句、循环语句（能够用于跳出循环，标号只能用于循环）） continue（只能作用于循环结构，继续循环。特点：结束本次循环，继续下一次循环）

break和continue单独存在时，下面可以有任何语句，因为都执行不到。

函数：

函数就是定义在类中的具有特定功能的一段独立小程序，也称为方法。

函数格式：修饰符返回值类型函数名（参数类型形式参数1，参数类型形式参数2，…）

{

执行语句；

Return返回值；

}

函数特点：

1、可将功能代码进行封装，便于对该功能进行复用

2、只有被调用才执行，函数的出现提高了代码的复用性

3、若无返回值，返回值类型可用关键字void，return若在最后可以省略不写

注意：

1、函数只能调用函数，不能再函数内部定义函数

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

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

数组：同一种类型数据的集合，其实数组就是一个容器。数组可以给其中的元素从0开始编号，方便操作这些元素。

格式:

1、元素类型【】数组名=new 元素类型【元素个数或数组长度】

eg：int【】 arr=new int【5】；

2、元素类型【】数组名=new 元素类型【】{元素，元素……}；

int【】 arr=new int【】{3,5,7}；

int【】 arr={3,5,7}；

内存结构：

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

堆内存：数组和对象，通过new建立的实例都存放在堆内存中

每一个实体都有内存地址值，实体中的变量都有默认初始化值

实体不再被使用，会在不确定的时间被垃圾回收器回收

方法区、本地方法区、寄存器

java基础视频第四天重点总结：

数组的操作：

1、获取数组中的元素，通常用遍历

2、获取数组的元素个数 .length

Eg：随便定义一个数组，获取数组的长度与元素（用到数组，通常都要用到for循环）

class ArrayDemo6

{

public static void main(String[] args)

{

int[] arr={5,8,7,6,4,55,4,88};

System.out.println("length:"+arr.length);

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

{

System.out.println("arr["+x+"]="+arr[x]+";");

}

本节重点：将给定数组进行排序两种方式（选择排序和冒泡排序）

最快的排序方式：希尔排序（三层循环加位运算）

选择排序、代码实现：

class SelectSort

{

public static void main(String[] args)

{

int[] arr={8,7,5,4,9,5,88,4,5,454};

printSort(arr);

sort(arr);

printSort(arr);

}

public static void sort(int[] arr)//选择排序

{

for(int x=0;x<arr.length;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;

}

public static void printSort(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 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;

}

util包中Arrays.Sort（）//java中已经定义好的排序方式，开发中使用。

折半查找：能够提高效率

//折半查找

class ArrayTest7

{

public static void main(String[] args)

{

int[] arr={1,5,7,8,9,12,45,78};

int index=arrayTest(arr,7);

System.out.println("index="+index);

}

public static int arrayTest(int[] arr,int key)

{

int min,mid,max;

min=0;

max=arr.length-1;

mid=(min+max)/2;

while(arr[mid]!=key)

{

if(key>arr[mid])

min=mid+1;

else

min=mid-1;

if(min>max)

return -1;

mid=min+max/2;

}

return mid;

}

查表法求十六进制：将所有的元素临时存储起来，建立对应关系

每一次&15之后的值作为索引去查建立好的表，就可以找对应的元素，这样比-10+‘A’简单。表可以通过数组的形式建立。

public static void toHex_1(int num)

{

char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

char[] arr=new char[8];

int pos=0;

while(num!=0)

{

int temp=num&15;

arrpos++]=chs[temp];

num=num>>>4;

}

for(int x=pos-1;x>=0;x--)

{

System.out.print(arr[x]+",");

}

//万能进制转换

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 ;

}