String&stringBuffer&包装类

 

一、String类的特点：

很多中语言都有对字符串的描述，以及功能的提供

 

String s= new String（）的值就是空参数，即就是s=“”里面没有值；

String s=”abc”  s是一个类类型对象，即“abc”就是一个对象；

只要是引号里面的值都是类对象；

字符串的最大特点是，他是一个常量，一旦被初始化，就不可以被改变；；

即这个对象的内容一旦被初始化，就不会被改变，

但是注意，他的声明被改变指向，不表示对象的值变了，只是变量的指向不同了；

声明并不等于变量本身，只是一种指向而已；

String字符串是常量池的一部分；

String s2 = new String(“abc”) 这和上面的一种定义取值是一样的；

String s1 = “abc”

 

String类判断值相等只能用equals方法，因为他重写了Object类中的这个方法，定义了独特的内容。即用来判断这个String类中的字符串内容是否相同；不能用“==”。“==”表示地址值是否相同；

 

s1和s2有什么区别：

s1在内存中有一个对象；s2在内存共有两个对象；

 

常量池其实就是一个数组，需要什么数值，他就把里面的值取出来放在这个数组里面；就是这么一个过程，有相同的需要直接指向就行了，不需要再放，没有就再放；

 

说明一下常量池是指这个内存里的值都是固定不变的，不会变化，可以包含任何的类型，这是常量的定义，

 

 

二、String类中的方法；

 

String s1 = “abc”；String  s2 = “abc”；在这里s1==s2是真，因为他们都是常量池的内容，并且常量池的特点是都是finally的，所以不会创建新的对象，直接指向其就可以了，那么就相等了。

 

方法区数据里有，类方法，静态去，常量池，

常量池的数据是固定不变的，字符串就是在常量池当中；

 

String类是用于描述字符串事物，String类事物的特点肯定很自由他自己知道，他把他们都封装起来，那么他就对外提供了多个访问方法对字符串进行操作；

 

常见的操作方法有哪些呢?

1、获取

         1.1字符串中的包含的字符数，也就是字符串的长度；

                   intlength（）：获取长度；

                   数组也有长度，但是他是属性，没有括号，字符串的长度是方法有括号。

 

         1.2根据位置获取位置上的某个字符；

                   charcharAt（int index）：

         1.3根据字符获取该字符在字符串中的位置

                   intindexOf（int ch）：返回的是ch在字符串中第一次出现的位置；

                   intindexOf（int ch，int fromIndex）：从fromIndex指定位置开始，获取ch在字符串   中的出现的位置；

                   如果访问到的字符串中不存在的脚标时，会发生指针异常；

                   如果没有找到要指引的字符，那么就返回-1；

                   intindexOf（String str）：返回的是str在字符串中第一次出现的位置；

                   intindexOf（String str，int fromIndex）：从fromIndex指定位置开始，获取str在字    符串中的出现的位置；

                   注意，位置和数组的位置差不多，是从零脚标位置一样；

 

         反向索引：

                   lastIndexof();从最后一个数开始查找，提高查找效率；但是脚标不会发生改变；

        

 

                   1.5版本的新特性，基本数据类型的新特性，装箱；即所有的对象都可以用Object类表示，基本数据类型也是；

 

2、判断、

         2.1字符串中是否包含某一个子串；

                   booleancontains（str）；判断字符串是否存在，是否包含；

                   特殊之处：indexOf（str）可以索引str第一次出现的位置，如果返回-1，表示str不在字符串中存在，所以也可以用于指定判断是否包含；

                   if（str。indexOf（“aa”）！=-1）

                   而且该方法即可以判断，又可以获取出现的位置；

         2.2字符串是否有内容；

                   booleanisEmpty();原理就是判断长度是否为0；注意“”和null是有区别的；

         2.3字符串是否是以指定内容开头；

                   booleanstartsWith（str）；

         2.4字符串是否是以指定内容结尾；

                   booleanendsWith（str）；

        

                   以上四种可以用于查找文件夹中的某个文件类型或者名称；

         2.5判断字符串内容是否相同，是复写了Object类中的equals方法；

                   booleanequals （str）；

         2.6判断内容是否相同，并忽略大小写；

                   booleanequalsIsIgnoreCase（）；

3、转换

         3.1将字符数组转成字符串

                   构造函数 String （char[]）;

                   构造函数 String（char[]，offset，count）将字符数组中的一部分转成字符串；

                   构造函数就要先new一个实例才可以；

                   静态方法

                                     staticString copyValueOf(char[] data)

                                     staticString copyValueOf(char[] data, int offset, int count)

                                     staticString valueOf(char[] data)

         3.2将字符串转成字符数组；（重点）

                   char[]  toCharArray();没有参数，因为转的对象就是字符串，里面用的就是this，故省略

                  

         3.3将字节数组转成字符串；

                   String（byte[]）;

                   String（byte[]，offset，count）将字节数组中的一部分转成字符串；

 

         3.4将字符串转成字节数组；

                   byte[]  getBytes（）；

         3.5将基本数据类型转成字符串；

                   staticString String valueOf(int)

                   staticString String valueOf(double)

                   //3+“”；//String.valueOf(3);两种表达的结果是一样的，这样表达比较无聊；可以少用；

 

                   注意特殊：字符串和字节数组在转换过程中，是可以指定编码表的；

         但凡要做编码操作，要变成字节才行，字符是不行的；

 

4、替换

         字符间的替换String     replace（oldchar，newchar）；

注意，替换之后，得到的结果是一个新的字符串，即重新创建了一个新的对象；不是覆盖了原来的字符串；

如果要替换的字符不存在，那么返回来的值还是原串；

         字符串的替换Stringreplace(CharSequence target, CharSequence replacement)

5、切割：

String[] split(regex); 可以把字符串分开的；

6、子串：获取字符串中的一部分

String subString（begin）；从指定位置开始到结尾；

String subString（begin，end）；包含头，不包含尾；

运用：s. subString（0，s.length()）这种表达可以获得整个字符串，因为字符串最后一个脚标是length-1；

         如果给出的脚标不存在，那么就会出现脚标越界异常；

7、转换，去除空格，比较：

         7.1将字符串转成大写或者小写；

                   StringtoUpperCase();转大写

                   StringtoLowerCare();转小写

         7.2将字符串两段的多个空格去处；

                   Stringtrim();

                   可能会因为用户多敲了一个空格会被误解帐号被盗了；

         7.3对两个字符串进行自然顺序的比较;

                   intcompareTo(String);

                   只比较第一个不同的字符进行排序；

 

三、字符串练习：

         字符串方法必须要会，会到不借助api，不借助eclipse的功能，能手写出来，才能说明你有开发经验；否则谁都不信；

 

 

开发中，功能尽量细化出来，变成一个小的函数，而且方便修改，填充内容（抽象的思维），以及调用，

 

 

四、StringBuffer

StringBuffer缓冲区，String的字符串一旦初始化不能被改变，StringBuffer可以对字符串进行修改，StringBuffer是一个容器；

StringBuffer是字符串缓冲区，是一个容器；容器具备的特点就是对数据的改变；

所以StringBuffer应该有以下功能：存储，删除，获取，修改 

CURD  create  update  read delete;

 

注意final类不能够进行继承；

 

1、存储

         StringBuffer   append（）  将指定数据作为参数添加到已有数据结尾处；

         这个方法返回来的还是本类对象，因此还可以继续调用方法；

         sb.append().append().append()  可以把结果作为对象继续引用本类方法；

         存储的一个方式或者添加的一种方式，因为他访问的对象是原缓冲区的对象；

         因为缓冲区是一个容器，所以添加数据后，还是是这个容器对象，虽然里面数据变化了；

因为这个容器就可以直接作为一个对象。里面的数据无论怎么变化，这个容器还是这个对象；

        

         StringBuffer  insert（index，数据）；可以将数据插入到指定index的位置；

 

         缓冲区的特点就是可以不断的往里面添加数据，而最终用的时候都变成了一连串的字符串形式用；

        

         StringBuffer是字符串缓冲期，是一个容器，而且长度是可变化的；并且可以操作多个数据类型；最终可以通过toString方法变成字符串；

        

2、删除

StringBuffer  delete （start，end）：删除缓冲区的数据，包含start，不包含end；

StringBuffer  deleteCharAt（index）：删除指定位置的字符；

 

清空缓冲区的方法：sb.delete(0,sb.length());

 

 

3、获取

char charAt(int index) 

int indexOf(String str)

int lastIndexOf(String str)

int length() 

String substring(int start, int end)

 

4、修改：把原来串中的数据改变一下；

StringBuffer replace(int start, int end,String str)  包含头，不包含尾；

void setCharAt(int index, char ch)  把指定的位置替换为某字符串；

 

5、反转；StringBufferreverse() 

 

 

以上的方法要熟记；

 

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

将缓冲区中的指定数据存储到指定的字符数组中；

 

五、StringBulider  在JDK1。5版本之后出现的；

StringBulider是线程不同步的；而StringBuffer是同步的；

StringBulider此类提供一个与 StringBuffer 兼容的，是可以替换的；多线程下StringBulider不同步，故不安全，而单线程StringBulider不需要判断锁，比StringBuffer性能更优；

当然，多线程，你也可以自己多线程用StringBulider，然后自己加一个锁即可；

 

Java升级考虑三个方面，提高效率，简化书写，提高安全性；

 

建议以后开发就用Stringbuilder。这样可以提高效率；

 

六、基本数据类型，对象包装类；

 

一个类，他自己的特点和功能只有他自己最清楚，所以把他自己知道的各种功能都封装起来；变成一个类；以后使用只需访问之即可；

一切变成对象之后，指挥他就可以调用其所有工具了；

 

byte------Byte  

short------Short

int---------Integer

long-------Long

float-------Float

double----Double

char-------Character

 

 

 

 

基本数据类型对象包装类的最常见的作用，就是用于基本数据类型和字符串类型之间做转换，即基本数据类型转成字符串；字符串转成基本数据类型；

基本数据类型转字符串,两种方法；

基本数据类型+“”；

Integer.toString();

字符串转成基本数据类型：

static int parseInt(String s)   

   double=parseDouble();

Integer.parseInt();

 

布尔型的转换

static boolean parseBoolean(String s)

boolean b = Boolean.parseBoolean(“true”)

 

parseInt(String s, int radix)  把其他进制形式转为十进制的数字；

 

 

把字符串转为int型的数据

 

除了上面的静态方法外，还可以用对象调用方式

（new  Integer(String s)）. intintValue() 来转换，用这种方式来返回int类型数据；

 

注意：equals方法在包装类中，表示的是值相等；

 

Integer x= new Integer（123）；

Integer y= new Integer（“123”）；

 

x==y为假，因为两个对象；x。equals（y）为真；

 

JDK的新特性：

基本数据类型新建对象可以直接这么写：

Integer x = 123；这样来建立一个对象，叫做自动装箱；

x=x+2；这样写，是叫做自动拆箱；变成了int类型；

 

注意一点：新特性中x可以为null，这样参加运算就会Runtime异常抛出。所以用Integer来声明时，一定要进行空值判断；但是用int声明就不需要；

 

Integer m=128；Integer  n=128；  m==n结果为假，因为两个对象；

Integer x=127；Integer  y=127；     x==y结果为真；因为当数值在byte范围内时，对于新特性，如果该数值已经存在，为节约内存，则不会再开辟新的空间，新的声明指向已有的对象；

 

int compareTo(Integer anotherInteger)  一个小方法；