1). 基本数据类型包装类存在的意义
(1). 比如int有自己的取值范围，但是是一个数字都很大的取值范围，很难记忆。
(2). 一个数的二进制转换成十进制，大小是多少？
以上的细节如果能封装到一个对象里面，这样程序使用起来会非常方便。
2). 基本数据类型的包装类
位于java.lang包中，对应关系如下
char Character
byte Byte、short Short、int integer、long Long
boolean Boolean
float Float、double Double
【这些类都比较相似，以Integer为例做讲解】
2. Integer类
1). Integer类的字段
public static final int MIN_VALUE = 0x80000000;
//全局常量：整形中最大值 (2^31 -1)
public static final int MAX_VALUE = 0x7fffffff;
//全局常量：整形中最小值 (-2^31)
【作用】基本数据包装类的全局字段：用于判定一个数是否在整数的范围内
2). Integer类常用的方法
基本数据类型的包装类的常用方法就是：帮助基本数据类型和字符串类型之间做转换
(1). 基本数据类型 转换成String类型 (以Integer为例)
[1]. 运算符操作法：基本数据类型数据+" "
[2]. 静态作法：基本数据类型包装类.toString(基本类型数据)
[3]. 非静态方法：Object类的toString()方法
(2). String类型 转换成 基本数据类型
[1]. 静态方法：基本数据类型包装类.parseXxx(str)
[2]. 非静态方法：基本数据类型包装类对象.xxxValue(str)
【注】xxx代表基本数据类型 Xxx代表基本数据类型对应的包装类
【注意】{1}Character没有parseXxx(str) 这个方法与之对应的是：
Character.toUpperCase(charch)和Character.toUpperCase(char ch)
可以把对应的字符进行大小写转换
【注意】{2}char本身就是String的组成部分，所以不用转换
【注意】{3} parseXxx(str)中的str必须是数字格式的，否则抛出异常
e.g.xxx是int的话，则Xxx表示Integer；xxx是char，则Xxx是Character
(3). 进制转换和移位运算举例(Integer为例)
[1]. 进制转换操作
【转二进制字符串】public static StringtoBinaryString(int i)
【转十六进制字符串】public static String toHexString(int i)
【转八进制字符串】public static String toOctalString(int i)
【parseXxx重载形式】static int parseInt(String s, int radix)
radix表示字符串s中的整数的进制表示形式
e.g.
int x =Integer.parseInt("110", 2);//说明字符串中110是二进制形式
System.out.println(x); //打印结果6 二进制的110----十进制数字是6
x=Integer.parseInt("3c", 16);//说明字符串中3c是十六进制形式
System.out.println(x);//打印结果60 十六进制的3c----十进制数字是60
[2]. 移位操作
【左移位】static int rotateLeft(int i, int distance)
【右移位】static int rotateRight(int i, int distance)
(4). 基本数据类型的equals()方法
包装类重写了Object的equals方法，用于比较两个数值大小是否相同
e.g.
Integer x =new Integer("123"); //接受字符串
Integer y =new Integer(123); //接受整型值
//new出来的两个不同对象，地址一定不一样，打印false
System.out.println(x ==y);
//x和y的值都是123 所以 equals比较结果为true
System.out.println(x.equals(y));
3. 基本数据包装类的新特性
(1). 自动装箱和自动拆箱
【自动装箱和自动拆箱新特性的目的】简化书写
[1]. 自动装箱
[2]. 自动拆箱
自动拆箱的原理：调用的基本包装类对象.xxxValue();
【解释】
x =x+2：赋值运算左边是x+2 x是Integer类型的对象，自动拆箱成基本数据类型，和整形数据2进行相加。
相加的整形结果再次自动装箱成Integer对象，让引用x指向这个新的Integer对象。
为什么不是2自动装箱成Integer对象在进行运算呢？
因为Integer这个类没有定义+这个运算。
注意【异常抛出】
当包装类引用指向null的时候，是不能进行自动拆箱的。因为自动拆箱的原理就是调用方法调用的基本包装类对象.xxxValue();但是自动拆箱的时候，运算的元素是null。
null是没有办法调用成员变量和函数的，所以抛出空指针异常
举例：
(2). 当整形数值大小在一个字节byte之间并且被封装成基本数据类型对应的对象的时候，Java认为是常使用的小数值的对象。全部缓存在常量池中，以后再次使用的时候，直接到常量池中获取，而不必再次开辟内存空间来新建对象------享元设计模式思想
int 是基本类型，直接存数值
Integer是类，产生对象时用一个引用指向这个对象
Java把内存划分成两种：一种是栈内存，另一种是堆内存
在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配
而实际的对象是在存储堆内存中
即
int i = 5;//直接在栈中分配空间
Integer i = new Integr(5);//对象是在堆内存中,而i(引用变量)是在栈内存中
在堆中分配的内存，由java虚拟机的自动垃圾回收器来管理.
因为在堆中分配空间所需的时间远大于从栈中分配存储空间,所以JAVA速度比C 慢
当需要往ArrayList，HashMap中放东西时，像int，double这种基本类型是放不进去的，因为容器都是装object的，这是就需要这些基本类型的外覆类了。Java中每种基本类型都有相应的外覆类。
int 和 Integer 的区别
java 提供两种不同的类型：引用类型（或者封装类型，Warpper）和原始类型（或内置类型，Primitive）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型 封装类
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的 数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。
int 是基本类型， (int)(Math.Random()*100)就是一个数，可以进行加见乘除。 Integer是class ,那么 new Integer(temp)就是一个对象了，可以用到Integer这个class的方法，例如用intvalue()可以返回这个int的值。
存储方式及位置的不同，基本类型是直接存储变量的值保存在堆栈中能高效的存取，封装类型需要通过引用指向实例，具体的实例保存在堆中
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
1、整数：包括int,short,byte,long ,初始值为0
2、浮点型：float,double ,初始值为0.0
3、字符：char ,初始值为空格，即'' "，如果输出，在Console上是看不到效果的。
4、布尔：boolean ,初始值为false
基本型别 大小 最小值 最大值
boolean ----- ----- ------
char 16-bit Unicode 0 Unicode 2^16-1
byte 8-bit -128 +127
short 16-bit -2^15 +2^15-1
int 32-bit -2^31 +2^31-1
long 64-bit -2^63 +2^63-1
float 32-bit IEEE754 IEEE754
double 64-bit IEEE754 IEEE754
void
注意：
表格里的^代表的是次方;
java采用unicode，2个字节来表示一个字符。
基本类型的包装类
Integer 、Long、Short、Byte、Character、Double、Float、Boolean、BigInteger、BigDecmail
其中BigInteger、BigDecimal没有相对应的基本类型，主要应用于高精度的运算，BigInteger 支持任意精度的整数，
BigDecimal支持任意精度带小数点的运算。
基本类型与包装类型的异同：
1、在Java中，一切皆对象，但八大基本类型却不是对象。
2、声明方式的不同，基本类型无需通过new关键字来创建，而封装类型需new关键字。
3、存储方式及位置的不同，基本类型是直接存储变量的值保存在堆栈中能高效的存取，封装类型需要通过引用指向实例，具体的实例保存在堆中。
4、初始值的不同，封装类型的初始值为null，基本类型的的初始值视具体的类型而定，比如int类型的初始值为0，boolean类型为false；
5、使用方式的不同，比如与集合类合作使用时只能使用包装类型。
一.什么是装箱？什么是拆箱？
在前面的文章中提到，Java为每种基本数据类型都提供了对应的包装器类型，至于为什么会为每种基本数据类型提供包装器类型在此不进行阐述，有兴趣的朋友可以查阅相关资料。在Java SE5之前，如果要生成一个数值为10的Integer对象，必须这样进行：
Integer i = new Integer(10);
而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了：
Integer i = 10;
这个过程中会自动根据数值创建对应的 Integer对象，这就是装箱。
那什么是拆箱呢？顾名思义，跟装箱对应，就是自动将包装器类型转换为基本数据类型：
Integer i = 10; //装箱 int n = i; //拆箱
简单一点说，装箱就是 自动将基本数据类型转换为包装器类型；拆箱就是 自动将包装器类型转换为基本数据类型。
下表是基本数据类型对应的包装器类型：
int（4字节） Integer
byte（1字节） Byte
short（2字节） Short
long（8字节） Long
float（4字节） Float
double（8字节） Double
char（2字节） Character
boolean（未定） Boolean
二.装箱和拆箱是如何实现的
上一小节了解装箱的基本概念之后，这一小节来了解一下装箱和拆箱是如何实现的。
我们就以Interger类为例，下面看一段代码：
public class Main { public static void main(String[] args) { Integer i = 10; int n = i; } }
反编译class文件之后得到如下内容：
查看大图
从反编译得到的字节码内容可以看出，在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。
其他的也类似，比如Double、Character，不相信的朋友可以自己手动尝试一下。
因此可以用一句话总结装箱和拆箱的实现过程：
装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。
三.面试中相关的问题
虽然大多数人对装箱和拆箱的概念都清楚，但是在面试和笔试中遇到了与装箱和拆箱的问题却不一定会答得上来。下面列举一些常见的与装箱/拆箱有关的面试题。
1.下面这段代码的输出结果是什么？
public class Main { public static void main(String[] args) { Integer i1 = 100; Integer i2 = 100; Integer i3 = 200; Integer i4 = 200; System.out.println(i1==i2); System.out.println(i3==i4); } }
也许有些朋友会说都会输出false，或者也有朋友会说都会输出true。但是事实上输出结果是：
truefalse
View Code
为什么会出现这样的结果？输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。此时只需一看源码便知究竟，下面这段代码是Integer的valueOf方法的具体实现：
public static Integer valueOf(
int i) { if
(i >= -128 = IntegerCache.high) return IntegerCache.cache[i + 128
]; else return new Integer(i); }
View Code
而其中IntegerCache类的实现为：
private static class IntegerCache { static final int high; static final Integer cache[]; static { final int low = -128; // high value may be configured by property int h = 127; if (integerCacheHighPropValue !=
null) { // Use Long.decode here to avoid invoking methods that // require Integer's autoboxing cache to be initialized int
i = Long.decode(integerCacheHighPropValue).intValue(); i = Math.max(i, 127
); // Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - -low); } high = h; cache = new Integer[(high - low) + 1]; int j = low; for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++); } private IntegerCache() {} }
View Code
从这2段代码可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。
上面的代码中i1和i2的数值为100，因此会直接从cache中取已经存在的对象，所以i1和i2指向的是同一个对象，而i3和i4则是分别指向不同的对象。
2.下面这段代码的输出结果是什么？
public class Main { public static void main(String[] args) { Double i1 = 100.0; Double i2 = 100.0; Double i3 = 200.0; Double i4 = 200.0; System.out.println(i1==i2); System.out.println(i3==i4); } }
也许有的朋友会认为跟上面一道题目的输出结果相同，但是事实上却不是。实际输出结果为：
falsefalse
View Code
至于具体为什么，读者可以去查看Double类的valueOf的实现。
在这里只解释一下为什么Double类的valueOf方法会采用与Integer类的valueOf方法不同的实现。很简单：在某个范围内的整型数值的个数是有限的，而浮点数却不是。
注意，Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。
Double、Float的valueOf方法的实现是类似的。
3.下面这段代码输出结果是什么：
public class Main { public static void main(String[] args) { Boolean i1 = false; Boolean i2 = false; Boolean i3 = true; Boolean i4 = true; System.out.println(i1==i2); System.out.println(i3==i4); } }
输出结果是：
truetrue
View Code
至于为什么是这个结果，同样地，看了Boolean类的源码也会一目了然。下面是Boolean的valueOf方法的具体实现：
public static Boolean valueOf(
boolean b) { return
(b ? TRUE : FALSE); }
View Code
而其中的 TRUE 和FALSE又是什么呢？在Boolean中定义了2个静态成员属性：
public static final
Boolean TRUE = new Boolean(true); /** * The <code>Boolean</code> object corresponding to the primitive * value <code>false</code>. */ public static final Boolean FALSE = new Boolean(false);
View Code
至此，大家应该明白了为何上面输出的结果都是true了。
4.谈谈Integer i = new Integer(xxx)和Integer i =xxx;这两种方式的区别。
当然，这个题目属于比较宽泛类型的。但是要点一定要答上，我总结一下主要有以下这两点区别：
1）第一种方式不会触发自动装箱的过程；而第二种方式会触发；
2）在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下要优于第一种情况（注意这并不是绝对的）。
5.下面程序的输出结果是什么？
public class Main { public static void main(String[] args) { Integer a = 1; Integer b = 2; Integer c = 3; Integer d = 3; Integer e = 321; Integer f = 321; Long g = 3L; Long h = 2L; System.out.println(c==d); System.out.println(e==f); System.out.println(c==(a+b)); System.out.println(c.equals(a+b)); System.out.println(g==(a+b)); System.out.println(g.equals(a+b)); System.out.println(g.equals(a+h)); } }
先别看输出结果，读者自己想一下这段代码的输出结果是什么。这里面需要注意的是：当 "=="运算符的两个操作数都是 包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。另外，对于包装器类型，equals方法并不会进行类型转换。明白了这2点之后，上面的输出结果便一目了然：
truefalsetruetruetruefalsetrue
View Code
第一个和第二个输出结果没有什么疑问。第三句由于 a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法），因此它们比较的是数值是否相等。而对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较。同理对于后面的也是这样，不过要注意倒数第二个和最后一个输出的结果（如果数值是int类型的，装箱过程调用的是Integer.valueOf；如果是long类型的，装箱调用的Long.valueOf方法）。
java语言规范中说道：在许多情况下包装与解包装是由编译器自行完成的（在这种情况下包装成为装箱，解包装称为拆箱）；
其实按照我自己的理解自动装箱就可以简单的理解为将基本数据类型封装为对象类型，来符合java的面向对象；例如用int来举例：
//声明一个Integer对象
Integer num = 10;
//以上的声明就是用到了自动的装箱：解析为
Integer num = new Integer(10);以上就是一个很好的体现，因为10是属于基本数据类型的，原则上它是不能直接赋值给一个对象Integer的，但jdk1.5后你就可以进行这样的声明，这就是自动装箱的魅力
自动将基本数据类型转化为对应的封装类型。成为一个对象以后就可以调用对象所声明的所有的方法
自动拆箱：故名思议就是将对象重新转化为基本数据类型：
//装箱
Integer num = 10;
//拆箱
int num1 = num;自动拆箱有个很典型的用法就是在进行运算的时候：因为对象时不恩直接进行运算的，而是要转化为基本数据类型后才能进行加减乘除
Integer num = 10;
//进行计算时隐含的有自动拆箱
System.out.print(num--);哈哈 应该感觉很简单吧，下面我再来讲点稍微难点的，
//在-128~127 之外的数
Integer num1 = 297; Integer num2 = 297;
System.out.println("num1==num2: "+(num1==num2));
// 在-128~127 之内的数
Integer num3 = 97; Integer num4 = 97;
System.out.println("num3==num4: "+(num3==num4)); 打印的结果是：num1==num2: false num3==num4: true
很奇怪吧：这就归结于java对于Integer与int的自动装箱与拆箱的设计，是一种模式：叫享元模式（flyweight）
为了加大对简单数字的重利用，java定义：在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，始终只存在一个对象
而如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个 Integer对象；明白了吧
以上的现象是由于使用了自动装箱所引起的，如果你没有使用自动装箱，而是跟一般类一样，用new来进行实例化，就会每次new就都一个新的对象；
这个的自动装箱拆箱不仅在基本数据类型中有应用，在String类中也有应用，比如我们经常声明一个String对象时：
String str = "sl";
//代替下面的声明方式
String str = new String("sl");
基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。虽然为您打包基本数据类型提供了方便，但提供方便的同时表示隐藏了细节，建议在能够区分基本数据类型与对象的差别时再使用。
autoboxing和unboxing
在Java中，所有要处理的东西几乎都是对象 (Object)，例如之前所使用的Scanner是对象，字符串(String)也是对象，之后还会看到更多的对象。然而基本(Primitive)数据类型不是对象，也就是您使用int、double、boolean等定义的变量，以及您在中直接写下的字面常量。
在前一个小节中已经大致看到了操作对象的方便性，而使用Java有一段时间的人都知道，有时需要将基本数据类型转换为对象。例如使用Map对象要put()方法时，需要传入的参数是对象而不是基本数据类型。
要使用打包类型(Wrapper Types)才能将基本数据类型包装为对象，前一个小节中您已经知道在J2SE 5.0之前，要使用以下语句才能将int包装为一个Integer对象：Integer integer = new Integer(10);
在 J2SE 5.0之后提供了自动装箱的功能，您可以直接使用以下语句来打包基本数据类型：Integer integer = 10;
在进行编译时，编译器再自动根据您写下的语句，判断是否进行自动装箱动作。在上例中integer参考的会是Integer类的实例。同样的动作可以适用于 boolean、byte、short、char、long、float、double等基本数据类型，分别会使用对应的打包类型(Wrapper Types)Boolean、Byte、Short、Character、Long、Float或Double。下面直接使用自动装箱功能来改写范例 4.4。
范例4.5 AutoBoxDemo.java
public class AutoBoxDemo {
public static void main(String[] args) {
Integer data1 = 10;
Integer data2 = 20;
// 转为double值再除以3
System.out.println(data1.doubleValue() / 3);
// 进行两个值的比较
System.out.println(data1.compareTo(data2));
}
}
程序看来简洁了许多，data1与data2在运行时就是Integer的实例，可以直接进行对象操作。的结果如下：
3.3333333333333335
–1
自动装箱运用的方法还可以如下：
int i = 10;
Integer integer = i;
也可以使用更一般化的java.lang.Number类来自动装箱。例如：
Number number = 3.14f;
3.14f会先被自动装箱为Float，然后指定给number。
从J2SE 5.0开始可以自动装箱，也可以自动拆箱(unboxing)，也就是将对象中的基本数据形态信息从对象中自动取出。例如下面这样写是可以的：
Integer fooInteger = 10;
int fooPrimitive = fooInteger;
fooInteger引用至自动装箱为Integer的实例后，如果被指定给一个int类型的变量fooPrimitive，则会自动变为int类型再指定给fooPrimitive。在运算时，也可以进行自动装箱与拆箱。例如：
Integer i = 10;
System.out.println(i + 10);
System.out.println(i++);
上例中会显示20与10，编译器会自动进行自动装箱与拆箱，也就是10会先被装箱，然后在i + 10时会先拆箱，进行加法运算；i++该行也是先拆箱再进行递增运算。再来看一个例子：
Boolean boo = true;
System.out.println(boo && false);
同样的boo原来是Boolean的实例，在进行AND运算时，会先将boo拆箱，再与false进行AND运算，结果会显示false。
//////////////////////////////////////////////////////////////////
装箱：从基本类型转换成Object类型，称之为装箱；***拆箱：从Object转换乘基本类型的操作，称之为拆箱。 这个操作在反射过程中用的比较的多。
装箱：在堆中建立一个Object实例，把你指定的值复制成去；***拆箱：判别引用指向的堆中信息是否是要拆成的类型，是取出堆中值送给栈中变量，否则报异常
///////////////////////////////////////////////////////////////////
装箱是值类型到object类型或到该值类型所实现的任何接口类型的隐士转换。
将一个值类型装箱会分配一个对象实例并将该值复制到新的对象中。
int i=123;
object o=i;
这句话的结果是在堆栈上创建一个对象o,而该对象在堆上引用int类型的值。该值是赋值给变量i
的值类型值的一个副本。
下面是显示执行装箱转换
int i=123;
ojbect o=(object)i;
此例将整数变量i通过装箱转换为对象o。这样，存储在变量i中的值就从123改为456。此例显示对象保留了内容的原始副本。即123。
取消装箱是从object类型到值类型或从接口类型到实现该接口的值类型的显示转换。取消装箱操作包括：
检查对象实例，确保它是给定值类型的一个装箱值。
将该值从实例复制到值类型变量中。
例子：
int i=123;
object box=i;
int j=(int)box;
基本数据类型对象包装类的最常用功能：
基本数据类型 ----〉 字符串
public static String Integer.toString(int); //将基本数据转成字符串
字符串 ----〉 基本数据类型
可能会产生NumberFormatException
public static int Integer.parseInt(String str); //将字符串转成基本数据
public static boolean Boolean.parseBoolean("true"); //将字符串装成boolean
Xxx a = Xxx.parseXxx(String); //通用的样式
十进制 ----〉 其他进制
Integer.toBinaryString(int); 转成2进制
Integer.toOctalString(int); 转成8进制
Integer.toHexString(int); 转成16进制
其他进制 ----〉 十进制
public static int parseInt(String s, int radix)
使用第二个参数指定的参数，将字符串参数解析为有符号的整数。
eg:
parseInt("110", 10); 返回110；
parseInt("110", 2); 返回6；
parseInt("99",8); 抛出NumberFormatException
parseInt("3c",16);返回60
自动拆箱和自动装箱
1，当Integer为null时会抛空值异常。所以需要做判断；
2， 如果
Integer a = new Integer("123");Integer b = new Integer(123);
System.out.println("a==b:" + (a==b)); //会输出false
Integer m = 128; Integer n = 128;
System.out.println("m==n:" + (m==n)); //会输出false
Integer x = 127; Integer y = 127;
System.out.println("x==y:" + (x==y)); //会输出true
//因为当数值在byte范围时，对于新特性，如果该数值已经存在，则不会开辟新空间，会输出true
//超出byte范围时，就会开辟新空间，所以为128时，会输出false；
基本数据类型对象包装类的最常用功能：
基本数据类型 ----〉 字符串
public static String Integer.toString(int); //将基本数据转成字符串
字符串 ----〉 基本数据类型
可能会产生NumberFormatException
public static int Integer.parseInt(String str); //将字符串转成基本数据
public static boolean Boolean.parseBoolean("true"); //将字符串装成boolean
Xxx a = Xxx.parseXxx(String); //通用的样式
十进制 ----〉 其他进制
Integer.toBinaryString(int); 转成2进制
Integer.toOctalString(int); 转成8进制
Integer.toHexString(int); 转成16进制
其他进制 ----〉 十进制
public static int parseInt(String s, int radix)
使用第二个参数指定的参数，将字符串参数解析为有符号的整数。
eg:
parseInt("110", 10); 返回110；
parseInt("110", 2); 返回6；
parseInt("99",8); 抛出NumberFormatException
parseInt("3c",16);返回60
自动拆箱和自动装箱
1，当Integer为null时会抛空值异常。所以需要做判断；
2， 如果
Integer a = new Integer("123");Integer b = new Integer(123);
System.out.println("a==b:" + (a==b)); //会输出false
Integer m = 128; Integer n = 128;
System.out.println("m==n:" + (m==n)); //会输出false
Integer x = 127; Integer y = 127;
System.out.println("x==y:" + (x==y)); //会输出true
//因为当数值在byte范围时，对于新特性，如果该数值已经存在，则不会开辟新空间，会输出true
//超出byte范围时，就会开辟新空间，所以为128时，会输出false；
String类
1，字符串是一个特殊的对象
2，字符串一旦初始化就不可以被改变
3, String str= "abc"; String str1 = new String("abc");有什么区别？
public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence
java程序中的所有字符串字面值（如“abc”）都作为此类的实例实现。
| String s1 = "abc";
| String s2 = new String("abc");
s1== s2 ; //比较是内存中的地址，所以为false
s1.equals(s2); //String类复写了Object类中的equals方法，
//该方法用于判断字符串是否相同。
s1和s2有什么区别？
s1在内存中有一个对象，s2在内存中有两个对象。
String的常见的方法：
常见操作 | 获取
| 判断
| 转换
获取
public int length();
public char charAt(int index);
注意：当index超出字符串的脚标范围时会发生StringIndexOutOfBoundsException.
public int indexOf(int ch);返回的是char在字符串第一次出现的位置
注意：如果ch在字符串中没有找到，会返回-1
public int indexOf(int ch, int fromIndex);从fromIndex位置开始，
获取ch在字符串第一次出现的位置
public int indexOf(String str);
public int indexOf(String str, int fromIndex);
public int lastIndexOf(int ch);
判断
public boolean endsWith(String str);
public boolean startsWith(String str);
public boolean isEmpty(); 字符串长度是否为0，
public boolean contains(CharSequence s);是否包含指定字符串
特殊之处：indexOf(str):可以索引str第一次出现的位置，
如果返回-1，表示str不在字符串中。
if((indexOf(str) != -1)){
....
}
public boolean equals(String str);
public boolean equalsIgnoreCase(String str);
转换(字符串和字节数组在转换过程中，是可以指定编码表的)
字符数组---->字符串
构造方法： new String(char[] value)
new String(char[] val, int offset, int count):将字符数组中的一部分转成字符串
静态方法： public static String copyValueOf(char[] chars)
public static String copyValueOf(char[] chars, int offset,int count)
public static String valueOf(char[]);
*字符串 ----> 字符数组
public char[] toCharArray()
字节数组 ----> 字符串
构造方法： new String(byte[] value)
字符串 ----> 字节数组
public byte[] getBytes();
基本数据类型 ----> 字符串
public String valueOf(int)
public String valueOf(double)
public String valueOf()
替换
public String replace(char oldchar, char newchar);替换单个字符
public String replace(CharSequence target, CharSequence replacement)；替换一部分字符串
切割
public String[] split(regex);
eg: String str = "zhangsan,lisi,wangwu";
String[] arrStr = s.split(",");
for(String s : arrStr){
.................
}
子串，获取字符串中的一部分
public String subString(int begin);
public String subString(int begin,int end);//得到的子串包含begin位不包含end索引位的字符
转换，去除空格，比较
大小写转换
public String toUpperCase();
public String toLowerCase();
去除字符串两端的多个空格
public String trim();
对两个字符串进行自然顺序的比较
public int compareTo(String str);
eg： String s1="abc";
String s2 = "aaa";
System.out.println(s1.compareTo(s2)); //输出1
StringBuffer
是字符串缓冲区，
是线程同步的，安全的
是一个容器。
1, 长度可以变化，
2, 可以操作多个数据类型
3, 最终会通过toString方法变成字符串
有 CRUD操作：create,read,update,delete
存储：
添加： public StringBuffer append();//将指定数据作为参数添加到结尾处。
eg： sb.append("abc").append(true).append(43); //名词：方法调用链
插入： public StringBuffer insert(int, str); //将指定数据作为参数插入到指定位置。
删除：
public StringBuffer delete(int start, int end);
//删除从脚标start开始到end（不包含end）的字符
eg: stringBuffer.delete(0, stringBuffer.length()); //全部清空stringBuffer
public StringBuffer deleteCharAt(index);
//删除单个字符
获取：
public char charAt()
public int indexOf(String str)
public int length()
public String substring(int start, int end); //返回的是String而不是StringBuffer
修改（替换）：
public StringBuffer replace(int start, int end, String str);
public void setCharAt(int index, Char char); //替换某一位字符,没有返回
反转
public StringBuffer reverse();
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin);
StringBuffer中从脚标srcBegin到srcEnd的字符（不包含srcEnd位的字符）放入到字符数组dst中,从脚标dstBegin开始放入;
StringBuilder （jdk1.5 版本之后出现）
一个可变的字符序列。
线程不同步，不安全，所以多线程时使用StringBuffer；一般情况下建议使用StringBuilder可以提高效率
基本数据类型对象包装类的最常用功能：
基本数据类型 ----〉 字符串
public static String Integer.toString(int); //将基本数据转成字符串
字符串 ----〉 基本数据类型
可能会产生NumberFormatException
public static int Integer.parseInt(String str); //将字符串转成基本数据
public static boolean Boolean.parseBoolean("true"); //将字符串装成boolean
Xxx a = Xxx.parseXxx(String); //通用的样式
十进制 ----〉 其他进制
Integer.toBinaryString(int); 转成2进制
Integer.toOctalString(int); 转成8进制
Integer.toHexString(int); 转成16进制
其他进制 ----〉 十进制
public static int parseInt(String s, int radix)
使用第二个参数指定的参数，将字符串参数解析为有符号的整数。
eg:
parseInt("110", 10); 返回110；
parseInt("110", 2); 返回6；
parseInt("99",8); 抛出NumberFormatException
parseInt("3c",16);返回60
自动拆箱和自动装箱
1，当Integer为null时会抛空值异常。所以需要做判断；
2， 如果
Integer a = new Integer("123");Integer b = new Integer(123);
System.out.println("a==b:" + (a==b)); //会输出false
Integer m = 128; Integer n = 128;
System.out.println("m==n:" + (m==n)); //会输出false
Integer x = 127; Integer y = 127;
System.out.println("x==y:" + (x==y)); //会输出true
//因为当数值在byte范围时，对于新特性，如果该数值已经存在，则不会开辟新空间，会输出true
//超出byte范围时，就会开辟新空间，所以为128时，会输出false；
String类
1，字符串是一个特殊的对象
2，字符串一旦初始化就不可以被改变
3, String str= "abc"; String str1 = new String("abc");有什么区别？
public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence
java程序中的所有字符串字面值（如“abc”）都作为此类的实例实现。
| String s1 = "abc";
| String s2 = new String("abc");
s1== s2 ; //比较是内存中的地址，所以为false
s1.equals(s2); //String类复写了Object类中的equals方法，
//该方法用于判断字符串是否相同。
s1和s2有什么区别？
s1在内存中有一个对象，s2在内存中有两个对象。
String的常见的方法：
常见操作 | 获取
| 判断
| 转换
获取
public int length();
public char charAt(int index);
注意：当index超出字符串的脚标范围时会发生StringIndexOutOfBoundsException.
public int indexOf(int ch);返回的是char在字符串第一次出现的位置
注意：如果ch在字符串中没有找到，会返回-1
public int indexOf(int ch, int fromIndex);从fromIndex位置开始，
获取ch在字符串第一次出现的位置
public int indexOf(String str);
public int indexOf(String str, int fromIndex);
public int lastIndexOf(int ch);
判断
public boolean endsWith(String str);
public boolean startsWith(String str);
public boolean isEmpty(); 字符串长度是否为0，
public boolean contains(CharSequence s);是否包含指定字符串
特殊之处：indexOf(str):可以索引str第一次出现的位置，
如果返回-1，表示str不在字符串中。
if((indexOf(str) != -1)){
....
}
public boolean equals(String str);
public boolean equalsIgnoreCase(String str);
转换(字符串和字节数组在转换过程中，是可以指定编码表的)
字符数组---->字符串
构造方法： new String(char[] value)
new String(char[] val, int offset, int count):将字符数组中的一部分转成字符串
静态方法： public static String copyValueOf(char[] chars)
public static String copyValueOf(char[] chars, int offset,int count)
public static String valueOf(char[]);
*字符串 ----> 字符数组
public char[] toCharArray()
字节数组 ----> 字符串
构造方法： new String(byte[] value)
字符串 ----> 字节数组
public byte[] getBytes();
基本数据类型 ----> 字符串
public String valueOf(int)
public String valueOf(double)
public String valueOf()
替换
public String replace(char oldchar, char newchar);替换单个字符
public String replace(CharSequence target, CharSequence replacement)；替换一部分字符串
切割
public String[] split(regex);
eg: String str = "zhangsan,lisi,wangwu";
String[] arrStr = s.split(",");
for(String s : arrStr){
.................
}
子串，获取字符串中的一部分
public String subString(int begin);
public String subString(int begin,int end);//得到的子串包含begin位不包含end索引位的字符
转换，去除空格，比较
大小写转换
public String toUpperCase();
public String toLowerCase();
去除字符串两端的多个空格
public String trim();
对两个字符串进行自然顺序的比较
public int compareTo(String str);
eg： String s1="abc";
String s2 = "aaa";
System.out.println(s1.compareTo(s2)); //输出1
StringBuffer
是字符串缓冲区，
是线程同步的，安全的
是一个容器。
1, 长度可以变化，
2, 可以操作多个数据类型
3, 最终会通过toString方法变成字符串
有 CRUD操作：create,read,update,delete
存储：
添加： public StringBuffer append();//将指定数据作为参数添加到结尾处。
eg： sb.append("abc").append(true).append(43); //名词：方法调用链
插入： public StringBuffer insert(int, str); //将指定数据作为参数插入到指定位置。
删除：
public StringBuffer delete(int start, int end);
//删除从脚标start开始到end（不包含end）的字符
eg: stringBuffer.delete(0, stringBuffer.length()); //全部清空stringBuffer
public StringBuffer deleteCharAt(index);
//删除单个字符
获取：
public char charAt()
public int indexOf(String str)
public int length()
public String substring(int start, int end); //返回的是String而不是StringBuffer
修改（替换）：
public StringBuffer replace(int start, int end, String str);
public void setCharAt(int index, Char char); //替换某一位字符,没有返回
反转
public StringBuffer reverse();
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin);
StringBuffer中从脚标srcBegin到srcEnd的字符（不包含srcEnd位的字符）放入到字符数组dst中,从脚标dstBegin开始放入;
StringBuilder （jdk1.5 版本之后出现）
一个可变的字符序列。
线程不同步，不安全，所以多线程时使用StringBuffer；一般情况下建议使用StringBuilder可以提高效率
. String类概述
1). String类基本概念
(1). String类的源码声明及含义
[1]. String类声明
public final class String
implementsjava.io.Serializable, Comparable<String>, CharSequence
[2]. String类是final修饰的类，所以String类不能被继承，那么String类中的操作字符串的方法就不能被重写。
2). String类对象和字面值对象的关系
(1). 字符串字面值常量对象----字符串
Java中由双引号"Demo Run--"括起来的全部是String类的实例常量！！！！！简称字符串
(2). 字符串的特点
[1]. 字符串本身就是String类的对象
【注意】只要是双引号括起来的就是String类对象
[2]. 字符串最大的特点
一旦被初始化，字符串里面的内容就不能被改变。所以准确地说：字符串是一个常量对象
(3). 关于字符串的问题解读
[1]. 例1：解读String s1 ="abc";
{1}. s1是String类类型的引用，所以s1指向的一定是对象。所以推知"abc"一定是对象。实际上"abc"就是字符串，字符串是String类的常量对象。
由于是对象，所以可以调用方法：常见的："abc".equals(x)。
{2}. "abc" 一旦被初始化，值就不能被改变。因为是常量。
[2]. 例2：解读
String s1 ="abc";
s1 ="rr";
出现上面这种情况，千万别认为"abc"的值变化了。实际上"abc"是常量，值永远不能变，只不过s1重新指向了新的字符串(String类的常量对象)，这个新的String类常量对象是"rr"
[3]. 面试题
String s1 ="abc";
String s2 =new String("abc");
//执行完前两句，内存中有几个对象？
System.out.println(s1 ==s2);//打印结果是多少？
System.out.println(s1.equals(s2)); //打印结果是多少？
{1}. s1和s2的区别
s1这一句执行完之后，在内存中创建了一个对象"abc"----这一句涉及到一个对象
s2这一句执行完之后，在内存中又创建了另一个对象----这一句涉及到两个对象
{2}. 打印结果
{2}1. System.out.println(s1 ==s2);
由于s2指向的对象是根据"abc" new出来的堆内存对象，所以s1和s2指向的一定是两个不同的对象。所以用==来比较这两个不同地址的对象，结果一定是false。
{2}2. System.out.println(s1.equals(s2));
String类将Object类中的equals方法进行了重写，String类中的equals方法不再是调用==操作符，而是比较的是字符串中的值。所以这个输出true。
2. 内存中的方法区
1). 方法区的划分
(1). 代码区域 存放类中方法的源代码的位置
(2). 静态区域 存放类中静态数据的地方
(3). 常量池 存放的数据是常量。一旦被初始化，值就固定不变的位置
[1]. 常见的常量池存放的是：
【个人总结】String类的常量对象(字符串)、基本数据类型包装类的对应值在1B范围的小数值对象等。
**Java认为这部分的常量被使用的频率很高，将这些对象存放在常量池是用来进行数据共享的。这是享元模式设计思想的体现。
[2]. 常量池中的数据的特点
{1}. 一旦被初始化，值就不能被改变
{2}. 由于常量池的目的在于常用数据的资源共享。
所以常量池中的对象不会重复建立。仅仅创建一次。
如果程序中再次使用到，就回到常量池中寻找，找到了，直接拿去使用，提高了效率，节省了内存空间。
[3]. 字符串常量池题目与解析
例3：
String s1 ="abc";
String s2 =new String("abc");
String s3 ="abc";
System.out.println(s1 ==s2);//false
System.out.println(s1 ==s3); //打印值是多少？
解析：String s3 ="abc";中再次使用到了字符串常量。字符串全部存放在常量池，所以，程序再次使用到的时候，回去常量池中再次寻找。找到了，就直接拿去使用，不会重复建立值相同的对象。
所以执行完String s3 ="abc";之后，栈中的两个String类的引用变量s1和s2同时指向方法区中常量池的字符串"abc"。
所以这条输出语句System.out.println(s1 ==s3);打印值是true
基本数据类型对象包装类的最常用功能：
基本数据类型 ----〉 字符串
public static String Integer.toString(int); //将基本数据转成字符串
字符串 ----〉 基本数据类型
可能会产生NumberFormatException
public static int Integer.parseInt(String str); //将字符串转成基本数据
public static boolean Boolean.parseBoolean("true"); //将字符串装成boolean
Xxx a = Xxx.parseXxx(String); //通用的样式
十进制 ----〉 其他进制
Integer.toBinaryString(int); 转成2进制
Integer.toOctalString(int); 转成8进制
Integer.toHexString(int); 转成16进制
其他进制 ----〉 十进制
public static int parseInt(String s, int radix)
使用第二个参数指定的参数，将字符串参数解析为有符号的整数。
eg:
parseInt("110", 10); 返回110；
parseInt("110", 2); 返回6；
parseInt("99",8); 抛出NumberFormatException
parseInt("3c",16);返回60
自动拆箱和自动装箱
1，当Integer为null时会抛空值异常。所以需要做判断；
2， 如果
Integer a = new Integer("123");Integer b = new Integer(123);
System.out.println("a==b:" + (a==b)); //会输出false
Integer m = 128; Integer n = 128;
System.out.println("m==n:" + (m==n)); //会输出false
Integer x = 127; Integer y = 127;
System.out.println("x==y:" + (x==y)); //会输出true
//因为当数值在byte范围时，对于新特性，如果该数值已经存在，则不会开辟新空间，会输出true
//超出byte范围时，就会开辟新空间，所以为128时，会输出false；
String类
1，字符串是一个特殊的对象
2，字符串一旦初始化就不可以被改变
3, String str= "abc"; String str1 = new String("abc");有什么区别？
public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence
java程序中的所有字符串字面值（如“abc”）都作为此类的实例实现。
| String s1 = "abc";
| String s2 = new String("abc");
s1== s2 ; //比较是内存中的地址，所以为false
s1.equals(s2); //String类复写了Object类中的equals方法，
//该方法用于判断字符串是否相同。
s1和s2有什么区别？
s1在内存中有一个对象，s2在内存中有两个对象。
String的常见的方法：
常见操作 | 获取
| 判断
| 转换
获取
public int length();
public char charAt(int index);
注意：当index超出字符串的脚标范围时会发生StringIndexOutOfBoundsException.
public int indexOf(int ch);返回的是char在字符串第一次出现的位置
注意：如果ch在字符串中没有找到，会返回-1
public int indexOf(int ch, int fromIndex);从fromIndex位置开始，
获取ch在字符串第一次出现的位置
public int indexOf(String str);
public int indexOf(String str, int fromIndex);
public int lastIndexOf(int ch);
判断
public boolean endsWith(String str);
public boolean startsWith(String str);
public boolean isEmpty(); 字符串长度是否为0，
public boolean contains(CharSequence s);是否包含指定字符串
特殊之处：indexOf(str):可以索引str第一次出现的位置，
如果返回-1，表示str不在字符串中。
if((indexOf(str) != -1)){
....
}
public boolean equals(String str);
public boolean equalsIgnoreCase(String str);
转换(字符串和字节数组在转换过程中，是可以指定编码表的)
字符数组---->字符串
构造方法： new String(char[] value)
new String(char[] val, int offset, int count):将字符数组中的一部分转成字符串
静态方法： public static String copyValueOf(char[] chars)
public static String copyValueOf(char[] chars, int offset,int count)
public static String valueOf(char[]);
*字符串 ----> 字符数组
public char[] toCharArray()
字节数组 ----> 字符串
构造方法： new String(byte[] value)
字符串 ----> 字节数组
public byte[] getBytes();
基本数据类型 ----> 字符串
public String valueOf(int)
public String valueOf(double)
public String valueOf()
替换
public String replace(char oldchar, char newchar);替换单个字符
public String replace(CharSequence target, CharSequence replacement)；替换一部分字符串
切割
public String[] split(regex);
eg: String str = "zhangsan,lisi,wangwu";
String[] arrStr = s.split(",");
for(String s : arrStr){
.................
}
子串，获取字符串中的一部分
public String subString(int begin);
public String subString(int begin,int end);//得到的子串包含begin位不包含end索引位的字符
转换，去除空格，比较
大小写转换
public String toUpperCase();
public String toLowerCase();
去除字符串两端的多个空格
public String trim();
对两个字符串进行自然顺序的比较
public int compareTo(String str);
eg： String s1="abc";
String s2 = "aaa";
System.out.println(s1.compareTo(s2)); //输出1
StringBuffer
是字符串缓冲区，
是线程同步的，安全的
是一个容器。
1, 长度可以变化，
2, 可以操作多个数据类型
3, 最终会通过toString方法变成字符串
有 CRUD操作：create,read,update,delete
存储：
添加： public StringBuffer append();//将指定数据作为参数添加到结尾处。
eg： sb.append("abc").append(true).append(43); //名词：方法调用链
插入： public StringBuffer insert(int, str); //将指定数据作为参数插入到指定位置。
删除：
public StringBuffer delete(int start, int end);
//删除从脚标start开始到end（不包含end）的字符
eg: stringBuffer.delete(0, stringBuffer.length()); //全部清空stringBuffer
public StringBuffer deleteCharAt(index);
//删除单个字符
获取：
public char charAt()
public int indexOf(String str)
public int length()
public String substring(int start, int end); //返回的是String而不是StringBuffer
修改（替换）：
public StringBuffer replace(int start, int end, String str);
public void setCharAt(int index, Char char); //替换某一位字符,没有返回
反转
public StringBuffer reverse();
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin);
StringBuffer中从脚标srcBegin到srcEnd的字符（不包含srcEnd位的字符）放入到字符数组dst中,从脚标dstBegin开始放入;
StringBuilder （jdk1.5 版本之后出现）
一个可变的字符序列。
线程不同步，不安全，所以多线程时使用StringBuffer；一般情况下建议使用StringBuilder可以提高效率
. String类概述
1). String类基本概念
(1). String类的源码声明及含义
[1]. String类声明
public final class String
implementsjava.io.Serializable, Comparable<String>, CharSequence
[2]. String类是final修饰的类，所以String类不能被继承，那么String类中的操作字符串的方法就不能被重写。
2). String类对象和字面值对象的关系
(1). 字符串字面值常量对象----字符串
Java中由双引号"Demo Run--"括起来的全部是String类的实例常量！！！！！简称字符串
(2). 字符串的特点
[1]. 字符串本身就是String类的对象
【注意】只要是双引号括起来的就是String类对象
[2]. 字符串最大的特点
一旦被初始化，字符串里面的内容就不能被改变。所以准确地说：字符串是一个常量对象
(3). 关于字符串的问题解读
[1]. 例1：解读String s1 ="abc";
{1}. s1是String类类型的引用，所以s1指向的一定是对象。所以推知"abc"一定是对象。实际上"abc"就是字符串，字符串是String类的常量对象。
由于是对象，所以可以调用方法：常见的："abc".equals(x)。
{2}. "abc" 一旦被初始化，值就不能被改变。因为是常量。
[2]. 例2：解读
String s1 ="abc";
s1 ="rr";
出现上面这种情况，千万别认为"abc"的值变化了。实际上"abc"是常量，值永远不能变，只不过s1重新指向了新的字符串(String类的常量对象)，这个新的String类常量对象是"rr"
[3]. 面试题
String s1 ="abc";
String s2 =new String("abc");
//执行完前两句，内存中有几个对象？
System.out.println(s1 ==s2);//打印结果是多少？
System.out.println(s1.equals(s2)); //打印结果是多少？
{1}. s1和s2的区别
s1这一句执行完之后，在内存中创建了一个对象"abc"----这一句涉及到一个对象
s2这一句执行完之后，在内存中又创建了另一个对象----这一句涉及到两个对象
{2}. 打印结果
{2}1. System.out.println(s1 ==s2);
由于s2指向的对象是根据"abc" new出来的堆内存对象，所以s1和s2指向的一定是两个不同的对象。所以用==来比较这两个不同地址的对象，结果一定是false。
{2}2. System.out.println(s1.equals(s2));
String类将Object类中的equals方法进行了重写，String类中的equals方法不再是调用==操作符，而是比较的是字符串中的值。所以这个输出true。
2. 内存中的方法区
1). 方法区的划分
(1). 代码区域 存放类中方法的源代码的位置
(2). 静态区域 存放类中静态数据的地方
(3). 常量池 存放的数据是常量。一旦被初始化，值就固定不变的位置
[1]. 常见的常量池存放的是：
【个人总结】String类的常量对象(字符串)、基本数据类型包装类的对应值在1B范围的小数值对象等。
**Java认为这部分的常量被使用的频率很高，将这些对象存放在常量池是用来进行数据共享的。这是享元模式设计思想的体现。
[2]. 常量池中的数据的特点
{1}. 一旦被初始化，值就不能被改变
{2}. 由于常量池的目的在于常用数据的资源共享。
所以常量池中的对象不会重复建立。仅仅创建一次。
如果程序中再次使用到，就回到常量池中寻找，找到了，直接拿去使用，提高了效率，节省了内存空间。
[3]. 字符串常量池题目与解析
例3：
String s1 ="abc";
String s2 =new String("abc");
String s3 ="abc";
System.out.println(s1 ==s2);//false
System.out.println(s1 ==s3); //打印值是多少？
解析：String s3 ="abc";中再次使用到了字符串常量。字符串全部存放在常量池，所以，程序再次使用到的时候，回去常量池中再次寻找。找到了，就直接拿去使用，不会重复建立值相同的对象。
所以执行完String s3 ="abc";之后，栈中的两个String类的引用变量s1和s2同时指向方法区中常量池的字符串"abc"。
所以这条输出语句System.out.println(s1 ==s3);打印值是true
. String类的获取功能
(1). int length()
[1]. 功能描述：获取字符串的长度，也就是获取字符串中包含的字符数
[2]. 注意：String类的这个方法和数组的属性length别弄混淆了。
{1}. 数组中的表示数组的长度是属性length,由于是属性，后面没有()
{2}. 字符串中的表示字符串的长度是方法length(),由于是方法，后面有()
(2). char chatAt(int index)
[1]. 功能描述：根据位置获取该字符串指定位置上的某个字符
[2]. 注意：如果访问到字符串中不存在的角标，会抛出运行时异常----字符串越界异常：
java.lang.StringIndexOutOfBoundsException
[3]. 数组越界异常和字符串越界异常是不一样的
两者都是角标越界(IndexOutOfBoundsException) 异常的子类
{1}. 数组越界异常是 java.lang.ArrayIndexOutOfBoundsException
{2}. 字符串越界异常是 java.lang.StringIndexOutOfBoundsException
(3). int indexOf(int ch)
[1]. 功能描述：根据字符获取该字符在字符串中第一次出现的位置
[2]. 输入参数：是字符的ASCII码值，而不是char类型的。
原因：由于char可以自动转换成int类型的数值，这样，indexOf方法既可以直接接受字符作为实参，也可以接受该字符的ASCII码作为实参。
[3]. 重载方法I：
int indexOf(int ch, intfromIndex) 是从指定位置起始搜索字符ch在字符串中第一次出现的位置。
【注意】intindexOf(int ch)默认是从其实位置fromIndex=0的位置进行搜索。
[4]. 重载方法II：
intindexOf(String str) 获取子串str在大字符串中第一次出现的位置
[5].如果没有找到，返回-1
(4). int lastIndexOf(int ch)
功能描述：根据字符获取该字符在字符串中最后一次出现的位置
(5). StringsubString(int beginIndex)
[1]. 功能描述：获取从指定位置开始一直到结尾的子串
[2]. 重载方法：String substring(int beginIndex, int endIndex)
获取从指定位置开始到指定结束位置的子串。[beginIndex, endIndex)
【规律】这种指定两个端点的Java功能，都是包含头不包含尾的操作
2. String类的判断功能
判断功能的返回值一定是布尔值boolean
(1). boolean contains (CharSequence s)
[1]. public interface CharSequence
{1}. CharSequence是一个接口
{2}. CharSequence这个接口的已知实现子类有String、StringBuilder和StringBuffer三个类。所以，这个方法的参数是一种多态的形式，可以接受以上三种类型的引用变量。
[2]. 功能描述：字符串中是否包含某一子串
[3]. 区分indexOf(String str)和contains(CharSequence)方法
仅仅比较的是indexOf重载方法中的一个：查询子串第一次出现的位置。
{1}. indexOf(Stringstr) 两重功能
{1}1. 获取子串在整个字符串中第一次出现的位置。
{1}2. 如果没找到，返回值为-1。所以根据返回值是否为-1作为寻找子串是否存在的判断条件。
【等价条件】if(str.indexOf("aa") ==-1) <====>if(str.contains("aa"))
{2}. contains(CharSequence s) 仅仅具有一重功能
【应用场合】
【既判断又获取位置】使用indexOf(String str)
【只判断】使用contains(CharSequence s)
(2). boolean isEmpty ()
[1]. 功能描述：判断字符串是否为空 //从JDK6开始
[2]. isEmpty()功能的实质：内部封装了str.length() ==0这个条件。这个功能的意义就是见名知意，简化书写。
(3). boolean startsWith (String str)
功能描述：判断字符串是否以指定内容开头
(4). boolean endsWith (String str)
功能描述：判断字符串是否以指定内容结尾
【startsWith()和endsWith()应用场景】常用于判断文件名是否符合某种条件
(5). boolean equals (String str)
[1].功能描述：判断两个字符串内容是否相同
[2]. 这个方法是String子类重写Object父类的equals方法，不是String类特有的方法。
[3]. 对大小写敏感
(5). boolean equalsIgnoreCase (String str)
功能描述：判断两个字符串内容是否相同，忽略大小写
. String类的转换功能
(1). 将字符串转换成字符数组
[1]. 实现方式I：非静态方法 ----String的构造方法
{1}. String(char value[])
{2}. String(char value[], int offset, int count)
将字符数组的一部分转换为字符串
[2]. 实现方式II.1：静态方法---- String的copyValueOf
{1}. static String copyValueOf(char data[])
{2}. static String copyValueOf(char data[], int offset, int count)
[3]. 实现方式II.2：静态方法 ----String的valueOf
{1}. static String valueOf(char data[])
{2}. static String valueOf(char data[], int offset, int count)
【总结1】
{1}. valueOf()有多种重载形式，不仅可以操作字符数组，也可以操作基本数据类型
{2}. copyValueOf()有两种重载形式，仅仅可以操作字符数组
【总结2】
当把字符数组转化为字符串的时候：valueOf()<=====>copyValueOf()
(2). 将字符数组转换成字符串【逆过程】
实现方式：char[]toCharArray()
(3). 将字节数组转换成字符串
实现方式：非静态方法 ----String的构造方法
{1}. String(byte value[])
{2}. String(byte value[], int offset, int count)
(4). 将字符串转换成字节数组
[1]. 实现方式：非静态方法 ----String的getBytes()方法
[2]. 注意：getBytes()方法可以接受字符编码。
所以，在使用getBytes()方法的过程中，可以指定字符编码**
(5). 将基本数据类型转换成字符串
[1]. 实现方式I：静态方法 ----String的valueOf()方法
static String valueOf(基本数据类型)
[2]. 实现方式II：操作符方式 ----“+”和“”拼接 -----简便方法
基本数据类型数据+""<====> String.valueOf(基本数据类型数据)
(6). 将字符串转换成对应大写或者小写字符串
[1]. String toUpperCase() ---->转成大写字符串
[2]. String toLowerCase() ---->转成小写字符串
(7). 将字符串两端空格去掉
实现方式：String trim()
2. String类的替换功能
(1). String replace (char oldChar,char newChar)
****字符替换字符****
[1]. 将字符串中的oldChar表示的字符全部替换成newChar表示的字符
[2]. 注意：由于字符串一旦被初始化，值就不能被改变，所以replace返回的是值为新的字符串在常量池的地址的String类引用，而不是返回void。
e.g.
[3].如果替换的字符不存在：此时返回原字符串
e.g.此时两个引用指向常量池中的同一个常量池中的字符串
(2). Stringreplace (CharSequence target, CharSequence replacement)
****字符子串替换字符子串****
(3). 其余替换功能都涉及到正则表达式，到正则表达式部分再介绍
3. 字符串的其他功能
(1). 自然顺序比较功能
[1]. 方法来源：实际上是实现Comparable接口中的方法compareTo()
[2]. 实现方式：intcompareTo(String anotherString)
[3]. 返回值不是boolean而是int类型的 ----->因为比较的结果有三种 >、<和=
比较规则：调用compareTo()的字符串做被减数，compareTo()方法的参数做减数。两者做差。结果就有>0、=0和<0
e.g.
String s1 ="abc";
String s2 ="dce";
System.out.println(s1.compareTo(s2));
分析：s1做被减数，s2做减数，s1-s2<0===> s1 <s2
(2). 分割功能
[1]. 实现方式：String[]split(String regex)
[2]. 参数可以是正则表达式，也可以是普通字符串
java--5基本数据类型、包装类和字符串类
猜你喜欢
转载自zhyp29.iteye.com/blog/2305607
今日推荐
周排行