java

8313674---你个垃圾广告

你这个假设是不是假设错了？这个假设如果是对的那么这个情况是不可理解的用真实的数据来陈述

在说他们之间的区别之前，先考虑如下几个问题： 1、getCurrentSession()与openSession()的区别？ * 采用getCurrentSession()创建的session会绑定到当前线程中，而采用openSession() 创建的session则不会 * 采用getCurrentSession()创建的session在commit或rollback时会自动关闭，而采用openSession() 创建的session必须手动关闭 2、使用getCurrentSession()需要在hibernate.cfg.xml文件中加入如下配置： * 如果使用的是本地事务（jdbc事务） <property name="hibernate.current_session_context_class">thread</property> * 如果使用的是全局事务（jta事务） <property name="hibernate.current_session_context_class">jta</property> 以上是hibernate中一些使用，下面来说说jdbc与jta的区别： JDBC 事务 JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式：自动提交和手工提交。 #在jdbc中，事务操作缺省是自动提交。也就是说，一条对数据库的更新表达式代表一项事务操作，操作成功后，系统将自动调用commit()来提交，否则将调用rollback()来回滚。 # 在jdbc中，可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成后调 用commit()来进行整体提交，倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常；此时就可以在异常捕获时调用 rollback()进行回滚。这样做可以保持多次更新操作后，相关数据的一致性，示例如下： try { conn = DriverManager.getConnection ("jdbc:oracle:thin:@host:1521:SID","username","userpwd"; conn.setAutoCommit(false);//禁止自动提交，设置回滚点 stmt = conn.createStatement(); stmt.executeUpdate(“alter table …”); //数据库更新操作1 stmt.executeUpdate(“insert into table …”); //数据库更新操作2 conn.commit(); //事务提交 }catch(Exception ex) { ex.printStackTrace(); try { conn.rollback(); //操作不成功则回滚 }catch(Exception e) { e.printStackTrace(); } } JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。 JTA事务 JTA(Java Transaction API) 为 J2EE 平台提供了分布式事务服务。 要用 JTA 进行事务界定，应用程序要调用 javax.transaction.UserTransaction 接口中的方法。例如： utx.begin(); // ... DataSource ds = obtainXADataSource(); Connection conn = ds.getConnection(); pstmt = conn.prepareStatement("UPDATE MOVIES ..."); pstmt.setString(1, "Spinal Tap"); pstmt.executeUpdate(); // ... utx.commit(); 让我们来关注下面的话： “用 JTA 界定事务，那么就需要有一个实现 javax.sql.XADataSource 、 javax.sql.XAConnection 和 javax.sql.XAResource 接口的 JDBC 驱动程序。一个实现了这些接口的驱动程序将可以参与 JTA 事务。一个 XADataSource 对象就是一个 XAConnection 对象的工厂。 XAConnection s 是参与 JTA 事务的 JDBC 连接。” 要使用JTA事务，必须使用XADataSource来产生数据库连接，产生的连接为一个XA连接。 XA连接（javax.sql.XAConnection）和非XA（java.sql.Connection）连接的区别在于：XA可以参与JTA的事务，而且不支持自动提交。 注意: Oracle, Sybase, DB2, SQL Server等大型数据库才支持XA, 支持分布事务。 My SQL 连本地都支持不好，更别说分布事务了。 JTA方式的实现过程： 用XADataSource产生的XAConnection它扩展了一个getXAResource()方法,事务通过这个方法把它加入到事务容器中进行 管理.对于调用者来说,根本看不到事务是如果管理的,你只要声明开始事务,告诉容器我下面的操作要求事务参与了,最后告诉事务说到这儿可以提交或回滚了, 别的都是黑箱操作。 在使用JTA之前，你必须首先实现一个Xid类用来标识事务（在普通情况下这将由事务管理程序来处理）。Xid包含三个元素：formatID、gtrid（全局事务标识符）和bqual（分支修饰词标识符）。 下面的例子说明Xid的实现： import javax.transaction.xa.*; public class MyXid implements Xid { protected int formatId; protected byte gtrid[]; protected byte bqual[]; public MyXid() { } public MyXid(int formatId, byte gtrid[], byte bqual[]) { this.formatId = formatId; this.gtrid = gtrid; this.bqual = bqual; } public int getFormatId() { return formatId; } public byte[] getBranchQualifier() { return bqual; } public byte[] getGlobalTransactionId() { return gtrid; } } 其次，你需要创建一个你要使用的数据库的数据源： public DataSource getDataSource() throws SQLException { SQLServerDataSource xaDS = new com.merant.datadirect.jdbcx.sqlserver.SQLServerDataSource(); xaDS.setDataSourceName("SQLServer"); xaDS.setServerName("server"); xaDS.setPortNumber(1433); xaDS.setSelectMethod("cursor"); return xaDS; } 例1 这个例子是用“两步提交协议”来提交一个事务分支： XADataSource xaDS; XAConnection xaCon; XAResource xaRes; Xid xid; Connection con; Statement stmt; int ret; xaDS = getDataSource(); xaCon = xaDS.getXAConnection("jdbc_user", "jdbc_password"); xaRes = xaCon.getXAResource(); con = xaCon.getConnection(); stmt = con.createStatement(); xid = new MyXid(100, new byte[]{0x01}, new byte[]{0x02}); try { xaRes.start(xid, XAResource.TMNOFLAGS); stmt.executeUpdate("insert into test_table values (100)"); xaRes.end(xid, XAResource.TMSUCCESS); ret = xaRes.prepare(xid); if (ret == XAResource.XA_OK) { xaRes.commit(xid, false); } } catch (XAException e) { e.printStackTrace(); } finally { stmt.close(); con.close(); xaCon.close(); } 当然，实际过程中，我们不需要写这些代码，这些代码是JTA最终的实现代码。 关于“两步提交协议”，可以参看下面的文章： http://www.ibm.com/developerworks/cn/db2/library/techarticles/dm-0505weber/index.html两阶段提交（Two-Phase-Commit）协议 首先，两阶段提交（Two-Phase-Commit）事务的启动与常规的单阶段提交（One-Phase-Commit）事务类似。接着，应用程序/客 户机对该两阶段提交（Two-Phase-Commit）操作中所涉及的所有数据库执行其修改工作。现在，在最终提交该事务之前，客户机通知参与的数据库准备提交（第 1 阶段）。如果客户机从数据库收到一条“okay”，就发出命令向数据库提交该事务（第 2 阶段）。最后分布式事务（Distributed Transaction）结束。 上面的例子演示了如何在 Java 中使用 JTA 实现两阶段提交（Two-Phase-Commit）协议。在该应用程序中，如果一个事务分支报告了错误，您就要负责进行错误处理。但是“两阶段提交协议 简介”小节中提到仍然存在一个问题，那就是如果第 2 阶段中一个事务分支发生故障，该怎么办呢？ 如果再次查看程序代码，您可以看到在“第 1 阶段”和“第 2 阶段”之间有一个很小的时间间隔。在这一时间间隔中，出于某种理由，其中某一参与数据库可能崩溃。如果发生了，我们将陷入分布式事务已经部分提交的情形中。 假 定下列情形：在“第 1 阶段”之后，您从 DB2 和 IDS 数据库中都收到了“okay”。在下一步中，应用程序成功提交了 DB2 的事务分支。接着，应用程序通知 DB2 事务分支提交事务。现在，在应用程序可以通知 IDS 事务分支提交它这一部分之前，IDS 引擎由于断电发生崩溃。这就是一种部分提交全局事务的情形。您现在该怎么办呢？ 在重启之后，DB2 和 IDS 都将尝试恢复打开的事务分支。该引擎等待来自应用程序的提示如何做。如果应用程序没有准备重新发送“第 2 阶段”的提交，该事务分支将被引擎所启动的试探性回滚中止。这是非常糟糕的，因为这将使该全局事务处于不一致状态。 一种解决方案是用一个小型应用程序连接引擎中打开的事务分支，并通知引擎提交或回滚这一打开的事务。如果您使用 IDS 作为后端，那么还有一个隐藏的 onmode 标志，允许您结束打开的事务分支。（onmode -Z xid）。 在 DB2 UDB 中，您可以发出 LIST INDOUBT TRANSACTIONS 来获得打开的 XA 事务的有关信息。您必须查看 DB2 Information Center 中的描述来解决该问题。 上面描述的情形是一个很好的例子，也是使用应用程序服务器（Application Server）或事务监控器（Transaction Monitor）的理由。在使用一个中间层服务器时，就由该服务器负责保持事情正常。

在说他们之间的区别之前，先考虑如下几个问题： 1、getCurrentSession()与openSession()的区别？ * 采用getCurrentSession()创建的session会绑定到当前线程中，而采用openSession() 创建的session则不会 * 采用getCurrentSession()创建的session在commit或rollback时会自动关闭，而采用openSession() 创建的session必须手动关闭 2、使用getCurrentSession()需要在hibernate.cfg.xml文件中加入如下配置： * 如果使用的是本地事务（jdbc事务） <property name="hibernate.current_session_context_class">thread</property> * 如果使用的是全局事务（jta事务） <property name="hibernate.current_session_context_class">jta</property> 以上是hibernate中一些使用，下面来说说jdbc与jta的区别： JDBC 事务 JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式：自动提交和手工提交。 #在jdbc中，事务操作缺省是自动提交。也就是说，一条对数据库的更新表达式代表一项事务操作，操作成功后，系统将自动调用commit()来提交，否则将调用rollback()来回滚。 # 在jdbc中，可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成后调 用commit()来进行整体提交，倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常；此时就可以在异常捕获时调用 rollback()进行回滚。这样做可以保持多次更新操作后，相关数据的一致性，示例如下： try { conn = DriverManager.getConnection ("jdbc:oracle:thin:@host:1521:SID","username","userpwd"; conn.setAutoCommit(false);//禁止自动提交，设置回滚点 stmt = conn.createStatement(); stmt.executeUpdate(“alter table …”); //数据库更新操作1 stmt.executeUpdate(“insert into table …”); //数据库更新操作2 conn.commit(); //事务提交 }catch(Exception ex) { ex.printStackTrace(); try { conn.rollback(); //操作不成功则回滚 }catch(Exception e) { e.printStackTrace(); } } JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。 JTA事务 JTA(Java Transaction API) 为 J2EE 平台提供了分布式事务服务。 要用 JTA 进行事务界定，应用程序要调用 javax.transaction.UserTransaction 接口中的方法。例如： utx.begin(); // ... DataSource ds = obtainXADataSource(); Connection conn = ds.getConnection(); pstmt = conn.prepareStatement("UPDATE MOVIES ..."); pstmt.setString(1, "Spinal Tap"); pstmt.executeUpdate(); // ... utx.commit(); 让我们来关注下面的话： “用 JTA 界定事务，那么就需要有一个实现 javax.sql.XADataSource 、 javax.sql.XAConnection 和 javax.sql.XAResource 接口的 JDBC 驱动程序。一个实现了这些接口的驱动程序将可以参与 JTA 事务。一个 XADataSource 对象就是一个 XAConnection 对象的工厂。 XAConnection s 是参与 JTA 事务的 JDBC 连接。” 要使用JTA事务，必须使用XADataSource来产生数据库连接，产生的连接为一个XA连接。 XA连接（javax.sql.XAConnection）和非XA（java.sql.Connection）连接的区别在于：XA可以参与JTA的事务，而且不支持自动提交。 注意: Oracle, Sybase, DB2, SQL Server等大型数据库才支持XA, 支持分布事务。 My SQL 连本地都支持不好，更别说分布事务了。 JTA方式的实现过程： 用XADataSource产生的XAConnection它扩展了一个getXAResource()方法,事务通过这个方法把它加入到事务容器中进行 管理.对于调用者来说,根本看不到事务是如果管理的,你只要声明开始事务,告诉容器我下面的操作要求事务参与了,最后告诉事务说到这儿可以提交或回滚了, 别的都是黑箱操作。 在使用JTA之前，你必须首先实现一个Xid类用来标识事务（在普通情况下这将由事务管理程序来处理）。Xid包含三个元素：formatID、gtrid（全局事务标识符）和bqual（分支修饰词标识符）。 下面的例子说明Xid的实现： import javax.transaction.xa.*; public class MyXid implements Xid { protected int formatId; protected byte gtrid[]; protected byte bqual[]; public MyXid() { } public MyXid(int formatId, byte gtrid[], byte bqual[]) { this.formatId = formatId; this.gtrid = gtrid; this.bqual = bqual; } public int getFormatId() { return formatId; } public byte[] getBranchQualifier() { return bqual; } public byte[] getGlobalTransactionId() { return gtrid; } } 其次，你需要创建一个你要使用的数据库的数据源： public DataSource getDataSource() throws SQLException { SQLServerDataSource xaDS = new com.merant.datadirect.jdbcx.sqlserver.SQLServerDataSource(); xaDS.setDataSourceName("SQLServer"); xaDS.setServerName("server"); xaDS.setPortNumber(1433); xaDS.setSelectMethod("cursor"); return xaDS; } 例1 这个例子是用“两步提交协议”来提交一个事务分支： XADataSource xaDS; XAConnection xaCon; XAResource xaRes; Xid xid; Connection con; Statement stmt; int ret; xaDS = getDataSource(); xaCon = xaDS.getXAConnection("jdbc_user", "jdbc_password"); xaRes = xaCon.getXAResource(); con = xaCon.getConnection(); stmt = con.createStatement(); xid = new MyXid(100, new byte[]{0x01}, new byte[]{0x02}); try { xaRes.start(xid, XAResource.TMNOFLAGS); stmt.executeUpdate("insert into test_table values (100)"); xaRes.end(xid, XAResource.TMSUCCESS); ret = xaRes.prepare(xid); if (ret == XAResource.XA_OK) { xaRes.commit(xid, false); } } catch (XAException e) { e.printStackTrace(); } finally { stmt.close(); con.close(); xaCon.close(); } 当然，实际过程中，我们不需要写这些代码，这些代码是JTA最终的实现代码。 关于“两步提交协议”，可以参看下面的文章： http://www.ibm.com/developerworks/cn/db2/library/techarticles/dm-0505weber/index.html两阶段提交（Two-Phase-Commit）协议 首先，两阶段提交（Two-Phase-Commit）事务的启动与常规的单阶段提交（One-Phase-Commit）事务类似。接着，应用程序/客 户机对该两阶段提交（Two-Phase-Commit）操作中所涉及的所有数据库执行其修改工作。现在，在最终提交该事务之前，客户机通知参与的数据库准备提交（第 1 阶段）。如果客户机从数据库收到一条“okay”，就发出命令向数据库提交该事务（第 2 阶段）。最后分布式事务（Distributed Transaction）结束。 上面的例子演示了如何在 Java 中使用 JTA 实现两阶段提交（Two-Phase-Commit）协议。在该应用程序中，如果一个事务分支报告了错误，您就要负责进行错误处理。但是“两阶段提交协议 简介”小节中提到仍然存在一个问题，那就是如果第 2 阶段中一个事务分支发生故障，该怎么办呢？ 如果再次查看程序代码，您可以看到在“第 1 阶段”和“第 2 阶段”之间有一个很小的时间间隔。在这一时间间隔中，出于某种理由，其中某一参与数据库可能崩溃。如果发生了，我们将陷入分布式事务已经部分提交的情形中。 假 定下列情形：在“第 1 阶段”之后，您从 DB2 和 IDS 数据库中都收到了“okay”。在下一步中，应用程序成功提交了 DB2 的事务分支。接着，应用程序通知 DB2 事务分支提交事务。现在，在应用程序可以通知 IDS 事务分支提交它这一部分之前，IDS 引擎由于断电发生崩溃。这就是一种部分提交全局事务的情形。您现在该怎么办呢？ 在重启之后，DB2 和 IDS 都将尝试恢复打开的事务分支。该引擎等待来自应用程序的提示如何做。如果应用程序没有准备重新发送“第 2 阶段”的提交，该事务分支将被引擎所启动的试探性回滚中止。这是非常糟糕的，因为这将使该全局事务处于不一致状态。 一种解决方案是用一个小型应用程序连接引擎中打开的事务分支，并通知引擎提交或回滚这一打开的事务。如果您使用 IDS 作为后端，那么还有一个隐藏的 onmode 标志，允许您结束打开的事务分支。（onmode -Z xid）。 在 DB2 UDB 中，您可以发出 LIST INDOUBT TRANSACTIONS 来获得打开的 XA 事务的有关信息。您必须查看 DB2 Information Center 中的描述来解决该问题。 上面描述的情形是一个很好的例子，也是使用应用程序服务器（Application Server）或事务监控器（Transaction Monitor）的理由。在使用一个中间层服务器时，就由该服务器负责保持事情正常。

我看你的格式错误的应该只有三条打印语句中的第一句出错。原因在格式输出中%是一个特殊符号用来转义的。%）这是一个错误的转义。你把9.0后面的"%"去掉就不会出错了。格式字符串语法 产生格式化输出的每个方法都需要格式字符串 和参数列表。格式字符串是一个 String，它可以包含固定文本以及一个或多个嵌入的格式说明符。请考虑以下示例： Calendar c = ...; String s = String.format("Duke"s Birthday: %1$tm %1$te,%1$tY", c); 此格式字符串是 format 方法的第一个参数。它包含三个格式说明符 "%1$tm"、"%1$te" 和 "%1$tY"，它们指出应该如何处理参数以及在文本的什么地方插入它们。格式字符串的其余部分是包括 "Dukes Birthday: " 和其他任何空格或标点符号的固定文本。 参数列表由传递给位于格式字符串之后的方法的所有参数组成。在上述示例中，参数列表的大小为 1，由对象 Calendarc 组成。 常规类型、字符类型和数值类型的格式说明符的语法如下： %[argument_index$][flags][width][.precision]conversion 可选的 argument_index 是一个十进制整数，用于表明参数在参数列表中的位置。第一个参数由 "1$" 引用，第二个参数由 "2$" 引用，依此类推。 可选 flags 是修改输出格式的字符集。有效标志集取决于转换类型。 可选 width 是一个非负十进制整数，表明要向输出中写入的最少字符数。 可选 precision 是一个非负十进制整数，通常用来限制字符数。特定行为取决于转换类型。 所需 conversion 是一个表明应该如何格式化参数的字符。给定参数的有效转换集取决于参数的数据类型。 用来表示日期和时间类型的格式说明符的语法如下： %[argument_index$][flags][width]conversion 可选的 argument_index、flags 和 width 的定义同上。 所需的 conversion 是一个由两字符组成的序列。第一个字符是 "t" 或 "T"。第二个字符表明所使用的格式。这些字符类似于但不完全等同于那些由 GNU date 和 POSIX strftime(3c) 定义的字符。 与参数不对应的格式说明符的语法如下： %[flags][width]conversion 可选 flags 和 width 的定义同上。 所需的 conversion 是一个表明要在输出中所插内容的字符。 转换 转换可分为以下几类： 常规 - 可应用于任何参数类型 字符 - 可应用于表示 Unicode 字符的基本类型：char、Character、byte、Byte、short 和 Short。当 Character.isValidCodePoint(int) 返回 true 时，可将此转换应用于 int 和 Integer 类型 数值整数 - 可应用于 Java 的整数类型：byte、Byte、short、Short、int、Integer、long、Long 和 BigInteger浮点 - 可用于 Java 的浮点类型：float、Float、double、Double 和 BigDecimal日期/时间 - 可应用于 Java 的、能够对日期或时间进行编码的类型：long、Long、Calendar 和 Date。 百分比 - 产生字面值 "%" ("u0025") 行分隔符 - 产生特定于平台的行分隔符 下表总结了受支持的转换。由大写字符（如 "B"、"H"、"S"、"C"、"X"、"E"、"G"、"A" 和 "T"）表示的转换与由相应的小写字符的转换等同，根据流行的 Locale 规则将结果转换为大写形式除外。后者等同于 String.toUpperCase() 的以下调用 out.toUpperCase() 转换 参数类别 说明 "b", "B"常规 如果参数 arg 为 null，则结果为 "false"。如果 arg 是一个 boolean 值或 Boolean，则结果为 String.valueOf() 返回的字符串。否则结果为 "true"。 "h", "H"常规 如果参数 arg 为 null，则结果为 "null"。否则，结果为调用 Integer.toHexString(arg.hashCode()) 得到的结果。 "s", "S"常规 如果参数 arg 为 null，则结果为 "null"。如果 arg 实现 Formattable，则调用 arg.formatTo。否则，结果为调用 arg.toString() 得到的结果。 "c", "C"字符 结果是一个 Unicode 字符 "d"整数 结果被格式化为十进制整数 "o"整数 结果被格式化为八进制整数 "x", "X"整数 结果被格式化为十六进制整数 "e", "E"浮点 结果被格式化为用计算机科学记数法表示的十进制数 "f"浮点 结果被格式化为十进制数 "g", "G"浮点 根据精度和舍入运算后的值，使用计算机科学记数形式或十进制格式对结果进行格式化。 "a", "A"浮点 结果被格式化为带有效位数和指数的十六进制浮点数 "t", "T"日期/时间 日期和时间转换字符的前缀。请参阅日期/时间转换。 "%"百分比 结果为字面值 "%" ("u0025") "n"行分隔符 结果为特定于平台的行分隔符 任何未明确定义为转换的字符都是非法字符，并且都被保留，以供将来扩展使用。

Can"t call invalidate() when session is no longer valid.

用session的removeAttribute("uiUsers");方法试试嘿嘿，不好用的话跟我说声，我再给你看看

不想看代码。说说基本原理吧。很简单。创建一个Image对象，不过要创建的是mutable image，简单说就是用类似createImage(int width,int height)这种方式创建的Image，这种Image可以随时更改Image画面，而我们通常用createImage(String name)这种方式创建的IMage画面是不可以改变的。明白了这一点，其他的迎刃而解。只需要创建一个mutableImage，然后把所有需要画的东西都画到这个Image上，然后再次将这个Image输出到屏幕上。paint(Graphics g){ //建立一个缓冲的图，也就是一个mutable image，100X100大小 Image offscreen = Image.CreateImage(100,100); //取得在这个图上绘画所使用的Graphics实例gg Graphics gg = offscreen.getGraphics(); //下面用gg往那个offscreen上，也就是mutable image上绘画 gg.drawString("test", 0, 0, Graphics.TOP|Graphics.LEFT); gg.drawImage(.....); .... //上面绘画结束，缓冲图满足要求，将这个缓冲图形一次性绘制到实际屏幕上 g.drawImage(offscreen, 0, 0, Graphics.TOP|Graphics.LEFT);}这样，ok了。实际上很多手机canvas都提供了双缓冲功能，至于j2se上，很少摸了。有空到我博客看看，里面可能有你想要的知识。

行排序直接输出结果10 分钟前StarのLight | 分类：JAVA相关 | 浏览9次

序列号主要用于将内存中的数据序列化用，就是一个ID。

实现java.io.Serializable这个接口是为序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性。如果你修改了此类, 要修改此值。否则以前用老版本的类序列化的类恢复时会出错。实现后如果你用的是工具的话会出来警告,他会提示你,可以自动生成private static final long serialVersionUID = 1L; 为了在反序列化时，确保类版本的兼容性，最好在每个要序列化的类中加入private static final long serialVersionUID这个属性，具体数值自己定义.　　 在JDK中，可以利用JDK的bin目录下的serialver.exe工具产生这个serialVersionUID，如对于Test.class可执行如下命令：serialver Test。 这样，即使某个类在与之对应的对象已经序列化出去后做了修改，该对象依然可以被正确反序列化。否则，如果不显式定义该属性，这个属性值将由JVM根据类的相关信息计算，而修改后的类的计算结果与修改前的类的计算结果往往不同,从而造成对象的反序列化因为类版本不兼容而失败。 不显式定义这个属性值的另一个坏处是，不利于程序在不同的JVM之间的移植。因为不同的编译器实现该属性值的计算策略可能不同，从而造成虽然类没有改变，但是因为JVM不同，出现因类版本不兼容而无法正确反序列化的现象出现。 当我们的系统不太经常需要序列化类时，可以去掉这些警告，做如下设置：Window-->Preferences-->Java，将serializable class without serialVersionUID的设置由warning改为Ignore。然后Eclipse会重新编译程序，那些警告信息也就消失了。最后的建议是，如果我们开发大量需要序列化的类的时候，我们最好还是还原为原来的设置。这样可以保证系统的性能和健壮。关于serialVersionUID的解释 serialVersionUID作用： 序列化时为了保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。 你可以随便写一个，在Eclipse中它替你生成一个，有两种生成方式：一个是默认的1L，比如：private static final long serialVersionUID = 1L;一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：private static final long serialVersionUID = -8940196742313994740L;之类的。 Eclipse提示The serializable class XXX does not declare a static final serialVersionUID field of type long 那是Eclipse提供这个提示功能给你吧.你点它warning的icon两下Eclipse就会自动给定.如果你不喜欢,可以把它关掉,windows -> preferences -> compiler -> Error/Warnings-> Potential Programming problems将Serializable class without serialVersionUID的warning改成ignore.其实如果你没有考虑到兼容性问题时,那就把它关掉吧.其实有这个功能是好的.只要任何类别实作了Serializable这个介面,如果没有加入serialVersionUID,Eclipse都会给你warning提示,这个serialVersionUID为了让该类别Serializable後兼容.考虑一下,如果今天你的类Serialized存到硬碟里,可是後来你却更改了类别的field(增加或减少或改名).当你Deserialize时,就会出现Exception.这样就会做成不兼容性的问题.但当serialVersionUID相同时,它就会将不一样的field以type的预设值Deserialize.这个可以避开不兼容性的问题.异常状态：The serializable class XXX does not declare a static final serialVersionUID field of type long

序列化。。。

出于很多原因我们想使用自定义的序列化方法取代Java默认的机制。一个最常见的原因是提高性能，而另一个原因是有时候我们无法使用默认的序列化方法。在这篇文章中，我们具体来讨论怎样通过定制的序列化方法，对一个较大的、带有不可序列化属性的对象进行序列化。下面这段代码定义了一个简单的类。它可以把一个给定的对象序列化到一个指定的文件，或者从相同的文件中把对象反序列化出来。112345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485 package dustin.examples.serialization; import static java.lang.System.out; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; /** * Simple serialization/deserialization demonstrator. * * @author Dustin */ public class SerializationDemonstrator { /** * Serialize the provided object to the file of the provided name. * @param objectToSerialize Object that is to be serialized to file; it is * best that this object have an individually overridden toString() * implementation as that is used by this method for writing our status. * @param fileName Name of file to which object is to be serialized. * @throws IllegalArgumentException Thrown if either provided parameter is null. */ public static <T> void serialize(final T objectToSerialize, final String fileName) { if (fileName == null) { throw new IllegalArgumentException( "Name of file to which to serialize object to cannot be null."); } if (objectToSerialize == null) { throw new IllegalArgumentException("Object to be serialized cannot be null."); } try (FileOutputStream fos = new FileOutputStream(fileName); ObjectOutputStream oos = new ObjectOutputStream(fos)) { oos.writeObject(objectToSerialize); out.println("Serialization of Object " + objectToSerialize + " completed."); } catch (IOException ioException) { ioException.printStackTrace(); } } /** * Provides an object deserialized from the file indicated by the provided * file name. * * @param <T> Type of object to be deserialized. * @param fileToDeserialize Name of file from which object is to be deserialized. * @param classBeingDeserialized Class definition of object to be deserialized * from the file of the provided name/path; it is recommended that this * class define its own toString() implementation as that will be used in * this method"s status output. * @return Object deserialized from provided filename as an instance of the * provided class; may be null if something goes wrong with deserialization. * @throws IllegalArgumentException Thrown if either provided parameter is null. */ public static <T> T deserialize(final String fileToDeserialize, final Class<T> classBeingDeserialized) { if (fileToDeserialize == null) { throw new IllegalArgumentException("Cannot deserialize from a null filename."); } if (classBeingDeserialized == null) { throw new IllegalArgumentException("Type of class to be deserialized cannot be null."); } T objectOut = null; try (FileInputStream fis = new FileInputStream(fileToDeserialize); ObjectInputStream ois = new ObjectInputStream(fis)) { objectOut = (T) ois.readObject(); out.println("Deserialization of Object " + objectOut + " is completed."); } catch (IOException | ClassNotFoundException exception) { exception.printStackTrace(); } return objectOut; } }

public class Test { public static void main(String[] args) { int sum = 0; int num = 0; while(++num <= 200) { int remainder = num % 10; if (remainder != 3 && remainder != 5 && remainder != 6 && remainder != 7 && remainder != 9) { sum += num; } } System.out.println("sumuff1a " + sum); }}

double weightx和double weighty参数(默认值为0)这是两个非常重要的参数，该参数直接影响到怎样设置网格单元的大小，因此常握好该参数就可以对网格包布局应用自如。该参数对x方向和y方向指定一个加权值。这个加权值直接影响到网格单元的大小，比如weightx的值分别为10，20，30，则在容器的x方向也就是列的方向，按一定的比例(比如1:2:3其具体算法请参看java文件)分配三个网格单元，其中加权值越大网格单元就越大，可以看出值的大小是没有关系的，加权值的作用是让容器以设定的值的比例在横向和纵向分配网格，且在容器的大小改变时这个比例不改变。如果weightx只设置了一个值，而组件却不只一个以上，则被设置了的这个组件的网格单元的大小为容器在x方向的大小减去那两个组件的最小尺寸就是该组件的网格单元大小。默认情况下组件的最小尺寸是比较小的。如果两个参数都为0(默认值)，则组件会被显示在容器的中央，不管容器是放大还是缩小组件都只会显示在容器的中央。由上所述，在使用网格包布局时首先应先使用weightx和weighty来划分网格单元(不是直接划分,而是按一定比例来划分)，网格单元划分出来后，组件放置在网格单元中的位置和大小就由后面介绍的约束来决定。一定要注意的是设置权值后要使当前的设置生效应使用setConstraints()函数一次，如果连续设置多个同一方向的权值，则只有最后一次设置的权值有效，比如出现同时两行都设置了x方向的权值，则以最后一行设置的x方向的权值为标准来划分网格单元。因此在使用GridBagLayout网格包布局管理器之前应先设置好网格单元，即要把容器划分为几行几列的网格单元，每行每列在容器中的宽度和高度比例，每个组件应在哪个网格单元。int fill参数(默认值为GridBagConstraints.NONE)fill参数指定组件填充网格的方式，当某组件的网格单元大于组件的大小时被使用，一般情况下组件是以最小的方式被显示的，如果不使用fill参数，则有可能组件占不完整个网格单元，也就是说组件占据的空间比划分的网格单元小，这时组件将显示在网格单元中的某个位置(具体在什么位置由网格包中的参数来设置)。其可取的值如下：GridBagConstraints.NONE默认值，不改变组件的大小。GridBagConstraints.HORIZONTAL使组件足够大，以填充其网格单元的水平方向，但不改变高度，其值等于整数2。GridBagConstraints.VERTICAL使组件足够大，以填充其网格单元的垂直方向，但不改变宽度，其值等于整数3。GridBagConstraints.BOTH使组件足够大，以填充其整个网格单元，其值等于整数1。int gridwidth和int gridheight参数(默认值为1)该参数指定组件占据多少个网格单元，gridwidth指定组件占据多少个网格单元的宽度，gridheight指定组件占据多少个网格单元的高度。两个参数的默认值都为1。其中值GridBagConstraints.REMAINDER表示当前组件在其行或列上为最后一个组件，也就是说如果是行上的最后一个组件的话，那么下一个组件将会被添加到容器中的下一行，如果在行上不指定该值(同时也不指定gridx和gridy参数)，那么无论添加多少个组件都是在同一行上，同样如果在列上不指定该值(同时也不指定gridx和gridy参数)则无论添加多少行组件，都无法把容器填满。值GridBagConstraints.RELATIVE表示当前组件在其行或列上为倒数第二个组件。示例：import java.awt.*;public class Program{public static void main(String[] args){ Frame ff = new Frame();GridBagLayout gr = new GridBagLayout();GridBagConstraints gc = new GridBagConstraints(); //创建一个名为gc的约束对象ff.setLayout(gr); //将容器ff的布局设为GridBagLayout//创建一组按钮组件Button bb1 = new Button(bb1); Button bb2 = new Button(bb2); Button bb3 = new Button(bb3);Button bb4 = new Button(bb4); Button bb5 = new Button(bb5); Button bb6 = new Button(bb6);Button bb7 = new Button(bb7); Button bb8 = new Button(bb8);gc.fill = GridBagConstraints.BOTH;//设置约束的fill参数,该参数表示当组件的大小小于网格单元的大小时在水平和垂直方向都填充，gc.weightx =11; //设置x方向的加权值为11。gc.weighty = 11;//设置y方向的加权值为11。gr.setConstraints(bb1, gc); //将以上gc所设置的约束应用到按钮组件bb1gc.weightx = 22;//设置x方向的加权值为22，如果不设置weightx则以下的组件都将自动应用上面所设置的weightx值11。gr.setConstraints(bb2, gc); //将以上所设置的约束应用到按钮组件bb2。//gc.weighty=111; //注意如果不注释掉该行，则以后使用gc约束的按钮组件在y方向的加权值将为111，而在前面设置的y方向的加权值11将失去作用。gc.weightx =33;gc.gridwidth = GridBagConstraints.REMAINDER;//设置gridwidth参数的值为REMAINDER这样在后面使用该约束的组件将是该行的最后一个组件。gr.setConstraints(bb3, gc); //第一行添加了三个按钮组件bb1,bb2,bb3，且这3个按钮的宽度按weightx设置的值11,22,33按比例设置宽度GridBagConstraints gc1 = new GridBagConstraints();//创建第二个约束gc1gc1.fill = GridBagConstraints.BOTH;gc1.weighty = 22; //将第2行的y方向加权值设为22gr.setConstraints(bb4, gc1);gr.setConstraints(bb5, gc1);gc1.gridwidth = GridBagConstraints.REMAINDER;gr.setConstraints(bb6, gc1); //第二行添加了三个按钮组件bb4,bb5,bb6gc1.weighty =33;gc1.gridwidth = GridBagConstraints.REMAINDER;gr.setConstraints(bb7, gc1);//第三行添加了一个按钮组件bb7gc1.weighty=0;gr.setConstraints(bb8, gc1); //第四行添加了一个按钮组件bb8，bb8并没有添加到bb7的后面，因为bb8使用了bb7前面的gridwidth参数设置的值，所以bb8也是单独的一行。ff.setSize(500, 300);ff.add(bb1); ff.add(bb2);ff.add(bb3); ff.add(bb4); ff.add(bb5); ff.add(bb6); ff.add(bb7); ff.add(bb8);ff.setVisible(true);} }运行结果见下图int gridx和int gridy参数(默认值为GridBagConstraints.RELATIVE)该参数表示组件被添加到容器中的X或者Y坐标处，坐标以网格单元为单位，也就是说不管网格单元有多大，一个网格单元就是1X1的大小，也就是说如果把gridx和gridy都设为1，那么该组件会被显示到第二行的行二列上。其中值GridBagConstraints.RELATIVE(默认值)表示当前组件紧跟在上一个组件的后面。int ipadx和int ipady参数(默认值为0)ipadx和ipady也被称为内部填充，该参数用以设置组件的最小尺寸，如果参数值为正值则组件的最小尺寸将比原始最小尺寸大，如果为负值，则组件的最小尺寸将会变得比原始的最小尺寸小。该参数也可以理解为直接为组件指定大小，这个设置的大小就是组件的最小尺寸。其设置后组件的大小为组件的原始最小尺寸加上ipadx*2个像素。int anchor参数(默认值为GridBagConstraints.CENTER)该参数指定当组件的大小小于网格单元时，组件在网格单元中的位置。一般情况下，在设置了weightx或者weighty的加权值时，如果不使用fill参数填充空白区域，则组件的大小将小于网格单元的大小，这时使用anchor参数就能看到其中的效果了。anchor参数可取的值有：GridBagConstraints.CENTER；GridBagConstraints.NORTH；GridBagConstraints.NORTHEAST；GridBagConstraints.EAST；GridBagConstraints.SOUTHEAST；GridBagConstraints.SOUTH；GridBagConstraints.SOUTHWEST；GridBagConstraints.WEST；GridBagConstraints.NORTHWEST；即居中，北，东北，东，东南，南，西南，西，西北方向。Insets insets参数(默认值为0)insets参数也被称为外部填充，该参数指定组件与网格单元之间的最小空白区域大小，要注意的是即使使用了fill参数填充横向和纵向但只要设置了insets参数，同样会留出insets所设置的空白区域，在insets设置的空白区域不会被填充。在使用该参数时需要设置对象的top，left，right，bottom四个方向的值来调整组件与网格单元之间的空白区域大小，比如gc.insets=new Insets(10,10,10,10);其中gc是GridBagConstraints类型的约束对象，这里要注意后面的new Insets其中的Insets第一个字母是大写的。当然也可以为insets指定负值，以扩大其网格单元。示例：import java.awt.*;public class Program{public static void main(String[] args){//将容器ff的布局设为GridBagLayoutFrame ff = new Frame();GridBagLayout gr = new GridBagLayout();GridBagConstraints gc = new GridBagConstraints(); //创建一个名为gc的约束对象ff.setLayout(gr);//创建一组按钮组件Button bb1 = new Button(bb1); Button bb2 = new Button(bb2); Button bb3 = new Button(bb3);Button bb4 = new Button(bb4); Button bb5 = new Button(bb5); Button bb6 = new Button(bb6);Button bb7 = new Button(bb7); Button bb8 = new Button(bb8);gc.fill = GridBagConstraints.BOTH;gc.weightx = 11; gc.weighty = 11;gr.setConstraints(bb1, gc);gc.weightx = 22;gc.gridx = 1; gc.gridy = 1; //将下一个组件放置在坐标为1,1的位置。gr.setConstraints(bb2, gc);gc.weightx = 33;gc.gridx = 2; gc.gridy = 1; //将下一个组件放置在坐标为2,1的位置。gc.insets = new Insets(-10, -10, -10, -10); //将下一个组件与网格单元的空白区域向外扩展10个像素,在这里可以看到网格包布局允许组件之间重叠。gc.gridwidth = GridBagConstraints.REMAINDER;gr.setConstraints(bb3, gc);GridBagConstraints gc1 = new GridBagConstraints();gc1.weighty = 22;gc1.ipadx = 50; gc1.ipady = 50; //将组件的最小尺寸加大ipadx*2个像素。gr.setConstraints(bb4, gc1);gc1.ipadx = 0;gc1.ipady = 0; //将以后的组件的最小尺寸设置为默认值,如果省掉该行,则以后组件的最小尺寸都会加大ipadx*2个像素。gc1.anchor = GridBagConstraints.NORTHWEST; //将下一个组件bb5的位置放置在单元网格的西北方向。gr.setConstraints(bb5, gc1); //因为bb5未设置fill,同时bb5设置了weightx(由gc参数设置)和weighty两个值以确定bb5所在的网格单元的大小，因而组件bb5的原始最小尺寸无法占据整个网格单元。gc1.fill = GridBagConstraints.BOTH;gc1.gridwidth = GridBagConstraints.REMAINDER;gr.setConstraints(bb6, gc1);gc1.weighty = 33;gc1.insets = new Insets(5, 15,40,150); //使下一个组件bb7与网格单元之间在上，左，下，右，分别保持5,15,40,150个像素的空白位置。gr.setConstraints(bb7, gc1);gc1.weighty = 0;gc1.insets = new Insets(0, 0, 0, 0); //将insets的参数值设为默认值。gr.setConstraints(bb8, gc1);ff.setSize(500, 300);ff.add(bb1); ff.add(bb2); ff.add(bb3); ff.add(bb4); ff.add(bb5); ff.add(bb6); ff.add(bb7); ff.add(bb8);ff.setVisible(true);}}

RSA算法非常简单，概述如下：找两素数p和q取n=p*q取t=(p-1)*(q-1)取任何一个数e,要求满足e<t并且e与t互素（就是最大公因数为1）取d*e%t==1这样最终得到三个数： n d e设消息为数M (M <n)设c=(M**d)%n就得到了加密后的消息c设m=(c**e)%n则 m == M，从而完成对c的解密。注：**表示次方,上面两式中的d和e可以互换。在对称加密中：n d两个数构成公钥，可以告诉别人；n e两个数构成私钥，e自己保留，不让任何人知道。给别人发送的信息使用e加密，只要别人能用d解开就证明信息是由你发送的，构成了签名机制。别人给你发送信息时使用d加密，这样只有拥有e的你能够对其解密。rsa的安全性在于对于一个大数n，没有有效的方法能够将其分解从而在已知n d的情况下无法获得e；同样在已知n e的情况下无法求得d。<二>实践接下来我们来一个实践，看看实际的操作：找两个素数：p=47q=59这样n=p*q=2773t=(p-1)*(q-1)=2668取e=63，满足e<t并且e和t互素用perl简单穷举可以获得满主 e*d%t ==1的数d：C:Temp>perl -e "foreach $i (1..9999){ print($i),last if $i*63%2668==1 }"847即d＝847最终我们获得关键的n=2773d=847e=63取消息M=244我们看看加密：c=M**d%n = 244**847%2773用perl的大数计算来算一下：C:Temp>perl -Mbigint -e "print 244**847%2773"465即用d对M加密后获得加密信息c＝465解密：我们可以用e来对加密后的c进行解密，还原M：m=c**e%n=465**63%2773 ：C:Temp>perl -Mbigint -e "print 465**63%2773"244即用e对c解密后获得m=244 , 该值和原始信息M相等。<三>字符串加密把上面的过程集成一下我们就能实现一个对字符串加密解密的示例了。每次取字符串中的一个字符的ascii值作为M进行计算，其输出为加密后16进制的数的字符串形式，按3字节表示，如01F代码如下：#!/usr/bin/perl -w#RSA 计算过程学习程序编写的测试程序#watercloud 2003-8-12#use strict;use Math::BigInt;my %RSA_CORE = (n=>2773,e=>63,d=>847); #p=47,q=59my $N=new Math::BigInt($RSA_CORE{n});my $E=new Math::BigInt($RSA_CORE{e});my $D=new Math::BigInt($RSA_CORE{d});print "N=$N D=$D E=$E ";sub RSA_ENCRYPT{my $r_mess = shift @_;my ($c,$i,$M,$C,$cmess);for($i=0;$i < length($$r_mess);$i++){$c=ord(substr($$r_mess,$i,1));$M=Math::BigInt->new($c);$C=$M->copy(); $C->bmodpow($D,$N);$c=sprintf "%03X",$C;$cmess.=$c;}return $cmess;}sub RSA_DECRYPT{my $r_mess = shift @_;my ($c,$i,$M,$C,$dmess);for($i=0;$i < length($$r_mess);$i+=3){$c=substr($$r_mess,$i,3);$c=hex($c);$M=Math::BigInt->new($c);$C=$M->copy(); $C->bmodpow($E,$N);$c=chr($C);$dmess.=$c;}return $dmess;}my $mess="RSA 娃哈哈哈～～～";$mess=$ARGV[0] if @ARGV >= 1;print "原始串：",$mess," ";my $r_cmess = RSA_ENCRYPT($mess);print "加密串：",$$r_cmess," ";my $r_dmess = RSA_DECRYPT($r_cmess);print "解密串：",$$r_dmess," ";#EOF测试一下：C:Temp>perl rsa-test.plN=2773 D=847 E=63原始串：RSA 娃哈哈哈～～～加密串：5CB6CD6BC58A7709470AA74A0AA74A0AA74A6C70A46C70A46C70A4解密串：RSA 娃哈哈哈～～～C:Temp>perl rsa-test.pl 安全焦点（xfocus）N=2773 D=847 E=63原始串：安全焦点（xfocus）加密串：3393EC12F0A466E0AA9510D025D7BA0712DC3379F47D51C325D67B解密串：安全焦点（xfocus）<四>提高前面已经提到，rsa的安全来源于n足够大，我们测试中使用的n是非常小的，根本不能保障安全性，我们可以通过RSAKit、RSATool之类的工具获得足够大的N 及D E。通过工具，我们获得1024位的N及D E来测试一下：n=0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5FCD15F90B66EC3A85F5005DBDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F017F9CCF1538D4C2013433B383B47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD60438941D2ED173CCA50E114705D7E2BC511951d=0x10001e=0xE760A3804ACDE1E8E3D7DC0197F9CEF6282EF552E8CEBBB7434B01CB19A9D87A3106DD28C523C29954C5D86B36E943080E4919CA8CE08718C3B0930867A98F635EB9EA9200B25906D91B80A47B77324E66AFF2C4D70D8B1C69C50A9D8B4B7A3C9EE05FFF3A16AFC023731D80634763DA1DCABE9861A4789BD782A592D2B1965设原始信息M=0x11111111111122222222222233333333333完成这么大数字的计算依赖于大数运算库，用perl来运算非常简单：A) 用d对M进行加密如下：c=M**d%n :C:Temp>perl -Mbigint -e " $x=Math::BigInt->bmodpow(0x11111111111122222222222233333333333, 0x10001, 0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5FCD15F90B66EC3A85F5005DBDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F017F9CCF1538D4C2013433B383B47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD60438941D2ED173CCA50E114705D7E2BC511951);print $x->as_hex"0x17b287be418c69ecd7c39227ab681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd45692b007f3a2f7c5f5aa1d99ef3866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b3028f9461a3b1533ec0cb476441465f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91f1834580c3f6d90898即用d对M加密后信息为：c=0x17b287be418c69ecd7c39227ab681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd45692b007f3a2f7c5f5aa1d99ef3866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b3028f9461a3b1533ec0cb476441465f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91f1834580c3f6d90898B) 用e对c进行解密如下：m=c**e%n ：C:Temp>perl -Mbigint -e " $x=Math::BigInt->bmodpow(0x17b287be418c69ecd7c39227ab681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd45692b007f3a2f7c5f5aa1d99ef3866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b3028f9461a3b1533ec0cb476441465f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91f1834580c3f6d90898, 0xE760A3804ACDE1E8E3D7DC0197F9CEF6282EF552E8CEBBB7434B01CB19A9D87A3106DD28C523C29954C5D86B36E943080E4919CA8CE08718C3B0930867A98F635EB9EA9200B25906D91B80A47B77324E66AFF2C4D70D8B1C69C50A9D8B4B7A3C9EE05FFF3A16AFC023731D80634763DA1DCABE9861A4789BD782A592D2B1965, 0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5FCD15F90B66EC3A85F5005DBDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F017F9CCF1538D4C2013433B383B47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD60438941D2ED173CCA50E114705D7E2BC511951);print $x->as_hex"0x11111111111122222222222233333333333(我的P4 1.6G的机器上计算了约5秒钟）得到用e解密后的m=0x11111111111122222222222233333333333 == MC) RSA通常的实现RSA简洁幽雅，但计算速度比较慢，通常加密中并不是直接使用RSA 来对所有的信息进行加密，最常见的情况是随机产生一个对称加密的密钥，然后使用对称加密算法对信息加密，之后用RSA对刚才的加密密钥进行加密。最后需要说明的是，当前小于1024位的N已经被证明是不安全的自己使用中不要使用小于1024位的RSA，最好使用2048位的。----------------------------------------------------------一个简单的RSA算法实现JAVA源代码：filename:RSA.java/** Created on Mar 3, 2005** TODO To change the template for this generated file go to* Window - Preferences - Java - Code Style - Code Templates*/import java.math.BigInteger;import java.io.InputStream;import java.io.OutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.io.FileWriter;import java.io.FileReader;import java.io.BufferedReader;import java.util.StringTokenizer;/*** @author Steve** TODO To change the template for this generated type comment go to* Window - Preferences - Java - Code Style - Code Templates*/public class RSA {/*** BigInteger.ZERO*/private static final BigInteger ZERO = BigInteger.ZERO;/*** BigInteger.ONE*/private static final BigInteger ONE = BigInteger.ONE;/*** Pseudo BigInteger.TWO*/private static final BigInteger TWO = new BigInteger("2");private BigInteger myKey;private BigInteger myMod;private int blockSize;public RSA (BigInteger key, BigInteger n, int b) {myKey = key;myMod = n;blockSize = b;}public void encodeFile (String filename) {byte[] bytes = new byte[blockSize / 8 + 1];byte[] temp;int tempLen;InputStream is = null;FileWriter writer = null;try {is = new FileInputStream(filename);writer = new FileWriter(filename + ".enc");}catch (FileNotFoundException e1){System.out.println("File not found: " + filename);}catch (IOException e1){System.out.println("File not found: " + filename + ".enc");}/*** Write encoded message to "filename".enc*/try {while ((tempLen = is.read(bytes, 1, blockSize / 8)) > 0) {for (int i = tempLen + 1; i < bytes.length; ++i) {bytes[i] = 0;}writer.write(encodeDecode(new BigInteger(bytes)) + " ");}}catch (IOException e1) {System.out.println("error writing to file");}/*** Close input stream and file writer*/try {is.close();writer.close();}catch (IOException e1) {System.out.println("Error closing file.");}}public void decodeFile (String filename) {FileReader reader = null;OutputStream os = null;try {reader = new FileReader(filename);os = new FileOutputStream(filename.replaceAll(".enc", ".dec"));}catch (FileNotFoundException e1) {if (reader == null)System.out.println("File not found: " + filename);elseSystem.out.println("File not found: " + filename.replaceAll(".enc", "dec"));}BufferedReader br = new BufferedReader(reader);int offset;byte[] temp, toFile;StringTokenizer st = null;try {while (br.ready()) {st = new StringTokenizer(br.readLine());while (st.hasMoreTokens()){toFile = encodeDecode(new BigInteger(st.nextToken())).toByteArray();System.out.println(toFile.length + " x " + (blockSize / 8));if (toFile[0] == 0 && toFile.length != (blockSize / 8)) {temp = new byte[blockSize / 8];offset = temp.length - toFile.length;for (int i = toFile.length - 1; (i <= 0) && ((i + offset) <= 0); --i) {temp[i + offset] = toFile[i];}toFile = temp;}/*if (toFile.length != ((blockSize / 8) + 1)){temp = new byte[(blockSize / 8) + 1];System.out.println(toFile.length + " x " + temp.length);for (int i = 1; i < temp.length; i++) {temp[i] = toFile[i - 1];}toFile = temp;}elseSystem.out.println(toFile.length + " " + ((blockSize / 8) + 1));*/os.write(toFile);}}}catch (IOException e1) {System.out.println("Something went wrong");}/*** close data streams*/try {os.close();reader.close();}catch (IOException e1) {System.out.println("Error closing file.");}}/*** Performs <tt>base</tt>^^<tt>pow</tt> within the modular* domain of <tt>mod</tt>.** @param base the base to be raised* @param pow the power to which the base will be raisded* @param mod the modular domain over which to perform this operation* @return <tt>base</tt>^^<tt>pow</tt> within the modular* domain of <tt>mod</tt>.*/public BigInteger encodeDecode(BigInteger base) {BigInteger a = ONE;BigInteger s = base;BigInteger n = myKey;while (!n.equals(ZERO)) {if(!n.mod(TWO).equals(ZERO))a = a.multiply(s).mod(myMod);s = s.pow(2).mod(myMod);n = n.divide(TWO);}return a;}}在这里提供两个版本的RSA算法JAVA实现的代码下载：1. 来自于 http://www.javafr.com/code.aspx?ID=27020 的RSA算法实现源代码包:http://zeal.newmenbase.net/attachment/JavaFR_RSA_Source.rar2. 来自于 http://www.ferrara.linux.it/Members/lucabariani/RSA/implementazioneRsa/ 的实现:http://zeal.newmenbase.net/attachment/sorgentiJava.tar.gz - 源代码包http://zeal.newmenbase.net/attachment/algoritmoRSA.jar - 编译好的jar包另外关于RSA算法的php实现请参见文章:php下的RSA算法实现关于使用VB实现RSA算法的源代码下载(此程序采用了psc1算法来实现快速的RSA加密):http://zeal.newmenbase.net/attachment/vb_PSC1_RSA.rarRSA加密的JavaScript实现: http://www.ohdave.com/rsa/参考资料：http://www.lenovonet.com/product/showarticle.asp?id=118

java中提供了signal的机制。在sun.misc包下，属于非标准包。重要涉及到两个类：Signal和SignalHandler。其中Signal主要使用了静态方法Signal.handle(Signal, SignalHandler)，而SignalHandler是一个接口。

这可能是由于窗口透明度设置导致的问题。当使用JFrame的setUndecorated()方法将其设置为无边框窗口时，其默认背景就会变成透明色。而在某些情况下，这种透明窗口背景会影响JCEF的渲染效果。解决方案是在窗口中添加一个透明面板来作为最上层的容器，并将JCEF控件添加到该面板中。具体可以参考如下代码示例：import java.awt.BorderLayout;import java.awt.Color;import javax.swing.JComponent;import javax.swing.JFrame;import javax.swing.JPanel;import org.cef.CefApp;import org.cef.CefClient;import org.cef.browser.CefBrowser;import org.cef.browser.CefMessageRouter;import org.cef.handler.CefLifeSpanHandlerAdapter;import org.cef.handler.CefLoadHandlerAdapter;import org.cef.handler.CefRequestContextHandlerAdapter;public class JCEFTransparencyIssue { public static void main(String[] args) { CefApp cefApp = null; try { cefApp = CefApp.getInstance(args); } catch (UnsatisfiedLinkError e) { System.out.println("CefApp missing dependent libraries!"); } JPanel containerPane = new JPanel(); containerPane.setBackground(new Color(0, 0, 0, 0)); // 创建CefBrowser并添加到透明面板中 CefClient client = cefApp.createClient(); CefBrowser browser = client.createBrowser("about:blank", false, false); containerPane.add(browser.getUIComponent(), BorderLayout.CENTER); JFrame frame = new JFrame(); frame.setContentPane(containerPane); // 将透明面板添加为主窗口的容器 frame.setBackground(new Color(0, 0, 0, 0)); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(800, 600); frame.setLocationRelativeTo(null); frame.setUndecorated(true); // 设置无边框 frame.setVisible(true); browser.loadURL("https://www.baidu.com/"); }}在这个示例中，首先创建了一个透明的JPanel作为最上层的容器，并将CefBrowser添加到该透明面板的中心。然后将透明面板设置为窗口的内容面板，在add()和setContentPane()方法中都传入了BorderLayout.CENTER参数，将CefBrowser置于面板的中心位置。希望这能对你有所帮助！

Hi，其实你不是遇到瓶颈，只是你不知道应该学什么罢了，或许你说的，也许是我经历过的，我说一下下面这种现象，如果你觉得我说对了，那么请按照我的方法去学习现象1：工作中的内容得心应手，想学一些新东西，但是呢，这些新东西，工作中又用不到，这岂不是耽误自己宝贵的时间现象2：想跳槽，面试的时候碰壁，因为面试问的东西，自己从来没用过，尤其是让你说原理的时候，更是完全不知道如果你的内心存在上述两种现象，那么我曾经也遇见过，我提供一下我的建议吧，当然每个人的学习方式是不一样的，在此仅供你参考了解数据结构，其目的是为了阅读源码；这里推荐一本书，叫《JAVA数据结构和算法》Robert著的，有中文版，其中主要是数组，链表，HashMap的数据结构开始阅读JAVA集合框架源码，此时，你会深深感激你在1中做的事情阅读设计模式，其目的是为了阅读SpringMVC源码，这里推荐一本书，叫《headfirst设计模式》，你不需要全部读完，只需要认真读完前5章节，目的是为了更深的理解接口，抽象类，继承这些概念，当你读完之后，我保证你对接口，抽象类，继承，有颠覆的认知，绝对不是现在的你可以理解的阅读Spring MVC源代码，请注意，我说的是Spring MVC，而不是Spring，为什么呢，因为Spring核心概念依赖注入和AOP的代码，极度晦涩复杂，你根本无法理解其中有多么难，所以这里我建议你阅读spring mvc源代码，为什么是spring mvc，而不是mubatis，德鲁伊数据源，或者tomcat源代码？？有必要跟你提及一下，spring的代码规范是java业界最为规范，java 文档最齐全的源码，各种设计模式层出不穷从上述1-4，没有一年是达不到的，到了这里，你可以学习一些其他的中间件了，这取决于你所在公司用了什么，比如你们公司用了rabbit MQ，那么你可以了解一下，你们用了kafka，你也可以学习一下，在这里，如果你们公司用了netty，我强烈推荐你要深入了解一下netty从5开始就是你个人和所在环境用的东西了，到了此时，我已经没有什么推荐给你的了，加油吧，1-4我保证你能学到很多东西，20K是没有什么问题了，然后就是架构层次的东西了，说这些还早，我也不想打字了，作为前辈只能说这么多了

最近有好多小伙伴向我咨询：“如何学习JAVA?”，其实这个问题太宽泛了，好像每个人在一开始接触java的时候都会请教这个问题。本人对这个问题有很深的体悟和感慨,一开始想要自学，结果不够自律，后来选择了一家培训机构进行学习。今天，北京IT培训想要在这里分享我的心路历程。一．明确自己学习的原因1.问问自己是抱着什么目的要学习Java，没有目标的学习是效率极低的，并且容易半途而废；2.了解Java可以做什么，Java可以从事的岗位以及软件行业的发展情况；3.自己是否对Java方向感兴趣；二．学习Java基础1.学习准备推荐看视频入门，可以通过某宝以及某鱼购买相关的视频，别挑三拣四，选中一个视频看完再说，对于初学者，无论选哪一个都是值得你学习的。有人说编辑器等IDE环境不适合看视频，浪费时间，但是初学者在学习第一个编程IDE时，推荐看视频或者通过搜索引擎了解工具的使用，看书其实在刚开始可能更浪费时间；看完基础视频对知识有个大概的了解，这时候看书就不会一头雾水，此时可以通过看书来深入学习，之后的学习可以自己选择看书还是看视频，最好的方法是花时间既看视频也看书；学着学着忘掉前面的别总想着回头记住，先往后学，有些基础知识暂时用不上，当你学到应用的知识时自然会慢慢理解；2.书籍推荐入门书籍：《HeadFirstJava》、《Java核心技术》进阶书籍：《Java编程思想》三．JavaWeb1.学习路线学习完Java基础，接着适合学习JavaWeb，这个推荐看视频，学习数据库和JDBC基础知识以及基本的前端知识，然后学习SSM框架，学习路线为：Mysql->JDBC->HTML、CSS、JavaScript、JSP->Spring->SpringMVC->Mybatis->SSM整合->SSM项目实战2.书籍推荐《深入分析javaweb技术内幕》《架构探险-从零开始写javaweb框架》并发编程《Java并发编程的艺术》设计模式《HeadFirst设计模式》JVM《深入理解Java虚拟机》要想超越别人，不仅仅要掌握实战技能，更重要的是基础扎实

https://github.com/bethrobson/Head-First-Java/tree/master/chap02

入门找个书就行了，一两本书是不可能精通java的。

从加入BAT起，就一直从事后端开发，从PHP到JAVA，也经历过自学成才的过程。接下来我就根据我的经验来为大家分享我读过的，javaweb后端开发的好书。《thinkinginjava》中文版叫《Java编程思想》，是Java学习领域的圣经，也是入门书。基本上，Java成手都会推荐新人来看这本，里面详尽介绍了Java的基本概念，对于打牢Java基础，后面不论是做web开发，还是app开发，都有非常重要的作用。不过这本书过于厚重，里面有些Java的使用方式已经过时，因此只建议读懂这本书的前半部分，夯实基础即可。《headfirstjava》这本书可以与上面的那本辅助着看，相对来说，它读起来更加轻快，里面很多结合实际生活的例子也很幽默，算是深入浅出。或者可以考虑先读这本，把基础打个七分牢固，然后再去读《thinkinginjava》来补充最后的三分。《headfirstservlet》javaweb开发少不了要知道servlet，就算现在有很多成熟的框架，比如SSH,SSM,SPRINGBOOT，其中已经将servlet的部分封装了起来，但是发展到后期想往高级Java工程师方向前进的话，还是需要去了解很多底层的原理。《图解HTTP》javaweb开发自然少不了web相关的。作为目前最广泛使用的http协议，在开发过程中自然也要掌握相关的知识，才能写出优雅美丽的接口。《JavaEE互联网轻量级框架整合开发》目前所有开发Javaweb的项目都会选择使用框架，从而减轻程序员的很多负担，目前常用的框架SSM已经逐渐把SSH淘汰，因此，非常建议了解这本介绍SSM框架的书，能够大大提高工作效率。《深入浅出SpringBoot2.x》最后是这本springboot，因为springboot目前势头更加强劲，由于它能够仅仅依赖注解就完成配置，而不需要很麻烦的xml文件，我们公司很多项目已经淘汰了SSM，用上了springboot。以上是我的浅见，欢迎各位在下方评论区给我交流点赞。

《java从入门到精通》--基础语法、用法《java编程思想》--java必看的书没有之一，但是入门不建议看剩下的了解下数据库、框架之类的就ok了。比如说mysql、spring系列（springmvc、springboot、springcloud）等等，剩下的一些插件、中间件等工作以后再学

Java自学路线第1阶段Java核心技术第2阶段数据库关键技术第3阶段Web开发与实战应用第4阶段经典&流行框架第5阶段Java高级&前沿技术第6阶段企业接轨项目以在线教育项目为例第7阶段大数据技术java自学路线

先放我收集的书籍，百度云链接：https://pan.baidu.com/s/1XG2U7_do0C55NkB5ndfHUAjava入门书籍推荐：Head First Java(中文版)(第2版)head first系列的教材,看起来都特别轻松，图文并茂，简单易懂,适合初学者选择。Java核心技术 第七版 统全面讲解Java语言的核心概念、语法、重要特性和开发方法，包含大量案例，实践性强。Java开发实战经典书中的代码和案例较多,知识点也比较全面,在实际开发的过程中来讲解一些基础内容,对于新手而言很实用。Thinking In Java 4Think in java被誉为“java圣经”。无论你处于什么阶段，每一次阅读都能有所收获。进阶篇：《Effective Java中文版 第2版》本书介绍了在java编程中78条极具实用价值的经验规则，每条规则都以简短、独立的小文章形式出现，并通过例子代码加以进一步说明,这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。Java并发编程实战深入浅出地介绍了Java线程和并发，是一本完美的Java并发参考手册。其中并非只讲述了Java的多线程设施，对一般的并发编程的rationale也有相当透彻的阐述测试驱动开发 by Example书中不仅以案例的形式呈现了测试驱动开发的原则和方法，而且详尽地阐述了测试驱动开发(TDD)的模式和最佳实践。重构_改善既有代码的设计书中给出了70多个可行的重构，每个重构都介绍了一种经过验证的代码变换手法的动机和技术。本书提出的重构准则将帮助你一次一小步地修改你的代码，从而减少了开发过程中的风险。java攻城狮推荐学习书籍：企业应用架构模式作者将40多种经常出现的解决方案转化成模式，最终写成这本能够应用于任何一种企业应用平台的、关于解决方案的、不可或缺的手册。敏捷开发-敏捷软件开发：原则、模式与实践(全)好的技术书籍的标准是通俗易懂;文字精炼;耐读，有吸引力;有思想性。作者的书写功力有目共睹.《Java性能优化权威指南》Java性能优化圣经！主要为Java SE 和Java EE 应用的性能调优提供建议。主要包括以下几方面：性能监控、性能分析、Java HotSpot VM 调优、高效的基准测试以及Java EE 应用的性能调优。

最近有好多小伙伴向我咨询：“如何学习JAVA?”，其实这个问题太宽泛了，好像每个人在一开始接触java的时候都会请教这个问题。本人对这个问题有很深的体悟和感慨,一开始想要自学，结果不够自律，后来选择了一家培训机构进行学习。今天，云南IT培训http://www.kmbdqn.cn/想要在这里分享我的心路历程。一．明确自己学习的原因1.问问自己是抱着什么目的要学习Java，没有目标的学习是效率极低的，并且容易半途而废；2.了解Java可以做什么，Java可以从事的岗位以及软件行业的发展情况；3.自己是否对Java方向感兴趣；二．学习Java基础1.学习准备推荐看视频入门，可以通过某宝以及某鱼购买相关的视频，别挑三拣四，选中一个视频看完再说，对于初学者，无论选哪一个都是值得你学习的。有人说编辑器等IDE环境不适合看视频，浪费时间，但是初学者在学习第一个编程IDE时，推荐看视频或者通过搜索引擎了解工具的使用，看书其实在刚开始可能更浪费时间；看完基础视频对知识有个大概的了解，这时候看书就不会一头雾水，此时可以通过看书来深入学习，之后的学习可以自己选择看书还是看视频，最好的方法是花时间既看视频也看书；学着学着忘掉前面的别总想着回头记住，先往后学，有些基础知识暂时用不上，当你学到应用的知识时自然会慢慢理解；2.书籍推荐入门书籍：《HeadFirstJava》、《Java核心技术》进阶书籍：《Java编程思想》三．JavaWeb1.学习路线学习完Java基础，接着适合学习JavaWeb，这个推荐看视频，学习数据库和JDBC基础知识以及基本的前端知识，然后学习SSM框架，学习路线为：Mysql->JDBC->HTML、CSS、JavaScript、JSP->Spring->SpringMVC->Mybatis->SSM整合->SSM项目实战2.书籍推荐《深入分析javaweb技术内幕》《架构探险-从零开始写javaweb框架》并发编程《Java并发编程的艺术》设计模式《HeadFirst设计模式》JVM《深入理解Java虚拟机》要想超越别人，不仅仅要掌握实战技能，更重要的是基础扎实

一、Java从入门到精通《Java从入门到精通(第3版)》从初学者角度出发，通过通俗易懂的语言、丰富多彩的实例，详细介绍了使用Java语言进行程序开发需要掌握的知识。《Java从入门到精通(第3版)》编辑推荐：“软件开发视频大讲堂”丛书系清华社“视频大讲堂”重点大系之一。该大系包括多个子系列，每个子系列的图书在其同品种的图书中销售名列前茅，二、Java核心技术(卷1):基础知识Java领域最有影响力和价值的著作之一，与《Java编程思想》齐名，10余年全球畅销不衰，广受好评；2）根据JavaSE7全面更新，系统全面讲解Java语言的核心概念、语法、重要特性和开发方法，包含大量案例，实践性强三、Java编程思想《Java编程思想(第4版)》书共22章，包括操作符、控制执行流程、访问权限控制、复用类、多态、接口、通过异常处理错误、字符串、泛型、数组、容器深入研究、Iava"UO系统、枚举类型、并发以及图形化用户界面等内容。这些丰富的内容，包含了Java语言基础语法以及高级特性，适合各个层次的Java程序员阅读，同时也是高等院校讲授面向对象程序设计语言以及Java语言的绝佳教材和参考书。四、深入理解Java虚拟机:JVM高级特性与最佳实践第1版两年内印刷近10次，4家网上书店的评论近4?000条，98%以上的评论全部为5星级的好评，是整个Java图书领域公认的经典著作和超级畅销书，繁体版在台湾也十分受欢迎。第2版在第1版的基础上做了很大的改进：根据最新的JDK1.7对全书内容进行了全面的升级和补充；增加了大量处理各种常见JVM问题的技巧和最佳实践；增加了若干与生产环境相结合的实战案例；对第1版中的错误和不足之处的修正；等等。第2版不仅技术更新、内容更丰富，而且实战性更强。五、Sun公司核心技术丛书:EffectiveJava中文版在Java编程中78条极具实用价值的经验规则，这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。通过对Java平台设计专家所使用的技术的全面描述，揭示了应该做什么，不应该做什么才能产生清晰、健壮和高效的代码。第2版反映了Java5中最重要的变化，并删去了过时的内容。六、图灵程序设计丛书:Java程序员修炼之道《Java程序员修炼之道》分为四部分，第一部分全面介绍Java7的新特性，第二部分探讨Java关键编程知识和技术，第三部分讨论JVM上的新语言和多语言编程，第四部分将平台和多语言编程知识付诸实践。从介绍Java7的新特性入手，《Java程序员修炼之道》涵盖了Java开发中最重要的技术，比如依赖注入、测试驱动的开发和持续集成，探索了JVM上的非Java语言，并详细讲解了多语言项目，特别是涉及Groovy、Scala和Clojure语言的项目。此外，书中含有大量代码示例，帮助读者从实践中理解Java语言和平台。七、HeadFirstJava(中文版）《HeadFirstJava》(中文版)(第2版)是本完整的面向对象(object-oriented，OO)程序设计和Java的学习指导。此书是根据学习理论所设计的，让你可以从学习程序语言的基础开始一直到包括线程、网络与分布式程序等项目。最重要的，你会学会如何像个面向对象开发者一样去思考。八、Java7入门经典《Java7入门经典》是关于Java语言讲解最为细致、全面的入门书籍，介绍了使用最新的JavaJDK7开发程序所需要的所有基础知识。书中包含大量的示例，清晰地解释了涉及的关键概念，演示了Java开发的复杂细节。

Java核心技术·卷1 ， 卷2 ，是很不错的

import java.awt.BorderLayout;import java.awt.FileDialog;import java.awt.TextArea;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.io.File;import java.io.FileOutputStream;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JOptionPane;import javax.swing.JPanel;public class TextEditc { static String filepath; static JFrame frame = new JFrame("文本编辑器"); static TextArea textArea = new TextArea("", 20, 30, TextArea.SCROLLBARS_BOTH); static JButton jButton1 = new JButton("保存"), jButton2 = new JButton("取消"), jButton3 = new JButton("退出"); JPanel panel = new JPanel(); public TextEditc() { frame.add(textArea, BorderLayout.CENTER); panel.add(jButton1); panel.add(jButton2); panel.add(jButton3); frame.add(panel, BorderLayout.SOUTH); frame.setSize(500, 400); frame.setVisible(true); init(); } public void init() { jButton1.addActionListener(new SaveFileAction(filepath)); jButton2.addActionListener(new ResetTextArea()); jButton3.addActionListener(new ExitSystemJB()); } public static void main(String[] args) { new TextEditc(); }}// 保存文件按钮监听事件class SaveFileAction implements ActionListener { private String filepath = null; public SaveFileAction(String filepath) { this.filepath = filepath; } public void actionPerformed(ActionEvent e) { FileDialog dialog = new FileDialog(new JFrame(), "保存文件", FileDialog.LOAD); dialog.setVisible(true); filepath = dialog.getDirectory() + dialog.getFile(); File file = new File(filepath); FileOutputStream fileOutputStream = null; try { fileOutputStream = new FileOutputStream(file); // String content = textArea.getText(); String content = TextEditc.textArea.getText(); byte[] b = content.getBytes(); fileOutputStream.write(b); fileOutputStream.close();// 关闭输出流 } catch (Exception e1) { e1.printStackTrace(); } }}// 取消按钮监听事件class ResetTextArea implements ActionListener { public void actionPerformed(ActionEvent e) { // textarea区域设置为空 TextEditc.textArea.setText(""); }}// 退出按钮监听事件class ExitSystemJB implements ActionListener { public void actionPerformed(ActionEvent e) { int a = JOptionPane.showConfirmDialog(null, "确定关闭吗？", "温馨提示", JOptionPane.YES_NO_OPTION); if (a == 0) { System.exit(0); // 关闭 } }}

就是说，一共有99瓶酒，喝下一瓶输出 take one down，干掉了一个，知道最后没有酒了，输出no more bottles of beer on the wall

别听他们的，thinking in java本来就是入门书籍，而且是其中的经典。

有一定JAVA基础，可以选择

一般再版的JAVA技术书，都是基于新版的JDK。比如《java参考大全》第四版是基于jdk1.4进行讲解，而第五版是基于jdk1.5.

表示非常喜欢head first系列的丛书，以一种带你走进知识的并结合现实来让你学习，而且排版布局都非常有新意，容易让人快速进入学习状态我自己有一本head first design的书，感觉受益匪浅而且学的很清晰虽然没看过head first java ，但是感觉你值得拥有

《JAVA核心技术》相当于API，知识点覆盖全面，但不够生动，不适合初学者x0dx0a《head first》是本很不错的书，例子简单易懂，而且有趣，适合你看x0dx0a x0dx0a另外可以把《java编程思想》买了，2本结合看比较好

extends PersonAs1.setName("张三");s1.setDepartment("计算机系");System.out.println(s1.getName());System.out.println(s1.getDepartment());

public interface JpaSpecificationExecutor<T> {T findOne(Specification<T> var1);List<T> findAll(Specification<T> var1);Page<T> findAll(Specification<T> var1, Pageable var2);List<T> findAll(Specification<T> var1, Sort var2);long count(Specification<T> var1);Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

你这个findone(id)是用自己的@Query注解的jpql语句？如果不是，方法应该是findOne(Intergerid)才对，可但是你这个实体类哪里有id的字段；你也可以试试findBy字段这种方式另外注意下几个Repository接口的细微区别，会不会问题出在接口选择上面！

这个程序也许能满足你的要求：import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class BigInteger//定义长整型的类{ private static final int add1Max=1000;//可计算最长位数 private static final int add2Max=1000;//同上 private char[] add1 = new char[add1Max]; private char[] add2 = new char[add1Max]; private int len1; private int len2; public void setAdd1() throws IOException { int i=0; String sLine1; System.out.print("请输入第一个长整数: ");//输入第一个长整数 BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); sLine1=in.readLine(); for(;i<sLine1.length();i++) add1[i]=sLine1.charAt(i); for(i=0;i<add1Max;i++)//len1=add1.length() { if(add1[i]!="") len1++; } } public void setAdd2() throws IOException { int i=0; String sLine2; System.out.print("请输入第二个长整数 : ");//输入第二个长整数 BufferedReader in2 = new BufferedReader(new InputStreamReader(System.in)); sLine2 = in2.readLine(); for(i=0;i<sLine2.length();i++) add2[i]=sLine2.charAt(i); for(i=0;i<add2Max;i++)//len2=add2.length() { if(add2[i]!="") len2++; } } public char[] getAdd1() { return add1; } public char[] getAdd2() { return add2; } public int getLen1() { return len1; } public int getLen2() { return len2; } public void add(char[] add1,char[] add2)//BigInteger相加方法 { int len = Math.max(len1,len2); int i; char[] temp1 = new char[len]; char[] temp2 = new char[len]; char[] result = new char[len+1]; for(i=0;i<len1;i++) temp1[len-1-i]=add1[len1-1-i]; for(i=0;i<len2;i++) temp2[len-1-i]=add2[len2-1-i]; int m=0; for(i=0;i<len;i++)//相加 { if(temp1[len-1-i]!=0) temp1[len-1-i]-=48; if(temp2[len-1-i]!=0) temp2[len-1-i]-=48; m=temp1[len-1-i]+temp2[len-1-i]; if(m>=10) { m-=10; result[len-i]+=m; result[len-1-i]+=1; } else result[len-i]+=m; } System.out.print("相加的和为:");//输出相加结果 i=0; if(result[0]==0) i=1; for(;i<len+1;i++) System.out.print(Integer.toString(result[i])); } public static void main(String[] args) throws IOException//主方法 { BigInteger big = new BigInteger();//生成一个BigInteger对象 big.setAdd1();//得到数1 big.setAdd2();//得到数2 char[] num1 = big.getAdd1();//相加 char[] num2 = big.getAdd2();//相减 int len1 = big.getLen1(); int len2 = big.getLen2(); System.out.println(); System.out.println("第一个长整数的长度是: " + len1); System.out.println("第二个长整数的长度是: " + len2); big.add(num1,num2); System.out.println(); }}运行结果如下：请输入第一个长整数: 222222222222222222222222222222222222222222555555555555555555555555请输入第二个长整数 : 88888888888888888888888888888888888888899999999999999999999999999第一个长整数的长度是: 66第二个长整数的长度是: 65相加的和为:311111111111111111111111111111111111111122555555555555555555555554

英文字符编码为65-90,97-122

正则比较好，四楼的也可以的

楼上的不要乱答啊！不知道就别答，混分也要有个限度。

jsp中：request方法客户端IP: request.getRemoteAddr()输出：192.168.0.106客户端主机名：request.getRemoteHost()输出：abcrequest.getHeader("Host") 输出：192.168.0.1：8080Web服务器名字：request.getServerName()输出：192.168.0.1服务器监听的端口：request.getServerPort()输出：8080 在JSP里，获取客户端的IP地址的方法是：request.getRemoteAddr（），这种方法在大部分情况下都是有效的。但是在通过了 Apache，Squid等反向代理软件就不能获取到客户端的真实IP地址了。如果使用了反向代理软件，用 request.getRemoteAddr（）方法获取的IP地址是：127.0.0.1或 192.168.1.110，而并不是客户端的真实IP。经过代理以后，由于在客户端和服务之间增加了中间层，因此服务器无法直接拿到客户端的 IP，服务器端应用也无法直接通过转发请求的地址返回给客户端。但是在转发请求的HTTP头信息中，增加了X－FORWARDED－FOR信息。用以跟踪 原有的客户端IP地址和原来客户端请求的服务器地址。当我们访问index.jsp/时，其实并不是我们浏览器真正访问到了服务器上的index.jsp 文件，而是先由代理服务器去访问index.jsp ，代理服务器再将访问到的结果返回给我们的浏览器，因为是代理服务器去访问index.jsp的，所以index.jsp中通过 request.getRemoteAddr（）的方法获取的IP实际上是代理服务器的地址，并不是客户端的IP地址。于是可得出获得客户端真实IP地址的方法一：public String getRemortIP(HttpServletRequest request) {if (request.getHeader("x-forwarded-for") == null) {return request.getRemoteAddr();}return request.getHeader("x-forwarded-for");}获得客户端真实IP地址的方法二：public String getIpAddr(HttpServletRequest request) {String ip = request.getHeader("x-forwarded-for");if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {ip = request.getHeader("Proxy-Client-IP");}if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {ip = request.getHeader("WL-Proxy-Client-IP");}if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {ip = request.getRemoteAddr();}return ip;}可是，如果通过了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP值，究竟哪个才是真正的用户端的真实IP呢？答案是取X-Forwarded-For中第一个非unknown的有效IP字符串。如：X-Forwarded-For：192.168.1.110， 192.168.1.120， 192.168.1.130， 192.168.1.100用户真实IP为： 192.168.1.110

你把这个方法写进你的程序,程序开始后先获取IP,然后判断IP是否和你的一致,如果不一致直接return;即可./** * 获取外网IP * @param request * @return */public static String getIpAddr(HttpServletRequest request) { String ipAddress = null; // ipAddress = this.getRequest().getRemoteAddr(); ipAddress = request.getHeader("x-forwarded-for"); if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) { ipAddress = request.getHeader("Proxy-Client-IP"); } if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) { ipAddress = request.getHeader("WL-Proxy-Client-IP"); } if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) { ipAddress = request.getRemoteAddr(); if (ipAddress.equals("127.0.0.1")) { // 根据网卡取本机配置的IP InetAddress inet = null; try { inet = InetAddress.getLocalHost(); } catch (UnknownHostException e) { e.printStackTrace(); } ipAddress = inet.getHostAddress(); } } // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照","分割 if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length() // = 15 if (ipAddress.indexOf(",") > 0) { ipAddress = ipAddress.substring(0, ipAddress.indexOf(",")); } } return ipAddress; }————————————————版权声明：本文为CSDN博主「秋9」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/jlq_diligence/article/details/87871484

这是我刚刚学C++的时候经常写的

import java.util.Arrays;import java.util.Comparator;import java.util.HashMap;import java.util.Scanner;import java.util.Stack;import java.util.Vector;import java.util.regex.MatchResult;public class Test { private CarStop carStop = new CarStop(3); private CarTunnel tunnel = new CarTunnel(); public void test(){ //存放车辆信息，因为不是顺序输入的，所以放到Map中 HashMap<Integer, Car> carMap = new HashMap<Integer, Car>(); //最早进入车库的时间和最晚出车库的时间 int startTime, endTime; startTime = Integer.MAX_VALUE; endTime = Integer.MIN_VALUE; Scanner scanner = new Scanner(System.in); //("A"或者"D"或者"E", int, int) while(scanner.hasNext("\((A|D|E),(\d+),(\d+)\)")){ scanner.next("\((A|D|E),(\d+),(\d+)\)"); MatchResult r = scanner.match(); Car car; //如果输入A if (r.group(1).equalsIgnoreCase("A")){// 该车已经记录过 if (carMap.keySet().contains(Integer.parseInt(r.group(2)))){// 取出来设置到达时间 car = carMap.get(Integer.parseInt(r.group(2))); car.arrive = Integer.parseInt(r.group(3)); }else{// 否则就记录该车 car = new Car(Integer.parseInt(r.group(2)), Integer.parseInt(r.group(3))); carMap.put(car.no, car); } if (car.arrive < startTime) startTime = car.arrive; if (car.leave > endTime) endTime = car.leave;// 出库时间和到达时间同样处理 }else if (r.group(1).equalsIgnoreCase("D")){ if (carMap.keySet().contains(Integer.parseInt(r.group(2)))){ car = carMap.get(Integer.parseInt(r.group(2))); car.leave = Integer.parseInt(r.group(3)); }else{ car = new Car(Integer.parseInt(r.group(2)), 0, Integer.parseInt(r.group(3))); carMap.put(car.no, car); } if (car.arrive < startTime) startTime = car.arrive; if (car.leave > endTime) endTime = car.leave; }else if (r.group(1).equalsIgnoreCase("E")){ break; } }// 把记录过的车做成数组并且排序 Car[] cars = new Car[carMap.size()]; cars = carMap.values().toArray(cars); Arrays.sort(cars, new Comparator<Car>(){// 排序顺序是到达时间>出库时间>车牌 public int compare(Car c1, Car c2) { if (c1.arrive!=c2.arrive) return c1.arrive - c2.arrive; if (c1.leave!=c2.leave) return c1.leave - c2.leave; return c1.no - c2.no; } }); for (int time=startTime; time<=endTime; time++){ System.out.println("TIME:" + time); for (int k=0;k<cars.length;k++){ Car car = cars[k]; //如果有车在没有进入停车场的时候就已经到了出库时间 if (car.leave == time && carStop.isFull() && !carStop.contains(car)){ for (int i=tunnel.size()-1;i>=0;i--){ Car c = tunnel.get(i); if (c.equals(car)){ for (int j=i+1;j<tunnel.size();j++){ System.out.println(car + "为" + car + "让路，重新进入等待区"); } tunnel.remove(car); System.out.println(car + "没进入过停车场就离开了"); }else{ System.out.println(car + "为" + car + "让路"); } } }else{// 如果有车子现在到达 if (car.arrive == time){// 停车场不满 if (!carStop.isFull()) {// 进入停车场 carStop.push(car);// 开始计费 car.chargeStart = time; System.out.println(car + "进入停车场并且开始计费"); }else{// 停车场满，等待 System.out.println(car + "到达，在等待区等待"); tunnel.push(car); } } } } //deal with cars in stop //the case cars leave at same time is not included // 按照后进先出的顺序看有没有车要离开 for (int k=carStop.size() - 1; k>=0; k--){ Car car = carStop.elementAt(k); //准备离开 if (car.leave == time){ Car otherCar;// 所有在他后面进来的车准备让路 while ((otherCar = carStop.pop())!=car){// 进入等待区的最前面 tunnel.unshift(otherCar); System.out.println(otherCar + "准备为" + car + "让路"); } for (int m=tunnel.size()-1;m>=0;m--){ System.out.println(tunnel.elementAt(m) + "为" + car + "让路"); } System.out.println(otherCar + "离开，停车时间:" + (otherCar.leave - otherCar.chargeStart)); for (int m=0; m<tunnel.size(); m++){ System.out.println(tunnel.elementAt(m) + "让路完毕，重新进入等待区"); } Car waitingCar; //停车场有空位，等待序列最前面的车入库 while ( !carStop.isFull() && (waitingCar = tunnel.shift())!=null ){ carStop.push(waitingCar);// 停车计时开始 if (waitingCar.chargeStart == -1) { System.out.println(waitingCar + "停车计时时间改为:" + time); waitingCar.chargeStart = time; } System.out.println(waitingCar + "进入停车场"); } } } } } public static void main(String[] args){ new Test().test(); }}@SuppressWarnings("serial")class CarTunnel extends Vector<Car>{ public CarTunnel(){ super(); } public Car shift(){ if (size() == 0) return null; return remove(0); } public void unshift(Car car){ super.add(0, car); } public void push(Car car){ super.add(car); } public Car pop(){ if (size() == 0) return null; return remove(size()-1); }}@SuppressWarnings("serial")class CarStop extends Stack<Car>{ private int size; public CarStop(int size){ this.size = size; } public boolean isFull(){ return size() == size; } public Car pop(){ return super.pop(); } public Car push(Car car){ if (size() <= size){ return super.push(car); }else{ return null; } }}class Car{ public int no; public int arrive; public int leave; public int chargeStart = -1; public Car(int no, int timeIn, int timeOut){ this.no = no; this.arrive = timeIn; this.leave = timeOut; } public Car(int no, int timeIn){ this(no, timeIn, -1); } public String toString(){ return String.format("Car(%d)", no); }}结果：(A,6,31)(A,5,30)(A,4,20)(A,3,16)(A,2,15)(A,1,10)(D,1,50)(D,2,30)(D,3,31)(D,4,25)(D,5,32)(D,6,40)(E,0,0)TIME:10Car(1)进入停车场并且开始计费TIME:11TIME:12TIME:13TIME:14TIME:15Car(2)进入停车场并且开始计费TIME:16Car(3)进入停车场并且开始计费TIME:17TIME:18TIME:19TIME:20Car(4)到达，在等待区等待TIME:21TIME:22TIME:23TIME:24TIME:25Car(4)没进入过停车场就离开了TIME:26TIME:27TIME:28TIME:29TIME:30Car(5)到达，在等待区等待Car(3)准备为Car(2)让路Car(5)为Car(2)让路Car(3)为Car(2)让路Car(2)离开，停车时间:15Car(3)让路完毕，重新进入等待区Car(5)让路完毕，重新进入等待区Car(3)进入停车场Car(5)停车计时时间改为:30Car(5)进入停车场TIME:31Car(6)到达，在等待区等待Car(5)准备为Car(3)让路Car(6)为Car(3)让路Car(5)为Car(3)让路Car(3)离开，停车时间:15Car(5)让路完毕，重新进入等待区Car(6)让路完毕，重新进入等待区Car(5)进入停车场Car(6)停车计时时间改为:31Car(6)进入停车场TIME:32Car(6)准备为Car(5)让路Car(6)为Car(5)让路Car(5)离开，停车时间:2Car(6)让路完毕，重新进入等待区Car(6)进入停车场TIME:33TIME:34TIME:35TIME:36TIME:37TIME:38TIME:39TIME:40Car(6)离开，停车时间:9TIME:41TIME:42TIME:43TIME:44TIME:45TIME:46TIME:47TIME:48TIME:49TIME:50Car(1)离开，停车时间:40

利用协议头 http取出IP地址 进行判断限制登录 也可以用js

还是多看看书吧！

if (会员） { if (count > 200) { count = count *0.75; } else { couunt = count *0.8; }} else { count = count * 0.9;}return count;

你的积分好多哦 这样的题 你都给100

关键代码就是： rtruns[l].setFontName("宋体"); import java.awt.Dimension;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException; import ...

输入格式？

　　User.java　　public class User {　　private String userName; // 账号　　private double amount; // 金额　　public String getUserName() {　　return userName;　　}　　public void setUserName(String userName) {　　this.userName = userName;　　}　　public double getAmount() {　　return amount;　　}　　public void setAmount(double amount) {　　this.amount = amount;　　}　　}　　BankService.java　　import com.bank.po.User;　　public interface BankService {　　//用户选择操作类型　　public void userChoose(String serialNumber);　　//开户　　public User addUser();　　//存款　　public User addAmount(User user);　　//取款　　public User withdrawal(User user);　　//查询余额　　public void lookBalance(User user);　　}　　BankServiceImpl.java　　import com.bank.po.User;　　import com.bank.service.BankService;　　import com.bank.util.InputUtil;　　public class BankServiceImpl implements BankService{　　private static User user;　　public void userChoose(String serialNumber){　　System.out.println("Please choose the type of operation(Input serial number):");　　System.out.println("1 : 开户(Add user)");　　System.out.println("2 : 存款(deposit)");　　System.out.println("3 : 取款(withdrawals)");　　System.out.println("4 : 查询余额(Inquires the balance)");　　serialNumber = InputUtil.input();　　if("1".equalsIgnoreCase(serialNumber)){　　user = addUser();　　}else{　　if(null != user){　　if("2".equalsIgnoreCase(serialNumber)){　　user = addAmount(user);　　System.out.println("Deposit success !");　　}　　if("3".equalsIgnoreCase(serialNumber)){　　user = withdrawal(user);　　System.out.println("Withdrawals success !");　　}　　if("4".equalsIgnoreCase(serialNumber))　　lookBalance(user);　　else{　　System.out.println("Input is wrong, please input anew !");　　}　　}else{　　System.out.println("Please first open an account");　　}　　}　　userChoose(null);　　}　　public User addUser() {　　User user = new User();　　System.out.println("Welcome to use: please first accounts !");　　System.out.println("Please enter your user name :");　　String userName = InputUtil.input();　　System.out.println("Please input amount(please input digital) :");　　String amount = InputUtil.input();　　user.setUserName(userName);　　user.setAmount(Double.parseDouble(amount));　　return user;　　}　　public User addAmount(User user) {　　System.out.println("Please input amount(please input digital) :");　　String amount = InputUtil.input();　　user.setAmount(user.getAmount() + Double.parseDouble(amount));　　return user;　　}　　public User withdrawal(User user) {　　System.out.println("Please input amount(please input digital) :");　　String amount = InputUtil.input();　　user.setAmount(user.getAmount() - Double.parseDouble(amount));　　return user;　　}　　public void lookBalance(User user) {　　System.out.println("Your balance for :" + user.getAmount());　　}　　}　　InputUtil.java　　public class InputUtil {　　public static String input(){　　Scanner sc = new Scanner(System.in);　　String input = sc.next();　　return input;　　}　　}　　测试类　　Test.java　　import com.bank.service.BankService;　　import com.bank.service.impl.BankServiceImpl;　　public class Test {　　public static void main(String[] args) {　　BankService bank = new BankServiceImpl();　　bank.userChoose(null);　　}　　}

最方便的是调用获取IP的 WebService,找到直接调

我也还是学生，我最喜欢帮别人做作业的哈~import java.util.Scanner;/*.使用do-while循环：输出询问“我爱你，嫁给我吧？”，选择“你喜欢我吗？(y/n):"， * 如果输入为y则打印”我们形影不离“，若输入为n,则继续询问*/public class 第一题 {public static void main(String[] args) { Scanner s = new Scanner(System.in); do{ System.out.println("我爱你，嫁给我吧？ 你喜欢我吗？(y/n):"); if(s.next().equalsIgnoreCase("y")) { System.out.println("我们形影不离"); break; } else continue; }while(true);}} /*任意输入一个整数（小于10位），求这个整数有多少位？*/import java.util.Scanner;public class 第二题 { public static void main(String[] args) { System.out.println("任意输入一个整数（小于10位）:"); String str = new Scanner(System.in).next(); System.out.println("这个整数有"+ str.length()+"位"); }} import java.util.Scanner;/*编写一个程序，最多接受10个数字，并求出其中所有正数的和。统计用户输入正数的个数，并显示个数和这些正数的和*/public class 第三题 {public static void main(String[] args) { Scanner s = new Scanner(System.in); String str = null; int count = 0; int countPlus = 0; int num = 0; int sum = 0; System.out.println("输入最多10个数字（输入e结束）："); while( count <= 10 ) { if((str = s.next()).equalsIgnoreCase("e")) break; num = Integer.parseInt(str); if(num > 0) { countPlus++; sum += num; } count++; } System.out.println("正数的个数为:"+countPlus+",正数的和为:"+sum);}} /*用for循环计算出1~100之间所有不能被3整除的整数的和。*/public class 第四题 {public static void main(String[] args) { int sum = 0; for(int i = 1;i <= 100;i++) if(i % 3 != 0) sum += i; System.out.println(sum);}} /*用for循环计算出1~100之间所有不能被3整除的整数的和,以及输出当和刚好大于或等于2000时的这个数字*/public class 第五题 {public static void main(String[] args) { int sum = 0; int i = 1; int j = 0; for(;i <= 100;i++) if(i % 3 != 0) { sum += i; if(sum >= 2000 && j == 0) j = i; } System.out.println("和为:"+sum+",刚好大于或等于2000时的数字为:"+j);}}public class 第六题 {public static void main(String[] args) { for(int i = 1;i <= 7; i += 2) { for(int j = 1;j <= i;j++) { System.out.print("*"); } System.out.println(); } for(int i = 5;i >= 1;i -= 2) { for(int j = 1; j <= i;j++) { System.out.print("*"); } System.out.println(); }}}

public String getIpAddr(HttpServletRequest request) { String ip = request.getHeader("x-forwarded-for"); if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { ip = request.getHeader("Proxy-Client-IP"); } if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { ip = request.getHeader("WL-Proxy-Client-IP"); } if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) { ip = request.getRemoteAddr(); } return ip; }

修改字符串的目的是为了得到新的字符串，类String和类StringBuffer都提供了相应的方法。 1．String类提供的方法： 　　concat( ) 　　replace( ) 　　substring( ) 　　toLowerCase( ) 　　toUpperCase( ) 　　◇ public String contat(String str); 　　用来将当前字符串对象与给定字符串str连接起来。 　　◇ public String replace(char oldChar,char newChar); 　　用来把串中出现的所有特定字符替换成指定字符以生成新串。◇ public String substring(int beginIndex)； 　　public String substring(int beginIndex,int endIndex); 　　用来得到字符串中指定范围内的子串。 　　◇ public String toLowerCase(); 　　把串中所有的字符变成小写。 　　◇ public String toUpperCase(); 　　把串中所有的字符变成大写。

public String IP() throws IOException{String IP=null;URL url = new URL("http://iframe.ip138.com/ic.asp");URLConnection conn = url.openConnection();conn.setRequestProperty("User-Agent","Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2.15) Gecko/20110303 Firefox/3.6.15");conn.setRequestProperty("Content-Type", "text/html");conn.setRequestProperty("Accept","text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");InputStream is = conn.getInputStream();BufferedReader br = new BufferedReader(new InputStreamReader(is,"GB2312"));String line = null;while ((line = br.readLine()) != null) {if (line.contains("您的IP是")) {// System.out.println(line);int start = line.indexOf("[") + 1;int end = line.indexOf("]");IP=line.substring(start, end);}}br.close();return IP;}抓取网路使用的IP

boolean mark = true;boolean mark2 = true;while(mark){ System.out.println("你爱我吗? （回答是/否）"); mark2 = true; BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); String str=null; while((str=br.readLine())!=null && mark2 ) { if(str.equals("是")){ mark = false; }else{ mark2 = false; } } }

字符串对象.equalsIgnoreCase（对比的对象）

String str = “asdfgh”int a ；String test = str.subString(5)System.out.put(test);结果为"h"

日历,直接调用日期函数.几乎什么都不用做.记事本,直接调用打开/保存函数,也几乎什么都不用做.只要写两条代码改改字体改改大小就行了.

import java.util.Scanner;public class test{ public static void main(String[] args) { String phoneNum,str="",begin="",end=""; int count = 0; System.out.print("请输入一个11位手机号："); phoneNum = new Scanner(System.in).next(); while (phoneNum.length()!=11||(int)(phoneNum.substring(0,1).charAt(0))!=49) { System.out.println("你输入的不是一个11位手机号！ "); System.out.print("请输入一个11位手机号："); phoneNum = new Scanner(System.in).next(); } for (int i = 0; i < phoneNum.length(); i++) { if ((int)(phoneNum.substring(i,i+1).charAt(0))>=48&&(int)(phoneNum.substring(i,i+1).charAt(0))<=57 ) { count++; } } while (count!=phoneNum.length()) { System.out.println("你输入的不是一个11位手机号！ "); System.out.print("请输入一个11位手机号："); phoneNum = new Scanner(System.in).next(); } for (int i = 0; i < 3; i++) { //截取开头三位 str+=phoneNum.substring(i,i+1); begin=str; } for (int i = 3; i <= 6; i++) { //截取并替换4到7位 str+="X"; } for (int i = 7; i < phoneNum.length(); i++) { //截取剩余四位 str+=phoneNum.substring(i,i+1); end+=phoneNum.substring(i,i+1); } System.out.println("你输入的手机号是："+str); if (begin.equalsIgnoreCase("135")&&end.equalsIgnoreCase("1234")) { System.out.println("恭喜您获得了一等奖！"); }else { System.out.println("很遗憾，你未能中奖！"); } }}

http://b.faloo.com/f/342075.html?pid=62538

楼上正解 呵呵

public static String parseWeek(String str){ if("mon".equals(str.toLowerCase())){ return "一"; } else if("tue".equals(str.toLowerCase())){ return "二"; } else if("wed".equals(str.toLowerCase())){ return "三"; } else if("thu".equals(str.toLowerCase())){ return "四"; } else if("fri".equals(str.toLowerCase())){ return "五"; } else if("sat".equals(str.toLowerCase())){ return "六"; } else if("sun".equals(str.toLowerCase())){ return "日"; }else{ return "无法识别您输入的日期"; } }

区分，有一个不区分的，equalsIgnoreCase boolean equals(Object anObject) 将此字符串与指定的对象比较。 boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。

public static void main(String[] args) {System.out.println("游戏开始");for (int i = 0; i < 3; i++) {int r=((int) (Math.random()*3+1));//系统产生一个1-3的随机数System.out.println("请输入数字1-3【1:剪刀 2:石头3:布】");Scanner scan=new Scanner(System.in);int q=scan.nextInt();//用户输入一个数字if(q==r) System.out.println("平局");if(q>r) System.out.println("你赢啦");if(q<r) System.out.println("你输啦");}}

为什么不用正则表达式，没有什么比这个更简单吧，为什么不用最佳解决方案

equalsIgnoreCasepublic boolean equalsIgnoreCase(String anotherString)将此 String 与另一个 String 进行比较，不考虑大小写。如果两个字符串的长度相等，并且两个字符串中的相应字符都相等（忽略大小写），则认为这两个字符串是相等的。 在忽略大小写的情况下，如果下列至少一项为 true，则认为 c1 和 c2 这两个字符相同。 这两个字符相同（使用 == 运算符进行比较）。 对每个字符应用方法 Character.toUpperCase(char) 产生相同的结果。 对每个字符应用方法 Character.toLowerCase(char) 产生相同的结果。参数：anotherString - 与此 String 进行比较的 String。 返回：如果参数不为 null，且这两个 String 在忽略大小写时相等，则返回 true；否则返回 false。另请参见：equals(Object), Character.toLowerCase(char), Character.toUpperCase(char)

告诉你一个想法，设置三个变量表示数字，字母和其他字符。使用输入流。每个输入字符，判断这个字符的asc码，尽可能多的字母，数字的号码的数量。根据每次的一个相应的变量1，最后的输出变量，分别

把方法移到父类中去。

public static void main(String[] args) { Scanner input = new Scanner(System.in); do{ System.out.println("..."); System.out.println("Input YES to continue or NO to break:"); }while(input.next().equalsIgnoreCase("YES"));}

import java.util.Scanner; public class test{public static void main(String[] args) {String choose="";int score=0;boolean bFlag = false; //只打印正确的选择System.out.println("请输入要查询的分数线（比如民办本科、艺术类本科、体育类本科、二本、一本）：");choose = new Scanner(System.in).next();if (choose.trim().equalsIgnoreCase("民办本科")) {bFlag = true;score = 350;}else if (choose.trim().equalsIgnoreCase("艺术类本科")) {bFlag = true;score = 290;}else if (choose.trim().equalsIgnoreCase("体育类本科")) {bFlag = true;score = 280;}else if (choose.trim().equalsIgnoreCase("二本")) {bFlag = true;score = 445;}else if (choose.trim().equalsIgnoreCase("一本")) {bFlag = true;score = 555;}if (bFlag==true) {System.out.println(choose+"录取分数线： "+score+"分");}else {System.out.println("对不起，你的输入不正确！");}}}

public class Test { private static Scanner sc; private static Random rad; private static final String[] FINGERS = { "剪刀", "石头", "布" }; private static int win = 0, loose = 0, draw = 0; public static void main(String[] args) { // 捕获用户输入类 sc = new Scanner(System.in); //产生随机数的类 rad = new Random(); //一进来就让用户输入开始游戏，直到输入E， 退出游戏。 while (true) { System.out.println("~~~~~~~~~~~~剪刀石头布游戏，输入E可以退出~~~~~~~~~~~"); System.out.println("请选择你要出什么？Z——剪刀，X——石头，C——布"); //获取用户输入的字符 String command = sc.nextLine(); //输入字符转换 手势没发比较大小 就把字符转换成数字比较大小 int playerFinger = getValue(command); if (playerFinger == -1) {//用户输入的是E ==> -1 表示退出 break; } else if (playerFinger == 3) {//用户输入的是 E Z X C 之外的字符 ==> 3 表示输入的不是合法的，然后继续让用户重新输入 System.out.println("输入错误，请参考说明！"); continue; } //当用户输入 ZXC 中的字符时才会到这一步 //用户的输入转换成了 0，1，2 //finger[0]="剪刀" finger[1]="石头" finger[2]="布" 程序第一行定义好的 System.out.println("你出的是" + FINGERS[playerFinger]); //生成随机整数 3以内的（1，2，3） int cpuFinger = rad.nextInt(3); //finger[0]="剪刀" finger[1]="石头" finger[2]="布" 程序第一行定义好的 System.out.println("计算机出的是" + FINGERS[cpuFinger]); //比较两个数字，你可以理解 0 就是剪刀，1是石头 2 是布 int result = playerFinger - cpuFinger; if (0 == result) {//结果等于零说明两个数字一样 System.out.println("平局！"); draw++; } else if (-1 == result || 2 == result) {// 0-1=-1，1-2=-1，2-0=2 表示你输的三种情况 ；0 就是剪刀，1是石头 2 是布 System.out.println("你输了！"); loose++; } else {//剩下的情况除了平局，输局 肯定就是你赢了 System.out.println("你赢了！"); win++; } } System.out.println("游戏结束！ 游戏统计次数"); System.out.println(String.format("赢：%d 输：%d 平局：%d", win, loose, draw)); } /** * 用户输入字符进行转换 * 输入字符 E 就返回-1 作为后续判断，表示退出程序 * 输入字符 Z 返回 0 代表剪刀 * 输入字符 X 返回 1 代表石头 * 输入字符 C 返回 2 代表布 * 输入其他字符 返回3 ，表明输入的不是符合规则的手势（0，1，2） * * @param command * @return */ private static int getValue(String command) { if (command.equalsIgnoreCase("E")) { return -1; } if (command.equalsIgnoreCase("Z")) { return 0; } if (command.equalsIgnoreCase("X")) { return 1; } if (command.equalsIgnoreCase("C")) { return 2; } return 3; }}

楼上的说法都很正确，我就不用再回答了

public static void main(String[] args) { System.out.println("请输入："); try { char w = (char) System.in.read(); while (w != "n") { if (w == "D") { System.out.println("干燥"); w = (char) System.in.read(); } else if (w == "M") { System.out.println("啊啊"); w = (char) System.in.read(); } else if (w == " ") { w = (char) System.in.read(); } else { System.out.println("请输入："); w = (char) System.in.read(); } } } catch (Exception e) { e.printStackTrace(); } }

.equalsIgnoreCase()

int month = new Scanner(System.in).nextInt(); String s=(month>1&&month<=3)?"Spring":month<=6?"Summer":month<=9?"Autumn":month<=12?"Winter":"must be between 1 and 12"; System.out.println(s);