Java的char类型包含哪些数据？

java的char是2字节，16bit，包含所有ascii字符，而且更多，api文档里有描述

10年的岳麓网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。网络营销推广的优势是能够根据用户设备显示端的尺寸不同，自动调整岳麓建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联公司从事“岳麓网站设计”,“岳麓网站推广”以来，每个客户项目都认真落实执行。

char的数据是通过 UnicodeData 文件中的信息定义的，该文件是 Unicode Consortium 维护的 Unicode Character Database 的一部分。此文件指定了各种属性，其中包括每个已定义 Unicode 代码点或字符范围的名称和常规类别。

此文件及其描述可从 Unicode Consortium 获得，网址如下：

Unicode 字符表示形式

char 数据类型（和 Character 对象封装的值）基于原始的 Unicode 规范，将字符定义为固定宽度的 16 位实体。Unicode 标准曾做过修改，以允许那些其表示形式需要超过 16 位的字符。合法代码点 的范围现在是从 U+0000 到 U+10FFFF，即通常所说的 Unicode 标量值。（请参阅 Unicode 标准中 U+n 表示法的定义。）

从 U+0000 到 U+FFFF 的字符集有时也称为 Basic Multilingual Plane (BMP)。代码点大于 U+FFFF 的字符称为增补字符。Java 2 平台在 char 数组以及 String 和 StringBuffer 类中使用 UTF-16 表示形式。在这种表现形式中，增补字符表示为一对 char 值，第一个值取自高代理项 范围，即 (\uD800-\uDBFF)，第二个值取自低代理项 范围，即 (\uDC00-\uDFFF)。

所以，char 值表示 Basic Multilingual Plane (BMP) 代码点，其中包括代理项代码点，或 UTF-16 编码的代码单元。int 值表示所有 Unicode 代码点，包括增补代码点。int 的 21 个低位（最低有效位）用于表示 Unicode 代码点，并且 11 个高位（最高有效位）必须为零。除非另有指定，否则与增补字符和代理项 char 值有关的行为如下：

只接受一个 char 值的方法无法支持增补字符。它们将代理项字符范围内的 char 值视为未定义字符。例如，Character.isLetter('\uD840') 返回 false，即使是特定值，如果在字符串的后面跟着任何低代理项值，那么它将表示一个字母。

接受一个 int 值的方法支持所有 Unicode 字符，其中包括增补字符。例如，Character.isLetter(0x2F81A) 返回 true，因为代码点值表示一个字母（一个 CJK 象形文字）。

在 Java SE API 文档中，Unicode 代码点 用于范围在 U+0000 与 U+10FFFF 之间的字符值，而 Unicode 代码点 用于作为 UTF-16 编码的代码单元的 16 位 char 值。有关 Unicode 技术的详细信息，请参阅 Unicode Glossary。

java代码怎么实现 excel导入的文本值转换成日期

读取excel文件中日期内容是通过poi获取的,代码如下:

HSSFWorkbook excbook = new HSSFWorkbook(ExcFile);

//获取第一个sheet页 HSSFSheet excSheet = excbook.getSheetAt(0);

//获取第一行

HSSFRow oneRow = excSheet.getRow(0);

//获取第一行的第一个表格  

HSSFCell oneCell = oneRow.getCell(0);   

switch (oneCell.getCellType()) {

case HSSFCell.CELL_TYPE_NUMERIC:

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  

if(HSSFDateUtil.isCellDateFormatted(oneCell)){ 

String  str = sdf.format(HSSFDateUtil.getJavaDate(oneCell.getNumericCellValue())).toString();

System.out.println(str); 

}

break;

}

怎样用java代码获取txt文本的指定值

[Java] view plain copy

import java.io.*;

public class hh {

/**

* @param args

*/

public static void main(String[] args) {

// 指定读取的行号

int lineNumber = 2;

// 读取文件

//File sourceFile = new File("D:/java/test.txt");

File sourceFile = new File("C://TEXT.txt");

try {

// 读取指定的行

readAppointedLineNumber(sourceFile, lineNumber);

// 获取文件的内容的总行数

System.out.println(getTotalLines(sourceFile));

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

// 读取文件指定行。

static void readAppointedLineNumber(File sourceFile, int lineNumber)

throws IOException {

FileReader in = new FileReader(sourceFile);

LineNumberReader reader = new LineNumberReader(in);

String s = "";

if (lineNumber = 0 || lineNumber getTotalLines(sourceFile)) {

System.out.println("不在文件的行数范围(1至总行数)之内。");

System.exit(0);

}

int lines = 0;

while (s != null) {

lines++;

s = reader.readLine();

if((lines - lineNumber) == 0) {

System.out.println(s);

System.exit(0);

}

}

reader.close();

in.close();

}

// 文件内容的总行数。

static int getTotalLines(File file) throws IOException {

FileReader in = new FileReader(file);

LineNumberReader reader = new LineNumberReader(in);

String s = reader.readLine();

int lines = 0;

while (s != null) {

lines++;

s = reader.readLine();

if(lines=2){

if(s!=null){

System.out.println(s+"$");

}

}

}

reader.close();

in.close();

return lines;

}

}

如何查看jsp中java代码的值

jsp中查看java代码变量的值是通过打印的方式来查看的，最常用的是用c:out标签输出。

在Servlet文件中：

// 放入String类型，用c:out输出 String c_out_simple_string = "hello beijing 2008"; request.setAttribute("c_out_simple_string", c_out_simple_string);

在JSP文件中：

c_out_simple_string的值是： "${c_out_simple_string}"

c:out标签是JSTL的核心标签库中的一员，使用非常普遍且非常简单。在本示例中只使用c:out标签的value属性，value属性值的来源是EL表达式，通过EL表达式取出变量c_out_simple_string的值赋给c:out标签的value属性，然后通过c:out标签显示出来。

如何写出好的Java代码

如何写出好的Java代码

1． 优雅需要付出代价。

从短期利益来看，对某个问题提出优雅的解决方法，似乎可能花你更多的时间。但当它终于能够正确执行并可轻易套用于新案例中，不需要花上数以时计，甚至以天计或以月计的辛苦代价时，你会看得到先前所花功夫的回报（即使没有人可以衡量这一点）。这不仅给你一个可更容易开发和调试的程序，也更易于理解和维护。这正是它在金钱上的价值所在。这一点有赖某种人生经验才能够了解，因为当你努力让某一段程序代码变得比较优雅时，你并不是处于一种具生产力的状态下。但是，请抗拒那些催促你赶工的人们，因为那么做只会减缓你的速度罢了。

2． 先求能动，再求快。

即使你已确定某段程序代码极为重要，而且是系统的重要瓶颈，这个准则依然成立。尽可能简化设计，让系统能够先正确动作。如果程序的执行不够快，再量测其效能。几乎你总是会发现，你所认为的”瓶颈”其实都不是问题所在。把你的时间花在刀口上吧。

3． 记住”各个击破”的原理。

如果你所探讨的问题过于混杂，试着想像该问题的基本动作会是什么，并假设这一小块东西能够神奇地处理掉最难的部分。这”一小块”东西其实就是对象–请撰写运用该对象的程序代码，然后检视对象，并将其中困难的部分再包装成其他对象，依此类推。

4． 区分class开发者和class使用者（使用端程序员）。

Class 使用者扮演着”客户”角色，不需要（也不知道）class的底层运作方式。Class开发者必须是class设计专家，并撰写class，使它能够尽可能被大多数新手程序员所用，而且在程序中能够稳当执行。一套程序库只有在具备通透性的情况下，使用起来才会容易。

5．当你撰写class时，试着给予明了易懂的名称，减少不必要的注解。

你给客户端程序员的接口，应该保持概念上的单纯性。不了这个目的，当函数的重载（overloading）适合制作出直觉、易用的接口时，请善加使用。

6． 也必你的分析和设计必须让系统中的classes保持最少，须让其Public interfaces保持最少，以及让这些classes和其他classes之间的关联性（ 尤其是base classes）保持最少。

如果你的设计所得结果更甚于此，请问问自己，是否其中每一样东西在整个程序生命期中都饶富价值？如果并非如此，那么，维护它们会使你付出代价。开发团队的成员都有不维护”无益于生产力提升”的任何东西的倾向；这是许多设计方法无法解释的现象。

7． 让所有东西尽量自动化。先撰写测试用的程序代码（在你撰写class之前），并让它和class结合在一起。请使用makefile或类似工具，自动进行测试动作。

通过这种方式，只要执行测试程序，所有的程序变动就可以自动获得验证，而且可以立即发现错误。由于你知道的测试架构所具备的安全性，所以当你发现新的需求时，你会更勇于进行全面修改。请记住，程序语言最大的改进，是来自型别检查、异常处理等机制所赋予的内置测试动作。但这些功能只能协助你到达某种程度。开发一个稳固系统时，你得自己验证自己的classes或程序的性质。

8． 在你撰写class之前先写测试码，以便验证你的class 是否设计完备。如果你无法撰写测试码，你便无法知道你的class 的可能长相。撰写测试码通常能够显现出额外的特性（features）或限制 ( constraints)__它们并不一定总是能够在分析和设计过程中出现。测试码也可做为展示class 用法的示例程序。

9． 所有软件设计上的问题，都可以通过”引入额外的概念性间接层（conceptual indirection）”加以简化。这个软件工程上的基础法则是抽象化概念的根据，而抽象化概念正是面向对象程序设计的主要性质。

10． 间接层(indirection)应该要有意义（和准则-9致）。

这里所指的意义可以像”将共用程序代码置于惟一函数”这么简单。如果你加入的间接层（或抽象化、或封装等等）不具意义，它可能就和没有适当的间接层一样糟糕。

11． 让class尽可能微小而无法切割（atomic）。

赋予每个class单一而清楚的用途。如果你的classes或你的系统成长得过于复杂，请将复杂的classes切割成比较简单的几个classes。最明显的一个判断指针就是class的大小：如果它很大，那么它工作量过多的机会就可能很高，那就应该被切割。重新设计class的建议线索是：

1） 复杂的switch语句：请考虑运用多态（Polymorphism）。

2） 许多函数各自处理类型极为不同的动作：请考虑切割为多个不同的（classes）。

12． 小心冗长的引数列（argument lists）。

冗长的引数列会使函数的调用动作不易撰写、阅读、维护。你应该试着将函数搬移到更适当的class中，并尽量以对象为引数。

13． 不要一再重复。

如果某段程序代码不断出现于许多derived class函数中，请将该段程序代码置于某个base class 函数内，然后在derived class函数中调用。这么做不仅可以省下程序代码空间，也可以让修改该段程序代码动作更易于进行。有时候找出此种共通程序代码还可以为接口增加实用功能。

14． 小心switch语句或成串的if-else 子句。

通常这种情况代表所谓的”type-check coding”。也就是说究竟会执行哪一段程序代码，乃是依据某种型别信息来做抉择（最初，确切型别可能不十分明显）。你通常可以使用继承和多态来取代此类程序代码；Polymorphical method （多态函数）的调用会自动执行此类型别检验，并提供更可靠更容易的扩充性。

15． 从设计观点来看，请找出变动的事物，并使它和不变的事物分离。

也就是说，找出系统中可能被你改变的元素，将它们封装于classes中。你可以在《Thinking in Patterns with Java》（可免费下载于 www. BruceEckel. Com）大量学习到这种观念。

16． 不要利用subclassing来扩充基础功能。

如果某个接口元素对class而言极重要，它应该被放在base class 里头，而不是直到衍生（derivation）时才被加入。如果你在继承过程中加入了函数，或许你应该重新思考整个设计。

17． 少就是多。

从class 的最小接口开始妨展，尽可能在解决问题的前提下让它保持既小又单纯。不要预先考量你的class被使用的所有可能方式。一旦class被实际运用，你自然会知道你得如何扩充接口。不过，一旦class被使用后，你就无法在不影响客户程序代码的情况下缩减其接口。如果你要加入更多函数倒是没有问题–不会影响既有的客户程序代码，它们只需重新编译即可。但即使新函数取代了旧函数的功能，也请你保留既有接口。如果你得通过”加入更多引数”的方式来扩充既有函数的接口，请你以新引数写出一个重载化的函数；通过 这种方式就不会影响既有函数的任何客户了。

18． 大声念出你的classes,确认它们符合逻辑。

请base class和derived class 之间的关系是”is-a”(是一种)，让class和成员对象之间的关系是”has-a”(有一个)。

19． 当你犹豫不决于继承（inheritance）或合成（组合，composition）时，请你问问自己，是否需要向上转型（upcast）为基础型别。

如果不需要，请优先选择合成（也就是是使用成员对象）。这种作法可以消除”过多基础型别”。如果你采用继承，使用者会认为他们应该可以向上转型。

20． 运用数据成员来表示数值的变化，运用经过覆写的函数（overrided method）来代表行为的变化 。

也就是说，如果你找到了某个 class, 带有一些状态变量，而其函数会依据这些变量值切换不同的行为，那么你或许就应该重新设计，在subclasses 和覆写后的函数（overrided methods）中展现行为止的差异。

21． 小心重载（overloading）。

函数不应该依据引数值条件式地选择执行某一段程序代码。这种情况下你应该撰写两个或更多个重载函数（overloaded methods）

22． 使用异常体系（exception hierarchies）

最好是从Java标准异常体系中衍生特定的classes, 那么，捕捉异常的人便可以捕捉特定异常，之后才捕捉基本异常。如果你加入新的衍生异常，原有的客户端程序仍能通过其基础型别来捕捉它。

23． 有时候简单的聚合（aggregation）就够了。

飞机上的”旅客舒适系统”包括数个分离的元素：座椅、空调、视讯设备等等，你会需要在飞机上产生许多这样的东西。你会将它们声明为Private成员并开发出一个全新的接口吗？不会的，在这个例子中，元素也是Public接口的一部分，所以仍然是安全的。当然啦，简单聚合并不是一个常被运用的解法，但有时候的确是。

24． 试着从客户程序员和程序维护的角度思考。

你的class应该设计得尽可能容易使用。你应该预先考量可能性有的变动，并针对这些 可能的变动进行设计，使这些变动日后可轻易完成。

25． 小心”巨大对象并发症”。

这往往是刚踏OOP领域的过程式（procedural）程序员的一个苦恼，因为他们往往最终还是写出一个过程式程序，并将它们摆放到一个或两个巨大对象中。注意，除了application framework (应用程序框架，译注：一种很特殊的、大型OO程序库，帮你架构程序本体)之外，对象代表的是程序中的观念，而不是程序本身。

26． 如果你得用某种丑陋的方式来达成某个动作，请将丑陋的部分局限在某个class里头。

27． 如果你得用某种不可移植方式来达成某个动作，请将它抽象化并局限于某个class里头。这样一个”额外间接层”能够防止不可移植的部分扩散到整个程序。这种作法的具体呈现便是Bridge设计模式（design pattern）。

28． 对象不应仅仅只用来持有数据。

对象也应该具有定义明确界限清楚的行为。有时候使用”数据对象”是适当的，但只有在通用形容器不适用时，才适合刻意以数据对象来包装、传输一群数据项。

29． 欲从既有的classes身上产生新的classes时，请以组合(composition)为优先考量。

你应该只在必要时才使用继承。如果在组合适用之处你却选择了继承，你的设计就渗杂了非必要的复杂性。

30． 运用继承和函数覆写机制来展现行为上的差异，运用fields(数据成员)来展现状态上的差异。

这句话的极端例子，就是继承出不同的classes表现各种不同的颜色，而不使用”color”field.

31． 当心变异性（variance）。

语意相异的两个对象拥有相同的动作（或说责任）是可能的。OO世界中存在着一种天生的引诱，让人想要从某个class继承出另一个subclass,为的是获得继承带来的福利。这便是所谓”变异性”。但是，没有任何正当理由足以让我们强迫制造出某个其实并不存在的superclass/subclass关系。比较好的解决方式是写出一个共用的base class,它为两个derived classes制作出共用接口–这种方式会耗用更多空间，但你可以如你所盼望地从继承机制获得好处，而且或许能够在设计上获得重大发现。

32． 注意继承上的限制。

最清晰易懂的设计是将功能加到继承得来的class里头；继承过程中拿掉旧功能（而非增加新功能）则是一种可疑的设计。不过，规则可以打破。如果你所处理的是旧有的class程序库，那么在某个class的subclass限制功能，可能会比重新制定整个结构（俾使新class得以良好地相称于旧 class）有效率得多。

33． 使用设计模式（design patterns）来减少”赤裸裸无加掩饰的机能（naked functionality）”。

举个例子，如果你的class只应该产出惟一一个对象，那么请不要以加思索毫无设计的手法来完成它，然后撰写”只该产生一份对象”这样的注解就拍拍屁股走人。请将它包装成singleton（译注：一个有名的设计模式，可译为”单件”）。如果主程序中有多而混乱的”用以产生对象”的程序代码，请找出类似 factory method这样的生成模式（creational patterns），使价钱可用以封装生成动作减少”赤裸裸无加掩饰的机能”（naked functionality）不仅可以让你的程序更易理解和维护，也可以阻止出于好意却带来意外的维护者。

34． 当心”因分析而导致的瘫痪（analysis paralysis）”。

请记住，你往往必须在获得所有信息之前让项目继续前进。而且理解未知部分的最好也最快的方式，通常就是实际前进一步而不只是纸上谈兵。除非找到解决办法，否则无法知道解决办法。Java拥有内置的防火墙，请让它们发挥作用。你在单一class或一组classes中所犯的错误，并不会伤害整个系统的完整性。

35． 当你认为你已经获得一份优秀的分析、设计或实现时，请试着加以演练。

将团队以外的某些人带进来-他不必非得是个顾问不可，他可以是公司其他团队的成员。请那个人以新鲜的姿态审视你们的成果，这样可以在尚可轻易修改的阶段找出问题，其收获会比因演练而付出的时间和金钱代价来得高。实现 （Implementation）

36. 一般来说，请遵守Sun的程序编写习惯。

价钱可以在以下网址找到相关文档：java.sun.com/docs/codeconv/idex.html。本书尽可能遵守这些习惯。众多Java程序员看到的程序代码，都有是由这些习惯构成的。如果你固执地停留在过去的编写风格中，你的（程序代码）读者会比较辛苦。不论你决定采用什么编写习惯，请在整个程序中保持一致。你可以在home.wtal.de/software-solutions/jindent上找到一个用来重排Java程序的免费工具。

37. 无论使用何种编写风格，如果你的团队（或整个公司，那就更好了）能够加以标准化，那么的确会带来显著效果。这代表每个人都可以在其他人不遵守编写风格修改其作品，这是个公平的游戏。标准化的价值在于，分析程序代码时所花的脑力较小，因而可以专心于程序代码的实质意义。

38. 遵守标准的大小写规范。

将 class名称的第一个字母应为大写。数据成员、函数、对象（references）的第一个字母应为小写。所有识别名称的每个字都应该连在一块儿，所有非首字的第一个字母都应该大写。例如： ThisIsAClassName thisIsAMethodOrFieldName 如果你在static final 基本型别的定义处指定了常量初始式（constant initializers）,那么该识别名称应该全为大写，代表一个编译期常量。 Packages是个特例，其名称皆为小写，即使非首字的字母亦是如此。域名（org, net, edu 等等）皆应为小写。（这是Java 1.1迁移至Java 2时的一项改变） 。

39、不要自己发明”装饰用的”Private数据成员名称。

通常这种的形式是在最前端加上底线和其他字符，匈牙利命名法（Hungarian notation）是其中最差的示范。在这种命名法中，你得加入额外字符来表示数据的型别、用途、位置等等。仿佛你用的是汇编语言（assembly language）而编译器没有提供任何协肋似的。这样的命名方式容易让人混淆又难以阅读，也不易推行和维护。就让classes和packages来进行”名称上的范

围制定（name scoping）”吧。

40、当你拟定通用性的class时，请遵守正规形式（canonical form）。

包括equals( )、hashCode( )、clone( ) ( 实现出Cloneable),并实现出Comparable和Serialiable等等。

41、对于那些”取得或改变Private数据值”的函数，请使用Java Beans 的”get”、”set”、”is”等命名习惯，即使你当时不认为自己正在撰写Java Bean。这么做不仅可以轻易以Bean的运用方式来运用你的class,也是对此类函数的一种标准命名方式，使读者更易于理解。

42、对于你所拟定的每一个class，请考虑为它加入static public test( )，其中含有class功能测试码。

你不需要移除该测试就可将程序纳入项目。而且如果有所变动，你可以轻易重新执行测试。这段程序代码也可以做为class的使用示例。

43、有时候你需要通过继承，才得以访问base class的protected成员。

这可能会引发对多重基类（multiple base types）的认识需求。如果你不需要向上转型，你可以先衍生新的class发便执行protected访问动作，然后在”需要用到上述 protected成员”的所有classes中，将新class声明为成员对象，而非直接继承。

44、避免纯粹为了效率考量而使用final函数。

只有在程序能动但执行不够快时，而且效能量测工具（profiler）显示某个函数的调用动作成为瓶颈时，才使用final函数。

45、如果两个classes因某种功能性原因而产生了关联（例如容器containers和迭代器iterators）,那么请试着让其中某个class成为另一个class 的内隐类（inner class）。

这不仅强调二者间的关联，也是通过”将class名称嵌套置于另一个class 内”而使同一个class 名称在单一Package中可被重复使用。Java 容器库在每个容器类中都定义了一个内隐的（inner）Iterator class,因而能够提供容器一份共通接口。运用内隐类的另一个原因是让它成为private实现物的一部分。在这里，内隐类会为信息隐藏带来好处，而不是对上述的class关联性提供肋益，也不是为了防止命名空间污染问题(namespace pollution)。

46、任何时候你都要注意那些高度耦合（coupling）的 classes.请考虑内隐类（inner classes）为程序拟定和维护带来的好处。内隐类的使用并不是要去除classes间的耦合，而是要让耦合关系更明显也更便利。

47、不要成为”过早最佳化”的牺牲品。

那会让人神经错乱。尤其在系统建构初期，先别烦恼究竟要不要撰写（或避免）原生函数（native methods）、要不要将某些数声明为final、要不要调校程序代码效率等等。你的主要问题应该是先证明设计的正确性，除非设计本身需要某种程度的效率。

48、让范围（作用域，scope）尽可能愈小愈好，这么一来对象的可视范围和寿命都将尽可能地小。

这种作法可降低”对象被用于错误场所，因而隐藏难以察觉的臭虫”的机会。假设你有个容器，以及一段走访该容器的程序片段。如果你复制该段程序代码，将它用于新的容器身上，你可能会不小心以旧容器的大小做为新容器的走访上限值。如果旧容器已不在访问范围内，那么编译期便可找出这样的错误。

49、使用Java 标准程序库提供的容器。

请熟悉他们的用法。你将因此大幅提升你的生产力。请优先选择ArrayList来处理序列（sequences），选择HashSet来处理集合（sets）、选择HashMap来处理关联式数组（associative arrays），选择Linkedlist (而不是Stack) 来处理 shacks和queues。

50、对一个强固的（robust）程序而言，每一个组成都必须强固。

请在你所撰写的每个class中运用Java 提供的所有强固提升工具：访问权限、异常、型别检验等等。通过这种方式，你可以在建构系统时安全地移往抽象化的下一个层次。

51、宁可在编译期发生错误，也不要在执行期发生错误。

试着在最靠近问题发生点的地方处理问题。请优先在”掷出异常之处”处理问题，并在拥有足够信息以处理异常的最接近处理函数（handler）中捕捉异常。请进行现阶段你能够对该异常所做的处理；如果你无法解决问题，应该再次掷出异常。

52、当心冗长的函数定义。

函数应该是一种简短的、”描述并实现class接口中某个可分离部分”的功能单元。过长且复杂的函数不仅难以维护，维护代价也高。或许它尝试做太多事情了。如果你发现这一类函数，代表它应该被切割成多相函数。这种函数也提醒你或许得撰写新的class。小型函数同样能够在你的class中被重复运用。（有时候函数必须很大才行，但它们应该只做一件事情。）

53、尽可能保持”Private”。

一旦你对外公开了程序库的概况（method、Class 或field）。你便再也无法移除它们。因为如果移除它们，便会破坏某个现有的程序代码，使得它们必须重新被编写或重新设计。如果你只公开必要部分，那么你便可以改变其他东西而不造成伤害。设计总是会演化，所以这是个十分重要的自由度。通过这种方式，实现码的更动对derived class 造成的冲击会降最低。在多线程环境下，私密性格外重要-只有private数据可受保护而不被un-synchronized（未受同步控制）的运用所破坏。

54、大量运用注解，并使用javadoc的”注解文档语法”来产生程序的说明文档。

不过注解应该赋予程序代码真正的意义；如果只是重申程序代码已经明确表示的内容，那是很烦人的。请注意，通常Java class和其函数的名称都很长，为的便是降低注解量。

55、避免使用”魔术数字”，也就是那种写死在程序代码里头的数字–如果你想改变它们，它们就会成为你的恶梦，因为你永远都没有办法知道”100″究竟代表” 数组大小”或其他东西。你应该产生具描述性的常量度名称，并在程序中使用该常量名称。这使程序更易于理解也更易于维护。

56、撰写构造函数时，请考虑异常状态。最好情境下，构造函数不执行任何会掷出异常的动作。

次佳情境下，class 只继承自（或合成自）强固的（robust）classes，所以如有任何异常被掷出，并不需要清理。其他情况下，你就得在finally子句清理合成后的classes。如果某个构造函数一定会失败，适当的动作就是掷出异常，使调用者不至于盲目认为对象已被正确产生而继续执行。

57、如果你的class需要在”客户程序员用完对象”后进行清理动作，请将清理动作，放到单一而定义明确的函数中。最好令其名称为cleanup() 以便能够将用途告诉他人。此外请将boolean旗标放到class中，用以代表对象是否已被清理，使finalize()得以检验其死亡条件（请参考第 4章）。

58、finalize() 只可用于对象死亡条件的检验（请参考4章），俾有益于调试。

特殊情况下可能需要释放一些不会被垃圾回收的内存。因为垃圾回收器可能不会被唤起处理你的对象，所以你无法使用finalize()执行必要的清理动作。基于这个原因，你得拟定自己的”清理用”函数。在class finalize()中，请检查确认对象的确已被清理，并在对象尚未被清理时，掷出衍生自Runtime Exception 的异常。使用这种架构前，请先确认finalize()在你的系统上可正常动作（这可能需要调用System.gc()来确认）。

59、如果某个对象在某个特定范围（scope）内必须被清理（cleaned up）,而不是被垃圾回收机制收回，请使用以下方法；将对象初始化，成功后立刻进入拥有finally子句的一个try区段内。Finally子句会引发清理动作。

60、当你在继承过程中覆写了finalize(),请记得调用super. Finalize()。

但如果你的”直接上一层superclass”是Object，，就不需要这个动作。你应该让super.finalize() 成为被覆写（overridden）之finalize()的最后一个动作而不是第一个动作，用以确保base class的组件在你需要它们的时候仍然可用。

61、当你撰写固定大小的对象容器，请将它们转换为数组–尤其是从某个函数返回此一容器时。

通过这种方式，你可以获得数组的”编译期型别检验”的好处，而且数组接收者可能不需要”先将数组中的对象加以转型”便能加以使用。请注意，容器库的base class (Java. Util. Collection) 具有两个toArray()，能够达到这个目的。

62、在interface(接口)和abstract class(抽象类)之间，优先选择前者。

如果你知道某些东西即将被设计为一个base class,你的第一选择应该是让它成为interface;只有在一定得放进函数或数据成员时，才应该将它改为abstract class. Interface只和”客户端想进行什么动作”有关，class则比较把重心放在实现细节上。

63、在构造函数中只做惟一必要动作：将对象设定至适当状态。

避免调用其他函数（除了final函数），因为这些函数可能会被其他人覆写因而使你在建构过程中得不可预期的结果（请参考第7章以取得更详细的信息）。小型而简单的构造函数比较不可能掷出异常或引发问题。

64、为了避免一个十分令人泄气的经验，请确认你的classpath中的每个名称，都只有一个未被放到packages里头class。否则编译器会先找到另一个名称相同的class，并回报错误消息。如果你怀疑你的classpath出了问题，试着从classpath中的每个起点查找同名的.class文件。最好还是将所有classes都放到packages里头。

65、留意一不小心犯下的重载（overloading）错误。

如果你覆写base class 函数时没有正确拼写其名称，那么便会增加一个新的函数，而不是覆写原有的函数。但是情况完全合法，所以你不会从编译器或执行期系统得到任何错误消息–你的程序代码只是无法正确作用，如此而已。

66、当心过早最佳化。

先让程序动起来，再让它快–但只有在你必须（也就是说只有在程序被证明在某段程序代码上遭遇效能瓶颈）时才这么做。除非你已经使用效能量测工具（profiler）找出瓶颈所在，否则你可能性只是在浪费你的时间。效能调校的”隐藏成本”便是让你的程序代码变得更不可读、更难维持。

67、记住，程序代码被阅读的时间多于它被撰写的时间。

清晰的设计能够制作出去易懂的程序。注解、细节说明、示例都是无价的。这些东西能够帮助你和你的后继者。如果没有其他信息，那么Java 线上文档找出一些有用的信息时，你所遭遇的挫败应该足以让你相信这一点。

java中字符、字符串的常用方法

char的所有方法:

static int charCount(int codePoint)

确定表示指定字符（Unicode 代码点）所需的 char 值的数量。

char charValue()

返回此 Character 对象的值。

static int codePointAt(char[] a, int index)

返回 char 数组的给定索引上的代码点。

static int codePointAt(char[] a, int index, int limit)

返回 char 数组的给定索引上的代码点，该数组中只有那些具有小于 limit 的 index 值的数组元素可以使用。

static int codePointAt(CharSequence seq, int index)

返回 CharSequence 的给定索引上的代码点。

static int codePointBefore(char[] a, int index)

返回 char 数组的给定索引前面的代码点。

static int codePointBefore(char[] a, int index, int start)

返回 char 数组的给定索引前面的代码点，该数组中只有那些具有大于等于 start 的 index 值的数组元素可以使用。

static int codePointBefore(CharSequence seq, int index)

返回 CharSequence 的给定索引前面的代码点。

static int codePointCount(char[] a, int offset, int count)

返回 char 数组参数的子数组中 Unicode 代码点的数量。

static int codePointCount(CharSequence seq, int beginIndex, int endIndex)

返回指定字符序列的文本范围内的 Unicode 代码点数量。

int compareTo(Character anotherCharacter)

根据数字比较两个 Character 对象。

static int digit(char ch, int radix)

返回使用指定基数的字符 ch 的数值。

static int digit(int codePoint, int radix)

返回使用指定基数的指定字符（Unicode 代码点）的数值。

boolean equals(Object obj)

将此对象与指定对象比较。

static char forDigit(int digit, int radix)

确定使用指定基数的特定数字的字符表示形式。

static byte getDirectionality(char ch)

返回给定字符的 Unicode 方向属性。

static byte getDirectionality(int codePoint)

返回给定字符（Unicode 代码点）的 Unicode 方向属性。

static int getNumericValue(char ch)

返回指定的 Unicode 字符表示的 int 值。

static int getNumericValue(int codePoint)

返回指定字符（Unicode 代码点）表示的 int 值。

static int getType(char ch)

返回一个指示字符的常规类别的值。

static int getType(int codePoint)

返回一个指示字符的常规类别的值。

int hashCode()

返回此 Character 的哈希码。

static boolean isDefined(char ch)

确定字符是否被定义为 Unicode 中的字符。

static boolean isDefined(int codePoint)

确定字符（Unicode 代码点）是否被定义为 Unicode 中的字符。

static boolean isDigit(char ch)

确定指定字符是否为数字。

static boolean isDigit(int codePoint)

确定指定字符（Unicode 代码点）是否为数字。

static boolean isHighSurrogate(char ch)

确定给出的 char 值是否为一个高代理项代码单元（也称为前导代理项代码单元）。

static boolean isIdentifierIgnorable(char ch)

确定是否应该认为指定字符是 Java 标识符或 Unicode 标识符中可忽略的一个字符。

static boolean isIdentifierIgnorable(int codePoint)

确定是否应该认为指定字符（Unicode 代码点）是 Java 标识符或 Unicode 标识符中可忽略的一个字符。

static boolean isISOControl(char ch)

确定指定字符是否为 ISO 控制字符。

static boolean isISOControl(int codePoint)

确定引用的字符（Unicode 代码点）是否为 ISO 控制字符。

static boolean isJavaIdentifierPart(char ch)

确定指定字符是否可以是 Java 标识符中首字符以外的部分。

static boolean isJavaIdentifierPart(int codePoint)

确定字符（Unicode 代码点）是否可以是 Java 标识符中首字符以外的部分。

static boolean isJavaIdentifierStart(char ch)

确定是否允许将指定字符作为 Java 标识符中的首字符。

static boolean isJavaIdentifierStart(int codePoint)

确定是否允许将字符（Unicode 代码点）作为 Java 标识符中的首字符。

static boolean isJavaLetter(char ch)

已过时。 由 isJavaIdentifierStart(char) 取代。

static boolean isJavaLetterOrDigit(char ch)

已过时。 由 isJavaIdentifierPart(char) 取代。

static boolean isLetter(char ch)

确定指定字符是否为字母。

static boolean isLetter(int codePoint)

确定指定字符（Unicode 代码点）是否为字母。

static boolean isLetterOrDigit(char ch)

确定指定字符是否为字母或数字。

static boolean isLetterOrDigit(int codePoint)

确定指定字符（Unicode 代码点）是否为字母或数字。

static boolean isLowerCase(char ch)

确定指定字符是否为小写字母。

static boolean isLowerCase(int codePoint)

确定指定字符（Unicode 代码点）是否为小写字母。

static boolean isLowSurrogate(char ch)

确定给定 char 值是否一个低代理项代码单元（也称为尾部代理项代码单元）。

static boolean isMirrored(char ch)

确定指定字符依据 Unicode 规范是否对称。

static boolean isMirrored(int codePoint)

确定指定字符（Unicode 代码点）依据 Unicode 规范是否对称。

static boolean isSpace(char ch)

已过时。 由 isWhitespace(char) 取代。

static boolean isSpaceChar(char ch)

确定指定字符是否为 Unicode 空白字符。

static boolean isSpaceChar(int codePoint)

确定指定字符（Unicode 代码点）是否为 Unicode 空白字符。

static boolean isSupplementaryCodePoint(int codePoint)

确定指定字符（Unicode 代码点）是否在增补字符范围内。

static boolean isSurrogatePair(char high, char low)

确定指定的 char 值对是否为有效的代理项对。

static boolean isTitleCase(char ch)

确定指定字符是否为首字母大写字符。

static boolean isTitleCase(int codePoint)

确定指定字符（Unicode 代码点）是否为首字母大写字符。

static boolean isUnicodeIdentifierPart(char ch)

确定指定字符是否可以是 Unicode 标识符中首字符以外的部分。

static boolean isUnicodeIdentifierPart(int codePoint)

确定指定字符（Unicode 代码点）是否可以是 Unicode 标识符中首字符以外的部分。

static boolean isUnicodeIdentifierStart(char ch)

确定是否允许将指定字符作为 Unicode 标识符中的首字符。

static boolean isUnicodeIdentifierStart(int codePoint)

确定是否允许将指定字符（Unicode 代码点）作为 Unicode 标识符中的首字符。

static boolean isUpperCase(char ch)

确定指定字符是否为大写字母。

static boolean isUpperCase(int codePoint)

确定指定字符（Unicode 代码点）是否为大写字母。

static boolean isValidCodePoint(int codePoint)

确定指定的代码点是否为从 0x0000 到 0x10FFFF 范围之内的有效 Unicode 代码点值。

static boolean isWhitespace(char ch)

确定指定字符依据 Java 标准是否为空白字符。

static boolean isWhitespace(int codePoint)

确定指定字符（Unicode 代码点）依据 Java 标准是否为空白字符。

static int offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)

返回给定 char 子数组中的索引，它是从给定 index 到 codePointOffset 代码点的偏移量。

static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset)

返回给定字符序列中的索引，它是从给定 index 到 codePointOffset 代码点的偏移量。

static char reverseBytes(char ch)

返回通过反转指定 char 值中的字节顺序而获得的值。

static char[] toChars(int codePoint)

将指定的字符（Unicode 代码点）转换成其存储在 char 数组中的 UTF-16 表示形式。

static int toChars(int codePoint, char[] dst, int dstIndex)

将指定字符（Unicode 代码点）转换为其 UTF-16 表示形式。

static int toCodePoint(char high, char low)

将指定的代理项对转换为其增补代码点值。

static char toLowerCase(char ch)

使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。

static int toLowerCase(int codePoint)

使用取自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为小写。

String toString()

返回表示此 Character 值的 String 对象。

static String toString(char c)

返回一个表示指定 char 值的 String 对象。

static char toTitleCase(char ch)

使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为首字母大写。

static int toTitleCase(int codePoint)

使用取自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为首字母大写。

static char toUpperCase(char ch)

使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。

static int toUpperCase(int codePoint)

使用取自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为大写。

static Character valueOf(char c)

返回一个表示指定 char 值的 Character 实例

string所有方法:

char charAt(int index)

返回指定索引处的 char 值。

int codePointAt(int index)

返回指定索引处的字符（Unicode 代码点）。

int codePointBefore(int index)

返回指定索引之前的字符（Unicode 代码点）。

int codePointCount(int beginIndex, int endIndex)

返回此 String 的指定文本范围中的 Unicode 代码点数。

int compareTo(String anotherString)

按字典顺序比较两个字符串。

int compareToIgnoreCase(String str)

按字典顺序比较两个字符串，不考虑大小写。

String concat(String str)

将指定字符串连接到此字符串的结尾。

boolean contains(CharSequence s)

当且仅当此字符串包含指定的 char 值序列时，返回 true。

boolean contentEquals(CharSequence cs)

将此字符串与指定的 CharSequence 比较。

boolean contentEquals(StringBuffer sb)

将此字符串与指定的 StringBuffer 比较。

static String copyValueOf(char[] data)

返回指定数组中表示该字符序列的 String。

static String copyValueOf(char[] data, int offset, int count)

返回指定数组中表示该字符序列的 String。

boolean endsWith(String suffix)

测试此字符串是否以指定的后缀结束。

boolean equals(Object anObject)

将此字符串与指定的对象比较。

boolean equalsIgnoreCase(String anotherString)

将此 String 与另一个 String 比较，不考虑大小写。

static String format(Locale l, String format, Object... args)

使用指定的语言环境、格式字符串和参数返回一个格式化字符串。

static String format(String format, Object... args)

使用指定的格式字符串和参数返回一个格式化字符串。

byte[] getBytes()

使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

byte[] getBytes(Charset charset)

使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。

void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)

已过时。 该方法无法将字符正确转换为字节。从 JDK 1.1 起，完成该转换的首选方法是通过 getBytes() 方法，该方法使用平台的默认字符集。

byte[] getBytes(String charsetName)

使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

将字符从此字符串复制到目标字符数组。

int hashCode()

返回此字符串的哈希码。

int indexOf(int ch)

返回指定字符在此字符串中第一次出现处的索引。

int indexOf(int ch, int fromIndex)

返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。

int indexOf(String str)

返回指定子字符串在此字符串中第一次出现处的索引。

int indexOf(String str, int fromIndex)

返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

String intern()

返回字符串对象的规范化表示形式。

boolean isEmpty()

当且仅当 length() 为 0 时返回 true。

int lastIndexOf(int ch)

返回指定字符在此字符串中最后一次出现处的索引。

int lastIndexOf(int ch, int fromIndex)

返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。

int lastIndexOf(String str)

返回指定子字符串在此字符串中最右边出现处的索引。

int lastIndexOf(String str, int fromIndex)

返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

int length()

返回此字符串的长度。

boolean matches(String regex)

告知此字符串是否匹配给定的正则表达式。

int offsetByCodePoints(int index, int codePointOffset)

返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。

boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)

测试两个字符串区域是否相等。

boolean regionMatches(int toffset, String other, int ooffset, int len)

测试两个字符串区域是否相等。

String replace(char oldChar, char newChar)

返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

String replace(CharSequence target, CharSequence replacement)

使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。

String replaceAll(String regex, String replacement)

使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

String replaceFirst(String regex, String replacement)

使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

String[] split(String regex)

根据给定正则表达式的匹配拆分此字符串。

String[] split(String regex, int limit)

根据匹配给定的正则表达式来拆分此字符串。

boolean startsWith(String prefix)

测试此字符串是否以指定的前缀开始。

boolean startsWith(String prefix, int toffset)

测试此字符串从指定索引开始的子字符串是否以指定前缀开始。

CharSequence subSequence(int beginIndex, int endIndex)

返回一个新的字符序列，它是此序列的一个子序列。

String substring(int beginIndex)

返回一个新的字符串，它是此字符串的一个子字符串。

String substring(int beginIndex, int endIndex)

返回一个新字符串，它是此字符串的一个子字符串。

char[] toCharArray()

将此字符串转换为一个新的字符数组。

String toLowerCase()

使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

String toLowerCase(Locale locale)

使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。

String toString()

返回此对象本身（它已经是一个字符串！）。

String toUpperCase()

使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

String toUpperCase(Locale locale)

使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。

String trim()

返回字符串的副本，忽略前导空白和尾部空白。

static String valueOf(boolean b)

返回 boolean 参数的字符串表示形式。

static String valueOf(char c)

返回 char 参数的字符串表示形式。

static String valueOf(char[] data)

返回 char 数组参数的字符串表示形式。

static String valueOf(char[] data, int offset, int count)

返回 char 数组参数的特定子数组的字符串表示形式。

static String valueOf(double d)

返回 double 参数的字符串表示形式。

static String valueOf(float f)

返回 float 参数的字符串表示形式。

static String valueOf(int i)

返回 int 参数的字符串表示形式。

static String valueOf(long l)

返回 long 参数的字符串表示形式。

static String valueOf(Object obj)

返回 Object 参数的字符串表示形式

文章题目：java代码有效文字值,java显示文字代码
链接地址：http://pwwzsj.com/article/dssigpd.html