JavaDoc、Scanner交互、增强for循环、方法重载、命令行传参、JavaDoc、Scanner交互、增强for循环、方法重载、命令行传参

Xxxxx
113 阅读4分钟

开启掘金成长之旅！这是我参与「掘金日新计划 · 2 月更文挑战」的第 2 天，点击查看活动详情

Java基础巩固，根据目录食用即可

JavaDoc

HelloWorld.java中写文档注释（类注释、方法注释），参数信息

  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况

法一：在终端输入命令：javadoc -encoding UTF-8 -charset UTF-8 HelloWorld.java 可以生成自己的API文档

法二：IDEA生成：

image.png

image.png

Locale 选择地区，也是文档的语言

Other command line arguments : -encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” -link http://docs.Oracle.com/javase/8/docs/api


Scanner交互

Scanner scanner = new Scanner(System.in);

  • next() String str = scanner.next();
  • nextLine() String str = scanner.nextLine();
Scanner scanner = new Scanner(System.in);

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

if (scanner.hasNextLine()){
    String str = scanner.nextLine();
    System.out.println("输出的内容为：" + str);
}
scanner.close();

next()

  • 读取到有效字符后才可以结束
  • 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
  • 只有输入有效字符后才将其后面输入的空白作为分隔符或结束符
  • 不能得到带空格的字符串

nextLine()

  • 以Enter为结束符
  • 可以获得空白

增强for循环

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

方法重载

重载就是在一个类中，函数名相同，形参不同的函数

重载规则

  • 方法名相同
  • 参数列表不同（个数、类型、排列顺序等）
  • 方法的返回类型可以相同可以不相同
  • 仅仅返回类型不同不足以成为方法的重载

例子:

public class Demo1 {
    public static void main(String[] args) {
        int add1 = add(1, 2);
        System.out.println(add1);  // 3
        double add2 = add(1, 2);
        System.out.println(add2);  // 3.0
        int add3 = add(1, 2, 3);
        System.out.println(add3);  // 6
    }

    public static int add(int a, int b){
        return a+b;
    }
    public static double add(double a, double b){
        return a+b;
    }
    public static int add(int a, int b, int c){
        return a+b+c;
    }
}

命令行传参

cmd终端输入命令，先编译： javac Demo2.java 需退回src包下输入完整的文件路径才可以运行，如: java com.liang.method.Demo2 hello 1 2 3

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

image.png

数组

声明数组：int[] array = null; 创建数组：array = new int[10]; 赋值：array[0] = 1;

二维数组：int[][] array = new int[10][10];

  • 数组是相同数据类型（数据类型可以为任意类型）的有序集合
  • 数组也是对象，数组元素相当于对象的成员变量
  • 数组长度是确定的、不可变的。

数组初始化

1、静态初始化：创建 + 赋值

int[] a = {1,2,3,4,5};

2、动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

3、默认初始化 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组使用

public class ArrayDemo {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        // for-each方法
        for (int i : array) {
            System.out.println(i);
        }
        printArray(reverseArray(array));
    }

    // 反转数组（数组作返回值）
    public static int[] reverseArray(int[] array) {
        int[] result = new int[array.length];

        for (int i = 0, j = result.length - 1; i < array.length; i++, j--) {
            result[j] = array[i];
        }
        return result;
    }

    // 打印数组元素
    public static void printArray(int[] array){
    	// for循环输出
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }
}

二维数组输出（两种方法）

法一：

 for (int[] i:array) {
        System.out.println(Arrays.toString(i));
 }

法二：增强型for循环

for (int[] i:array) {
    for(int j:i){
        System.out.print(j+"\t");
    }
    System.out.println();
}

稀疏数组

当一个数组中大部分元素为0或同一值的数组时，可以使用稀疏数组来保存该数组。

如下图：原始数组 ----- 稀疏数组

image.png

import java.util.Arrays;

public class ArrayDemo3 {
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;

        System.out.println("输出原始的数组：");
        for (int[] i : array1) {
            System.out.println(Arrays.toString(i));
//            for (int j : i) {
//                System.out.print(j + "\t");
//            }
//            System.out.println();
        }

        System.out.println("========================");
        System.out.println("转为稀疏数组保存：");
        int sum = 0;  // 获取有效值个数
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 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[i].length; j++) {
                if (array1[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

        // 输出稀疏数组
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t");
        }

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

        System.out.println("还原数组：");
        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];
        }

        for (int[] i : array3) {
            System.out.println(Arrays.toString(i));
        }
    }
avatar
文章
阅读
粉丝