【Java SE】流程控制，方法，数组

小灰灰 2022-12-14 12:23 127阅读 0赞

### 文章目录 ###

*   *  1、用户交互 Scanner
     *  2、顺序结构
     *  3、循环结构
     *  4、Java 方法
     *  5、数组

## 1、用户交互 Scanner ##

public class Demo2 { 
        public static void main(String[] args) { 
            Scanner scanner = new Scanner(System.in);
            // 判断用户还有没有输入
            if(scanner.hasNext()){ 
                // 接收输入的内容
                String str = scanner.next();
                String str2 = scanner.nextLine();
                System.out.println(str);
            }
            // 关闭 IO 流，节省资源
            scanner.close();
        }
    }

> next 和 nextLine 的区别

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_1_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center]  
类似于 C++ 中的 cin>>s 和 getline(cin,s) 的区别

另外 Scanner 可以接收特点类型的数值，比如整数，浮点数

## 2、顺序结构 ##

if else 语句

**switch 语句**

switch 有 case 穿透，新手在每一条语句后加 break;但是学到后期会发现，有些语句加了 break 反而实现不了需求，当然这是后话了！

从 Java jdk7 后，switch 的表达式支持 String 类型，之前仅仅支持 byte,char,int short 类型，但是其 **本质还是 int 类型**，所以总归来说，Switch 表达式支持的是 int 类型

下面使用 IDEA 反编译查看底层是怎么处理 Switch 表达式的

将对应的 .class 文件拷贝到 .java 文件的位置，然后在 IDEA 查看 .class 文件，就是反编译后的文件

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_1_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center 1]  
switch 中的 String 类型值通过调用 hashcode 映射为一个整数，根据整数进行判断，另外对于 char 类型的值，直接根据 ASCII 码转换成 int 来进行计算

## 3、循环结构 ##

有 while ,do-while ,for 语句

基础的就不啰嗦了，下面看看三种死循环的表达式

while(true)
    
    while(1)
    
    for(;;)

他们之间的区别是啥？

要分析这个问题，必须还是得研究研究反汇编文件

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center]  
可以看到源程序把 `for(;;)`当做 `while(true)` 处理

java IDEA 中 while 中只能是 Boolean 类型，下面从 C++ 编译器分析，`for(;;); while(1), while(true) 的区别`

在 VS 编译器，for 比 while 的效率明显高，不占用寄存器，不需要判断跳转

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center 1]  
在 gcc 编译器，三种写法都是一样的

## 4、Java 方法 ##

方法相当于C++中的函数，在程序中被创建，在其他地方被引用，方法的设计原则是：**一个方法完成一个功能，有利于扩展**

方法命名规则：第一个单词首字母小写，其他首字母大写

方法的定义：最前面有一个修饰符，这是和 C++ 函数唯一不同的地方，告诉编译器如何调用该方法，不过在 C++ 类中，也有它的修饰符

**命令行传参**

运行一个程序的时候，把参数传递给 main 方法，可以通过 for 循环打印出来验证

**可变参数**

在方法声明中，在指定类型后加一个省略号，一个方法只能定义一个可变参数，相当于是一个数组

public class methonDemo1 { 
        public static void main(String[] args) { 
            methonDemo1 methondem1 = new methonDemo1();
            methondem1.test(1,2,3);
        }
        public void test(int ...i){ 
            System.out.println(i[0]);
            System.out.println(i[1]);
            System.out.println(i[2]);
        }
    }

## 5、数组 ##

概念和 C++ 几乎一样

*  长度固定，一旦被创建大小不可改变
 *  元素必须是相同类型，不允许混合类型
 *  数组中存放的类型，可以是基本类型，也可以是引用类型
 *  数组本身就是对象，Java 中对象是存储在堆中的

写法和 C++ 稍有不同

public class Demo6Array { 
        public static void main(String[] args) { 
            // Java 写法
            int[] nums1 = { 1,2,3,4,5};
            int[] nums2 = new int[10];
            // C++ 写法
            int nums3[10] = new int;
        }
    }

**初始化方式和内存分析**

Java 内存

*  堆：存放 new 的对象和数组，可以被所有线程共享，不会存放别的对象引用
 *  栈：存放基本变量类型和值，存放这个引用在堆里面的具体地址
 *  方法区：包含了所有的 class ，static 变量，可以被所有线程共享

**Array 类**

数组的工具类，java.util.Arrays

类中的方法都是 static 修饰的静态方法，可以直接通过类名进行调用

常见的方法

public class Demo6Array { 
        public static void main(String[] args) { 
            int[] a = { 2,4,6,3,1,5,2,4,5,6,9,8,7,0};
            System.out.println(Arrays.toString(a));
            Arrays.sort(a);
            // 都赋值为 10
            Arrays.fill(a,10);
            System.out.println(Arrays.toString(a));
            // 判断两个数组是否相等
            Arrays.equals(a,a);
            // 二分查找：需要 a 是有序的
            System.out.println(Arrays.binarySearch(a,7));
        }
    }

**稀疏数组**

当一个数组中大部分元素为0或者都是同一个元素的时候，可以使用稀疏数组进行保存

左边是存储元素的数组，右边是稀疏数组，\[0\] 表示，该数组有 6 行，7列，8个值

\[1\] 表示 0,3 列存储一个元素为 22，其他类似

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_1_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center 2]

将二维数组转换为稀疏数组

public class Demo7Arrays { 
        public static void main(String[] args) { 
            // 定义一个二维数组
            int[][] array1 = new int[11][11];
            array1[1][2] = 2;
            array1[2][3] = 3;
            printlnArray(array1);
            // 定义稀疏数组
            System.out.println("稀疏数组为：");
            int count = 0;
            for(int i = 0;i<array1.length;++i){ 
                for(int j = 0;j<array1[i].length;++j){ 
                    if(array1[i][j] != 0){ 
                        count+=1;
                    }
                }
            }
            int[][] array2 = new int[count+1][3];
            array2[0][0] = 11;
            array2[0][1] = 11;
            array2[0][2] = count;
            int rows = 0;
            for(int i = 0;i<array1.length;++i){ 
                for(int j = 0;j<array1[i].length;++j){ 
                    if(array1[i][j] != 0){ 
                        ++rows;
                        array2[rows][0] = i;
                        array2[rows][1] = j;
                        array2[rows][2] = array1[i][j];
                    }
                }
            }
            printlnArray(array2);
            // 还原二维数组
        }
        public static void printlnArray(int[][] array){ 
            for(int i = 0;i<array.length;++i){ 
                for(int j = 0;j<array[i].length;++j){ 
                    System.out.print(array[i][j]+"\t");
                }
                System.out.println();
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_1_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/9ce71bd98b5242e58795c62952063103.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_1_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/215bc96125324147adff891ccc1439df.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/58d095b903104170875e2e4fd92a414b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/52feb6cbb0974f7b9301ea35b7980f10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_1_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/e63d05d467594e8abd020bce718ece9d.png