my-Java中常用类

Java中常用类

API （Application Programming Interface ），应用编程接口。

https://www.360docs.net/doc/ee23886.html,ng.Object 类

https://www.360docs.net/doc/ee23886.html,ng 包在使用的时候无需显式导入，编译时由编译器自动帮助我们导入。

当打印引用时，实际上会打印出引用所指对象的toString()方法的返回值，因为每个类都直接或间接地继承自Object，而Object 类中定义了toString()，因此每个类都有toString()这个方法。

Example:

public class TestObject

{

public static void main(String[] args)

{

Object obj = new Object();//只有一个无参的构造方法

System.out.println(obj);

System.out.println(obj.toString());

String str = “测试”;

System.out.println(str);

System.out.println(str.toString());

//为什么打印结果相同，很容易想到String类重写了Object的toString()方法}

}

class Person

{

public String toString()

{

return “Person类重写了toString()方法”;

}

}

关于进制的表示：16 进制，逢16 进一，16 进制的数字包括：0～9，A,B,C,D,E,F

equals()方法

该方法定义在Object 类当中，因此Java 中的每个类都具有该方法，对于Object类的equals()方法来说，它是判断调用equals()方法的引用与传进来的引用是否一致，即这两个引用是否指向的是同一个对象。对于Object 类的equals()方法来说，它等价于==。

对于String类的equals()方法来说，它是判断当前字符串与传进来的字符串的内容是否一致。

对于String 对象的相等性判断来说，请使用equals()方法，而不要使用==。

String类

String类在java中算是比较特殊的类.String类是不可变类，即String对象声明后，将不可修改。

String 是常量，其对象一旦创建完毕就无法改变。当使用+拼接字符串时，会生成新的String 对象，而不是向原有的String 对象追加内容。

实例化String类有两种方法：

●直接赋值的方式例如：String name=”张三”;

●直接调用String类中构造方法

String name = new String(“张三”);

String Pool（字符串池）

String s = “aaa”; （采用字面值方式赋值）

1) 查找String Pool中是否存在“aaa”这个对象，如果不存在，则在String Pool 中

创建一个“aaa”对象，然后将String Pool 中的这个“aaa”对象的地址返回来，赋给引用变量s，这样s会指向String Pool 中的这个“aaa”字符串对象

2) 如果存在，则不创建任何对象，直接将String Pool 中的这个“aaa”对象地址返

回来，赋给s 引用。

String s = new String(“aaa”);

1) 首先在String Pool 中查找有没有“aaa”这个字符串对象，如果有，则不在String

Pool中再去创建“aaa”这个对象了，直接在堆中（heap）中创建一个“aaa”字符串对象，然后将堆中的这个“aaa”对象的地址返回来，赋给s 引用，导致s 指向了堆中创建的这个“aaa”字符串对象。

2) 如果没有，则首先在String Pool 中创建一个“aaa“对象，然后再在堆中（heap）

创建一个”aaa“对象，然后将堆中的这个”aaa“对象的地址返回来，赋给s

引用，导致s 指向了堆中所创建的这个”aaa“对象。

题目一：

String str1 = new String("hello");

String str2 = new String("hello");

以上代码创建了几个对象？

创建了3个对象，堆区两个，常量池中一个。

使用String时，最好不要用new关键字，因为new String,会创建两个对象。

注意：只有采用双引号赋值字符串，那么在编译期将会放到方法区中的常量池中，如果运行时对字符串相加或相减，它是放到了堆中。

题目二：

给定以下字符串：TOM:90|FRANK:95|JSON:88

要求拆分，并打印出如下效果：

TOM-->90

FRANK-->95

JSON-->88

/*

功能：拆分字符串

*/

class TestString2

{

public static void main(String[] args)

{

String str = "TOM:90|FRANK:95|JSON:88";

String[] s1 = str.split("\\|");//|在java中表示“或”因此需要转义

for(String s : s1)

{

String[] s2 = s.split(":");

System.out.println(s2[0]+"-->"+s2[1]);

}

/*

for(int i = 0;i

{

String[] s2 = s1[i].split(":");

System.out.println(s2[0]+"-->"+s2[1]);

}

*/

}

题目三：

给定一个email地址，判断其是否合法的。

（提示：这里合法的要求只考虑email地址中是否有字符‘@’和‘.’并且‘@’必须在‘.’之前）

/*

功能：简单的验证email格式（包括@和.两个字符，并且@在.之前）

*/

class TestString3

{

public static void main(String[] args)

{

System.out.println(validateEmail("a@https://www.360docs.net/doc/ee23886.html,"));

}

private static boolean validateEmail(String email)

{

boolean flag = true;

if(email.indexOf("@")==-1 || email.indexOf(".")==-1 )

flag = false;

else if(email.indexOf("@") > email.indexOf(".") )

flag = false;

return flag;

}

}

String是不可变对象，如果多个字符串进行拼接，将会形成多个对象，这样可能造成内存溢出，会给垃圾回收带来工作量，如下面的应用最好不要用String。

public class TestString4 {

pubilc static void main(String[] args) {

String s = "";

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

/*以下语句会产生大量的对象，因为String为不可变对象，存在大量的对象相加或相减的时候，一般不建议使用String，建议使用StringBuffer或StringBuilder，优先选择StringBuilder，采用JProbe可以对内存进行分析*/

s += i;

}

}

}

包装类（Wrapper Class）

针对于原生数据类型的包装。所有的包装类（8个）都位于https://www.360docs.net/doc/ee23886.html,ng包下。

Java 中的8个包装类分别是：Byte,Short,Integer,Long,Float,Double,Character,Boolean。他们的使用方式都是一样的，可以实现原生数据类型与包装类型的双向转换。

基本类型的包装类主要提供了更多的实用操作，这样更容易处理基本类型。所有的包装类都是final的，所以不能创建其子类。

基本类型包装类

byte Byte

short Short

char Character

int Integer

long Long

float Float

double Double

boolean Boolean

类层次结构：

Example:

Public class TestInteger {

public static void main(String[] args) {

int i1 = 100;

Integer i2 = new Integer(i1);

double i3 = i2.doubleValue();

String s = "123":

int i4 = Integer.parseInt(s);

Integer i5 = new Integer(s);

Integer i6 = Integer.valueOf(s);

}

}

在JDK1.5以前，包装类和基本类型做运算时，必须将包装类转换成基本类型才可以，而JDK1.5提供Auto-boxing/unboxing（自动装箱和拆箱）

?自动将基础类型转换为对象

?自动将对象转换为基础类型

Example:

TestInteger2.java

public class TestInteger2 {

public static void main(String[] args) {

//在JDK1.5以前的版本，必须如下赋值

Integer i1 = new Integer(100);

//JDK1.5及以后版本，自动装箱

Integer i2 = 100;

//JDK1.5及以后版本，自动拆箱

int i3 = i2;

//在JDK1.5之前版本，必须如下赋值

int i4 = i2.intV alue();

}

}

Stringbuffer和StrubgBuilder

StringBuffer

StringBuffer称为字符串缓冲区，它的工作原理是：预先申请一块内存，存放字符序列，如果序列满了，会重新改变缓冲区的大小，以容纳更多的字符序列。StringBuffer是可变对象，这个是String最大的不同。

public class TestStringBuffer {

public static void main(String[] args) {

//StringBuffer sbString = new StringBuffer();

//完全可以修改为使用StringBuilder

StringBuilder sbString = new StringBuilder();

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

//sbString.append(i);

//sbString.append(",");

//也可以采用方法链编程

sbString.append(i).append(",");

System.out.println(sbString.toString());

//去除最后的逗号

System.out.println();

System.out.println(sbString.toString().substring(0,sbString.toString().length()-1));

}

}

}

StringBuilder

用法同StringBuffer，StringBuilder和StringBuffer的区别是：StrinbBuffer中所有的方法都是同步的，是线程安全的，但速度慢，StringBuilder的速度快，但不是线程安全的。

日期类

常用的日期类：

java.util.Date

java.text.SimpleDateFormat

java.util.Calendar

TestDate.java

public class TestDate {

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

//取得今天的日期

Date today = new Date();

System.out.println(today);

//格式化日期

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

System.out.println(sdf.format(today));

System.out.println(new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒").format(today));

//取得2012年9月16日是星期几？

Date d = new SimpleDateFormat("yyyy-MM-dd").parse("2012-09-16");

Calendar c = Calendar.getInstance();

//将日历修改为2012年9月16日

c.setTime(d);

//取得星期几

System.out.println(c.get(Calendar.DAY_OF_WEEK));

}

}

数字类

常用数字类：

java.text.DecimalFormat

java.math.BigDecimal：可以精确计算，特别在财务系统或银行系统

TestDecimal.java

import java.text.*;

public class TestDecimal {

public static void main() {

//加入千分位，保留两位小数

DecimalFormat df = new DecimalFormat("###,###,###.##");

System.out.println(df.format(12345.1234));

//加入千分位，保留六位小数，不够补0

System.out.println(new DecimalFormat("###,###,###,######").format(123456.1234));

System.out.println(new DecimalFormat("###,###,###,000000").format(123456.1234));

}

}

TestBigDecimal.java

import java.math.BigDecimal;

public class TestBigDecimal {

public static void main(String[] args) {

BigDecimal v1 = new BigDecimal(10);

BigDecimal v2 = new BigDecimal(20);

//加法运算

BigDecimal v3 = v1.add(v2);

System.out.println(v3);

}

}

Random

例子：

生成5个0~100之间的随机数。

import java.util.Random;

public class TestRandom {

public static void main(String[] args) {

Random r = new Random();

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

System.out.println(r.nextInt(100));

}

}

}

Enum枚举

1.为什么使用枚举？

TestEnum.java

public class TestEnum {

/*以下返回1或0存在一些问题，在编译时出现错误不容易发现，如：把返回值1改为了11，我们的程序仍然可以编译通过，因为1和11都是合法的数值，编译器无法检查（对于bug发现的越早越好，最好在编译阶段将所有的bug全部消灭）*/

public static void main(String[] args) {

int ret = method();

if(ret == 1) {

System.out.println("正确！");

}

if(ret == 0) {

System.out.println("错误！");

}

}

//正确返回1，错误返回0

private static int method() {

try {

//处理逻辑的代码

return 1;

} catch(Exception e) {

return 0;

}

}

}

2.改进以上的例子

TestEnum2.java

public class TestEnum2 {

/*此种方案比第一种方案好一些，有一个统一的约定，成功用1表示，失败用0表示

但也存在问题，如果不遵循约定，就会出现问题

成功返回的是SUCCESS，但是我们也可以改成数值型的-1，因为他们都是int类型，所以编译器认为都是合法的。

这样的话在编译阶段，就不能发现此问题，直到运行阶段才会发现该错误*/

private static final int SUCCESS = 1;

private static final int FAILURE = 0;

public static void main(String[] args) {

int ret = method();

if(ret == SUCCESS ) {

System.out.println("正确！");

}

if(ret == FAILURE) {

System.out.println("错误！");

}

}

//正确返回SUCCESS，错误返回FAILURE

private static int method() {

try {

//处理逻辑的代码

//return SUCCESS ;

return -1;

} catch(Exception e) {

return FAILURE;

}

}

}

3.采用枚举完善上面的例子

使用枚举类型，可以限定取值的范围，程序在编译阶段，就可以提早发现bug，这样的话，我们的程序就会更加的健壮。

TestEnum3.java

public class TestEnum3{

public static void main(String[] args) {

Result ret = method();

if(ret == Result .SUCCESS ) {

System.out.println("正确！");

}

if(ret == Result .FAILURE) {

System.out.println("错误！");

}

}

//正确返回SUCCESS，错误返回FAILURE

private static Result method() {

try {

//处理逻辑的代码

return Result .SUCCESS ;

} catch(Exception e) {

return Result .FAILURE;

}

}

enum Result {

SUCCESS,FAILURE

}

}