JAVA基础--JAVA API常见对象(字符串&缓冲区)

一、 String 类型

　　1. String类引入

　　　　第二天学习过Java中的常量：

　　　　　　  常量的分类：

　　　　  数值型常量：整数，小数（浮点数）

　　　　 字符型常量：使用单引号引用的数据

　　　　字符串常量：使用双引号引用的数据

　　　　 布尔型常量：true或false

　　　　 null常量：null

　　　　上述的大部分的常量都可以使用Java中提供的8种基本类型进行开辟空间，存储这些常量。

　　　　         字符串常量不属于8种基本类型中的数据。而它属于Java中的引用类型数据（类类型数据）。

　　　　　　  字符串数据在Java中使用String类进行描述。

　　　　　　  字符串数据它属于Java中一类数据，我们也可以把其看作一类事物。既然是一类事物，就一定可以使用Java中的某个类对其进行封装和描述。

　　　　　　　　后期我们学习的目标和重点：

　　　　　　　　 不再是如何去描述一个类（不是去定义类）。而是要学习怎么去使用别人（JDK）中提供好的类。需要知道这些类是干什么的，以及它中有哪些常用的方法，这些方法能够解决什么问题。

　　　　　　　　　　         后期学习新的类的时候，学习方式：

　　　　　　　　                   重点是使用自己的代码去测试这些类中的方法，并得到自己的结论。

　　　　2.String 类介绍

　　　　　　　　　　　

　　　　　　String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

　　　　　　在Java中只要使用双引号引用起来的任何数据它们都是String 的一个对象。

　　　　　　　　

　　　　　　字符串是常量；它们的值在创建之后不能更改。因为 String 对象是不可变的，所以可以共享。

　　　　　　虽然使用双引号引用起来的数据都是字符串，也是String的一个实例对象，但是这个对象中的字符数据一定写完，就已经是一个固定的数据，不能再进行修改，并且它存储在方法区的字符串常量池中。

　　　　　　

　　　　　　

　　　　3.String类构造方法　　　　　

　　　　String类中提供了大量的构造方法，都可以将不同形式的数据转成字符串对象。

　　　　

1 /*
 2  * 演示String类的构造方法
 3  */
 4 public class StringConstructorDemo {
 5     public static void main(String[] args) {
 6
 7         method5();
 8     }
 9     /*
10      * 面试题
11      */
12     public static void method5() {
13
14         String s = "abc";
15         String s2 = new String("abc");
16         /*
17          * s 和 s2 的区别？
18          * s它指向的方法区中的常量池中的 abc字符串
19          * s2它指向的是堆中的自己new的那个对象，而在堆中这个对象中维护的地址
20          * 指向的常量池中的abc字符串
21          *
22          * String s = "abc"; 在内存中只有一个对象
23          * String s2 = new String("abc"); 在内存中有2个对象
24          */
25         System.out.println(s);
26         System.out.println(s2);
27         System.out.println(s == s2);
28     }
29     /*
30      * 演示将int类型的数组转成字符串
31      */
32     public static void method4() {
33
34         int[] arr = {23456,23457,23458};
35         String s = new String(arr , 0 , 3);
36         System.out.println(s);
37     }
38     /*
39      * String(byte[] bytes, int offset, int length)
40      *   byte[] bytes : 指定需要被转成字符串的那个字节数组
41      *   int offset ： 从字节数组的那个下标开始转数据
42      *   int length ： 需要将从offset开始往后共计转多少数据
43      */
44     public static void method3() {
45
46         byte[] b = {97,98,99,100,65,49};
47
48         String s = new String( b , 4 ,4 );
49         System.out.println(s);
50     }
51     /*
52      * 演示String类中的有参数的构造方法
53      */
54     public static void method2() {
55
56         //创建字节数组
57         byte[] b = {97,98,99,100,65,49};
58
59         //将字节数组中的所有数据转成字符串
60         String s = new String( b );
61
62         System.out.println(s);
63     }
64     /*
65      *  演示空参数的构造方法
66      *  String()
67      */
68     public static void method1() {
69
70         /*
71          * 使用String类的构造方法得到String对象
72          * 使用空参数的构造方法创建出的String对象，这个对象在堆中
73          * 而这个字符串对象中没有任何字符数据
74          */
75         String s = new String();
76
77     }
78 }

　　　　4. String 类常用方法　　　　　

　　　　　　a. 拼接字符串

　　　　　　猜测到某个功能之后，继续猜测它的方法参数以及返回值类型

　　　　　　参数：有，至少2个。实际值需要一个参数

　　　　　　返回值类型：String ， 拼接后的新的字符串

　　　　　　

　　　　　　

　　　　　　b.根据字符找下标

　　　　　　

　　　　　　

　　　　　　

　　　　　　

　　　　c.根据下标找字符

　　　　　　

　　　　d.字符串的长度

　　　　　　

　　　　　　

　　　　　e. 获取字符串中的一段子串

　　　　　　　　

　　　　　

1 /*
 2  * 演示String类中的截取方法
 3  */
 4 public class StringMethodDemo2 {
 5     public static void main(String[] args) {
 6
 7         String s = "好好学习，天天向上";
 8         /*
 9          *  substring(int beginIndex)
10          *      从指定的字符串中的beginIndex位置开始截取子串，一直到结束
11          *  substring( int beginIndex , int endIndex )
12          *      从指定的字符串中的beginIndex位置开始到endIndex结束（不包含endIndex位置上的字符）
13          */
14         String ss = s.substring(2);
15         System.out.println(ss);
16         String ss2 = s.substring(0, 5);
17         System.out.println(ss2);
18     }
19 }

　　　　f. 字符串转数组

　　　　　　

　　　　　　

　　　　　　

1 //字符串转成字节数组
 2     public static void method2() {
 3         String s = "abdefg";
 4         //转字节数组
 5         byte[] bs = s.getBytes();
 6
 7         for (int i = 0; i < bs.length; i++) {
 8             System.out.println(bs[i]);
 9         }
10     }
11     //字符串转字符数组
12     public static void method1() {
13         String s = "abcefg";
14         //转字符数组
15         char[] cs = s.toCharArray();
16         for (int i = 0; i < cs.length; i++) {
17             System.out.println(cs[i]);
18         }
19     }

　　　　g. 其他判断方法

　　　　

　　　　

判断指定的字符串是否在调用contains方法的那个字符串中。

String s =”abcdefg”;

String s2 = “abc”;

boolean b = s.contains(s2);

判断s2 这个字符串在s字符串中是否存在。

　　　　

　　　　

判断字符串是否以指定的字符串结尾。

String s = “abc.java”;

boolean b = s.endsWith(“.java”);

　　　　

　　　h.其他的转换方法

　　　　         将字符串中的所有字母转成小写

　　　　

　　　　　　将字符串中的所有字母转成大写

　　　　

valueOf方法是将其他类型的数据转成字符串。

　　5.String类方法练习

　　　　a。对字符串中的数据进行排序　　　　

1 /*
 2  * 需求：对字符串中的数据进行排序
 3  *
 4  * 分析：
 5  *       需要一个字符串，将字符串转成字符数组。
 6  *      对数组遍历选择排序
 7  *  将数组转成字符串
 8  */
 9 public class StringTest2 {
10     public static void main(String[] args) {
11         String s ="aAZzBcDfPO";
12         String sortedStr = stringSort(s);
13         System.out.println(sortedStr);
14     }
15     //对指定的字符串进行排序
16     public static String stringSort(String s) {
17
18         //将字符串转成数组
19         char[] cs = s.toCharArray();
20         //使用选择排序
21         for( int i = 0 ; i < cs.length - 1 ; i++  ){
22             //外循环是提供数组中需要和后面比较的那个元素的下标
23             for( int j = i + 1 ; j < cs.length ; j++  ){
24                 //内循环是提供当前外环线下标后面剩余所有空间的下标
25                 //判断
26                 if( cs[i] > cs[j] ){
27                     char temp = cs[i];
28                     cs[i] = cs[j];
29                     cs[j] = temp;
30                 }
31             }
32         }
33         //将数组转成字符串
34         String ss = new String(cs);
35         return ss;
36     }
37 }

　　　　　b.统计指定字符在字符串中出现的次数

1 /*
 2  * 需求：统计指定字符在字符串中出现的次数
 3  * 分析：
 4  *      需要取出字符串中的每个字符，和需要统计次数的那个字符进行比较，
 5  *     如果相同，就让计数器+1，如果不相同，继续取出下一个字符，以此类推。
 6  *     将字符串中的全部字符遍历完成，指定的字符个数就统一在计数器中。
 7  */
 8 public class StringTest {
 9     public static void main(String[] args) {
10
11         String s = "asjdklafjklew4uiowrafn,dsfaksda";
12         char ch = 'z';
13         //需要计数器
14         int count = 0;
15         //使用循环遍历字符串
16         for( int i = 0 ; i < s.length() ; i++ ){
17             //取出每个字符数据和需要统计的字符判断
18             char c = s.charAt(i);
19             if( c == ch ){
20                 count++;
21             }
22         }
23         System.out.println(ch+"的次数是："+count);
24     }
25 }

　　　　c.对字符串按照指定的内容切割，然后排序

1 /*
 2  * 需求：对字符串按照指定的内容切割，然后排序
 3  *
 4  * 分析：
 5  *       必须有一个字符串。"abs Adsfj sldjk fljs dlkf"
 6  *      使用空格对字符串进行切割：
 7  *         "abs" "Adsfj" "sldjk" "fljs" "dlkf"
 8  *  切割之后，会得到多个字符串数据，需要对这些字符串进行排序。
 9  *      在Java中对字符串进行比较，有自己特定的规则：
10  *
11  *      选择2个字符串，使用它们相同下标位置上的字符对应的数字进行比较，
12  *      谁的数字大，这个字符串就大。
13  *
14  *      在String类中提供的compareTo的方法，可以对2个字符串进行大小的比较
15  */
16 public class StringTest3 {
17     public static void main(String[] args) {
18
19         String s = "abs Adsfj sldjk fljs alkf";
20
21         //切割
22         String[] strs = s.split(" ");
23
24         //排序
25         //Arrays.sort(strs);
26         for( int i = 0 ; i < strs.length - 1 ; i++ ){
27             for( int j = i + 1 ; j < strs.length ; j++ ){
28                 if( strs[i].compareTo(strs[j]) > 0 ){
29                     String temp = strs[i];
30                     strs[i] = strs[j];
31                     strs[j] = temp;
32                 }
33             }
34         }
35         //将String数组转成字符串
36         //String ss = Arrays.toString(strs);
37         String ss = "";
38         for (int i = 0; i < strs.length; i++) {
39             ss = ss + strs[i] + " ";
40         }
41         System.out.println(ss);
42     }
43 }

二·、字符串缓冲区

　　　1. 符串缓冲区介绍

　　　　　　a. 缓冲区思想：　　　　　

　　　　　　举例：超市的购物车。在购买商品的过程中，将需要够买的商品先临时存储在购物车中。这时的购物车就相当于一个容器，给其中添加需要购买的物品。

　　　　　　这里说的这个容器在Java中被称为缓冲区。

　　　　　　Java中也有缓冲区存在。主要是临时存储一些需要处理的数据，在处理完之后得到一个唯一的结果。

　　　　　　　b. 字符串缓冲区

　　　　　　字符串缓冲区：可以存储字符数据的容器，可以对这个容器中的字符数据进行各种的操作，在操作完成之后，会得到一个唯一的字符串常量，最后把这个字符串常量保存到方法区的常量池中。

　　　　　　如果在操作的过程中，没有操作完成，那么不会在常量池中保存任何数据。

　　　　　　　c.缓冲区常见的操作　　　　

　　　　　　缓冲区本身就是一个容器：

　　　　　　         它们都具备 增 删  改 查操作。

　　　　　　         增：给容器中添加数据

　　　　　　         删：从容器中删除数据

　　　　　　         改：修改容器中的数据

　　　　　　         查：查看容器中的数据

　　　　　　增删改查：CRUD。

　　　　　　         Create  Read  Update  Delete

　　　　　　　　 Java中针对字符串这类数据提供两个缓冲区对象：

　　　　　           StringBuffer

　　　　　　        StringBuilder

　　　2.  StringBuffer介绍

　　　　　　　　

　　线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

StringBuffer ：它是字符串缓冲区，支持对其中保存的数据进行增删改查操作。

StringBuffer中定义的方法是为增删改查设计的。

　　　

　　　　

　　　　3. StringBuffer中的方法介绍

　　　　　　　a. 添加方法

　　　　　　　　

　　　 　　　　　

　　　　　　　　b.删除方法

　　　　　　　　

　　　　　　　　

1 //删除方法
 2     public static void method3() {
 3         //创建字符串 缓冲区对象
 4         StringBuffer sb = new StringBuffer("abcdefg");
 5
 6         /*
 7          * 删除方法
 8          * delete(int start , int end)
 9          *     start是起始位置
10          *     end 结束位置
11          *  要求start一定要小于等于end
12          */
13         sb.delete(3, 3);
14
15         //删除指定位置上的字符
16         sb.deleteCharAt(3);
17
18         //将容器中的数据转成字符串
19         String s = sb.toString();
20
21         System.out.println(s);
22     }

　　　　　　　　c. 修改方法

　　　　　　　　

　　　　　　　　

1 //修改方法
 2     public static void method4() {
 3         //创建字符串 缓冲区对象
 4         StringBuffer sb = new StringBuffer("abcdefg");
 5
 6         //修改方法
 7         sb.setCharAt(3, 'A');
 8
 9         //将容器中的数据转成字符串
10         String s = sb.toString();
11
12         System.out.println(s);
13     }

　　　　　　d.获取方法　　　

capacity()  获取字符串缓冲区的容量  例如：水杯500ML 

length()    获取到的是字符串中的字符个数   例如：水杯中实际装的水的容量

charAt(int index)  获取字符串缓冲区容器中指定位置上的字符数据

indexOf(String str)

indexOf(String str, int fromIndex)

lastIndexOf(String str)

lastIndexOf(String str, int fromIndex)

reverse()  反转字符串缓冲区中的字符

　　　　e.StringBuffer的使用场景　　　　

如果程序中需要对字符串中的字符数据进行  CRUD 的时候，建议先将这个字符串存储到缓冲区中，然后对其进行操作，操作完成之后再重新转成字符串数据。

　　4.StringBuilder介绍　

StringBuilder类它是JDK5新增的。它的功能和StringBuffer一致。

区别：

StringBuffer 它在操作容器的时候，增  删  改  查 的过程中，不会发生不安全的问题。

StringBuilder  它也提供的对容器的增删改查操作，但是不保证安全。

在使用StringBuilder的时候，运行多个操作同时对容器进行。由于它不保证安全，因此它在操作的时候效率比StringBuffer高。

面试题：StringBuffer和StringBuilder的区别：

StringBuffer 安全的。StringBuilder 不安全。