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

原创
2018/05/09 16:54
阅读数 98

一、 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 不安全。

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部