howard2005

Java讲课笔记06：选择结构与条件循环

文章目录

零、本讲学习目标

1、掌握if和switch条件语句的使用
2、掌握while和do...while循环结构语句的使用

一、结构化程序设计

1、结构化基本原则

（1）自顶向下
（2）逐步求精
（3）模块化
（4）限制使用goto语句

2、三种流程控制结构

（1）顺序结构（Sequence Structure）
（2）选择结构（Selection Structure）
（3）循环结构（Loop Structure）

二、顺序结构

（一）顺序结构示意图
（二）顺序结构案例演示

案例1、计算三角形面积
案例2、求解一元二次方程

（三）顺序结构小结

三、选择结构

（一）选择结构概述
（二）单分支结构

1、语法格式
2、执行情况
3、案例演示：判断一个数是否是偶数。

（三）双分支结构

1、语法格式
2、执行情况
3、案例演示：计算三角形面积
4、课堂练习：判断一个年份是闰年还是平年。

（四）多分支结构

1、四种处理方式

（1）并列式多分支结构
（2）嵌套式多分支结构
（3）延拓式多分支结构
（4）开关式多分支结构

2、案例演示：评定成绩等级。

方法一、采用并列式多分支结构
方法二、采用嵌套式多分支结构
方法三、采用延拓式多分支结构
方法四、采用开关式多分支结构

3、课堂练习：计算分段函数值

三、为什么要用循环

1、老老实实的笨方法
2、采用循环结构的巧方法

（1）采用计数循环（for循环）
（2）采用条件循环（while循环）

四、条件循环

（一）while循环

1、语法格式
2、执行情况
3、案例演示

任务1、演示死循环（永真循环）
任务2、计算1 + 2 + 3 + …… + 100的值
课堂练习：编程计算1 + 3 + 5 + …… + 99的值
任务3、打印全部水仙花数

（二）do...while循环

1、语法格式
2、执行情况
3、案例演示：计算1 + 2 + 3 + …… + 100的值

五、课后作业

1、输出所有的玫瑰花数
2、完成猜数游戏，处理只玩一次就结束的情况
3、判断一个整数是否是素数
4、打印输出100以内的全部素数，每行打印5个素数
5、解决征婚测试问题

六、补充案例

1、幸运抽奖
2、给出年月日，确定它是该年的第几天
3、根据获奖名次给予奖励
4、购物打折
5、多级购物菜单系统
6、可进可退的多级购物菜单系统
7、四个整数排序
8、购物结算，打印购物小票

零、本讲学习目标

1、掌握if和switch条件语句的使用

2、掌握while和do…while循环结构语句的使用

一、结构化程序设计

1、结构化基本原则

（1）自顶向下

程序设计时，应先考虑总体，后考虑细节；先考虑全局目标，后考虑局部目标。不要一开始就过多追求众多的细节，先从最上层总目标开始设计，逐步使问题具体化。

（2）逐步求精

对复杂问题，应设计一些子目标作为过渡，逐步细化。

（3）模块化

一个复杂问题，肯定是由若干稍简单的问题构成。模块化是把程序要解决的总目标分解为子目标，再进一步分解为具体的小目标，把每一个小目标称为一个模块。

（4）限制使用goto语句

在程序比较简单是用goto语句是比较灵活，但是当程序比较复杂时很容易造成程序流程的混乱。利用goto语句对以后的后别人看程序是很难理解。调试程序的过程也会变得很困难。

2、三种流程控制结构

（1）顺序结构（Sequence Structure）

（2）选择结构（Selection Structure）

（3）循环结构（Loop Structure）

循环结构有两种情况：
（1）前测试条件循环：先检票后上车（有可能一次循环操作也不执行）
（2）后测试条件循环：先上车后检票（无论如何至少要执行一次循环操作）

二、顺序结构

有一个入口和一个出口，按从上向下依的顺序执行各语句。

（一）顺序结构示意图

（二）顺序结构案例演示

案例1、计算三角形面积

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：计算三角形面积
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example601 {
    public static void main(String[] args) {
        // 声明部分
        double a, b, c, p, s;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("a = ");
        a = sc.nextDouble();
        System.out.print("b = ");
        b = sc.nextDouble();
        System.out.print("c = ");
        c = sc.nextDouble();

        // 处理部分
        p = (a + b + c) / 2;
        s = Math.sqrt(p * (p - a) * (p - b) * (p - c));

        // 输出部分
        System.out.println("s = " + s);
    }
}

运行程序，查看结果：

但是，如果输入的a，b，c构不成三角形，结果如下：

案例2、求解一元二次方程

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：求解一元二次方程
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example602 {
    public static void main(String[] args) {
        // 声明部分
        double a, b, c, delta, x1, x2;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("a = ");
        a = sc.nextDouble();
        System.out.print("b = ");
        b = sc.nextDouble();
        System.out.print("c = ");
        c = sc.nextDouble();

        // 处理部分
        delta = b * b - 4 * a * c;
        x1 = (-b + Math.sqrt(delta)) / (2 * a);
        x2 = (-b - Math.sqrt(delta)) / (2 * a);

        // 输出部分
        System.out.println("x1 = " + x1);
        System.out.println("x2 = " + x2);
    }
}

运行程序，查看结果：

但是，输入的a，b，c导致了判别式小于零，得不到计算结果。

虽然程序运行没有抛出异常，但是NaN也不是我们想要看到的。

（三）顺序结构小结

顺序结构很简单，按照语句书写次序，依次从上往下执行。上述两个案例，大家可以看到，遇到不能求解的情形，就是给出一个NaN的结果，那并不是我们想要的结果。我们需要事先对能否求解进行判断，如果能求解，那么我们就计算给出结果；如果不能求解，我们就给出相应提示，告诉用户不能求解，这样处理，对用户比较友好。怎么根据情况不同来执行不同的操作呢？这就是我们下面要讲的选择结构。

三、选择结构

在实际生活中经常需要作出一些判断，比如开车来到一个十字路口，这时需要对红绿灯进行判断，如果前面是红灯，就停车等候，如果是绿灯，就通行。Java中有一种特殊的语句叫做选择结构语句，它也需要对一些条件作出判断，从而决定执行哪一段代码。

（一）选择结构概述

程序发生分支，根据判断框内的条件是否被满足来选择执行一块还是执行 B 块。无论条件是否被满足，只能选择执行一或 B 中之一，不能执行完一块后又执行 B 块无论走哪条路径，都要经过 C 点，然后脱离本选择结构框。

根据处理不同情况的个数，我们下面分成单分支结构、双分支结构与多分支结构来进行讲解。

（二）单分支结构

1、语法格式

if (条件) {
   语句组 
}

说明：如果语句组只是一条语句，那么花括号是可以省略的。

2、执行情况

如果条件成立，就执行语句组，否则啥也不做。

3、案例演示：判断一个数是否是偶数。

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：判断奇偶数
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example603 {
    public static void main(String[] args) {
        // 声明部分
        int n;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("n = ");
        n = sc.nextInt();

        // 处理部分 + 输出部分
        if (n % 2 == 0) {
            System.out.println(n + "是一个偶数。");
        }
    }
}

运行程序，查看结果：

单分支结构经常会嵌套在循环结构里，起一个过滤的作用，比如要对某个范围里满足什么条件的数进行处理。

补充案例：输出1~100之间能被3或5整除的数，要求每行输出5个数。

（三）双分支结构

1、语法格式

if (条件) {
   语句组1
} else {
   语句组2
}

2、执行情况

双分支结构就是我们通常讲的“花开两朵，各表一枝”或者“鱼和熊掌不可兼得”。语句组1与语句组2，根据条件成立与否，只有其中一个会被执行。

3、案例演示：计算三角形面积

提示：两步（判断 + 计算）
（1）利用三边关系定理判断能否构成三角形；
三边关系定理：任意两边之和大于第三边。
（2）如果能构成三角形，利用海伦公式来计算。
三边为 $a, b, c$ ，半周长 $p=\displaystyle \frac{a+b+c}{2}$
面积 $area=\displaystyle \sqrt{p(p-a)(p-b)(p-c)}$

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：计算三角形面积
 *       要判断能否构成三角形
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example604 {
    public static void main(String[] args) {
        // 声明部分
        double a, b, c, p, s;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("a = ");
        a = sc.nextDouble();
        System.out.print("b = ");
        b = sc.nextDouble();
        System.out.print("c = ");
        c = sc.nextDouble();

        // 处理部分 + 输出部分
        if (a + b > c && b + c > a && c + a > b) {
            p = (a + b + c) / 2;
            s = Math.sqrt(p * (p - a) * (p - b) * (p - c));
            System.out.println("s = " + s);
        } else {
            System.out.println(a + "、" + b + "、" + c + "无法构成三角形！");
        }
    }
}

运行程序，查看结果：

问题：判断条件能否换种花样呢？

说明：选择结构的条件是根据海伦公式（被开方数要非负）来确定的。
$\Leftrightarrow \displaystyle \frac{a+b+c}{2}>a \Leftrightarrow a+b+c>2a \Leftrightarrow b+c>a$
$\Leftrightarrow \displaystyle \frac{a+b+c}{2}>b \Leftrightarrow a+b+c>2b \Leftrightarrow c+a>b$
$\Leftrightarrow \displaystyle \frac{a+b+c}{2}>c \Leftrightarrow a+b+c>2c \Leftrightarrow a+b>c$
由此可见，两种判断条件其实是等价的，只是表现形式不同而已。

同学们，将代码修改之后运行，看一看是否能得到相同的运行结果。

大家可以看一下完成同样任务的Python代码：

4、课堂练习：判断一个年份是闰年还是平年。

其实，在上一讲的逻辑运算部分，大家已经完成了这个课堂练习。

（四）多分支结构

1、四种处理方式

多分支结构可有四种处理方式：并列式、嵌套式、延拓式、开关式

（1）并列式多分支结构

if (条件1) {
    语句组1
}
if (条件2) {
    语句组2
}
……
if (条件n) {
    语句组n
}

（2）嵌套式多分支结构

if (条件) {
    if (条件1) {
       语句组1
    } else {
       ……
    }
} else {
    if (条件2) {
       语句组2
    } else {
       ……
    }
}

（3）延拓式多分支结构

if (条件1) {
    语句组1
} else if (条件2) {
    语句组2
} 
……
} else if (条件n) {
    语句组n
} else {
    语句组n+1
}

（4）开关式多分支结构

switch (测试表达式) {
    case 值1:
        语句组1
        break;
    case 值2:
        语句组2
        break;
     ……
    case 值n:
        语句组n
        break;
    default:
        语句组n+1
}

2、案例演示：评定成绩等级。

(100, +∞)：超出范围
[90, 100]：优秀
[80, 90)：良好
[70, 80)：中等
[60, 70)：及格
[0, 60)：不及格
(-∞, 0)：超出范围

方法一、采用并列式多分支结构

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：并列式评定成绩等级
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example605 {
    public static void main(String[] args) {
        // 声明部分
        double score;
        String level;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("score = ");
        score = sc.nextDouble();

        // 处理部分
        level = "";
        if (score > 100) {
            level = "超出范围";
        }
        if (score >= 90 && score <= 100) {
            level = "优秀";
        }
        if (score >= 80 && score < 90) {
            level = "良好";
        }
        if (score >= 70 && score < 80) {
            level = "中等";
        }
        if (score >= 60 && score < 70) {
            level = "及格";
        }
        if (score >= 0 && score < 60) {
            level = "不及格";
        }
        if (score < 0) {
            level = "超出范围";
        }

        // 输出部分
        System.out.println("level = " + level);
    }
}

运行程序，查看结果：

总结：并列式多分支结构，优点是易于理解，但缺点是效率低（思考一下，为什么效率低）。

其实，这个程序可以作点优化，因为成绩大于100分或小于0分都是超出范围，所以可以将这两个并列的分之合而为一，如下图所示：

方法二、采用嵌套式多分支结构

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：嵌套式评定成绩等级
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example606 {
    public static void main(String[] args) {
        // 声明部分
        double score;
        String level;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("score = ");
        score = sc.nextDouble();

        // 处理部分
        level = "";
        if (score > 100) {
            level = "超出范围";
        } else {
            if (score >= 90) {
                level = "优秀";
            } else {
                if (score >= 80) {
                    level = "良好";
                } else {
                    if (score >= 70) {
                        level = "中等";
                    } else {
                        if (score >= 60) {
                            level = "及格";
                        } else {
                            if (score >= 0) {
                                level = "不及格";
                            } else {
                                level = "超出范围";
                            }
                        }
                    }
                }
            }
        }

        // 输出部分
        System.out.println("level = " + level);
    }
}

运行程序，查看结果：

刚才是从大到小依次判断分数段，其实也可以反过来，从小到大依次判断分数段，如下图所示：

总结：嵌套式多分支结构，优点是层次分明、效率高，但缺点是嵌套层次太多时显得很繁。

大家可以对照一下Python代码：

课堂作业： 网上搜一搜，了解Java语言最多允许嵌套多少层，顺带也查一查Python语言如何。

方法三、采用延拓式多分支结构

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：延拓式评定成绩等级
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example607 {
    public static void main(String[] args) {
        // 声明部分
        double score;
        String level;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("score = ");
        score = sc.nextDouble();

        // 处理部分
        level = "";
        if (score > 100) {
            level = "超出范围";
        } else if (score >= 90) {
            level = "优秀";
        } else if (score >= 80) {
            level = "良好";
        } else if (score >= 70) {
            level = "中等";
        } else if (score >= 60) {
            level = "及格";
        } else if (score >= 0) {
            level = "不及格";
        } else {
            level = "超出范围";
        }

        // 输出部分
        System.out.println("level = " + level);
    }
}

运行程序，查看结果：

刚才是从大到小依次判断分数段，其实也可以反过来，从小到大依次判断分数段，如下图所示：

总结：延拓式多分支结构，优点是只有一层，并且效率高。希望同学们务必掌握这一种多分支处理方式。

大家可以对照一下Python代码：

方法四、采用开关式多分支结构

关键点在于将成绩变量取整之后再整除10，以便将各个分数段转换成离散的整数值，这样才能用开关式多分支结构来进行处理。

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：开关式评定成绩等级
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example608 {
    public static void main(String[] args) {
        // 声明部分
        double score;
        String level;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("score = ");
        score = sc.nextDouble();

        // 处理部分
        level = "";
        if (score > 100 || score < 0) {
            level = "超出范围";
        } else {
            switch ((int) score / 10) {
                case 10:
                case 9:
                    level = "优秀";
                    break;
                case 8:
                    level = "良好";
                    break;
                case 7:
                    level = "中等";
                    break;
                case 6:
                    level = "及格";
                    break;
                default:
                    level = "不及格";
            }
        }

        // 输出部分
        System.out.println("level = " + level);
    }
}

运行程序，查看结果：

总结：开关式多分支结构，优点是书写简洁，并且效率高，但缺点是只能针对离散型的情况进行处理。

开关式多分支结构里的测试表达式，类型可以是整数、字符、甚至可以是字符串。

运行程序，查看结果：

3、课堂练习：计算分段函数值

$y=\begin{cases} 3x^2-1 &x\geq1 &(1)\\ -2x + 5 &-1\le x\lt 1 &(2)\\ 4x^2+3 &x\lt -1 &(3) \end{cases}$

我们在编写程序解决问题时，尽量开拓我们的思维，做到一题多解，正所谓条条道路通罗马。既然是一题多解，那就存在一个评判不同解法的问题，要学会了解不同解法的优劣。其实，做任何选择，都存在一个策略性的考虑。

All roads lead to Rome. 条条道路通罗马。

算法是程序的灵魂！！！

通过Python版猜数游戏引入循环结构！！！

三、为什么要用循环

如果要求输出一百遍“好好学习，天天向上！”，那你会怎么做？

1、老老实实的笨方法

System.out.println("第1遍写：好好学习，天天向上！"); 
System.out.println("第2遍写：好好学习，天天向上！"); 
System.out.println("第3遍写：好好学习，天天向上！"); 
System.out.println("第4遍写：好好学习，天天向上！"); 
……
System.out.println("第100遍写：好好学习，天天向上！");

此方法显然很糟糕，如果要你输出一万遍，那岂不令人崩溃？

2、采用循环结构的巧方法

（1）采用计数循环（for循环）

package net.hw.lesson06;

/**
 * 功能：重复口号一百遍
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example609 {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {// 循环头：初始条件、循环条件、更新条件
            System.out.println("第" + i + "遍写：好好学习，天天向上！");
        }
    }
}

运行程序，查看结果：

大家可以参看一下Python代码完成同样的任务：

（2）采用条件循环（while循环）

package net.hw.lesson06;

/**
 * 功能：重复口号一百遍
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example610 {
    public static void main(String[] args) {
        int i = 1; // 初始条件
        while (i <= 100) { // 循环条件
            System.out.println("第" + i + "遍写：好好学习，天天向上！");
            i++; // 更新条件
        }
    }
}

运行程序，查看结果：

大家可以参看用Python代码完成同样的任务：

四、条件循环

条件循环是根据条件来决定是否要执行循环或终止循环。
条件循环有两种，前测试条件循环while循环，后测试条件循环do…while循环。

（一）while循环

1、语法格式

初始条件
while (循环条件) {
     语句块
     break|continue;
     更新条件
}

2、执行情况

首先判断循环条件是真还是假，如果是真的，执行循环体，然后再次判断循环条件。如果是真的，继续循环，直到循环条件变成假的。有一种特殊情况：如果第一次判断循环条件就不成立，那么一次循环也不执行。

3、案例演示

任务1、演示死循环（永真循环）

package net.hw.lesson06;

/**
 * 功能：演示死循环（永真循环）
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example611 {
    public static void main(String[] args) {
        // 理论上是死循环，但实际上会结束
        int i = 1; // 初始条件
        while (i >= 1) { // 循环条件
            System.out.println("i = " + i);
            i = i + 10000; // 更新条件
        }
        System.err.println("i = " + i);

        // 最直接了当的死循环
        while (true) {
            System.out.println("我要出去玩！");
        }
    }
}

运行程序，查看结果：

会一直输出“我要出去玩！”，永远都不会结束，除非我们强制终止应用程序。

任务2、计算1 + 2 + 3 + …… + 100的值

这是一个非常经典的数学计算问题：公差为1的等差数列求和。

package net.hw.lesson06;

/**
 * 功能：计算1 + 2 + 3 + …… + 100的值
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example612 {
    public static void main(String[] args) {
        int i, sum = 0;

        i = 1; // 初始条件
        while (i <= 100) { // 循环条件
            sum += i; 
            i++; // 更新条件
        }

        System.out.println("1 + 2 + 3 + …… + 100 = " + sum);
    }
}

只要i <= 100成立，循环都会继续，直到i = 101，不满足条件了，循环才终止。

运行程序，查看结果：

修改一下代码，输出循环结束后循环变量i的值：

大家可以参看一下完成同样任务的Python代码：

课堂练习：编程计算1 + 3 + 5 + …… + 99的值

提示：有三种方法可以解决此问题。
（1）修改循环的更新条件：i = i + 2;
（2）在循环结构里嵌套一个过滤器：if (i % 2 == 1) sum += i;
（3）修改循环条件：i <= 50，修改累加语句 sum += 2 * i - 1;

任务3、打印全部水仙花数

所谓水仙花数，是指等于其各位数字立方和的三位数。

$153=1^3+5^3+3^3$
$370=3^3+7^3+0^3$
$371=3^3+7^3+1^3$
$407=4^3+0^3+7^3$

分析问题，首先水仙花数是三位数，那么我们可以确定范围：100~999，这个我们可以通过循环结构来搞定：

n = 100;
while (n <= 999) {
    n++;
}

然后对于这个范围的每个数n，我们要去判断它是否等于其各位数字的立方和，这里的难点或关键在于如何分解一个三位数，得到它的每位数字。

假设我们已经把三位数n分解成百位数p3，十位数p2，个位数p1，
这样我们的筛选条件就可以写出来：n == p3 * p3 * p3 + p2 * p2 * p2 + p1 * p1 * p1。

如何拆分一个三位数n呢？

首先求n的个位数：n % 10
然后要将三位数变成两位数：n = n / 10;
对于新的两位数n，又求它的个位数：n % 10
然后要将两位数变成一位数：n = n / 10;

也就是说我们可以交替使用求余和整除运算将一个三位数拆分，得到它的个位数、十位数和百位数。当然这个分解方法可以推广到任何多位数的拆分。

package net.hw.lesson06;

/**
 * 功能：打印水仙花数
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example613 {
    public static void main(String[] args) {
        // 声明部分
        int n;
        int p3; // 百位数
        int p2; // 十位数
        int p1; // 个位数

        // 处理部分
        n = 100; // 初始条件
        while (n <= 999) {// 循环条件
            p1 = n % 10; // 得到个位数
            p2 = n / 10 % 10; // 得到十位数
            p3 = n / 100; // 得到百位数
            if (n == p1 * p1 * p1 + p2 * p2 * p2 + p3 * p3 * p3) {// if负责筛选工作
                System.out.println(n + " = " + p3 + "^3 + " + p2 + "^3 + " + p1 + "^3");
            }
            n++; // 更新条件
        }
    }
}

大家可以参看一下完成同样任务的Python代码：

（二）do…while循环

1、语法格式

初始条件
do {
     语句块
     break|continue;
     更新条件
} while (循环条件);

2、执行情况

首先执行一次循环，然后判断循环条件，如果为真，继续循环，直到条件为假时结束循环。后测试当型循环，属于先上车后买票，无论如何都会执行一次循环。

3、案例演示：计算1 + 2 + 3 + …… + 100的值

package net.hw.lesson06;

/**
 * 功能：计算1 + 2 + 3 + …… + 100的值
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example614 {
    public static void main(String[] args) {
        int i, sum = 0;

        i = 1; // 初始条件
        do {
            sum += i;
            i++; // 更新条件
        } while (i <= 100); // 循环条件

        System.out.println("1 + 2 + 3 + …… + 100 = " + sum);
    }
}

运行程序，查看结果：

五、课后作业

1、输出所有的玫瑰花数

所谓玫瑰花数，是指等于其各位数字四次方之和的四位数。

$1634=1^4+6^4+3^4+4^4$
$8208=8^4+2^4+0^4+8^4$
$9474=9^4+4^4+7^4+4^4$

2、完成猜数游戏，处理只玩一次就结束的情况

3、判断一个整数是否是素数

什么是素数？一个整数除了1和本身之外没有其它因子，这个整数就是素数。比如，2、3、5、7、11、13……这些整数都是素数，但是我们来看6，除了1和6之外，还有其它因子2和3，6 = 2 * 3，因此6是合数。有一个特殊情况，1既不是素数，也不是合数。

4、打印输出100以内的全部素数，每行打印5个素数

5、解决征婚测试问题

六、补充案例

1、幸运抽奖

输入四位数的会员卡号，如果卡号的百位数等于计算机产生的随机数，那就参与幸运抽奖。

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：输入四位数的会员卡号，如果卡号的百位数
 * 等于计算机产生的随机数，那就参与幸运抽奖。
 * 作者：华卫
 * 日期：2020年11月12日
 */
public class Example615 {
    public static void main(String[] args) {
        //声明部分
        int cardNo; //会员卡号
        int hunNum; //百位数
        int rndNum; //随机数
        Scanner sc = new Scanner(System.in);//扫描器

        //输入部分
        System.out.print("输入会员卡号：");
        cardNo = sc.nextInt();//接收一个整数

        // 处理部分：首先要判断卡号是否合法，如果卡号合法，再看其百位数是否等于随机数，又有两种结果
        // 采用if嵌套来实现
        if (cardNo >= 1000 && cardNo <= 9999) {
            // 取出会员卡号的百位数
            hunNum = cardNo / 100 % 10;
            // 计算机产生[0,9]之间的随机整数（要掌握产生[a,b]之间随机整数的方法：伸缩变换-->取整-->平移变换）
            rndNum = (int) (Math.random() * 10);
            System.out.println("计算机产生的随机数：" + rndNum);
            if (hunNum == rndNum) {
                System.out.println("恭喜，你成为幸运会员！");
            } else {
                System.out.println("遗憾，欢迎你再来！");
            }
        } else {
            System.err.println("糟糕，卡号错误，不能参与幸运抽奖活动！");
        }
    }
}

运行程序，查看结果：

2、给出年月日，确定它是该年的第几天

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：给出年月日，确定它是该年的第几天。
 * 作者：华卫
 * 日期：2020年4月12日
 */

public class Example616 {
    public static void main(String[] args) {
        // 声明部分
        int year, month, day; // 年月日
        int days; // 第几天
        boolean isLeapYear; // 是否为闰年
        Scanner sc = new Scanner(System.in); // 扫描器

        // 输入部分
        System.out.print("year = ");
        year = sc.nextInt();
        System.out.print("month = ");
        month = sc.nextInt();
        System.out.print("day = ");
        day = sc.nextInt();

        // 处理部分
        isLeapYear = year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
        int sum = 0; // 当前月份之前几个月的总天数
        switch (month) {
            case 1:
                sum = 0;
                break;
            case 2:
                sum = 31;
                break;
            case 3:
                if (isLeapYear) {
                    sum = 31 + 29;
                } else {
                    sum = 31 + 28;
                }
                break;
            case 4:
                if (isLeapYear) {
                    sum = 31 + 29 + 31;
                } else {
                    sum = 31 + 28 + 31;
                }
                break;
            case 5:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30;
                } else {
                    sum = 31 + 28 + 31 + 30;
                }
                break;
            case 6:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31;
                }
                break;
            case 7:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30;
                }
                break;
            case 8:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30 + 31;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30 + 31;
                }
                break;
            case 9:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31;
                }
                break;
            case 10:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30;
                }
                break;
            case 11:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31;
                }
                break;
            case 12:
                if (isLeapYear) {
                    sum = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30;
                } else {
                    sum = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30;
                }
                break;
        }
        days = sum + day;

        // 输出部分
        System.out.println(year + "年" + month + "月" + day + "日是该年的第" + days + "天。");
    }
}

运行程序，查看结果：

3、根据获奖名次给予奖励

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：根据获奖名次给予奖励
 * 作者：华卫
 * 日期：2020年4月12日
 */

public class Example617 {
    public static void main(String[] args) {
        // 声明部分
        int rank; //获奖名次
        String reward; //给予的奖励
        Scanner sc = new Scanner(System.in); //扫描器
        //输入部分
        System.out.print("输入获奖名次：");
        rank = sc.nextInt(); //接收一个整数
        //处理部分
        switch (rank) {
            case 1:
                reward = "参加麻省理工大学组织的1个月夏令营！";
                break;
            case 2:
                reward = "奖励惠普笔记本电脑一部！";
                break;
            case 3:
                reward = "奖励移动硬盘一个！";
                break;
            default:
                reward = "没有任何奖励！";
                break;
        }
        //输出部分
        System.out.println(reward);
    }
}

运行程序，查看结果：

4、购物打折

实现购物打折；普通顾客购物满100元打9折；会员购物打8折；会员购物满200元打7.5折。

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：实现购物打折；普通顾客购物满100元打9折；
 * 会员购物打8折；会员购物满200元打7.5折。
 * 作者：华卫
 * 日期：2020年4月12日
 */

public class Example618 {
    public static void main(String[] args) {
        // 声明部分
        String rank; // 用户级别
        double money; // 购物金额
        double discount; // 购物折扣
        double pay; // 实付金额
        Scanner sc = new Scanner(System.in);// 扫描器

        // 输入部分
        System.out.print("输入用户级别：");
        rank = sc.next(); // 接收字符串
        System.out.print("输入购物金额：");
        money = sc.nextDouble(); // 接收实数

        // 处理部分
        if (rank.equals("会员")) { // 判断是否是会员
            if (money >= 200) {
                discount = 0.75;
            } else {
                discount = 0.8;
            }
        } else {
            if (money >= 100) {
                discount = 0.9;
            } else {
                discount = 1.0;
            }
        }
        pay = money * discount;

        // 输出部分
        if (rank.equals("会员")) {
            System.out.println("会员：购物打" + discount * 10 + "折，实付金额：" + pay);
        } else {
            if (discount == 1.0) {
                System.out.println("顾客：购物不打折，实付金额：" + pay);
            } else {
                System.out.println("顾客：购物打" + discount * 10 + "折，实付金额：" + pay);
            }
        }
    }
}

运行程序，查看结果：

5、多级购物菜单系统

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：设计购物系统的多级菜单
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example619 {
    public static void main(String[] args) {
        int choice; // 菜单选择号
        Scanner sc = new Scanner(System.in); // 扫描器

        // 显示登录菜单
        System.out.println("   登录菜单");
        System.out.println("==============");
        System.out.println(" 1. 登录系统");
        System.out.println(" 2. 退出系统");
        System.out.println("==============");
        System.out.print("输入菜单号(1,2)：");

        choice = sc.nextInt();
        switch (choice) {
            case 1:
                login(); // 调用登录系统的方法
                break;
            case 2:
                System.out.println("谢谢使用！");
                System.exit(0); // 退出应用程序
                break;
            default:
                System.err.println("输入菜单号错误！");
                break;
        }
    }

    /**
     * 定义系统登录方法
     */
    private static void login() {
        int choice; // 菜单选择号
        Scanner sc = new Scanner(System.in); // 扫描器

        // 显示主菜单
        System.out.println("       主菜单");
        System.out.println("==================");
        System.out.println(" 1. 客户信息管理");
        System.out.println(" 2. 购物结算");
        System.out.println(" 3. 真情回馈");
        System.out.println(" 4. 注销");
        System.out.println("==================");
        System.out.print("输入菜单号(1,2,3,4)：");
        choice = sc.nextInt();
        switch (choice) {
            case 1:
                customer_management(); //调用客户信息管理模块
                break;
            case 2:
                System.out.println("进入购物结算模块！");
                break;
            case 3:
                sincere_feedback(); //调用真情回馈模块
                break;
            case 4:
                System.out.println("登录账号已注销！");
                break;
            default:
                System.err.println("输入菜单号错误！");
                break;
        }
    }

    /**
     * 定义真情回馈方法
     */
    private static void sincere_feedback() {
        int choice; // 菜单选择号
        Scanner sc = new Scanner(System.in); // 扫描器

        // 显示真情回馈菜单
        System.out.println("     真情回馈");
        System.out.println("=================");
        System.out.println(" 1. 幸运大放送");
        System.out.println(" 2. 幸运抽奖");
        System.out.println(" 3. 生日问候");
        System.out.println("=================");
        System.out.print("输入菜单号(1,2,3)：");
        choice = sc.nextInt();
        switch (choice) {
            case 1:
                System.out.println("进入幸运大放送模块！");
                break;
            case 2:
                System.out.println("进入幸运抽奖模块！");
                break;
            case 3:
                System.out.println("朋友，祝你生日快乐！");
                break;
            default:
                System.err.println("输入菜单号错误！");
                break;
        }
    }

    /**
     * 定义客户信息管理方法
     */
    private static void customer_management() {
        int choice; // 菜单选择号
        Scanner sc = new Scanner(System.in); // 扫描器

        // 显示客户信息管理菜单
        System.out.println("    客户信息管理");
        System.out.println("=====================");
        System.out.println(" 1. 显示所有客户信息");
        System.out.println(" 2. 添加客户信息");
        System.out.println(" 3. 修改客户信息");
        System.out.println(" 4. 查询客户信息");
        System.out.println("=====================");
        System.out.print("输入菜单号(1,2,3,4)：");
        choice = sc.nextInt();
        switch (choice) {
            case 1:
                System.out.println("进入显示所有客户信息模块！");
                break;
            case 2:
                System.out.println("进入添加客户信息模块！");
                break;
            case 3:
                System.out.println("进入修改客户信息模块！");
                break;
            case 4:
                System.out.println("进入查询客户信息模块！");
                break;
            default:
                System.err.println("输入菜单号错误！");
                break;
        }
    }
}

运行程序，查看结果：

   登录菜单
==============
 1. 登录系统
 2. 退出系统
==============
输入菜单号(1,2)：1
       主菜单
==================
 1. 客户信息管理
 2. 购物结算
 3. 真情回馈
 4. 注销
==================
输入菜单号(1,2,3,4)：1
    客户信息管理
=====================
 1. 显示所有客户信息
 2. 添加客户信息
 3. 修改客户信息
 4. 查询客户信息
=====================
输入菜单号(1,2,3,4)：4
进入查询客户信息模块！

本程序存在不足之处，虽然能逐层调用下一级菜单，但是却不能逐层返回上一级菜单，要实现逐层返回功能，那得利用到循环结构。

6、可进可退的多级购物菜单系统

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：设计购物系统的多级菜单
 * 要求菜单操作可进可退
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example620 {
    public static void main(String[] args) {
        int choice; // 菜单选择号
        boolean isReturn; // 是否要返回
        Scanner sc = new Scanner(System.in); // 扫描器
        while (true) {
            isReturn = false; // 不返回
            // 显示登录菜单
            System.out.println(" 登录菜单");
            System.out.println("=============");
            System.out.println(" 1. 登录系统");
            System.out.println(" 2. 退出系统");
            System.out.println("=============");
            System.out.print("输入菜单号(1,2)：");
            choice = sc.nextInt();
            switch (choice) {
                case 1:
                    login(); // 调用登录系统的方法
                    break;
                case 2:
                    isReturn = true; // 要返回
                    break;
                default:
                    System.err.println("输入菜单号错误！");
                    break;
            }
            if (isReturn) { // 判断是否要返回
                System.out.println("谢谢使用！");
                break; // 跳出循环
            }
        }
    }

    // 定义登录系统的方法
    private static void login() {
        int choice; // 菜单选择号
        boolean isReturn; // 是否要返回
        Scanner sc = new Scanner(System.in); // 扫描器
        while (true) {
            isReturn = false; // 不返回
            // 显示主菜单
            System.out.println("     主菜单");
            System.out.println("================");
            System.out.println(" 1. 客户信息管理");
            System.out.println(" 2. 购物结算");
            System.out.println(" 3. 真情回馈");
            System.out.println(" 4. 注销");
            System.out.println("================");
            System.out.print("输入菜单号(1,2,3,4)：");
            choice = sc.nextInt();
            switch (choice) {
                case 1:
                    customer_management(); // 调用客户信息管理模块
                    break;
                case 2:
                    System.out.println("进入购物结算模块！");
                    break;
                case 3:
                    sincere_feedback(); // 调用真情回馈模块
                    break;
                case 4:
                    isReturn = true; // 要返回
                    break;
                default:
                    System.err.println("输入菜单号错误！");
                    break;
            }
            if (isReturn) { // 判断是否要返回
                System.out.println("登录账号已注销！");
                break;
            }
        }
    }

    // 定义真情回馈的方法
    private static void sincere_feedback() {
        int choice; // 菜单选择号
        boolean isReturn; // 是否要返回
        Scanner sc = new Scanner(System.in); // 扫描器
        while (true) {
            isReturn = false; // 不返回
            // 显示真情回馈菜单
            System.out.println("购物管理系统>真情回馈");
            System.out.println("==================");
            System.out.println(" 1. 幸运大放送");
            System.out.println(" 2. 幸运抽奖");
            System.out.println(" 3. 生日问候");
            System.out.println(" 4. 返回上级菜单");
            System.out.println("==================");
            System.out.print("输入菜单号(1,2,3,4)：");
            choice = sc.nextInt();
            switch (choice) {
                case 1:
                    System.out.println("进入幸运大放送模块！");
                    break;
                case 2:
                    System.out.println("进入幸运抽奖模块！");
                    break;
                case 3:
                    System.out.println("朋友，祝你生日快乐！");
                    break;
                case 4:
                    isReturn = true; // 要返回
                    break;
                default:
                    System.err.println("输入菜单号错误！");
                    break;
            }
            if (isReturn) { // 判断是否要返回
                break; // 跳出循环
            }
        }
    }

    // 定义客户信息管理的方法
    private static void customer_management() {
        int choice; // 菜单选择号
        boolean isReturn; // 是否要返回
        Scanner sc = new Scanner(System.in); // 扫描器
        while (true) {
            isReturn = false; // 不返回
            // 显示客户信息管理菜单
            System.out.println("购物管理系统>客户信息管理");
            System.out.println("======================");
            System.out.println(" 1. 显示所有客户信息");
            System.out.println(" 2. 添加客户信息");
            System.out.println(" 3. 修改客户信息");
            System.out.println(" 4. 查询客户信息");
            System.out.println(" 5. 返回上一级菜单");
            System.out.println("======================");
            System.out.print("输入菜单号(1,2,3,4,5)：");
            choice = sc.nextInt();
            switch (choice) {
                case 1:
                    System.out.println("进入显示所有客户信息模块！");
                    break;
                case 2:
                    System.out.println("进入添加客户信息模块！");
                    break;
                case 3:
                    System.out.println("进入修改客户信息模块！");
                    break;
                case 4:
                    System.out.println("进入查询客户信息模块！");
                    break;
                case 5:
                    isReturn = true;
                    break;
                default:
                    System.err.println("输入菜单号错误！");
                    break;
            }
            if (isReturn) { // 判断是否要返回
                break; // 跳出循环
            }
        }
    }
}

运行程序，查看结果：

 登录菜单
=============
 1. 登录系统
 2. 退出系统
=============
输入菜单号(1,2)：1
     主菜单
================
 1. 客户信息管理
 2. 购物结算
 3. 真情回馈
 4. 注销
================
输入菜单号(1,2,3,4)：1
购物管理系统>客户信息管理
======================
 1. 显示所有客户信息
 2. 添加客户信息
 3. 修改客户信息
 4. 查询客户信息
 5. 返回上一级菜单
======================
输入菜单号(1,2,3,4,5)：4
进入查询客户信息模块！
购物管理系统>客户信息管理
======================
 1. 显示所有客户信息
 2. 添加客户信息
 3. 修改客户信息
 4. 查询客户信息
 5. 返回上一级菜单
======================
输入菜单号(1,2,3,4,5)：5
     主菜单
================
 1. 客户信息管理
 2. 购物结算
 3. 真情回馈
 4. 注销
================
输入菜单号(1,2,3,4)：3
购物管理系统>真情回馈
==================
 1. 幸运大放送
 2. 幸运抽奖
 3. 生日问候
 4. 返回上级菜单
==================
输入菜单号(1,2,3,4)：4
     主菜单
================
 1. 客户信息管理
 2. 购物结算
 3. 真情回馈
 4. 注销
================
输入菜单号(1,2,3,4)：4
登录账号已注销！
 登录菜单
=============
 1. 登录系统
 2. 退出系统
=============
输入菜单号(1,2)：2
谢谢使用！

7、四个整数排序

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：输入四个整数进行排序
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example621 {
    public static void main(String[] args) {
        // 声明部分
        int x1, x2, x3, x4, t;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        System.out.print("x1 = ");
        x1 = sc.nextInt();
        System.out.print("x2 = ");
        x2 = sc.nextInt();
        System.out.print("x3 = ");
        x3 = sc.nextInt();
        System.out.print("x4 = ");
        x4 = sc.nextInt();

        // 处理部分（排序：比较+交换）

        // 第一轮比较，让x1成为最大的，需要比较3次
        if (x1 < x2) {
            t = x1;
            x1 = x2;
            x2 = t;
        }
        if (x1 < x3) {
            t = x1;
            x1 = x3;
            x3 = t;
        }
        if (x1 < x4) {
            t = x1;
            x1 = x4;
            x4 = t;
        }

        // 第二轮比较，让x2成为第二大的，需要比较2次
        if (x2 < x3) {
            t = x2;
            x2 = x3;
            x3 = t;
        }
        if (x2 < x4) {
            t = x2;
            x2 = x4;
            x4 = t;
        }

        // 第三轮比较，让x3成为第三大的，需要比较1次
        if (x3 < x4) {
            t = x3;
            x3 = x4;
            x4 = t;
        }

        System.out.println("降序：" + x1 + "  " + x2 + "  " + x3 + "  " + x4);

        // 第一轮比较，让x1成为最小的，需要比较3次
        if (x1 > x2) {
            t = x1;
            x1 = x2;
            x2 = t;
        }
        if (x1 > x3) {
            t = x1;
            x1 = x3;
            x3 = t;
        }
        if (x1 > x4) {
            t = x1;
            x1 = x4;
            x4 = t;
        }

        // 第二轮比较，让x2成为第二小的，需要比较2次
        if (x2 > x3) {
            t = x2;
            x2 = x3;
            x3 = t;
        }
        if (x2 > x4) {
            t = x2;
            x2 = x4;
            x4 = t;
        }

        // 第三轮比较，让x3成为第三小的，需要比较1次
        if (x3 > x4) {
            t = x3;
            x3 = x4;
            x4 = t;
        }

        System.out.println("升序：" + x1 + "  " + x2 + "  " + x3 + "  " + x4);
    }
}

运行程序，查看结果：

如果要对更多的数据进行排序，那么最好就要用到我们后面将会学习的数组。

8、购物结算，打印购物小票

package net.hw.lesson06;

import java.util.Scanner;

/**
 * 功能：购物结算（要打印购物小票）
 * 有三样商品：衬衫、球鞋、羽毛球
 * 每样商品都有不同的折扣，可以购买
 * 多件，最后计算实付金额
 * 作者：华卫
 * 日期：2020年4月12日
 */
public class Example622 {
    public static void main(String[] args) {
        // 声明部分
        double shirtPrice = 100, shoePrice = 200, footballPrice = 150; // 三种商品的单价
        int shirtCount = 0, shoeCount = 0, footballCount = 0; // 三种商品的购买数量
        double shirtDiscount = 0.8, shoeDiscount = 0.9, footballDiscount = 0.7; // 三种商品的折扣
        double shirtMoney = 0, shoeMoney = 0, footballMoney = 0; // 三种商品的购买金额
        double totalMoney = 0; // 实付金额
        int choice; // 选择的菜单号
        boolean isCheckOut; // 是否要结账
        Scanner sc = new Scanner(System.in); // 扫描器

        // 处理部分
        while (true) {
            isCheckOut = false; // 不结账
            System.out.println("         简易购物系统");
            System.out.println("=============================");
            System.out.println("1. 衬衫 单价：100 折扣：8折");
            System.out.println("2. 球鞋 单价：200 折扣：9折");
            System.out.println("3. 足球 单价：150 折扣：7折");
            System.out.println("4. 购物结算——打印购物小票");
            System.out.println("=============================");
            System.out.print("输入菜单号（1，2，3，4）：");
            choice = sc.nextInt();

            switch (choice) {
                case 1:
                    shirtMoney = shirtMoney + shirtPrice * shirtDiscount; // 统计衬衫的购买金额
                    shirtCount++; // 统计衬衫的购买数量
                    break;
                case 2:
                    shoeMoney = shoeMoney + shoePrice * shoeDiscount; // 统计球鞋的购买金额
                    shoeCount++; // 统计球鞋的购买数量
                    break;
                case 3:
                    footballMoney = footballMoney + footballPrice * footballDiscount; // 统计足球的购买金额
                    footballCount++; // 统计足球的购买数量
                    break;
                case 4:
                    isCheckOut = true; // 表明要结账
                    break;
                default:
                    System.out.println("\n菜单号输入错误，请重新输入！\n");
                    break;
            }

            System.out.println();
            if (shirtCount > 0) {
                System.out.println("你已购买" + shirtCount + "件衬衫。");
            }
            if (shoeCount > 0) {
                System.out.println("你已购买" + shoeCount + "双球鞋。");
            }
            if (footballCount > 0) {
                System.out.println("你已购买" + footballCount + "个足球。");
            }
            System.out.println();
            if (isCheckOut) { // 判断是否要结账
                System.out.println("\n谢谢惠顾，欢迎再次光临！\n");
                break; // 跳出循环
            }
        }

        totalMoney = shirtMoney + shoeMoney + footballMoney; // 统计购物总金额
        // 打印购物小票
        System.out.println("商品\t单价\t购买数量\t折扣\t购买金额");
        if (shirtCount > 0) {
            System.out.println("衬衫\t" + shirtPrice + "\t" + shirtCount + "\t\t\t" + shirtDiscount * 10 + "\t\t" + shirtMoney);
        }
        if (shoeCount > 0) {
            System.out.println("球鞋\t" + shoePrice + "\t" + shoeCount + "\t\t\t" + shoeDiscount * 10 + "\t\t" + shoeMoney);
        }
        if (footballCount > 0) {
            System.out.println("足球\t" + footballPrice + "\t" + footballCount + "\t\t\t" + footballDiscount * 10 + "\t\t" + footballMoney);
        }
        System.out.println("\n实付金额：" + totalMoney);
    }
}

运行程序，查看结果：

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：1

你已购买1件衬衫。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：2

你已购买1件衬衫。
你已购买1双球鞋。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：2

你已购买1件衬衫。
你已购买2双球鞋。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：3

你已购买1件衬衫。
你已购买2双球鞋。
你已购买1个足球。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：1

你已购买2件衬衫。
你已购买2双球鞋。
你已购买1个足球。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：1

你已购买3件衬衫。
你已购买2双球鞋。
你已购买1个足球。

         简易购物系统
=============================
1. 衬衫 单价：100 折扣：8折
2. 球鞋 单价：200 折扣：9折
3. 足球 单价：150 折扣：7折
4. 购物结算——打印购物小票
=============================
输入菜单号（1，2，3，4）：4

你已购买3件衬衫。
你已购买2双球鞋。
你已购买1个足球。


谢谢惠顾，欢迎再次光临！

商品	单价	购买数量	折扣	购买金额
衬衫	100.0	3			8.0		240.0
球鞋	200.0	2			9.0		360.0
足球	150.0	1			7.0		105.0

实付金额：705.0

你可能感兴趣的:(Java程序设计基础)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式 java
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
解线性方程组 qiuwanchi
package gaodai.matrix; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Test { public static void main(String[] args) { Scanner scanner = new Sc
在mysql内部存储代码 annan211 性能 mysql 存储过程触发器
在mysql内部存储代码在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。先看优点： 1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。 2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。 3 可以简化代码的维护和版本更新。 4 可以帮助提升安全，比如提供更细
Android使用Asynchronous Http Client完成登录保存cookie的问题 hotsunshine android
Asynchronous Http Client是android中非常好的异步请求工具除了异步之外还有很多封装比如json的处理，cookie的处理引用 Persistent Cookie Storage with PersistentCookieStore This library also includes a PersistentCookieStore whi
java面试题 Array_06 java 面试
java面试题第一，谈谈final, finally, finalize的区别。 final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
网站加速 oloz 网站加速
前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教. 1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。 2、采用Gzip对网页进行压缩； GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
正确书写单例模式随意而生 java 设计模式单例
　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。　　懒汉式，线程不安全　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
单例模式香水浓 java
懒汉调用getInstance方法时实例化 public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if(null == ins
安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" AdyZhang apache http server
安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" 每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。解决方法确保几处： 1、停止IIS启动 2、把端口80改成其它（譬如90，800，，，什么数字都好） 3、防火墙(关掉试试) 在运行处输入 cmd 回车，转到apa
如何在android 文件选择器中选择多个图片或者视频？ aijuans android
我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传但是android原生态的sdk中，只能一个一个的进行选择和上传。我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个处理方法官方的图片选择器(但是不支持所有版本的androi，只支持API Level
mysql中查询生日提醒的日期相关的sql baalwolf mysql
SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(), dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
MongoDB索引文件破坏后导致查询错误的问题 BigBird2012 mongodb
问题描述： MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。解决方案：使用脚本，重建MongoDB所有表的索引。 var names = db.getCollectionNames(); for( var i in names ){ var name = names[i]; print(name);
Javascript Promise bijian1013 JavaScript Promise
Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。一.认识Promises “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
[Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程 bit1129 zookeeper
Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是 public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
【Java命令三】jstack bit1129 jstack
jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump [hadoop@hadoop sbin]$ jstack Usage: jstack [-l] <pid> (to connect to running process) jstack -F
jboss 5.1启停脚本　动静分离部署 ronin47
以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename -b ip -g clustername -u broatcast jboss.messaging.ServerPeerID=int -Djboss.service.binding.set=p
UI之如何打磨设计能力? brotherlamp UI ui教程 ui自学 ui资料 ui视频
在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。 1.找到自己的方式如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
三色旗算法 bylijinnan java 算法
import java.util.Arrays; /** 问题：假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。网上的解法大多类似：在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
警告:No configuration found for the specified action: \'s chiangfai configuration
1.index.jsp页面form标签未指定namespace属性。  <%@taglib prefix="s" uri="/struts-tags"%> ... <s:form action="submit" method="post"&g
redis -- hash_max_zipmap_entries设置过大有问题 chenchao051 redis hash
使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑 #define ZIPMAP_BIGLEN 254 #define ZIPMAP_END 255 /* Return th
select into outfile access deny问题 daizj mysql txt 导出数据到文件
本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/ 为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。授权的语句如下： grant select on armory.* to rn
phpexcel导出excel表简单入门示例 dcj3sjt126com PHP Excel phpexcel
<?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE); if (PHP_SAPI == 'cli') die('This example should only be run from a Web Brows
美国电影超短200句 dcj3sjt126com 电影
1. I see．我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too．我也是。5. My god! 天哪!6. No way! 不行!7. Come on．来吧(赶快)8. Hold on．等一等。9. I agree。我同意。10. Not bad．还不错。11. Not yet．还没。12. See you．再见。13. Shut up!
Java访问远程服务 dyy_gusi httpclient webservice get post
随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
Maven的settings.xml配置 geeksun settings.xml
settings.xml是Maven的配置文件，下面解释一下其中的配置含义： settings.xml存在于两个地方： 1.安装的地方：$M2_HOME/conf/settings.xml 2.用户的目录：${user.home}/.m2/settings.xml 前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。
ubuntu的init与系统服务设置 hongtoushizi ubuntu
转载自： http://iysm.net/?p=178 init Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。 ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。运行
跟我学Nginx+Lua开发目录贴 jinnianshilongnian nginx lua
使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。目录第一章安装Nginx+Lua开发环境第二章 Nginx+Lua开发入门第三章 Redis/SSDB+Twemproxy安装与使用第四章 L
php位运算符注意事项 home198979 位运算 PHP &
$a = $b = $c = 0; $a & $b = 1; $b | $c = 1 问a,b,c最终为多少? 当看到这题时，我犯了一个低级错误，误以为位运算符会改变变量的值。所以得出结果是1 1 0 但是位运算符是不会改变变量的值的，例如： $a=1;$b=2; $a&$b; 这样a,b的值不会有任何改变
Linux shell数组建立和使用技巧 pda158 linux
1.数组定义　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。　　 2.数组读取与赋值　　得到长度：　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
hotspot源码(JDK7) ol_beta java HotSpot jvm
源码结构图，方便理解： ├─agent Serviceab
Oracle基本事务和ForAll执行批量DML练习 vipbooks oracle sql
基本事务的使用：从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚 select * from account; -- 创建一张账户表 create table account( -- 账户ID id number(3) not null, -- 账户名称 nam