瓜瓜头条

JAVA-02（语法介绍）

2023-05-23 10:12 由 睎 发表于 #后端开发

JAVA-02

Java流程控制

用户交互Scanner

Scanner类

属于IO流的类如果不关会一直占用资源

常用方法

​ 【Scanner scanner = new Scanner(System.in);】
​ .next(); 遇到空格就结束接收
​ .nextLine(); 遇到enter就结束接收
​ .hasNext() 判断是否有输入
​ .hasNextInt() 判断是否有整数输入
​ .close(); 关闭

举例【instance】
package com.xy.base;

import java.util.Scanner;

public class Demo11 {
    public static void main(String[] args) {

        //创建一个扫描对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收：");
        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            //使用next接收
            String str = scanner.next();
            System.out.println("输入的内容为："+str);
        }

        System.out.println("使用nextLine方式接收：");
        if(scanner.hasNext()){
            //使用next接收
            String str1 = scanner.nextLine();
            System.out.println("输入的内容为："+str1);
        }

        System.out.println("请输入一个整数:");
        //判断输入的是否为整数【判断是否有整数输入】
        if(scanner.hasNextInt()){
            int i = scanner.nextInt();
            System.out.println("输入的整数为："+i);
        }else{
            System.out.println("输入的不是整数！");
        }

        //凡是属于IO流的类如果不关会一直占用资源
        scanner.close();

    }
}

输入多个数字，并求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果

package com.xy.base;

import java.util.Scanner;

public class Demo11_instance {

    public static void main(String[] args) {
        //输入多个数字，并求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束并输出执行结果
        int count = 0;
        double sum = 0;

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据：");
        //while判断是否是数字输入
        while (scanner.hasNextDouble()){
            count++;
            sum = sum + scanner.nextDouble();
        }
        System.out.println(count + "个数据总和为：" + sum);
        System.out.println(count + "个数据平均数为：" + sum/count);

        //关闭！！！！！！不要忘记
        scanner.close();

    }
}

三种结构（顺序、选择、循环）

顺序结构

  1. Java最基本的结构，最简单的算法结构
  2. 任何算法都离不开的
  3. 一条一条从上到下执行
System.out.println("顺序结构！");
System.out.println("顺序结构！");
System.out.println("顺序结构！");

选择结构

1. if单选择结构
if(条件式){
	//满足表达式执行的语句
}
2. if...else双选择结构
if(条件式){
	//满足表达式执行的语句
}else{
	//不满足表达式执行的语句
}
3. if...else if多选择结构
if(条件式1){
	//满足表达式1执行的语句
}else if(条件式2){
	//满足表达式2执行的语句
}else{
	//都不满足执行的语句
}
4. 嵌套的if结构
if(条件式1){
	if(条件式1){
		//满足表达式1和2执行的语句
	}
}else{
	//不满足表达式1执行的语句
}
5. switch多选择结构

  • 语法：

    switch(expression){	//expression变量
	case value:	//【可选】判断变量的值是否等于value值
		//语句
		break;	//【可选】  若不选，会有case穿透效果
	case value:
		//语句
		break;
	...
	default:	//【可选】 以上case都不满足时执行default
		//语句
}

  • case穿透效果：如果当前case满足且结束没有break语句，那么将会执行下面所有的case，直到遇见break语句。

  • switch中的变量类型 ：byte、short、int或者char

  • 从Java SE7开始支持字符串String类型

    String  x = "注意";
switch (x){
	case "注意":
		System.out.println("注意");
    case  "协议":
        System.out.println("协议");
        break;
    default:
        System.out.println("default");
}

循环结构

1. while循环

  • 语法

    while(布尔表达式){
	//循环内容
}
2. do...while循环

  • 语法

    do{
	//循环内容
}while(布尔表达式);

  • while和do...while的区别

    • while先判断再执行，do...while先执行在判断
    • do...while至少执行一次，while可以一次也不执行
3. for循环

  • 语法

    for(初始化;布尔表达式;更新){
	//循环内容
}

  • 最有效，最灵活的循环结构

  • 循环次数是在执行之前就已经确定的

  • fou循环 ：先初始化，在判断真假，若为真则执行循环体，然后更新；若为假，则跳出循环

    for (int i = 0; i < 5; i++) {
	System.out.println("i:" + i);
    System.out.println("第" + i + "次循环！");
 }

  • 练习：打印九九乘法表

    for(int i = 1 ; i < 10 ; i ++){
    for (int j = 1 ; j <= i ; j ++){
    	//输出乘法并输出一个tab空格
    	System.out.print(j + "*" +i +"=" + j*i + "\t");
    }
    //换行
    System.out.println(); //等价于 System.out.print("\n");
}

  • 增强for循环【遍历数组】Java5引入的

    int[] num = {10,20,30,40,50};
for(int n:num){
	System.out.println(n);
}

break&continue

  1. break 强制退出循环

    int i = 0;
while(i < 100){
    i++;
    if(i == 10){
    	break;
    }
    System.out.println(i);
}

  2. continue 跳出本次循环，执行下一次【怂】

    int j = 0;
while (j < 10){
    j++;
    if (j%2 == 0) {
    	continue;
    }
    System.out.println(j);
}

练习：打印三角形

public class Demo13_instance {
    public static void main(String[] args) {
        //规定5行
        for(int i = 1 ; i <= 5 ; i ++){
            //打印空的倒直角三角形
            for(int j = 5 ; j >= i ; j --){
                System.out.print(" ");
            }
            //打印正直角三角形
            for (int j = 1 ; j <= i ; j ++){
                System.out.print("*");
            }
            //打印关于另一半直角三角形
            for(int j = 1 ; j <= i ; j ++){
                System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }
}

运行输出：

方法（Java只有值传递）

介绍

  1. 方法是解决一类问题的步骤的有序集合
  2. 方法包含于类或对象中
  3. 方法在程序中创建，在其他地方被引用
  4. 一个方法最后只做一个功能，方便扩展
修饰符 返回值类型 方法名（参数类型 参数名）{
	方法体
	return 返回值;   //返回返回值；终结方法
}

- 形参【形式参数】：在写方法时，在括号中的参数名，这里其实就是一个**占位符**
- 实参【实际参数】：在使用方法时，给方法传的参数

方法重载

  1. 定义：在一个类中，方法名相同，参数【形参】不同，返回值可同可不同
  2. 只是返回值不同，不构成重载
  3. 在执行时，编译器会根据调用方法的参数个数、参数类型去逐个匹配，如匹配出错，编译器报错
package com.xy.base;

public class Demo21 {

    public static void main(String[] args) {
        System.out.println(max(10,20));
        System.out.println(max(10,20.1));
    }

    public static double max(double x , double y){
        if (x > y){
            return x;
        }else if (x < y){
            return y;
        }else {
            System.out.println("x=y");
            return x;
        }
    }

    public static int max(int x , int y){
        if (x > y){
            return x;
        }else if (x < y){
            return y;
        }else {
            System.out.println("x=y");
            return x;
        }
    }
}

命令行传参

package com.xy.base;

public class Demo22 {
    public static void main(String[] args) {
        for (int i=0 ; i < args.length ; i++){
            System.out.println("arg[" + i + "]" + args[i]);
        }
    }
}

​ ①编译文件

​ ②运行文件这里注意找对文件位置

​ ③传递参数

​ ④运行结果【打印】

可变参数【jdk1.5 引入】

  1. 在方法声明中，指定参数类型后加一个省略号（...）

  2. 一个方法只能指定一个可变参数，它必须是方法的最后一个参数

    package com.xy.base;

public class Demo23 {

    public static void main(String[] args) {
        Demo23 demo23 = new Demo23();
        demo23.test(1,2,3,4,5);
    }

    public void test(int... i){
        System.out.println(i[0]);
    }
}

递归

  • 自己调自己

  • 一定要有出口【不可以一直递归，Java是栈机制，容易栈满】

    package com.xy.base;

public class Demo24 {
    //求阶乘
    public static int f(int n){
        if(n == 1){
            return 1;
        }else{
            return n*f(n-1);
        }
    }

    public static void main(String[] args) {
        System.out.println(f(25));
    }
}

数组

定义与使用

//定义数组  int nums2[]; 定义数组[c/c++风格]
int[] nums;
//分配空间
nums = new int[10];
//赋值
nums[0] = 1;

//二维数组
int[][] array = {{1,2},{1,3},{1,4}};
//遍历
for (int i = 0 ; i < array.length ; i ++){
    for(int j = 0 ; j < array[i].length ; j ++){
    	System.out.print(array[i][j]+"  ");
    }
    System.out.println();
}

使用

public class Demo32 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        //打印数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum = sum + array[i];
        }
        System.out.println("sum:"+sum);
        //寻找数组中最大的数
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(array[i] > max){
                max = array[i];
            }
        }
        System.out.println("max:"+max);

        //forEach jdk1.5没有下标
        for (int i : array) {
            System.out.println(i);
        }

        //反转数组
        int result[] = new int[array.length];
        for(int i=0,j=array.length-1 ; i<array.length ; i++,j--){
            result[j]=array[i];
        }
        //打印数组
        System.out.println(Arrays.toString(result));

    }
}

内存分析

  1. 堆：存放new的对象和数组；所有线程共享；不存放别的对象引用
  2. 栈：存放基本变量类型（包含这个基本类型的具体值）；引用对象的变量（会存放这个引用在堆里面的具体地址）
  3. 方法区：所有线程共享；包含所有的class和static变量
举例分析：

  • 首先声明一个数组 ——> 栈中就有了这个数组的名字

  • 然后给数组分配空间 ——> 堆中开辟了相应大小的空间

  • 最后赋值 ——> 堆中的数组空间内开始有值

三种初始化状态

静态初始化:创建+赋值
int[] a = {1,2,3,4,5,6,7,8,9};
动态初始化
int[] b = new int[5];
b[0] = 1;
数组默认初始化

数组是引用类型，他的元素相当于类的实例变量，因此数组在一分配空间时就已经被默认初始为相应类型的默认值了。

数组的特点

  1. 数组一经创建就长度确定
  2. 同一数组元素类型相同
  3. 数组中的元素可以是任何数据类型
  4. 数组变量属于引用类型，数组也可以看成对象
  5. 数组对象本身是在堆中的

Arrays类（import java.util.Arrays）

学会使用官方API帮助文档，这里介绍两个

int[] array = {1,5,7,33,2,879};
//打印Arrays.toString()
System.out.println(Arrays.toString(array));
//排序
Arrays.sort(array);
System.out.println(Arrays.toString(array));

冒泡排序

public class Demo35_sort {
    public static void main(String[] args) {
        int[] array = {1,5,7,33,2,879};
        sort(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * 冒泡排序
     */
    public static int[] sort(int[] array){
        int temp = 0;
        for(int i = 0 ; i < array.length-1 ; i++){
            boolean flag = false; //优化
            for (int j = 0 ; j < array.length-1-i ; j++){   //因为经过i轮排序之后，后面的i个数据已经是有序的了，所以减掉i
                if(array[j+1] < array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if(flag == false){  //优化
                break;
            }
        }
        return array;
    }

}

稀疏数组

  1. 定义：当一个数组中大部分元素都为0或同一数据时，可以使用稀疏数组来保存。

  2. 处理方式：

    • 记录数组一共有几行几列，有多少个不同值
    • 把具有不同值的元素的行和列以及值记录在一个小规模的数组中，从而缩小程序的规模
public class Demo36 {
    public static void main(String[] args) {
        //创建一个二维数组(原数组) 11*11 0:没有棋子 1：黑旗 2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;
        System.out.println("输出原始数组:");
        for(int[] ints : array1){
            for(int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //获取有效值
        int sum = 0;
        for(int[] ints : array1){
            for(int in : ints){
                if(in != 0){
                    sum ++ ;
                }
            }
        }
        System.out.println("有效数值个数："+sum);
        //创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //遍历数组，将非零值存放进稀疏数组
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[1].length; j++) {
                if(array1[i][j] != 0){
                    count ++;
                    array2[count][0]=i;   //二维数组的第count行的第0列存放数据的横坐标
                    array2[count][1]=j;   //二维数组的第count行的第1列存放数据的纵坐标
                    array2[count][2]=array1[i][j];   //二维数组的第count行的第3列存放数据的值
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                               +array2[i][1]+"\t"
                               +array2[i][2]+"\t");
        }
        
        //还原
        //创建数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //读取数据并存储
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];  
        }
        //输出还原得到的数组
        System.out.println("还原得到的数组：");
        for (int i = 0; i < array3.length; i++) {
            for (int j = 0; j < array3[i].length; j++) {
                System.out.print(array3[i][j]+"\t");
            }
            System.out.println();
        }
        
    }
}

热门相关：斗神战帝   惊世毒妃：轻狂大小姐   最强反套路系统   特工重生：快穿全能女神   法医王妃不好当！