面试真题-1

一、选择题

1. Linux中删除非空文件夹的命令是什么？ （A）

1. rm -rf temp
2. rm -f temp
3. rm -rf temp/*
4. rm -f temp/*

5. linux删除目录可以用rmdir，但是当目录非空时，就不可以用这个命令了。此时使用直接rm  -rf 即可：
   
   rm -rf 目录名字
   其中：
   -r 就是向下递归，不管有多少级目录，一并删除
    -f 就是直接强行删除，不作任何提示

1. Linux中查看上一个命令的结果的命令是什么？（C）

1. $1
2. $0
3. $?
4. @?

5. 在Linux中，查看上一个命令执行后的退出状态（即命令是否成功执行，成功通常是0，非0值表示有错误）的命令是$?。
   
   因此，正确答案是：$?。
   
   解释其他选项：
   
   $1、$2、$3... 等通常用于脚本中，表示传递给脚本的第一个、第二个、第三个...参数。
   $0 在脚本中表示脚本的名称。
   @? 并不是Linux shell中的有效命令或变量。

1. 计算机软件系统包括（D）

1. 编辑软件和连接程序
2. 数据软件和管理程序
3. 程序及文档
4. 系统软件和应用软件

计算机软件系统确实包括两大类，即系统软件和应用软件。因此，正确答案是（D）系统软件和应用软件。

1. 根据《信息安全等级保护管理办法》，信息系统的安全保护等级分为几级?(B)

A.4

B.5

c.6

D.7

根据《信息安全等级保护管理办法》，信息系统的安全保护等级分为五级，具体分级情况如下：

第一级（用户自主保护级）：信息系统受到破坏后，会对公民、法人和其他组织的合法权益造成损害，但不损害国家安全、社会秩序和公共利益。一般适用于小型私营、个体企业、中小学，乡镇所属信息系统、县级单位中一般的信息系统等。

第二级（系统审计保护级）：信息系统受到破坏后，会对公民、法人和其他组织的合法权益产生严重损害，或者对社会秩序和公共利益造成损害，但不损害国家安全。这一级别的信息系统需要依据国家有关管理规范和技术标准进行保护，国家信息安全监管部门对该级信息系统安全等级保护工作进行指导。

第三级（安全标记保护级）：信息系统受到破坏后，会对社会秩序和公共利益造成严重损害，或者对国家安全造成损害。第三级信息系统同样需要依据国家有关管理规范和技术标准进行保护，且国家信息安全监管部门对该级信息系统安全等级保护工作进行监督、检查。

第四级（结构化保护级）：信息系统受到破坏后，会对社会秩序和公共利益造成特别严重损害，或者对国家安全造成严重损害。对于这一级别的信息系统，其运营、使用单位需要依据国家有关管理规范、技术标准和业务专门需求进行保护，国家信息安全监管部门则对该级信息系统安全等级保护工作进行强制监督、检查。

第五级（访问验证保护级）：信息系统受到破坏后，会对国家安全造成特别严重损害。这是最高等级的信息系统安全保护级别，其运营、使用单位需要依据国家有关管理规范、技术标准和业务特殊需求进行保护。

1. 关于信息安全管理，说法错误的是：（D）

1. 信息安全管理是管理者为实现信息安全目标（信息资产的CIA等特性，以及业务运作的持续）而进行的计划、组织、指挥、协调和控制的一系列活动。
2. 信息安全管理是一个多层面、多因素的过程依赖于建立信息安全组织、明确信息安全角色及职责、制定信息安全方针策略标准规范、建立有效的监督审计等多方面非技术性的努力。
3. 实现信息安全，技术和产品是基础，管理是关键。
4. 信息安全管理是人员、技术、操作三者紧密结合的系统工程，是一个静态过程。

D选项错误地认为信息安全管理是一个静态过程。实际上，信息安全管理是一个动态过程，需要不断适应新的威胁、技术和业务需求。随着环境的变化，信息安全策略、控制措施和流程也需要定期评估和更新，以确保信息安全管理的有效性和适应性。因此，D选项的说法是错误的。

1. 有关危害国家秘密安全的行为的法律责任，正确的是:(A)

A.严重违反保密规定行为只要发生，无论是否产生泄密实际后果，都要依法追究责任

B.非法获取国家秘密，不会构成刑事犯罪，不需承担刑事责任

C.过失泄露国家秘密，不会构成刑事犯罪，不需承担刑事责任

D.承担了刑事责任，无需再承担行政责任和 /或其他处分

这是一道关于危害国家秘密安全行为法律责任的选择题。我们需要根据相关法律法规和常识，对每个选项进行逐一分析。

A项：严重违反保密规定行为只要发生，无论是否产生泄密实际后果，都要依法追究责任。这个选项是正确的。根据我国《保密法》和相关规定，保密工作实行“积极防范、突出重点、依法管理”的方针，既确保国家秘密安全，又便利信息资源合理利用。对于严重违反保密规定的行为，无论是否实际造成泄密后果，都应依法追究责任，以维护国家秘密的安全。

B项：错误的。根据我国《刑法》的相关规定，非法获取国家秘密的行为可能构成非法获取国家秘密罪，是需要承担刑事责任的。

C项：错误的。根据我国《刑法》第三百九十八条，过失泄露国家秘密，情节严重的，处三年以下有期徒刑或者拘役；情节特别严重的，处三年以上七年以下有期徒刑。因此，过失泄露国家秘密在特定情况下也可能构成刑事犯罪。

D项：错误的。在我国法律体系中，刑事责任、行政责任和其他处分（如党纪处分）是可能并存的。一个人因同一行为可能同时触犯多种法律规范，从而需要承担多种法律责任。

综上所述，A项“严重违反保密规定行为只要发生，无论是否产生泄密实际后果，都要依法追究责任”是正确的。
因此，答案是A。

1. 以下对于信息安全事件理解错误的是: (D)
   A.信息安全事件，是指由于自然或者人为以及软硬件本身缺陷或故障的原因，对信息系统造成危害，或在信息系统内发生对社会造成负面影响的事件 
   B.对信息安全事件进行有效管理和响应，最小化事件所造成的损失和负面影响，是组织信息安全战略的一部分
   C，应急响应是信息安全事件管理的重要内容
   D.通过部署信息安全策略并配合部署防护措施，能够对信息及信息系统提供保护，杜绝信息安全事件的发生

D. “通过部署信息安全策略并配合部署防护措施，能够对信息及信息系统提供保护，杜绝信息安全事件的发生。” 这个选项存在问题。虽然部署信息安全策略和防护措施可以显著降低信息安全事件的风险，但“杜绝”信息安全事件的发生是一个过高的期望。由于信息安全威胁的多样性和复杂性，以及系统可能存在的未知漏洞和人为错误，完全杜绝信息安全事件的发生是不现实的。

1. 下面哪项属于软件开发安全方面的问题（C）

1. 软件部署时所选用服务性能不高，导致软件执行效率低
2. 应用软件来考虑多线程技术，在对用户服务时按序排队提供服务
3. 应用软件存在sql注入漏洞，若被黑客利用能窃取数据库所用数据
4. 软件受许可证（license）限制，不能在多台电脑上安装。

A. 软件部署时所选用服务性能不高，导致软件执行效率低：
这个选项主要关注的是软件部署时的服务性能问题，它更多关联于软件运行的效率和性能，而非直接的安全性问题。

B. 应用软件来考虑多线程技术，在对用户服务时按序排队提供服务：
这个选项描述的是软件设计中的一个技术实现方式，即使用多线程技术来处理用户请求。这种方式主要是为了提高软件的并发处理能力和响应速度，而并非直接针对安全性问题。

C. 应用软件存在SQL注入漏洞，若被黑客利用能窃取数据库所用数据：
这个选项明确指出了软件开发中的一个典型安全漏洞——SQL注入。SQL注入是一种利用应用程序对用户输入数据的不正确处理而发生的安全漏洞，攻击者可以通过输入恶意的SQL代码来执行未经授权的数据库操作，如窃取、篡改或破坏数据库中的数据。这种漏洞直接威胁到软件和数据的安全性，因此它属于软件开发安全方面的问题。

D. 软件受许可证（license）限制，不能在多台电脑上安装：
这个选项涉及到的是软件的许可和版权问题，而非直接的安全性问题。

1. 操作系统是（C）

1. 软件与硬件的接口
2. 主机与外设的接口
3. 计算机与用户的接口
4. 高级语言与机器语言的接口

1. 将二进制11011101转化成十进制是（B）

A.220 B.221 C.251 D.321

要将二进制数 
11011101
11011101 转化为十进制数，我们可以使用“按权展开求和”的方法。
二进制数 
11011101
11011101 可以表示为：

1 \times 2^{7} + 1 \times 2^{6} + 0 \times 2^{5} + 1 \times 2^{4} + 1 \times 2^{3} + 1 \times 2^{2} + 0 \times 2^{1} + 1 \times 2^{0}
1×2
7
+1×2
6
+0×2
5
+1×2
4
+1×2
3
+1×2
2
+0×2
1
+1×2
0

计算每一项的值，我们得到：

= 128 + 64 + 0 + 16 + 8 + 4 + 0 + 1
=128+64+0+16+8+4+0+1

= 221

1. 在给定文件中 查找与设定条件相符的字符串命令为（A）

1. grep B.sort C.find D.gzip

grep命令简介：

grep是Global Regular Expression Print的缩写，即全面搜索正则表达式并把行打印出来。
它是一种强大的文本搜索工具，能够使用正则表达式搜索文本，并把匹配的行打印出来。
grep命令的基本用法：


-i：忽略大小写。
-n：显示匹配的行号。
-v：反向过滤，只显示不包含模式的所有行。
-c：输出匹配字符串行的数量。
-h：查询多文件时不显示文件名。
-l：只列出符合匹配的文件名，而不列出具体匹配行。
-s：不显示不存在或无匹配文本的错误信息

1. 下列哪些命令可以切换使用者身份（D）

1. passwd
2. log
3. who
4. su

passwd：

功能：用于修改用户的密码。
说明：passwd命令并不是用来切换使用者身份的，而是用于设置或更改用户密码。用户需要输入自己的当前密码，然后输入新密码两次以确认。

log：

并非直接用于切换使用者身份的命令。
在Linux中，log通常与各种系统和应用程序的日志文件相关联，用于记录系统或应用程序的运行情况、错误信息等，而不是用于用户身份的切换。

who：

功能：显示当前登录系统的用户信息。
说明：who命令用于列出当前登录到系统的所有用户的信息，包括用户名、登录终端、登录时间等。它并不提供切换使用者身份的功能。

su：

功能：用于切换当前用户身份至另一个用户身份，也可以切换至超级用户（root）。
说明：su是最简单的用户切换命令，通过该命令可以实现任何身份的切换，包括从普通用户切换为root用户、从root用户切换为普通用户以及普通用户之间的切换

1. 关于Java语句System.out.println(1234/1000*1000)的输出结果，下列哪个选项是正确的（B）

     A.1234 B.1000 C.1234.0   D.以上都不对

在Java中，当你执行类似 System.out.println(1234/1000*1000); 的语句时，重要的是要理解Java中的整数除法和整数乘法是如何工作的。

在这个特定的例子中，1234/1000 是一个整数除以整数的操作。在Java中，当两个整数进行除法运算时，结果也会被自动向下取整为整数（即丢弃小数部分）。因此，1234/1000 的结果不是 1.234，而是 1。

接下来，这个结果被乘以 1000。因为结果是整数 1，所以 1*1000 的结果也是整数 1000。

因此，System.out.println(1234/1000*1000); 的输出结果是 1000。

如果你想要得到 1234 除以 1000 然后再乘以 1000 的精确浮点数结果（即 1234.0），你应该至少有一个操作数是浮点数。这可以通过在数字后添加 .0（或其他小数部分）来实现，例如：

System.out.println(1234.0/1000*1000);


或者

System.out.println((double)1234/1000*1000);


这两种方式都会得到 1234.0 作为输出，因为 1234.0 是一个浮点数，所以 1234.0/1000 也是一个浮点数，保留了小数部分。

1. 以下哪个不是Java的线程类Thread对象的方法（B）

1. run() B.exit() C.wait() D.sleep()

A. run()：是Thread类的一个方法，用于定义线程执行的操作。当线程启动时，此方法被调用。它是Runnable接口中声明的run方法的实现。

B. exit()：实际上，exit()方法是System类的一个静态方法，用于终止当前正在运行的Java虚拟机（JVM）。它不是Thread类的方法。

C. wait()：是Object类的一个方法，但在多线程编程中，它经常与Thread一起使用。wait()方法导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法。虽然它不是Thread类的方法，但由于所有类都继承自Object，因此Thread对象也可以调用它。

D. sleep()：是Thread类的一个静态方法，它使当前正在执行的线程暂停执行指定的毫秒数（ms）。这不会释放任何监视器锁。

1. 以下关于Java的构造方法Constructor，说法错误的是（D） 

1. 构造方法在new运算符创建对象是执行
2. 构造方法与类名相同，可以加载多个不同的构造方法
3. 一个类可以不定义返回值
4. 类的构造方法中需要定义返回值

A. 构造方法在new运算符创建对象是执行：这是正确的。在Java中，构造方法是一种特殊的方法，它在创建对象时自动被调用。它主要用于初始化对象。

B. 构造方法与类名相同，可以加载多个不同的构造方法：这也是正确的。Java允许一个类有多个构造方法，只要它们的参数列表不同（这被称为构造方法的重载）。构造方法的名称必须与类名相同。

C. 一个类可以不定义返回值：这也是正确的。构造方法确实没有返回值类型，也不使用void关键字。这是它与其他方法的区别之一。

D. 类的构造方法中需要定义返回值：这是错误的。构造方法不需要（也不应该有）返回值类型，包括void。如果在构造方法后面声明了返回类型（包括void），那么它就不再是一个构造方法，而是一个普通的方法

1. 在Java中，使用JDBC连接数据库的步骤顺序是（A）

1. 导入驱动包->加载驱动->获取连接->发送SQL语句并处理->关闭连接
2. 加载驱动->获取连接->导入驱动包->发送SQL语句并处理->关闭连接
3. 导入驱动包->获取连接->加载驱动->发送SQL语句并处理->关闭连接
4. 加载驱动->导入驱动包->获取连接->发送SQL语句并处理->关闭连接

1. 以下关于Java命令作用的描述中，正确的是（A）

1. 它专门负责解析由Java编译器生成的.class文件
2. 它可以将编写好的Java文件编译成.class文件
3. 可以把文件压缩
4. 可以把数据打包

1. 下列关于Java中while语句的描述中，正确的是（A）

1. while语句循环体中可以没有语句
2. While语句的循环条件可以使整形变量
3. While语句的循环体必须使用大括号
4. Wuile语句的循环体至少执行一次

 

A. while语句循环体中可以没有语句
这是正确的。在Java中，while循环的循环体可以包含零个或多个语句。如果循环体为空（即没有语句），那么循环将不断检查条件，但永远不会执行任何操作，直到条件变为假（false）。

B. While语句的循环条件可以使整形变量
while语句的循环条件应该是一个布尔表达式（boolean expression），它评估为true或false。

C. While语句的循环体必须使用大括号
如果while循环的循环体只包含一条语句，那么大括号是可选的。然而，如果循环体包含多条语句，那么大括号是必需的，以将多条语句组合成一个块。因此，说“必须使用大括号”是不准确的。

D. Wuile语句的循环体至少执行一次
这个描述是错误的。while循环是一个前测试循环，意味着它首先评估循环条件，如果条件为false，则循环体根本不会执行。因此，while循环的循环体可能根本不会执行，更不用说“至少执行一次”了。

1. 从后台启动进程，应在命令的结尾加上符号( D )。

A.>

B.I

c@

D&

在Linux操作系统中，当用户输入一个命令并运行时，默认会启动一个前台进程。如果希望将进程放入后台运行，以便可以继续在同一个终端中执行其他命令，可以在命令的结尾添加&符号。这样，命令就会在后台执行，用户可以继续与终端进行交互，而无需等待该命令完成。

1. 下面哪个参数可以获取命令执行的返回值(  D   )。

A.$o

B.$1

c.@?

D.$?

1. 743标识的文件的权限是：

rwxr---wx

解析：linux系统的权限一般是用 1-3 位数字代表文件所有者的权限，4-6 位数字代表同组用户的权限，7-9 数字代表其他用户的权限。具体的权限是由数字来表示的，读取的权限等于 4，用 r 表示；写入的权限等于 2，用 w 表示；执行的权限等于 1，用 x 表示；通过4、2、1的组合，得到以下几种权限：0（没有权限）；4（读取权限）；5（4+1 | 读取+执行）；6（4+2 | 读取+写入）；7（4+2+1 | 读取+写入+执行）。

第一个数字7：表示文件所有者的权限。数字7等于4（读）+ 2（写）+ 1（执行），因此文件所有者具有读、写和执行权限。
第二个数字4：表示文件所属组的权限。数字4等于4（读）+ 0（写）+ 0（执行），因此所属组的用户只有读权限，没有写和执行权限。
第三个数字3：表示其他用户的权限。数字3等于2（写）+ 1（执行）+ 0（读）

• 判断题

（×）1.十六进制数是由0,1,2...13,14,15这十六种数码组成

解析：十六进制数为：0,1,2...9,A,B,C,D,E组成

（√）2.总线是由数据总线、地址总线和控制总线组成。

（√）3.使用命令“su -”切换用户，会加载切换用户的环境变量。

（×）4.使用vi修改打开文件，不想保存内容，可以在末行模式下输入：wq退出。

解析：不保存应输入：q!

:wq 或 :x 是用来保存文件并退出的命令。
:q 试图退出vi/vim，但如果自上次保存以来有更改，则会提示你保存更改。
:q! 强制退出vi/vim，不保存任何更改。

（×）5.在父类中声明final的方法，也可以在其子类中被重新定义（覆盖）。

解析：子类不能覆盖父类中被final和static声明的方法

（×）6.垃圾回收机制保证了Java程序不会出现内存溢出。

解析：垃圾回收机制只能防止内存溢出，并不能保证。

（√）7.计算机执行一条指令需要的时间为指令周期。

（√）8.给每个存储单元的编号，称为地址。

（√）9.简单性和可扩展性是SOAP的两个目标。

（√）10.关系数据库中空值（NULL）相当于没有输入

（×）11.病毒只感染可执行文件？

感染方式：病毒可以通过多种方式感染文件，包括但不限于可执行文件（.exe、.com等）、脚本文件（如JavaScript、VBScript等）、文档文件（如Word、Excel文档等，在宏病毒的情况下）等。

（√）12.VLAN可以看作是一个广播域？

（√）13.Java中使用了垃圾回收。

（×）14.  ls -l 是查看目录下的所有文件：

解析：-a 全部的文件，连同隐藏文件（ 开头为 . 的文件） 一起列出来

      -l长格式的形式查看当前目录下所有可见文件的详细属性

（×）程序能够按照人们的想法执行是因为存储在内存中：×

解析：程序是存储在外存（如硬盘，u盘，光盘），执行的时候必须先加载到内存中

• 代码分析题

1. 以下代码初始化一个字符串列表，并根据内容长度写入标准日志文件，请简述程序有什么逻辑错误。

public class TestList{

public static final int LISTLENGTH = 1000;

public static final int VALIDLENGTH = 20;

public static final int SLEEPTIME = 1000;

public static boolean isValidLength(String str){

if(str.length()<VALIDLENGTH){

return true;

}else{

return false;

}

}

public static void main(String[] args){

//TODO Auto-generated method stub

IStandardLog logger = LogUtil.getLogger();

List<String> strList = new ArrayList<String>(LISTLENGTH);

for(int i=1;i<=LISTLENGTH;i++){

strList.add("[log]lineNumber:"+i);

}

int j=0;

while(j<strList.size()){

String str = strList.get(j);

if(isValidLength(str)){

try{

logger.info(CollectContants.APP_NAME,str);

}catch(Exception e){

e.printStackTrace();

return;

}

j++;

}else{

try{

logger.error(CollectContants.APP_NAME,str);

}catch(Exception e){

e.printStackTrace();

return;

}

}

try{

Thread.sleep(SLEEPTIME);

}catch(InterruptedException e){

e.printStackTrace();

}

}

}

}

解析：因j值永远小于strList.size，故会出现死循环。另外，在已知循环次数的情况下，更好的做法应该是将while循环换成for循环。以避免出现死循环。

1. 阅读下段代码片段，请给出程序运行的结果。

public static void main(String[] args){

int i = 4;

while(i>0){

i--;

System.out.println(i);

}

}

解析：结果是3、2、1、0

初始时，i = 4。
进入 while 循环，因为 i > 0（4 > 0）为真。
在循环体内，i-- 将 i 减1，因此 i 变为 3。
打印 i 的当前值：System.out.println(i) 输出 3。
再次检查 i > 0（3 > 0）为真，进入循环。
i-- 将 i 减1，因此 i 变为 2。
打印 i 的当前值：System.out.println(i) 输出 2。
再次检查 i > 0（2 > 0）为真，进入循环。
i-- 将 i 减1，因此 i 变为 1。
打印 i 的当前值：System.out.println(i) 输出 1。
再次检查 i > 0（1 > 0）为真，进入循环。
i-- 将 i 减1，因此 i 变为 0。
打印 i 的当前值：System.out.println(i) 输出 0。
再次检查 i > 0（0 > 0）为假，退出循环。

1. 阅读下段代码片段，请给出程序运行的结果。

String s = new String("ABCDEFG");

System.out.println("s.substring(2,4) = " + s.substring(2, 4));

解析：s.substring(2,4) = CD

s.substring(2, 4):

substring(int beginIndex, int endIndex) 方法返回一个新字符串，它是此字符串的子字符串。子字符串从指定的 beginIndex 处开始，并扩展到索引 endIndex - 1 处。
在这个例子中，s.substring(2, 4) 表示从索引 2 开始（包括索引2），到索引 4 结束（不包括索引4）。
字符串 "ABCDEFG" 的索引如下：


0  1  2  3  4  5  6
A  B  C  D  E  F  G
因此，s.substring(2, 4) 返回 "CD"。

1. 阅读下段代码片段，请给出程序运行的结果。

  1: public static void main(String[] args) {

        int a;

        {

            a = 23;

            System.out.print(a);

        }

        {

            a = 45;

            System.out.print(a);

        }

        a = 81;

        System.out.print(a);

    }

   输出结果是?

解析：234581

int a;:

声明一个整型变量 a，但未初始化。
第一块代码块 { a = 23; System.out.print(a); }:

变量 a 被赋值为 23。
System.out.print(a); 输出 23。
第二块代码块 { a = 45; System.out.print(a); }:

变量 a 被重新赋值为 45。
System.out.print(a); 输出 45。
a = 81;:

变量 a 被重新赋值为 81。
System.out.print(a);:

输出 81。

1. 阅读下段代码片段，请给出程序运行的结果。

public static void main(String[] args){

int x = 1;

int y = 1;

if(x++==2&++y==2){

x=10;

}

System.out.println("二、x为"+x+"，y为"+y+"。");

}

解析：x为2，y为2

代码分析
int x = 1;

初始化 x 为 1。
int y = 1;

初始化 y 为 1。
if (x++ == 2 & ++y == 2) { ... }

x++ 是后置递增运算符，意味着 x 会先使用原值 1，然后再递增。所以 x++ == 2 的结果是 1 == 2，即 false。
++y 是前置递增运算符，意味着 y 会先递增，然后再使用递增后的值。所以 ++y 的值是 2，因此 ++y == 2 的结果是 2 == 2，即 true。
单独看 x++ == 2 为 false，++y == 2 为 true。
& 是按位与运算符，但在这里用作逻辑运算时，它不像 && 会短路。即使 x++ == 2 为 false，它也会继续执行 ++y == 2，所以 y 被递增了。
整个条件表达式的结果是 false & true，即 false，因此 if 块内的代码不会执行。
System.out.println("二、x为" + x + "，y为" + y + "。");

x 在 x++ 后变为 2。
y 在 ++y 后变为 2。
输出 x 和 y 的当前值。

5.阅读下段代码片段，请给出程序运行的结果

public static void main(String[] args) {

   String s = “a”;

   String q = “b”;

   show(s,q);

   System.out.println(s+q);

}

public static void show(String s, String q) {

   s = s + “a”;

   q = q + “b”;

}

解析：ab

String s = "a";

初始化字符串 s 为 "a"。
String q = "b";

初始化字符串 q 为 "b"。
show(s, q);

调用 show 方法，将 s 和 q 的值传递给方法参数。
在 show 方法中：

s = s + "a"; 创建了一个新的字符串 "aa" 并赋值给方法内的局部变量 s。
q = q + "b"; 创建了一个新的字符串 "bb" 并赋值给方法内的局部变量 q。
需要注意的是，Java 中字符串是不可变的（immutable），并且方法参数是按值传递的。这意味着 show 方法中的 s 和 q 只是 main 方法中 s 和 q 的副本，对它们的修改不会影响到原来的变量。
System.out.println(s + q);

打印 s 和 q 的当前值。
由于 show 方法中的修改不影响 main 方法中的 s 和 q，所以 s 仍然是 "a"，q 仍然是 "b"。

6.请排查分析下述命名SQL中的缺陷，给出解决方法

<!-- 根据流水号查询通知单附件-->

<select id=”queryTzdFjInfoCountById” parameterClass=”java.lang.String” resultClass=”java.lang.String”>

Select TZD_FJ_ID

From TZD_FJ_INFO where TZD_FJ_ID in $tzdFjIds$

解析：

<select id=”queryTzdFjInfoCountById” parameterClass=”java.lang.String” resultClass=”java.lang.String”>

Select TZD_FJ_ID

From TZD_FJ_INFO where TZD_FJ_ID in(

<if test=”ItemList != null and ItemList.size() > 0”>

<foreach collection=”ItemList” item=”MyItem” open=”” separator=”,”  close=””>

 #{MyItem)

</foreach>

    </if>

)

<!-- 根据流水号查询通知单附件 -->
<select id="queryTzdFjInfoCountById" parameterClass="java.util.List" resultClass="java.lang.String">
    SELECT TZD_FJ_ID
    FROM TZD_FJ_INFO
    WHERE TZD_FJ_ID IN
    <foreach item="item" index="index" collection="list" open="(" separator="," close=")">
        #{item}
    </foreach>
</select>

6.在多线程并发的情况下请指出下面程序存在的逻辑问题

public class Sequence {

   private static int value = 0;

   public static int getNext() {

      return value++;

}

}

多线程并发的时候，可能会取到相同的值

在多线程环境中，如果多个线程同时执行 getNext 方法，可能会出现以下情况：
线程A读取了当前的 value，然后线程B也读取了相同的 value。
线程A增加了 value，并将结果写回。
线程B也增加了 value，并将结果写回。
这种情况下，两个线程返回的值可能是相同的，导致 value 的递增序列出现错误。

• 简答题

• Object类的方法。

  1. toString()
  功能：返回该对象的字符串表示。默认情况下，返回的是对象的类型、@符号和对象的哈希码的无符号十六进制表示。
  重写建议：在自定义类中，通常会重写此方法以返回对象的详细信息，如成员变量的值。
  2. hashCode()
  功能：返回对象的哈希码值。该方法主要用于哈希表等基于哈希的数据结构。
  重写建议：当重写equals()方法时，通常也需要重写hashCode()方法，以确保两个相等的对象具有相同的哈希码。
  3. equals(Object obj)
  功能：指示其他某个对象是否与此对象“相等”。默认情况下，比较的是对象的内存地址（即是否是同一个对象）。
  重写建议：在自定义类中，如果需要根据对象的内容来判断是否相等，则需要重写此方法。
  4. getClass()
  功能：返回此Object的运行时类的Class对象。通过此方法，可以获取对象的实际类型信息。
  5. clone()
  功能：创建并返回此对象的一个副本。默认情况下，此方法是受保护的，并且抛出CloneNotSupportedException异常。
  使用条件：只有在类实现了Cloneable接口时，此方法才能被调用，并且需要重写此方法以提供具体的克隆逻辑。
  6. finalize()
  功能：当垃圾收集器确定没有对该对象的更多引用时，由对象的垃圾收集器调用此方法。子类可以重写此方法以执行清理操作。
  注意：在现代Java开发中，更推荐使用try-with-resources语句或其他资源管理方式来代替finalize()方法，因为finalize()方法的执行时机是不确定的，且其执行可能会被忽略。
  7. wait(), wait(long timeout), wait(long timeout, int nanos)
  功能：这些方法用于线程间的协作与同步。wait()方法使当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法。带有超时参数的wait()方法允许在等待一段时间后自动唤醒线程。
  8. notify(), notifyAll()
  功能：notify()方法唤醒在此对象监视器上等待的单个线程。notifyAll()方法唤醒在此对象监视器上等待的所有线程。
  
  总结

  Object类的方法在Java开发中扮演着基础而重要的角色。了解并合理使用这些方法，可以帮助开发者更好地编写高效、可维护的Java代码。需要注意的是，对于`clone(

1. 请简述Java中while循环与do循环的不同

答：while循环是先执行判断，若判断为真才进入循环，

do循环是先执行循环，再执行判断，若判断为真则继续循环，会至少执行一次。

1. 请简述比较符==与equals()的区别

答：==是运算符，若比较的是基本数据类型则是比较二者的值是否相等，若比较的是引用数据类型，则比较的是二者引用的地址是否相同。equals()是Object类的方法，默认是比较两个对象的引用是否相同，这种情况下跟==是一样的，但子类可以重写equals方法，比如string.equals()是比较字符串里的内容是否相等。

1. 请简述Java线程Thread中sleep()、wait()的区别。

答：

• 调用对象： wait()是Object类的方法，而sleep()是Thread类的静态方法。
• 释放资源： wait()会释放对象的锁，而sleep()不会释放任何资源。
• 线程状态： wait()使线程进入等待状态，而sleep()使线程进入休眠状态。

 3wait不需要进行异常处理;.sleep方法会抛出异常，需要进行异常处理理;

4.wait只能在同步方法和同步代码块中使用sleep可以在任何地方使用，。

1. 请简述Web应用中session和cookie的区别。

答：

1.存储位置不同。cookie是客户端技术，通常保存在客户端，可以被编辑，不是十分安全，session是服务器端技术，是保存在服务端，很安全。

2.存储的数据类型不同。cookie只能存储string类型的对象，session可以存储任意的java对象

3.对性能的影响不同。cookie对服务器性能不会产生影响，session过多会消耗服务器资源，影响一定的服务器性能

4.作用域不同。cookie只能在指定作用域有效，session在整个网页都有效

5.有效时间不同。cookie可以通过setMaxAge设定有效时间，在此时间内，即使关闭浏览器cookie也是存在的，而session在关闭网页后就结束了。

1、数据存储位置：cookie数据存放在客户的浏览器上，session数据放在服务器上。

2、安全性：cookie不是很安全，别人可以分析存放在本地的cookie并进行cookie欺骗，考虑到安全应当使用session。

3、服务器性能：session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，考虑到减轻服务器性能方面，应当使用cookie。

4、数据大小：单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。

5、信息重要程度：可以考虑将登陆信息等重要信息存放为session，其他信息如果需要保留，可以放在cookie中。

5.简述redirect和forward的区别

redirect是客户端发起的请求，forward是通过服务端发起的请求。

redirect是重定向，url会改变；forward是转发，url地址不会改变。

redirect是重新开始一个request，原页面的request生命周期结束；而forward是在原业务的生命周期内的。

在Java Web开发中，页面跳转是构建用户界面和实现业务逻辑的重要组成部分。Forward（转发）和Redirect（重定向）是两种常见的跳转方式

6.你认为好的软件项目应该具备哪些特点，请简要说明两到三点。

答：

1.合理的开发架构

2.有效的沟通

3.稳定的人员结构

4.良好的开发、测试规范

5.可控的需求变更

6.有效的风险管控

7.准确并有用的文档

7.作为软件开发人员需要哪些能力？

  1.扎实的计算机专业知识以及编程知识；

  2.良好的编码能力、自觉的规范意识；

  3.良好的语言沟通，表达能力以及团队精神和协作能力；

  4.持续不断的学习精神，快速的适应新的开发环境；

5.吃苦耐劳的精神，每天的事情尽量当天完成，不拖泥带水；

7.简单介绍一下你参与的java项目，你在其中扮演了什么样的角色，做出了什么贡献？

答：开放性题目，根据自身详细情况回答。

8.重写与重载的区别

答：方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。

9.200、404、500代码代表的含义

200：服务器成功返回网页

404：请求的网页不存在

500：（服务器内部错误）服务器遇到错误，无法完成请求

10.简述java访问修饰符的区别

public公共的，可以被所有其他类访问

private私有的，只能被自己访问

protected受保护得到，能被自身、子类及同一个包下的类访问

default默认的，能被自身和同一个包中的类访问

11.多线程中HashMap会有什么异常，为什么？

当多线程同时put时，若出现hash碰撞，可能会导致元素丢失

12.HashMap是如何存储数据的

HashMap是以链表+数组的形式存储数据的，每一个键值对所组成的Entry对象以数组的方式存放，而保存时，以按key的hash进行排列

13.简述进程和线程的区别：

  1.线程是程序执行的最小单位，进程是操作系统分配资源的最小单位；

  2.一个进程由一个或者多个线程组成，一个进程中至少有一个主线程；

  3.不同进程进程之间内存空间是独立的，同一个进程下的各个线程之间共享程序的内存空间；

  4.线程上下文切换要比进程上下文切换快很多；

14.简述线程的状态

 1.新建状态：新创建一个线程对象。

  2.就绪状态：线程对象被创建后，其他线程调用了该对象的start方法，该状态的线程获取到了除CPU以外的资源，位于可运行线程池中，等待获取CPU的使用权。

  3.运行状态：就绪状态的线程获取到CPU使用权，执行程序代码。

  4.阻塞状态：线程因为某种原因放弃了CPU使用权，暂时停止运行，直到线程进入就绪状态，才有机会转到运行状态。

  5.死亡状态：当一个线程正常执行完，那么就进入死亡状态。系统就会回收这个线程占用的资源。

1. 讲一下对Java语言的理解

Java语言是 SUN公司 1995 年推出的一门高级编程语言，起初主要应用在小型消费电子产品上，后来随着互联网的兴起，Java语言迅速崛起（Java applet 可以在浏览器中运行），成为大型互联网项目的首选语言。

2009 年 04 月 20 日，美国甲骨文公司 74 亿美元收购 Sun，取得 java 的版权。

java是一种跨平台的语言，一次编写，到处运行，在 Windows 上编写的代码可以不加修改的移植到 Linux 上，反之也可以，堪称“当今世界最重要、应用最广泛的编程语言”。

Java 是面向对象的语言，没有面向对象编程经验的人员需要花费一些时间来了解面向对象的概念、语法和编程思想。

Java 不只是一种编程语言，它是一个完整的平台，拥有庞大的库，将诸如图形绘制、Socket连接、数据库存取等复杂操作进行了最大程度的简化。

在世界编程语言排行榜中，Java几乎占据着第二名的位置，仅次于C语言。

17.fianl和finally有什么区别？

final 是java语言的关键字 意思为最终的，不可改变的。

final修饰的类不可以被继承。

final修饰的方法不可以被重写。

final修饰的全局变量必须在声明时赋值，否则就是系统指定默认值。

final修饰的局部变量可以先声明，后赋值。

final修饰的基本数据类型，代表着赋值之后不可改变。

final修饰的引用数据类型，不能重新赋值，不能指向其他对象，但对象中的值可以改变。

finally常与try-catch连用，用于异常的捕获，无论try中代码是否抛出异常，finally中代码都会执行。

finally中常是释放外部资源的相关代码。

与try-catch连用是，如果try-catch-finally中都有return，则执行finally中的return。

如果finally中没有return，程序不抛异常，则执行try中的return；如果程序抛异常，则执行catch中的return。

在执行return之前会先先执行finally中代码，再执行对应的return。虽然finally中代码被执行，但不影响return返回的值。

• 编程题

现在有一个字符串数组，每个数组元素的长度不超过10位，现在需要将其转换为定长格式、左靠齐、右边不满10位补空格的一个大字符串，请使用Java实现该转换函数String convert（String[] strs），并注意提高性能和降低内存占用。

答：

public String convert(String[] strs) throws Exception {

   if (strs == null || strs.length == 0) {

      return “” ;

   } else {

      StringBuffer buff = new StringBuffer();

      for (String str : strs) {

         int length = str.getBytes().length;

         if (length > 10) {

            throw new Exception(“元素超长:” + str);

         } else {

            buff.append(str);

            for (int i = length; i < 10; i++)  {

               buff.append(“”);

            }

         }

      }

      return buff.toString();

   }

}

public static String convert (String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        //初始化StringBuilder，用来构造结果字符串
        StringBuilder result  = new StringBuilder();

        //循环字符串数组中的每个元素
        for (String str : strs) {

            //将当前字符串添加到结果字符集之中
            result.append(str);

            int count = 10 - str.length();
            if (count > 0) {
                for (int i = 0; i < count; i++) {
                    result.append(' ');
                }
            }
        }
        return result.toString();
    }

    public static void main(String[] args) {
        // 示例测试
        String[] strs = {"hello", "world", "java", "code"};
        String result = convert(strs);

        // 打印结果字符串
        System.out.println(result);
        // 验证结果字符串长度是否符合预期
        System.out.println("Length: " + result.length());
    }

给你一个类 public class StringStack{},元素为String字符串，现在需要你实现一个栈，保证元素先进后出，完成方法：

push()

pop()

答：

public class StringStack {

private List<String> stack;

private int count; //栈中元素个数

private int stackSize; //栈的大小

//初始化

public StringStack(int stackSize) {

this.stack = new ArrayList<>();

this.stackSize = stackSize;

this.count = 0;

}

//入栈

public boolean push(String data) {

if (count == stackSize) {

return false;

}

stack.add(data);

++count;

return true;

}

//出栈

public String pop() {

if (stack.isEmpty()) {

return null;

}

String data = stack.remove(count-1);

--count;

return data;

}

}

public class StringStack {
    private LinkedList<String> stack;
    //构造方法
    public StringStack() {
        stack = new LinkedList<>();
    }

     //push 方法把元素推入栈顶
    public void push (String item) {
        stack.addFirst(item);
    }
    //判断栈是否为空、
    public boolean isEmpty() {
        return stack.isEmpty();
    }

    // pop方法，从栈顶弹出元素并返回

    public String pop() {
        if (stack.isEmpty()) {
            throw new IllegalStateException("stack is empty");
        }
        return stack.removeFirst();
    }

    public static void main(String[] args) {
        // 测试StringStack
        StringStack stringStack = new StringStack();

        // 测试push方法
        stringStack.push("first");
        stringStack.push("second");
        stringStack.push("third");

        // 测试pop方法
        System.out.println(stringStack.pop()); // 输出：third
        System.out.println(stringStack.pop()); // 输出：second
        System.out.println(stringStack.pop()); // 输出：first

        // 测试空栈时pop方法
        // System.out.println(stringStack.pop()); // 会抛出异常：Stack is empty
    }

}

计算费率

根据金额范围得到费率

  小于等于500万：0.008%

  大于500万，小于等于2500万：0.007%

  大于2500万，小于等于5000万：0.006%

  大于5000万：0.005%

根据费率计算出来的费用进行四舍五入

如果费用小于100，收取费用100；如果大于10000，收取费用10000；如果在100到10000之间，根据实际费用进行收取

答：

public static double FeeCalculator(double amount) {

// 根据金额范围初步计算费用

    if (amount <= 5000000) {

        amount = amount * 0.008;

    } else if (amount <= 25000000) {

        amount = amount * 0.007;

    } else if (amount <= 50000000) {

        amount = amount * 0.006;

    } else {

        amount= amount * 0.005;

    }

    

    //根据费用上下限计算实收费用

    if (amount < 100) {

        return 100;

    } else if (amount > 10000) {

        return 10000;

    } else {

        return Math.round(amount);

    }

}

public class FeeCalculator {
    public static double calculateFee(double amount) {
        double rate;
        if (amount <= 5000000) {
            rate = 0.00008;
        } else if (amount <= 25000000) {
            rate = 0.00007;
        }  else if (amount <= 50000000) {
            rate = 0.00006;
        } else {
            rate = 0.00005;
        }

        //计算费用
        Double fee = amount * rate;

        /*setScale 方法用于设置 BigDecimal 的小数点后的位数。在这里，setScale(0) 表示将数值缩放为零位小数，即整数。
        RoundingMode.HALF_UP 是一种舍入模式，表示四舍五入。如果小数部分是0.5或更大，则进位到下一位。如果小数部分小于0.5，则舍去小数部分。*//**/

//        BigDecimal feeRounded = new BigDecimal(fee).setScale(0, RoundingMode.HALF_UP);
        BigDecimal feeRounded = new BigDecimal(fee).setScale(0, RoundingMode.HALF_UP);
        if (feeRounded.doubleValue() < 100) {
            return 100;
        } else if (feeRounded.doubleValue() > 10_000) {
            return 10_000;
        } else {
            return feeRounded.doubleValue();
        }
    }
}

给一个字符串，返回第一个重复的字符的位置，如果字符串为空或没有重复的字符就返回-1；其他返回字符所在的位置，起始位置为0

答：

import java.util.HashSet;

public class FirstRepeatedChar {

    public static void main(String[] args) {

        String str = "hello world"; // 测试字符串

        int result = findFirstRepeatedCharIndex(str);

        System.out.println("第一个重复字符的位置是：" + result);

    }

    // 查找字符串中第一个重复字符的位置

    public static int findFirstRepeatedCharIndex(String str) {

        if (str == null || str.isEmpty()) {

            return -1; // 字符串为空，返回-1

        }

        HashSet<Character> set = new HashSet<>(); // 用HashSet存储已经遍历过的字符

        for (int i = 0; i < str.length(); i++) {

            char ch = str.charAt(i);

            if (set.contains(ch)) {

                return i; // 发现重复字符，返回其位置

            }

            set.add(ch); // 将字符加入HashSet

        }

        return -1; // 没有重复字符，返回-1

    }

}

import java.util.HashMap;

public class FirstRepeatedCharacter {
    
    public static int findFirstRepeatedCharacter(String str) {
        if (str == null || str.isEmpty()) {
            return -1;
        }

        HashMap<Character, Integer> charMap = new HashMap<>();

        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (charMap.containsKey(c)) {
                return charMap.get(c);
            } else {
                charMap.put(c, i);
            }
        }

        return -1;
    }

    public static void main(String[] args) {
        // 测试示例
        String test1 = "abcdefg";
        String test2 = "abca";
        String test3 = "aabbcc";
        String test4 = "";

        System.out.println("Test 1: " + findFirstRepeatedCharacter(test1)); // 输出：-1
        System.out.println("Test 2: " + findFirstRepeatedCharacter(test2)); // 输出：0
        System.out.println("Test 3: " + findFirstRepeatedCharacter(test3)); // 输出：0
        System.out.println("Test 4: " + findFirstRepeatedCharacter(test4)); // 输出：-1
    }
}

请手写冒泡排序:

    public void bubbleSort(int[] nums) {

        int length = nums.length;

        for (int i = 0; i < length; i++) {

            for (int j = 0; j < length-i-1; j++) {

                if (nums[j] > nums[j + 1]) {

public class BubbleSort {

    // 冒泡排序方法
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        boolean swapped;

        // 遍历数组
        for (int i = 0; i < n - 1; i++) {
            swapped = false;
            // 每次遍历，将最大的元素"冒泡"到末尾
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换相邻元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            // 如果没有交换，说明数组已经有序，提前结束排序
            if (!swapped) {
                break;
            }
        }
    }

    // 主方法，测试冒泡排序
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};

        System.out.println("未排序数组：");
        printArray(arr);

        bubbleSort(arr);

        System.out.println("排序后数组：");
        printArray(arr);
    }

    // 打印数组
    public static void printArray(int[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

                    int tem = nums[j];

                    nums[j] = nums[j + 1];

                    nums[j + 1] = tem;

                }

            }

        }

    }

代码分析题二

一、已知世界标准时间（UTC），求北京时间（CST）。

（注：世界标准时间晚于北京时间8小时，例如世界标准时间UTC为“2019-07-31T16:00:00.000Z”，北京时间为“2019-08-01 00：00：00”。）

参考答案：

package com.java;

import java.text.ParseException;

import java.time.LocalDateTime;

import java.time.ZonedDateTime;

import java.time.format.DateTimeFormatter;

public class TimeFormatTest {

 public static void main(String args[]) throws ParseException {

  String formatPattern = "yyyy-MM-dd HH:mm:ss";

  String utc = "2019-07-31T16:00:00.000Z";

  UTCToCST(utc, formatPattern);

 }

 public static void UTCToCST(String utc, String formatPattern) {

  ZonedDateTime zdt = ZonedDateTime.parse(utc);

  LocalDateTime localDateTime = zdt.toLocalDateTime();

  DateTimeFormatter formatter = DateTimeFormatter.ofPattern(formatPattern);

  String cst = formatter.format(localDateTime.plusHours(8));

  System.out.println("北京时间：" + cst);

 }

}

二、阅读下段代码，请说出程序运行的结果

public static viod main(String[] args){

{

int a = 1;

system.out.println(a);

}

{

int a = 2;

system.out.println(a);

}

int a = 3;

system.out.println(a);

}

参考答案：1、2、3

每个代码块中的 a 都是局部变量，它们在各自的作用域内互不影响。因此，程序将依次打印每个代码块中的 a 的值。

三、阅读下段代码，请说出程序运行的结果

public static void main()

{

int a = 4;

while (a>0) {

a--;

system.out.println(a);

}

}

参考答案：3、2、1、0

初始值a为4，满足条件a > 0，进入循环，a减1，打印出3。
a现在为3，满足条件a > 0，进入循环，a减1，打印出2。
a现在为2，满足条件a > 0，进入循环，a减1，打印出1。
a现在为1，满足条件a > 0，进入循环，a减1，打印出0。
a现在为0，不再满足条件a > 0，退出循环。
因此，该程序的运行结果将会依次打印出：3, 2, 1, 0。

public static void main(String[] args) {

   int a = 1;

   int b = 1;

   int c = 1;

   {

      a=2;

   }

   {

      a=3;

   }

  

   System.out.print(a);

   System.out.print(b);

   System.out.print(c);

}

参考答案：311

变量a、b、c都被初始化为1。
紧接着是两个花括号 {}，每个花括号内部修改了变量a的值。但是由于a是在同一个作用域内定义的，后一个花括号内的赋值会覆盖前一个花括号内的赋值。
最后，通过三次连续的System.out.print()语句打印变量a、b、c的值。
根据上述分析，变量a的赋值操作是最后一次为准，即a被赋值为3。而变量b和c没有被修改过，因此它们的值仍然是1。

因此，程序的输出结果将会是

• 在多线程中，以下的函数存在什么问题

public class test3(

private int number;

public int getNumber(){

return number ++;

}

}

参考答案：可能会返回多个相同的值

• 权限访问修饰符有哪些，请说明其区别

参考答案：

1.private:及私有的，对访问权限限制最窄的修饰符。被private修饰的属性以及方法只能被该类的对象访问。它的子类也不可以访问，更不支持跨包访问。

2.protected:及保护访问权限，是介于public和private之间的一种访问修饰。被protected修饰的属性及方法只能被类本身的方法和子类访问。（子类在不同的包中也可以访问）

3.public:及共有的，是访问权限限制最宽的修饰符。被public修饰的类、属性、及方法不仅可以跨类访问，而且可以跨包访问。

4.default:及默认的，不加任何访问修饰符。常被叫做“默认访问权限”或者“包访问权限”。无任修饰符时，只支持在同一个包中进行访问

• forward和redicted的区别是什么

参考答案：

1、请求方不同

redirect：客户端发起的请求

forward：服务端发起的请求

2、浏览器地址表现不同

redirect：浏览器地址显示被请求的

urlforward：浏览器地址不显示被请求的url

3、参数传递不同

redirect：重新开始一个request,原页面的request生命周期结束。

forward：forward另一个连接的时候。request变量是在其生命周期内的。另一个页面也可以使用，其实质是把目标地址include。

4、底层运作不同

redirect：发送的请求信息又回送给客户机，让客户机再转发到另一个资源上，需要在服务器和客户机之间增加一次通信。

forward：服务器端直接找到目标，并include过来。

5、定义不同

直接转发方式（Forward）：客户端和浏览器只发出一次请求，Servlet、HTML、JSP或其它信息资源，由第二个信息资源响应该请求，在请求对象request中，保存的对象对于每个信息资源是共享的。

间接转发方式（Redirect）实际是两次HTTP请求，服务器端在响应第一次请求的时候，让浏览器再向另外一个URL发出请求，从而达到转发的目的。

七、写一个队列类 public class MyStringQueue(),用字符串存储，要求先进先出，其构造方法为MyStringQueue(),进队列方法为inQueue(),出队列方法为outQueue().

参考答案:

public class MyStringQueue{

private List<String> queue;

public MyStringQueue(){

queue = new ArrayList<>();

}

public void inQueue(String str){

queue.add(str);

}

public String outQueue(){

if(queue.isEmpty()){

return null;

}

return queue.remove(0);

}

}

import java.util.LinkedList;

public class MyStringQueue {

    private LinkedList<String> queue;

    // 构造方法
    public MyStringQueue() {
        queue = new LinkedList<>();
    }

    // 进队列方法
    public void inQueue(String item) {
        queue.addLast(item);
    }

    // 出队列方法
    public String outQueue() {
        if (isEmpty()) {
            throw new IllegalStateException("Queue is empty");
        }
        return queue.removeFirst();
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return queue.isEmpty();
    }

    // 获取队列的大小
    public int size() {
        return queue.size();
    }

    public static void main(String[] args) {
        MyStringQueue queue = new MyStringQueue();

        // 测试进队列
        queue.inQueue("A");
        queue.inQueue("B");
        queue.inQueue("C");

        // 测试出队列
        System.out.println(queue.outQueue()); // 输出：A
        System.out.println(queue.outQueue()); // 输出：B
        System.out.println(queue.outQueue()); // 输出：C

        // 测试空队列异常
        // System.out.println(queue.outQueue()); // 会抛出异常：Queue is empty
    }
}

su –sa和su sa的区别

答：

su sa指切换到用户sa，但不切换环境变量

su –sa指切换到用户sa，并切换到sa的用户环境变量

加密算法有哪些？

国际算法：

对称：DES、3DES、AES、IDEA、BlowFish、TDEA

非对称：RSA、DH、DSA

国密算法：

对称：SM1、SM4

非对称：SM2

SM3为消息摘要，类比MD5.

常用Linux的命令及使用方法？

答：

文件和目录操作
ls - 列出目录内容

ls: 列出当前目录的文件和子目录
ls -l: 以详细列表形式显示文件和目录的详细信息
ls -a: 显示所有文件，包括隐藏文件（以.开头的文件）
cd - 切换工作目录

cd directory: 进入指定的目录
cd ..: 返回上一级目录
cd ~: 进入当前用户的主目录
pwd - 显示当前工作目录的绝对路径

mkdir - 创建新目录

mkdir directory: 创建名为 directory 的新目录
rm - 删除文件或目录

rm file: 删除名为 file 的文件
rm -r directory: 递归删除 directory 及其内容（谨慎使用）
cp - 复制文件或目录

cp source destination: 复制 source 文件或目录到 destination
mv - 移动文件或重命名

mv source destination: 将 source 移动到 destination，或者重命名 source 为 destination
touch - 创建空文件或更新文件的时间戳

touch file: 创建名为 file 的空文件
touch -a file: 更新 file 的访问时间
touch -m file: 更新 file 的修改时间
文件内容查看和编辑
cat - 显示文件内容

cat file: 将 file 文件的内容打印到标准输出
more / less - 分页显示文件内容

more file: 逐页显示 file 文件内容
less file: 与 more 类似，但提供更多交互选项
head / tail - 显示文件开头或结尾部分内容

head file: 显示 file 文件的前几行内容
tail file: 显示 file 文件的末尾几行内容
nano / vi / vim - 文本编辑器

nano file: 使用简单的文本编辑器 nano 编辑 file
vi file 或 vim file: 使用 vi 或 vim 编辑 file（vi 是基础的文本编辑器，vim 是其增强版）
系统管理和信息查看
ps - 显示当前运行的进程信息

ps: 显示当前用户的进程
ps aux: 显示系统上所有进程的详细信息
top - 动态显示系统运行状态和进程信息

kill - 终止进程

kill PID: 终止进程号为 PID 的进程
killall process_name: 终止所有名为 process_name 的进程
df - 显示磁盘空间使用情况

df: 显示文件系统的磁盘空间使用情况
df -h: 以人类可读的格式显示磁盘空间使用情况
du - 显示目录空间使用情况

du directory: 显示 directory 目录及其子目录的磁盘空间使用情况
du -h directory: 以人类可读的格式显示磁盘空间使用情况
free - 显示系统内存使用情况

网络操作
ping - 测试网络连通性

ping hostname: 向 hostname 发送 ICMP 请求以测试网络连接
ifconfig / ip - 显示和配置网络接口信息

ifconfig: 显示当前系统的网络接口信息
ip addr show: 显示当前系统的 IP 地址和网络接口信息
wget / curl - 下载文件

wget URL: 下载位于 URL 的文件到当前目录
curl -O URL: 将位于 URL 的文件下载到当前目录
用户和权限管理
useradd / adduser - 添加新用户

useradd username: 添加名为 username 的新用户
adduser username: 交互式地添加名为 username 的新用户
passwd - 修改用户密码

passwd username: 修改 username 用户的密码
chmod - 修改文件或目录的权限

chmod permissions file: 修改 file 的权限为 permissions（例如 chmod 755 file）
chown - 修改文件或目录的所有者

chown owner:group file: 将 file 的所有者修改为 owner，并将所属组修改为 group