public class LiteralDemo {
    public static void main(String[] args) {
        int dec = 100;            // 十进制
        int bin = 0b0110_0100;    // 二进制（JDK 7+），下划线分组，等价于 100
        int oct = 0144;           // 八进制，以 0 开头，等价于 100
        int hex = 0x64;           // 十六进制，以 0x 开头，等价于 100
        long big = 9_223_372_036_854_775_807L; // long 必须加 L（大写），否则按 int 解析直接编译失败
        float f = 3.14f;          // float 必须加 f，否则 3.14 是 double，赋值给 float 需要强转
        double d = 3.14;          // 后缀 d/D 可省略
        // long bad = 2147483648; // 编译错误：超出 int 范围，整数面量默认是 int 类型
        System.out.println(dec == bin && bin == oct && oct == hex); // true
        System.out.println(big);
    }
}

public class FloatPrecision {
    public static void main(String[] args) {
        System.out.println(0.1 + 0.2);                 // 0.30000000000000004
        System.out.println(0.1 + 0.2 == 0.3);          // false，永远不要用 == 比较浮点
        System.out.println(1.0 - 0.9);                 // 0.09999999999999998

        // 正确姿势一：允许误差的近似比较（epsilon 法）
        double a = 0.1 + 0.2, b = 0.3;
        final double EPS = 1e-9;
        System.out.println(Math.abs(a - b) < EPS);     // true

        // 正确姿势二：使用 BigDecimal，且必须用 String 构造！
        java.math.BigDecimal x = new java.math.BigDecimal("0.1");
        java.math.BigDecimal y = new java.math.BigDecimal("0.2");
        System.out.println(x.add(y));                  // 0.3

        // 错误示范：用 double 构造 BigDecimal，误差被"固化"进去
        java.math.BigDecimal wrong = new java.math.BigDecimal(0.1);
        System.out.println(wrong);                     // 0.1000000000000000055511151231257827021181583404541015625
    }
}

public class CharDemo {
    public static void main(String[] args) {
        char cn = '中';
        System.out.println((int) cn);                  // 20013，char 与 int 可自由互转（无符号16位）
        System.out.println('\u4e2d');                  // 中，Unicode 转义在编译期处理
        char nul = '\u0000';
        System.out.println((int) nul);                 // 0，默认值

        String emoji = "😀";                            // U+1F600，属于增补平面
        System.out.println(emoji.length());            // 2 —— 两个 UTF-16 码元
        System.out.println(emoji.codePointCount(0, emoji.length())); // 1 —— 一个码点
        System.out.println(Character.isSurrogate(emoji.charAt(0)));   // true

        // char 参与算术运算会被提升为 int
        char c1 = 'a';
        // char c2 = c1 + 1;   // 编译错误：结果是 int，需要强转
        char c2 = (char) (c1 + 1);
        System.out.println(c2);                        // b
    }
}

public class CastDemo {
    public static void main(String[] args) {
        byte b1 = 10, b2 = 20;
        // byte b3 = b1 + b2;   // 编译错误：byte + byte 的结果是 int
        byte b3 = (byte) (b1 + b2);   // 必须强转

        int i = 10;
        long l = i;                   // 自动拓宽（widening），安全
        // int j = l;                 // 编译错误：窄化（narrowing）必须显式强转
        int j = (int) l;

        long lv = 100L;
        float fv = lv;                // long → float 是合法拓宽，但可能丢精度！
        System.out.println(fv);       // 100.0

        System.out.println((int) 3.99);   // 3 —— 浮点转整型直接截断小数，不是四舍五入
        System.out.println(Math.round(3.5));  // 4 —— 四舍五入要用 Math.round

        System.out.println(1 / 2);        // 0 —— 整数除法！结果是 int 0，不是 0.5
        System.out.println(1.0 / 2);      // 0.5
        System.out.println(1 / 2.0);      // 0.5
    }
}

public class OverflowDemo {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);              // 2147483647
        System.out.println(Integer.MAX_VALUE + 1);          // -2147483648，静默溢出
        System.out.println(Integer.MIN_VALUE - 1);          // 2147483647
        System.out.println(Integer.MIN_VALUE * -1);         // -2147483648，取负也溢出！
        System.out.println(Math.abs(Integer.MIN_VALUE));    // -2147483648，Math.abs 也救不了
        System.out.println(Integer.MAX_VALUE + 1L);         // 2147483648，提升到 long 就正确

        // 安全的算术：JDK 8 提供的饱和/异常方法
        try {
            int r = Math.addExact(Integer.MAX_VALUE, 1);    // 溢出时抛 ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("捕获溢出：" + e.getMessage());
        }
        System.out.println(Math.multiplyHigh(2, 3));        // 取乘法的高 64 位，不易溢出
    }
}

public class InitOrder {
    private static int s = print("static 变量");
    private int i = print("实例变量");

    static { System.out.println("static 代码块"); }
    { System.out.println("实例代码块"); }

    public InitOrder() { System.out.println("构造器"); }

    private static int print(String msg) {
        System.out.println(msg);
        return 1;
    }

    public static void main(String[] args) {
        System.out.println("--- 第一次 new ---");
        new InitOrder();
        System.out.println("--- 第二次 new ---");
        new InitOrder();
    }
}
// 输出顺序：static 变量 → static 代码块 → --- 第一次 new --- → 实例变量 → 实例代码块 → 构造器
//          → --- 第二次 new --- → 实例变量 → 实例代码块 → 构造器
// 关键点：static 部分只在类加载时执行一次

public class FinalDemo {
    private static final int MAX = 100;          // 编译期常量（constant variable），会被内联进字节码
    private static final long NOW = System.currentTimeMillis();  // 运行期常量，不内联
    private final java.util.List<String> list = new java.util.ArrayList<>();

    void test() {
        list.add("hello");       // 合法：修改的是对象内容，不是引用
        // list = new ArrayList<>();  // 编译错误：final 引用不可重新赋值
        final int x;
        x = 10;                  // 空白 final（blank final）：声明时不赋值，使用前赋值即可
        System.out.println(MAX + " " + x);
    }
}

import java.util.*;

public class VarDemo {
    public static void main(String[] args) {
        var name = "sjava";                  // 推断为 String
        var list = new ArrayList<String>();  // 推断为 ArrayList<String>，右侧泛型信息保留
        var map = Map.of("k", 1);            // 推断为 Map<String, Integer>
        for (var e : list) {                 // 增强 for 中可用
            System.out.println(e.length());
        }
        // 以下全部为编译错误（限制）：
        // var x;                  // 必须初始化，否则无法推断
        // var n = null;           // 不能推断为任何类型
        // var a = 1, b = 2;       // 不支持复合声明
        // var arr = {1, 2, 3};    // 不支持数组初始化简写
        // var f = () -> {};       // 不能推断 Lambda 的类型（Lambda 需要目标类型）
        // var lambda = (var s) -> s.length(); // JDK 11+ 允许在 Lambda 形参上用 var（为了加注解）
    }
    // private var field = 1;      // 编译错误：var 不能用于成员变量
    // void m(var p) {}            // 编译错误：var 不能用于方法参数（构造器也不行）
    // var method() { return 1; }  // 编译错误：var 不能用于返回类型
}

public class ShortCircuit {
    static boolean sideEffect(String tag) {
        System.out.println("执行了：" + tag);
        return true;
    }
    public static void main(String[] args) {
        boolean r1 = false && sideEffect("A");   // A 不会被执行
        boolean r2 = true || sideEffect("B");    // B 不会被执行
        System.out.println(r1 + " " + r2);

        // 正确用法：利用短路做空指针防护（顺序至关重要）
        String s = null;
        if (s != null && s.length() > 0) {       // 安全
            System.out.println("非空");
        }
        // if (s.length() > 0 && s != null) { }  // NPE：顺序颠倒，短路保护失效

        // 陷阱：把带副作用的表达式放在右侧，会导致逻辑依赖执行顺序
        int i = 0;
        if (false && (++i > 0)) { }
        System.out.println("i = " + i);          // 0，++i 根本没执行
    }
}

public class BitMask {
    // 权限位设计：每个权限占一个二进制位，一个 int 可表示 32 种权限
    static final int READ    = 1 << 0;   // 0001 = 1
    static final int WRITE   = 1 << 1;   // 0010 = 2
    static final int DELETE  = 1 << 2;   // 0100 = 4
    static final int ADMIN   = 1 << 3;   // 1000 = 8

    public static void main(String[] args) {
        int perm = READ | WRITE;          // 授予：按位或，perm = 0011 = 3
        System.out.println(has(perm, READ));    // true
        System.out.println(has(perm, DELETE));  // false

        perm |= DELETE;                   // 追加权限：或运算
        perm &= ~WRITE;                   // 移除权限：与上一个取反的掩码
        perm ^= READ;                     // 切换权限：异或（有则去，无则加）
        System.out.println(Integer.toBinaryString(perm)); // 100 => 只剩 DELETE

        // 位图（bitmap）：用 long[] 标记 0~N 的存在性，JDK 的 BitSet 就是这个原理
        long[] bitmap = new long[2];      // 可表示 128 个位置
        int idx = 70;
        bitmap[idx >>> 6] |= 1L << (idx & 63);          // 置位（等价于 idx / 64 与 idx % 64）
        boolean exists = (bitmap[idx >>> 6] & (1L << (idx & 63))) != 0; // 查询
        System.out.println(exists);       // true

        // 其他常用技巧
        System.out.println((8 & -8));     // 8 —— x & -x 取最低位的 1
        System.out.println(5 << 1);       // 10 —— 左移一位 = 乘 2
        System.out.println(-8 >> 1);      // -4 —— 带符号右移，高位补符号位
        System.out.println(-8 >>> 1);     // 2147483644 —— 无符号右移，高位补 0（注意 int 是 32 位）
    }

    static boolean has(int perm, int bit) {
        return (perm & bit) == bit;       // 关键：等于 bit 而不是 != 0（多权限组合时更严谨）
    }
}

public class IncrementTrap {
    public static void main(String[] args) {
        int i = 1;
        int a = i++;      // a = 1, i = 2
        int b = ++i;      // b = 3, i = 3
        System.out.println("a=" + a + ", b=" + b + ", i=" + i);

        int j = 1;
        j = j++;          // 经典陷阱！结果 j 仍然是 1
        System.out.println("j = " + j);

        int k = 1;
        k = k++ + ++k;    // 1 + 3 = 4（第一个 k++ 返回 1，之后 k=2；++k 先增到 3 再返回 3）
        System.out.println("k = " + k);
    }
}

public class GuardClause {
    // 反例：箭头型代码，主逻辑被埋在三层嵌套里
    static String bad(User u) {
        if (u != null) {
            if (u.isVip()) {
                if (u.getBalance() > 100) {
                    return "允许下单";
                } else {
                    return "余额不足";
                }
            } else {
                return "非会员";
            }
        } else {
            return "用户不存在";
        }
    }

    // 正例：卫语句，逐层拦截
    static String good(User u) {
        if (u == null) return "用户不存在";
        if (!u.isVip()) return "非会员";
        if (u.getBalance() <= 100) return "余额不足";
        return "允许下单";
    }

    static class User {
        private boolean vip; private int balance;
        boolean isVip() { return vip; }
        int getBalance() { return balance; }
    }
}

public class SwitchEvolution {
    enum Status { NEW, PAID, CLOSED }

    // 传统写法：每个 case 都要 break，忘写就穿透（fall-through）
    static String classic(int day) {
        String name;
        switch (day) {
            case 1: case 7:        // 刻意的穿透合并
                name = "周末";
                break;
            case 6:
                name = "周六";
                break;
            default:               // default 不是语法强制，但规范强烈建议保留
                name = "工作日";
        }
        return name;
    }

    // String 匹配（JDK 7+）：本质是 hashCode + equals，case 值不能为 null，否则 NPE
    static int byString(String cmd) {
        switch (cmd) {
            case "start": return 1;
            case "stop":  return 2;
            default:      return -1;
        }
    }

    // JDK 14+ 箭头语法：无穿透，单表达式直接返回值
    static String arrow(Status s) {
        return switch (s) {
            case NEW    -> "待支付";
            case PAID   -> "已支付";
            case CLOSED -> "已关闭";
        };
    }

    // JDK 14+ 需要多语句时用 {} + yield 返回值
    static int score(Status s) {
        return switch (s) {
            case NEW -> 0;
            case PAID -> {
                int base = 100;
                System.out.println("计算积分");
                yield base * 2;       // yield 只能在 switch 表达式块中使用
            }
            case CLOSED -> 0;
        };
    }

    public static void main(String[] args) {
        System.out.println(classic(7) + " " + byString("stop"));
        System.out.println(arrow(Status.PAID) + " " + score(Status.PAID));
        // String s = null; byString(s);  // NullPointerException：switch 的表达式不能为 null
    }
}

public class LoopTrap {
    public static void main(String[] args) {
        // 坑1：浮点数做循环变量，误差累积导致循环次数不确定
        // for (double d = 0; d != 1.0; d += 0.1) {}  // 可能死循环，永远达不到精确的 1.0
        for (double d = 0; d < 1.0; d += 0.1) {       // 用 < 而不是 !=
            // ...
        }

        // 坑2：循环中修改集合结构
        var list = new java.util.ArrayList<>(java.util.List.of("a", "b", "c"));
        // for (String s : list) { if (s.equals("b")) list.remove(s); }  // ConcurrentModificationException
        var it = list.iterator();                      // 正确：用迭代器的 remove
        while (it.hasNext()) {
            if (it.next().equals("b")) it.remove();
        }

        // 坑3：循环内创建对象/重复计算 length
        int[] arr = new int[10];
        for (int m = 0, len = arr.length; m < len; m++) {   // 缓存 length，微优化
            arr[m] = m;
        }

        // 坑4：分号陷阱 —— for 后面多写分号，循环体变成空语句
        int sum = 0;
        for (int n = 0; n < 10; n++);   // 空循环体！下面这行只执行一次
        {
            sum++;
        }
        System.out.println("sum = " + sum);   // 1，而不是 10
    }
}

public class LabelDemo {
    public static void main(String[] args) {
        int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

        // 推荐：抽成方法用 return，语义清晰
        System.out.println(find(matrix, 5));

        // 标签写法：outer 标记外层循环，break outer 直接跳出两层
        outer:
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                if (matrix[i][j] == 5) {
                    System.out.println("找到于 [" + i + "][" + j + "]");
                    break outer;
                }
            }
        }

        // 无限循环的三种常见写法
        // while (true) { ... }         // 最常用
        // for (;;) { ... }             // 编译后指令更少，源码里两种等价
        // do { ... } while (true);
    }

    // 推荐写法
    static String find(int[][] m, int target) {
        for (int i = 0; i < m.length; i++) {
            for (int j = 0; j < m[i].length; j++) {
                if (m[i][j] == target) return "[" + i + "][" + j + "]";
            }
        }
        return "未找到";
    }
}

栈帧局部变量表                     堆
+---------+                    +-----------------------------+
|  a  ----|------------------> | 对象头 (MarkWord + KlassPtr) |
+---------+                    | length = 3                  |
                               | [0] = 0                     |
                               | [1] = 0                     |
                               | [2] = 0                     |
                               +-----------------------------+

int[][] m = new int[2][];  // 只分配了外层数组，m[0]、m[1] 都是 null
m[0] = new int[3];
m[1] = new int[5];

外层数组（堆）                 内层数组（堆，各自独立、长度可不同）
+----------+                +---+---+---+
| m[0] ----|--------------->| 0 | 0 | 0 |
+----------+                +---+---+---+
| m[1] ----|--------------->| 0 | 0 | 0 | 0 | 0 |
+----------+                +---+---+---+---+---+

import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        // 方式一：动态初始化（指定长度，元素取默认值）
        int[] a = new int[5];

        // 方式二：静态初始化（指定内容，长度由编译器推断）
        int[] b = new int[]{1, 3, 5, 7, 9};
        int[] c = {1, 3, 5, 7, 9};          // 简写，仅限声明时连用

        // 方式三：匿名数组，用于方法传参
        print(new int[]{2, 4, 6});

        // 不规则数组
        int[][] tri = new int[3][];
        for (int i = 0; i < tri.length; i++) {
            tri[i] = new int[i + 1];        // 第 i 行有 i+1 个元素
        }
        System.out.println(Arrays.deepToString(tri));   // [[0], [0, 0], [0, 0, 0]]
        System.out.println(Arrays.toString(c));         // [1, 3, 5, 7, 9]

        // Arrays 工具高频方法
        int[] src = {5, 3, 1, 4, 2};
        Arrays.sort(src);                               // 原地排序（基本类型用双轴快排）
        System.out.println(Arrays.toString(src));       // [1, 2, 3, 4, 5]
        System.out.println(Arrays.binarySearch(src, 4));// 3，二分查找前必须已排序
        Arrays.fill(src, 0);                            // 全部填 0
        int[] copy = Arrays.copyOf(src, 10);            // 扩容拷贝，多余位补默认值
        System.out.println(copy.length);                // 10
    }

    static void print(int[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

import java.util.Arrays;

public class CopyTrap {
    static class Node { int v; Node(int v) { this.v = v; } }

    public static void main(String[] args) {
        Node[] src = { new Node(1), new Node(2) };
        Node[] dst = Arrays.copyOf(src, src.length);

        System.out.println(src == dst);          // false，数组对象本身是新的
        System.out.println(src[0] == dst[0]);    // true，元素指向同一个 Node（浅拷贝！）

        dst[0].v = 99;
        System.out.println(src[0].v);            // 99 —— 修改副本影响了原数组，这正是浅拷贝的副作用

        // 基本类型数组没有这个问题，因为元素值就是数据本身
        int[] p = {1, 2, 3};
        int[] q = p.clone();
        q[0] = 100;
        System.out.println(p[0]);                // 1，不受影响

        // 深拷贝需要自己遍历并 new 出新对象
        Node[] deep = new Node[src.length];
        for (int i = 0; i < src.length; i++) {
            deep[i] = new Node(src[i].v);
        }
        System.out.println(deep[0] == src[0]);   // false
    }
}

import java.util.Arrays;

public class VarargsDemo {
    static int sum(int... nums) {
        int s = 0;
        for (int n : nums) s += n;      // nums 就是 int[]
        return s;
    }
    // static void sum(int[] nums) { }  // 编译错误：与 int... 冲突（同一签名）

    static void log(String prefix, Object... args) {   // 可变参数必须是最后一个形参
        System.out.println(prefix + Arrays.toString(args));
    }

    public static void main(String[] args) {
        System.out.println(sum());           // 0，可变参数可以传 0 个
        System.out.println(sum(1, 2, 3));    // 6
        System.out.println(sum(new int[]{4, 5})); // 9，也可直接传数组
        log("INFO", "a", 1);
        // log("INFO", null);                // 有歧义：null 既可是 (String, Object[])，也可是...
        log("INFO", (Object[]) null);        // 明确指定可消除歧义
    }
}

public class OverloadRule {
    static void f(int a)            { System.out.println("int"); }
    static void f(Integer a)        { System.out.println("Integer"); }
    static void f(long a)           { System.out.println("long"); }
    static void f(Object a)         { System.out.println("Object"); }
    static void f(int... a)         { System.out.println("int..."); }

    public static void main(String[] args) {
        f(1);           // int      —— 阶段1 精确匹配 int
        f(1L);          // long     —— 精确匹配 long
        f(Integer.valueOf(1)); // Integer —— 精确匹配
        short s = 1;
        f(s);           // int      —— 没有 short 重载，拓宽为 int（阶段1 允许拓宽）
        f('a');         // int      —— char 拓宽为 int
        f(1, 2);        // int...   —— 只有可变参数版本能匹配（阶段3）

        Object obj = new Integer(1);
        f(obj);         // Object   —— 依据变量的静态类型 Object，不是运行时的 Integer！
    }
}

public class PassByValue {
    static void change(int x)        { x = 100; }
    static void change(int[] arr)    { arr[0] = 100; }
    static void reassign(int[] arr)  { arr = new int[]{9, 9, 9}; }

    public static void main(String[] args) {
        int n = 1;
        change(n);
        System.out.println(n);            // 1 —— 基本类型：形参是独立副本，改不动

        int[] a = {1, 2, 3};
        change(a);
        System.out.println(a[0]);         // 100 —— 引用副本指向同一对象，能改对象内容

        reassign(a);
        System.out.println(a[0]);         // 100 —— 形参重新指向了新数组，主方法的 a 不受影响
    }
}

调用前（main 栈帧）                      调用中（main + change 两个栈帧）
main: a -> ref(0x100) ----+          main: a  -> ref(0x100) ----+
                          |          change: arr -> ref(0x100) -+--> 堆中数组 [1,2,3]
                          +--------> 堆中数组 [1,2,3]
                                     （两个引用副本指向同一个对象，所以 arr[0]=100 对 main 可见）

reassign 执行 arr = new int[]{9,9,9} 后：
main: a  -> ref(0x100) ----> 堆中数组 [100,2,3]   （main 看到的仍是原数组）
change: arr -> ref(0x200) -> 堆中新数组 [9,9,9]   （只有形参的副本改了指向）

public class Recursion {
    // 经典：斐波那契，递归写法时间复杂度 O(2^n)，改成循环后 O(n)
    static long fib(int n) {
        if (n <= 1) return n;
        return fib(n - 1) + fib(n - 2);
    }
    static long fibFast(int n) {
        if (n <= 1) return n;
        long a = 0, b = 1;
        for (int i = 2; i <= n; i++) {
            long t = a + b; a = b; b = t;
        }
        return b;
    }
    public static void main(String[] args) {
        System.out.println(fibFast(50));       // 12586269025
        // try { deep(0); } catch (StackOverflowError e) { System.out.println("栈溢出"); }
    }
    static void deep(int i) { deep(i + 1); }   // 无限递归 → StackOverflowError
}

import java.util.Scanner;

public class ScannerTrap {
    public static void main(String[] args) {
        Scanner sc = new Scanner("18\nsjava\n");

        // 错误示范
        int age = sc.nextInt();
        String name = sc.nextLine();        // 读到的是残留的换行符
        System.out.println("age=" + age + ", name=[" + name + "]");  // name=[]

        // 修复一：多调用一次 nextLine() 把换行符吃掉
        Scanner sc2 = new Scanner("18\nsjava\n");
        int age2 = sc2.nextInt();
        sc2.nextLine();                     // 吞掉残留换行
        String name2 = sc2.nextLine();
        System.out.println("age=" + age2 + ", name=[" + name2 + "]");  // name=[sjava]

        // 修复二（推荐）：全部用 nextLine() 读入，再自行解析
        Scanner sc3 = new Scanner("18\nsjava\n");
        int age3 = Integer.parseInt(sc3.nextLine().trim());
        String name3 = sc3.nextLine().trim();
        System.out.println("age=" + age3 + ", name=[" + name3 + "]");

        // hasNext 的正确用法
        Scanner sc4 = new Scanner("1 2 3");
        while (sc4.hasNextInt()) {
            System.out.print(sc4.nextInt() + " ");
        }
        sc.close();
    }
}

import java.io.*;
import java.util.*;

public class FastInput {
    // 模板一：BufferedReader + StringTokenizer，适合按空格分词的数据
    static class FastScanner {
        private final BufferedReader br;
        private StringTokenizer st;
        FastScanner(InputStream in) { br = new BufferedReader(new InputStreamReader(in)); }
        String next() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                String line = br.readLine();
                if (line == null) return null;
                st = new StringTokenizer(line);
            }
            return st.nextToken();
        }
        int nextInt() throws IOException { return Integer.parseInt(next()); }
        long nextLong() throws IOException { return Long.parseLong(next()); }
    }

    // 模板二：StreamTokenizer，纯数值读入最快的标准库方案
    static class TokenScanner {
        private final StreamTokenizer st;
        TokenScanner(InputStream in) {
            st = new StreamTokenizer(new BufferedReader(new InputStreamReader(in)));
            st.ordinaryChar('\'');     // 视需要调整分词字符
        }
        int nextInt() throws IOException { st.nextToken(); return (int) st.nval; }
        double nextDouble() throws IOException { st.nextToken(); return st.nval; }
    }

    public static void main(String[] args) throws IOException {
        // 示例：读 n 个整数求和
        String data = "5\n1 2 3 4 5\n";
        FastScanner fs = new FastScanner(new ByteArrayInputStream(data.getBytes()));
        int n = fs.nextInt();
        long sum = 0;
        for (int i = 0; i < n; i++) sum += fs.nextInt();
        System.out.println(sum);   // 15
    }
}

public class FormatDemo {
    public static void main(String[] args) {
        String name = "sjava";
        double price = 19.9876;
        int qty = 3;
        System.out.printf("商品：%s，单价：%.2f，数量：%d，合计：%.2f%n", name, price, qty, price * qty);
        // 商品：sjava，单价：19.99，数量：3，合计：59.96
        System.out.printf("|%8s|%-8s|%n", "右", "左");       // 对齐与宽度
        System.out.printf("折扣 %d%%%n", 20);                 // 输出百分号
        System.out.printf("255 = 0x%x = 0%o%n", 255, 255);    // 进制转换
        // 生成字符串而不打印（用于日志拼接、文件名）
        String s = String.format("%s-%03d", "order", 7);      // order-007，%03d 表示补零到 3 位
        System.out.println(s);
    }
}