Java学习日记（二）程序流程控制、函数、数组_定义一个功能,对两个数进行比较。获取较大的数。-CSDN博客

本文详细介绍了程序中的控制流程，包括if、switch、while等结构的使用方法及注意事项，并提供了丰富的示例代码帮助理解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、程序流程控制

★判断结构

if语句

三种格式：

1.if(条件表达式){

执行语句;

}

示例：

int x=2;

if(x= =2){

System.out.println(“if语句执行”);

}

2.if (条件表达式){

执行语句;

}else{

执行语句;

}

示例：

int x=1;

if(x>3){

System.out.println(“yes”);

}else{

System.out.println(“no”);

}

结果为：

附注：ifelse结构额简写格式就相当于三元运算符

变量=（条件表达式）？表达式1：表达式2；

三元运算符：

优点：可以简化if else代码

缺点：因为是一个运算符，所以运算结束必须要有一个结果。

int a=9,b;

b=(a>1)?100:200;

等同于：

int a=9,b;

if(a>1)

b=100;

else

b=200;

3.if(条件表达式){

执行语句;

}else if(条件表达式){

执行语句;

} else if(条件表达式){

执行语句;

}

……

else{

执行语句;

}

示例：

需求1：根据用户定义的数值不同。打印对应的星期英文

int num = 1;

if(num==1)

System.out.println("Monday");

else if(num==2)

System.out.println("Tuesday");

else if(num==3)

System.out.println("Wednesday");

else if(num==4)

System.out.println("Thursday");

else if(num==5)

System.out.println("Friday");

else if(num==6)

System.out.println("Saturday");

else

System.out.println("Sunday");

结果为：

Monday

需求2：根据用于指定月份，打印该月份所属的季节

规定：3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

int x=6;

if(x>12 || x<1)

System.out.println(x+"月份不存在");

else if(x>=3 && x<=5)

System.out.println(x+"春季");

else if(x>=6 && x<=8)

System.out.println(x+"夏季");

else if(x>=9 && x<=11)

System.out.println(x+"秋季");

else

System.out.println(x+"冬季");

结果为：

6夏季

或者写成：

int x=6;

if(x==3 || x==4 || x==5)

System.out.println(x+"春季");

else if(x==6 || x==7 || x==8)

System.out.println(x+"夏季");

else if(x==9 || x==10 || x==11)

System.out.println(x+"秋季");

else if(x==12 || x==1 || x==2)

System.out.println(x+"冬季");

else

System.out.println(x+"月份不存在");

结果为：

6夏季

if语句特点：

1.每一种格式都是单条语句

2.第二种格式与三元运算符的区别：

三元运算符运算完要有值出现，三元运算符可以在其他表达式中

3.条件表达式无论写成什么样子，只看最终的结构是否为true或者false。

★选择结构

switch语句

格式：

switch(){

case取值1:

执行语句;

break;

case 取值2:

执行语句;

break;

case取值3:

执行语句;

break;

……

default

执行语句;

break;

}

示例1：

int x = 6;

switch(x)//byte short int char

{

case4:

System.out.println("a");

break;

case6:

System.out.println("b");

break;

case2:

System.out.println("c");

break;

default:

System.out.println("d");

}

结果为：

实例2：

int a = 4, b = 2;

char ch = '+';

switch (ch) {

case'+':

System.out.println(a+ "+" + b + "=" + (a + b));

break;

case'-':

System.out.println(a+ "-" + b + "=" + (a - b));

break;

case'*':

System.out.println(a+ "*" + b + "=" + a * b);

break;

case'/':

System.out.println(a+ "/" + b + "=" + a / b);

break;

default:

System.out.println("dataerror!");

}

结果为：

4+2=6

if和switch语句很像。

具体什么场景下，应用哪个语句呢？

如果判断的具体数值不多，而是符合byte short int char这四种类型。

虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。

其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

switch语句特点：

1.switch语句选择的类型只有四种：byte、short、int、char；

2.case之间与default没有顺序。先执行第一个case，没有匹配的case执行default；

3.结束switch语句的两种情况：遇到break，执行到switch语句结束；

4.如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

★循环结构

代表语句：while、do…while，for

1.while语句格式：

while(条件表达式){

执行语句;

}

2.do…while语句格式：

do{

执行语句;

}while(条件表达式);

示例1：

int x = 3;

while(x<5)

{

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

x++;

}

结果为：

x=3

x=4

示例2：

int x = 2;

{

System.out.println("do: x="+x);

x++;

}while (x<4);

结果为：

do : x=2

do : x=3

while与do…while的区别在于：

do…while无论条件是否满足，循环体至少被执行一次。

3.for语句格式：

for(初始化表达式;循环条件表达式;循环后的操作表达式){

执行语句;

}

示例1:

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

{

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

}

结果为：

x=0

x=1

x=2

示例2：for循环嵌套（打印99乘法表）

for(int i=1;i<=9;i++){

for(int j=1;j<=i;j++){

System.out.print(i+"*"+j+"="+i*j+'\t');

}

System.out.println();

}

结果：

示例3：

需求打印如下所示：
1

123

1234

12345

代码片段：

for(int x=1;x<=5;x++){

for(int j=1;j<=x;j++){

System.out.print(j);

}

System.out.println();

}

示例4：

求1到100的和。

思路：通过变量记录每一次变化的结果，通过循环的形式，进行累计动作。

int sum = 0;

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

{

sum+= x;

}

System.out.println("for sum ="+sum);

结果为：

for sum = 5050

附注：

1.for里面的表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复整个过程，直到条件不再满足为止。

2.while和for可以互换，区别在于for为了循环而定义的变量在for循环结束后就在内存中释放，而while循环使用的变量在循环结束后还可以继续使用。

3.最简单无限循环格式，while(true),for(;;)无限循环存在的原因是并不知道循环多少次，而是根据某些条件来控制循环。

问：什么时候使用循环结构？

答：当要对某些语句执行很多次时，就要使用循环结构。

★其他流程控制语句

break，continue

break语句：应用范围——选择结构和循环结构

continue语句：应用于循环结构。

示例：（break）

w:for(int x=0; x<3; x++)

{

for(int y=0; y<4; y++){

System.out.println("x="+x+",y="+y);

}

breakw;

}

结果为：

x=0,y=0

x=0,y=1

x=0,y=2

x=0,y=3

示例：（continue）

需求获取1-10的奇数。

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

if(x%2==0)

continue;

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

}

结果为：

x=1

x=3

x=5

x=7

x=9

示例：（continue）

w:for(int x=0; x<3; x++){

for(int y=0; y<4; y++){

System.out.println("x="+x+",y="+y);

continue w;

}

结果为：

x=0,y=0

x=1,y=0

x=2,y=0

附注：

1.这两个语句离开应用范围是没有存在意义的；

2.这两个语句在单独存在其下面不可以有语句，因为执行不到；

3.continue语句是结束本次循环继续下一次循环；

4.标号的出现，可以让这两个语句作用于指定的范围。

二、函数

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

2.格式：

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

执行语句;

return返回值；

}

说明：

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

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

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

实际参数：传递给形式参数的具体参数

return：用于结束函数

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

3.特点：

★定义函数可以使功能代码进行封封装

★便于对该功能的复用

★函数只有被调用才会被执行

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

注意：

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

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

4.函数的应用

两个明确：

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

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

示例：

需求：定义一个功能，可以实现两个整数的相加运算

分析：

1.该功能的运算结果是什么——两个数的和，也是一个int型整数

2.在实现该功能的过程中是否有未知内容参与运算？——加数和被加数是不确定的（两个参数int，int）。

代码：

int getSum(int x,int y){

return x+y;

}

示例1：（判断两个数是否相同？）

思路：1.明确功能的结果：结果是：boolean 。

2.功能是否有未知内容参与运算。有，两个整数。

public static boolean compare(int x,int y){

return x==y;

}

示例2：（定义功能，对两个数进行比较。获取较大的数）

public static int getMax(int x,int y){

return(x>y?x:y);

}

5.函数的重载（overload）

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

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

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

示例：

//返回两个整数的和

int add(int x,int y){return x+y;}

//返回三个整数的和

int add(int x,int y,int z){return x+y+z;}

//返回两个小数的和

double add(double x,double y){return x+y;}

三、数组

1.定义：

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

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

格式：

1.元素类型[ ] 数组名=new元素类型[ 元素个数或者数组长度];

示例：int[ ] arr=new int[5];

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

示例：int[ ] arr=new int[]{3,2,51,62,8};

Int[ ] arr={3,5,4,7,5,6,43};

2.内存结构

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：

用于存储局部变量，当数据使用结束，所占空间会自动释放

堆内存：

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

◇每一个实体都有内存地址值

◇实体中的变量都有默认初始化值

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

3.常见问题

1.数组角标越界异常（ArrayIndexOutOfBoundsException）

示例：int[ ] arr=new int[2];

System.out.println(arr[3]);//访问到了数组中的不存在的角标时发生

2.空指针异常（NullPointException）

示例：int[ ] arr=null;

System.out.println(arr[0]);//arr引用没有指向实体，却在操作实体中的元素时

4.常见操作

●获取数组中的元素

示例：定义功能，用于打印数组中的元素。元素间用逗号隔开。

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]+"]");

}

在主函数中调用即可

int[] arr = {3,6,5,1,8,9,67};

printArray(arr);

结果为：

[3, 6, 5, 1, 8, 9, 67]

●获取最值（最大值，最小值）

ⅰ.获取数组中的最大值。

思路：

1.获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。通过一个变量进行临储。

2.让数组中的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值，就用该该变量记录较大值。

3.当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

步骤：

1.定义变量。初始化为数组中任意一个元素即可。

2.通过循环语句对数组进行遍历。

3.在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；

方式一：

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;

}

方式二：

可不可以将临时变量初始化为0呢？可以。这种方式，其实是在初始化为数组中任意一个角标。

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];

}

ⅱ.获取最小值(也有两种方式，这里就写一种)

public static int getMin(int[] arr) {

intmin = 0;

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

if(arr[x]<arr[min])

min= x;

}

return arr[min];

}

●排序（选择排序，冒泡排序）

ⅰ. 选择排序

内循环结束一次，最值出现在头脚标位置上

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;

}

ⅱ. 冒泡排序

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;

}

●折半查找（二分查找）——必须保证数组是有序的

方式一：

public static int halfSearch(int[] arr,intkey) {

int min,max,mid;

min= 0;

max= arr.length-1;

mid= (max+min)/2;

while(arr[mid]!=key){

if(key>arr[mid])

min= mid + 1;

elseif(key<arr[mid])

max= mid - 1;

if(min>max)

return -1;

mid= (max+min)/2;

}

return mid;

}

方式二：

public static int halfSearch_2(int[]arr,int key){

intmin = 0,max = arr.length-1,mid;

while(min<=max){

mid= (max+min)>>1;

if(key>arr[mid])

min= mid + 1;

elseif(key<arr[mid])

max= mid - 1;

else

return mid;

}

return-1;

}

定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。

public static int getIndex(int[] arr,intkey) {

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

if(arr[x]==key)

returnx;

}

return -1;

}

获取索引的另外形式：

public static int getIndex_2(int[] arr,intkey) {

int min = 0,max = arr.length-1,mid;

while(min<=max){

mid= (max+min)>>1;

if(key>arr[mid])

min= mid + 1;

elseif(key<arr[mid])

max= mid - 1;

else

returnmid;

}

return min;

}

5.数组中的数组（二维数组）

格式1：int[ ][ ] arr=new int[3][2];

定义了名称为arr的二维数组

二维数组中的3个一维数组

每一个一维数组中有2个元素

一维数组的名称分别为arr[0], arr[1], arr[2]

给第一个一维数组1脚标赋值为88的写法是：arr[0][1]=88;

格式2：int[ ][ ] arr=new int[3][ ];

二维数组中的3个一维数组

每个一维数组都是默认初始化值null

可以对这三个一维数组分别进行初始化

arr[0]=newint[3];

arr[1]=newint[1];

arr[2]=newint[3];

格式3：int[ ][ ] arr={{3,8,2},{2,4},{6,5,3,8}};

定义了名称为arr的二维数组

二维数组中的3个一维数组

每一个一维数组中具体元素也都已经初始化

第一个一维数组arr[0]={3,8,2};

第二个一维数组arr[1]={2,4};

第三个一维数组arr[0]={ 6,5,3,8};

第三个一维数组的长度表示方式为：arr[2].length;

练习：

1. 1~100之间 7的倍数的个数。并打印。

思路：

1，先对1~100进行循环(遍历)通过循环的形式。

2，在遍历的过程中，定义条件。只对7的倍数进行操作。

3，因为7的倍数不确定，只要符合条件，就通过一个变量来记录住这个变化的次数。

步骤：

1，定义循环语句，选择for语句。

2，在循环中定义判断。只要是7的倍数即可。使用if语句。条件：7的倍数 x%7==0；

3，定义变量，该变量随着7的倍数的出现而自增。

public class ForGetNum {

       publicstatic void main(String[] args) {

              int count = 0;

              for(int x = 1; x <= 100; x++) {

                     if(x % 7 == 0) {

                            count++;

                            System.out.println("x="+ x + '\t');

                     }

              }

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

       }

}

结果为：

x=7

x=14

x=21

x=28

x=35

x=42

x=49

x=56

x=63

x=70

x=77

x=84

x=91

x=98

count=14

2. 3000米长的绳子，每天减一半。问多少天这个绳子会小于5米？不考虑小数。

public class GetDay {

       public static void main(String[] args) {

              int day = 0;

              for(int x = 3000; x >= 5; x /= 2) {

                     day++;

              }

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

       }

}

结果为：

day=10

3. 定义一个功能，用于打印矩形

public static void draw(int row,int col){

       for(int x=0; x<row; x++){

              for(int y=0; y<col; y++){

                     System.out.print("*");

              }

              System.out.println();

       }

}

在主函数中直接调用即可

draw(3,4);

结果为：

****

4. 定义一个打印99乘法表功能的函数

public static void print99(){

       for(int x=1; x<=9; x++){

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

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

              }

              System.out.println();

       }

}

在主函数中直接调用即可

print99();

结果与上面for循环中的一致

5.将给定的数组进行反转，效果：[3,55,6,7,44]------>[44,7,6,55,3]

public class ReverseArray {

       public static void main(String[] args) {

              int[] arr = {3,55,6,7,44};

              reverseArray(arr);

              printArray(arr);

       }

       publicstatic void reverseArray(int[] arr){

              for(intstart=0,end=arr.length-1;start<end;start++,end--){

                     swap(arr,start,end);

              }

       }

       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]+"]");

              }

       }

}

结果：

[44,7,6,55,3]

6.进制转换

ⅰ.十进制转换成十六进制

public static void toHex(int num) {

       StringBuffersb = new StringBuffer();

       for(intx=0; x<8; x++){

              int temp = num & 15;

              if(temp>9)

                     sb.append((char)(temp-10+'A'));

              else

                     sb.append(temp);

              num  = num >>> 4;

       }

       System.out.println(sb.reverse());

}

ⅱ.十进制转换成二进制

public static void toBin(int num) {

       StringBuffersb = new StringBuffer();

       while(num>0){

              sb.append(num%2);

              num= num / 2;

       }

       System.out.println(sb.reverse());

}