Java基本数据类型和String ，及其使用

一、基本数据

虽然本文很简单，但是，这是基础必备的内容。其实内容也很好记，可是时间久了就容易忘记，所以还是有必要记录一下

1.基本数据类型及其大小

基本类型	大小	包装类
boolean	-	Boolean
char	2	Character
byte	1	Byte
short	2	Short
int	4	Integer
float	4	Float
long	8	Long
double	8	Double

2.Math类相关函数

double floor(double a);

表示向下取整，即小于等于a的最大整数，虽然返回类型是double型，但是，表示的还是个int
数据，因此需要强制类型转换为int。

例如：Math.floor(1.5)=1 ,
　　　Math.floor(-1.5)=-2 .

原理很简单，但是如果你觉得很容易记混，不妨用数轴来记忆：

-2　 -1.5　 -1　 -0.5　 0 　　0.5 　 1　　1.5
-----^----------^----------^----------^------------>

从数轴上面就可以看出，不超过1.5的整数是1，不超过-1.5的整数是-2

long round(double a)

就是小学中数学学的四舍五入，内部的实现为：Math.floor(x+0.5)，即将原来的数+0.5，再取不超过这个数的最大整数。

例如：Math.round(-1.5)=1 ,
　　　Math.round(1.5)=2 .

同样，我们可以借助上面的数轴来记忆，-1.5+0.5=-1，因此，-1.5的round值就是-1 .

double ceil(double a)

表示向上取整，即大于等于a的最小整数，与floor概念相反。

如：Math.ceil(1.5)=2 ,
　　Math.ceil(-1.5)=-1 .

double random()

产生随机数，随机数范围为[0,1)，如果需要生成指定范围的随机数代码可如下：

public static double random(double min, double max) { 
    double r = Math.random();  
    return min + (max - min) * r; 
}

3. Integer的 == 比较

关于Integer，你知道多少？
　Integer的是int的包装类，int的初值为0，Ingeter的初值为null。我们先看一段代码：

public static void main(String[] args) { 
   Integer a1=1; 
   Integer a2=1; 
   Integer c1=new Integer(1); 
   Integer c2=new Integer(1); 

   Integer b1=200; 
   Integer b2=200; 
   Integer d1=new Integer(200); 
   Integer d2=new Integer(200); 

   System.out.println("a1==a2 ? "+(a1==a2)); 
   System.out.println("b1==b2 ? "+(b1==b2)); 
   System.out.println("c1==c2 ? "+(c1==c2)); 
   System.out.println("d1==d2 ? "+(d1==d2)); 
}

运行结果你都知道吗？先别看后面的运行结果，自己先写出答案，然后将你的答案跟运行结果比较一下！

运行结果：
a1==a2 ? true
b1==b2 ? false
c1==c2 ? false
d1==d2 ? false

为什么是这样的呢？我们一个一个解释。先比较a和b两组，Integer初始化时，缓存Integer对象数据，这些Integer对象对应的int值为byte范围，即[-128,127]。当直接给Integer赋int值时，如果值得范围为[-128,127]，Integer直接从缓存中取Integer对象，因此，当直接赋的int值处于[-128,127]时，Integer对象为相同的对象。而通过new方式取的Integer对象，是直接从堆里面分配的对象，因此，不管具体的int
值为多少，==判断的结果都是false

---

---

二、String类型

我们平时所接触的最多的类型可以算的上是String了，而Java库中的String类封装的非常完善，正因如此，我们需要好好研究一下String！

1、 equals与==的区别

==：对于基本类型，比较的是它们的值。对于复合类型（直接在堆中分配空间），比较的是它们在内存中的地址。
　　equals：该方法属于Object，而所有类都继承于Object，这个基类，因此每个类都有这个方法。Object类中equals的默认实现是 **return (this == obj); ** ，即默认是比较对象的内存地址。但在库中的一些类会覆盖从写equals这个方法，如：String、Integer、Date这些类中equals有自身的实现，而不再是比较类在堆内存中的地址。String中的equals，首先判断==，如果地址相同，那一定是返回true；如果地址不相同，再比较字符串字面值是否相等。

2、 Switch能否用string做参数？

在Java7之前，switch只支持byte、short、char、int及其对应的封装类，以及Enum类型，
　　在Java 7之后（Java7和Java8），String类型被加上。

3 String、StringBuffer与StringBuilder的区别

（1） 字符串是否可变：
　　String: 使用字符数组保存字符串：private final char value[];关键字final决定了String对象不可变。
　　StringBuilder和StringBuffer继承自AbStractStringBuilder类，AbstractStringBuilder类也是使用字符数组保存字符串：char[] value;没有final，可知这两个对象都是可变的。
（2）线程安全：
　　String对象不可变，也就可以理解为常量，显然线程安全。
　　StringBuffer对方法加了同步锁，因此是线程安全的。
　　StringBuilder没有加锁，是非线程安全的。

4、String 常用的函数

4.1、split

split函数原型为：String[] split(String regex)。参数regex不是一个简单的字符串，而是一个正则表达式。因此，对于正则表达式中的关键字你需要使用转意符\，例如.和|都是转义字符,必须得加"\"：如果用.作为分隔的话,必须写为String.split("\.")，而不能直接这样String.split(".");如果用|作为分隔的话,必须写为String.split("\|")，而不能直接这样String.split("|");如果在一个字符串中有多个分隔符,可以用|作为连字符，比如待分割的字符串为String s="my; name,is HuaChao"，如果希望把单词提取出来（以标点符号和空格为分割字符），可以写为：s.split(",| |;");注意， 两个|之间有空格，",| |;"表示，以,或空格以及;分割字符串。

4.2 replace、replaceAll、replaceFirst

先分别看看它们的函数原型(replace有两个重载函数）：replace:原型为String replace(char oldChar, char newChar) ，即将所有的oldChar字符替换为newChar字符replace:原型为String replace(CharSequence target, CharSequence eplacement) ，即将所有的target字符串替换为replacement字符串.
　　replaceAll：原型为String replaceAll(String regex, String replacement)，参数regex
从名称可以看出，它是一个正则表达式。replacement为替换的新字符串，即将原字符串中，所有满足正则表达式regex的部分替换为replacement .
　　replaceFirst：原型为String replaceFirst(String regex, String replacement) ，跟replaceAll很像，只不过replaceFirst是替换第一个满足正则表达式regex的部分。

下面我们通过代码来理解：

public static void main(String[] args) throws Exception { 
    String s="my.name.is.HuaChao";  
    System.out.println(s.replace('.', '*'));  
    System.out.println(s.replace(".", "*"));  
    System.out.println(s.replaceAll(".", "*"));  
    System.out.println(s.replaceFirst(".", "*"));  
}

运行结果如下：
mynameis*HuaChao

mynameis*HuaChao
******************
*y.name.is.HuaChao

运行结果中，很好理解，第1个replace里面的参数是字符，不是正则表达式，replace会把所有的.字符替换为；同样，第二个replace里面的参数是字符串，不是正则表达式；而replaceAll中，第一个参数是正则表达式，第二个参数是字符串，而正则表达式中的.是表示任意字符，因此，会把所有的字符替换为；最后replaceFirst，只替换第一个字符。

4.3 正则表达式

上面多次提到了正则表达式，接下来我们看看Java中如何使用正则表达式。如果我们需要从字符串中匹配出满足我们自定义的正则表达式的部分，就可以通过使用Pattern这个类。我们先看一个实际应用，假设我们要取出一个字符串中所有的字母，并显式出来：

public static void main(String[] args) { 
    String dataStr = "--->我是干扰字符<---M12v,L23f,d34"; 
    Pattern pattern = Pattern.compile("[a-zA-Z]"); 
    Matcher matcher = pattern.matcher(dataStr); 
    // 遍历匹配正则表达式的字符串 
    while (matcher.find()) { 
        // s为匹配的字符串 
        String s = matcher.group(); 
        System.out.println(s);  
    } 
}

运行结果为：

M v L f d