JAVASE_13_#JavaAPI_String和StringBuffer

最新推荐文章于 2022-12-05 16:32:54 发布

一枚用户

最新推荐文章于 2022-12-05 16:32:54 发布

阅读量549

点赞数

分类专栏： javaSE

本文链接：https://blog.csdn.net/kkopopo/article/details/20444251

版权

javaSE 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

1.String概述------>一旦被初始化就不可改变(final常量的特性)【放在常量池中】

见CDDN/kkopophttp://blog.csdn.net/kkopopo/article/details/20207495

String s1 = "" ;

String s2 = null ;

System.out.println( "----" +s1+ "****" ); //结果----****s1.length()结果是0

System.out.println( "----" +s2+ "****" ); //结果----null****s2.length()抛异常java.lang.NullPointerException

1.2,常量

String s1 = "abc" ; //s1是一个类类型变量，"abc"是一个对象

//字符串最大的特点： 一旦被初始化就不可改变(final常量的特性)【放在常量池中】

1.3关于"=="和equals(),都是比较的内存地址，但是在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。

String tom = "I am student"; 这个是字符串常量，存储在常量池中

String jerry = "I am student"; 因为在常量池中已有，就不创建新的，直接从常量池中调用，所以一样

tom == jerry ---------true;

tom.equals(jerry)-----true;

//******************************************//

String tom = new String("I am student");

String jerry = new String("I am stundet");

tom == jerry--------false//new产生先对象，不相同

tom.equals(jerry)---true//

1.4**********************************

 
         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
         7 
       
         8 
       
         9 
       
         10 
       
         11 
       
         12 
       
         13 
       
         public  
         class  
         StringDemo { 
        
         public  
         static  
         void  
         main(String[] args) { 
        
         String s1 = "abc"; 
        
                 String s2 = new String("abc"); 
        
                 //s1和s2有什么区别？ 
        
                 //s1在内存中有一个对象。 
        
                 //s2在内存中有两个对象。(可能是1个对象)下面有解析 
        
         System.out.println(s1==s2); 
         //false 
        
         System.out.println(s1.equals(s2)); 
         //true,String类复写了Object类中equals方法， 
        
         //该方法用于判断字符串是否相同。 
        
         } 
        
         }

说到java中堆、栈和常量池，首先还是看看他们各自存放的数据类型吧！

堆：存放所有new出来的对象；

栈：存放基本类型的变量数据和对象的应用，对象（new出来的对象）本身并不存在栈中，而是存放在堆中或者常量池中（字符串常量对象存放在常量池中）；

常量池：存放基本类型常量和字符串常量。

对于栈和常量池中的对象可以共享，对于堆中的对象不可以共享。

栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会自动消失。

堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。

<一>字符创String

而对于字符串来说，其对象的引用都是存储在栈中的.

如果是编译期已经创建好（即指用双引号定义的）的就存储在常量池中，如果是运行期（new出来的对象）则存储在堆中。

对于equals相等的字符串，在常量池中是只有一份的，在堆中则有多份。

String str1="abc";//编译期就创建好了,存在常量池中

String str2="abc";

String str3="abc";

String str4=new String("abc");//运行期new出来的

String str5=new String("abc");

对于浅蓝色箭头，通过new操作产生一个字符串（“abc”）时，

会先去常量池中查找是否有“abc”对象，如果没有则在常量池中创建一个此字符串对象，

然后堆中再创建一个常量池中此“abc”对象的拷贝对象，

所以，对于String str=new String("abc")，如果常量池中原来没有"abc"则产生两个对象，否则产生一个对象。

<二>基本类型和基本类型的常量

变量和引用变量--------变量和引用存储在栈中

常量:-------------存储在常量池中

int a1 = 1, a2 = 1, a3 = 1;
public static final int INT1 = 1;
public static final int INT2 = 1;
public static final int INT3 = 1;

<三>成员变量和局部变量

对于成员变量和局部变量来说，

成员变量是方法外部，类得内部定义的变量;

局部变量就是方法或语句块内部定义的变量，注意，局部变量必须初始化。

局部变量（形式参数）的数据存于栈内存中，并且它（局部变量）随方法的消失而消失。

我们的程序里不可避免大量使用字符串处理，避免使用String，应大量使用StringBuffer，

因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象，请看下列代码；

  
  String s = "Hello";
s = s + " world!";
String s = "Hello";
s = s + " world!";

在这段代码中，s原先指向一个String对象，内容是”Hello”，

然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？

答案是没有。这时，s不指向原来那个对象了，而指向了另一个String对象，内容为”Hello world!”;

原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。

通过上面的说明，我们很容易导出另一个结论，

如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。

因为String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。

这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。

并且，这两种类的对象转换十分容易。

2.创建功能方法---------------****笔试面试有****

-----必须熟练掌握到不参照API和Eclipse工具独立写出,否则面试官不相信你有编程经验

1：获取

1.1 int length() //数组中也有但是属性arr.length，这个是方法

1.2 char charAt() // str.chatAt(4)=='c';不是""是''

                 //sop(str.charAt(4);//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。

1.3 int indexOf( int ch) //ch在字符串中第一次出现的位置

     int indexOf( int ch, int fromIndex) //从fromIndex指定位置开始，获取ch在字符串中出现的位置

                                     //str.indexOf('m',3));//如果没有找到，返回-1.

     int indexOf (String str)

     int indexOf(String str, int fromIndex)

     int lastIndexOf( int ch) //反向索引一个字符出现位置，注意字符的角标固定无论正向反向

2：判断

2.1 boolean contains()**

//特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。

//所以，也可以用于对指定判断是否包含。

//if(str.indexOf("aa")!=-1)

//而且该方法即可以判断，有可以获取出现的位置。

2.2 boolean isEmpty()

2.3 boolean startsWith(str)

2.4 boolean endsWith(str)

2.5 boolean equals(str) //复写了Object类中的equals方法。

2.6 boolean equalsIgnoreCase() //判断内容是否相同，并忽略大小写。 用户登录

3：转换

3.1 构造方法:将字符数组转成字符串

String(Byte[])//默认字符集

String( Byte[ ],charsetName)//制定字符集,把字节转换成String

String( char [])

String( char [],offset,count) //将字符数组中的一部分转成字符串。

     静态方法：

     static String copyValueOf( char []) //将返回指定数组中表示该字符序列的String

     static String copyValueOf( char [] data, int offset, int count)

     static String valueOf( char []):

3.2 char[] toCharArray(): // ** 将字符串转成字符数组

String s1 = "zxcvbnm" ;

char[] chs = s1.toCharArray();

3.3 String( byte [])

     String( byte [],offset,count):将字节数组中的一部分转成字符串。

3.4 byte[]  getBytes()://把String转化成字节数组byte[],和toCharArray()不同

  byte []  getBytes(charsetName): //带字符集

3.5 static String valueOf( int )

static String valueOf( double )

     //形式1：3+"";

   //形式2：String.valueOf(3);// 特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

   //形式3：Integer.toString( 34 ); //将整数34变成“34”

4：替换

4.1 String replace(oldchar,newchar);//与StringBuffer的返回值类型不同.

//StringBuffer replace(int start, int end, String str)

     String s = "hello java" ;

     String s1 = s.replace( 'q' , 'n' ); //如果要替换的字符不存在，返回的还是原串。

     String s1 = s.replace( "java" , "world" );

         sop( "s=" +s); //s不变，因为字符串一旦初始化就不可以改变

         sop( "s1=" +s1); //hello world

5：切割

5.1 String[] split(regex);

String s = "zhagnsa,lisi,wangwu" ;

String[] arr = s.split( "," ); //切割符不会出现在数组中

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

6.1 String substring(begin); 从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。

String substring(begin,end); //end是角标值，不是个数包含头，不包含尾。s.substring(0,s.length());

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

7.1 String toUpperCase();

     String toLowerCase();

7.2 String trim(); //去除字符串两边的空格,字符串中间的空格不会去除

7.3 int compareTo(string); //返回值是ASCLL值得差值

     String s1 = "a1c" ;

     String s2 = "aaa" ;

     sop(s1.compareTo(s2)); //返回值是-48=49('1')-97('a')

3.String函数练习

1 ，模拟一个trim方法，去除字符串两端的空格。

思路：

1 ，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。

结尾处判断空格也是如此。

2 ，当开始和结尾都判断到不是空格时，就是要获取的字符串。

//===================================================================

2 ，将一个字符串进行反转。将字符串中指定部分进行反转， "abcdefg" ;abfedcg

思路：

1 ，曾经学习过对数组的元素进行反转。

2 ，将字符串变成数组，对数组反转。

3 ，将反转后的数组变成字符串。

4 ，只要将或反转的部分的开始和结束位置作为参数传递即可。

//===================================================================

3 ，获取一个字符串在另一个字符串中出现的次数。

"abkkcdkkefkkskk"

思路：

1 ，定义个计数器。

2 ，获取kk第一次出现的位置。

3 ，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。

每获取一次就计数一次。

4 ，当获取不到时，计数完成。

//===================================================================

4

，获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。

"abcwerthelloyuiodef"

"cvhellobnm"

思路：

1 ，将短的那个子串按照长度递减的方式获取到。

2 ，将每获取到的子串去长串中判断是否包含，

如果包含，已经找到！。

//===================================================================

对字符串中字符进行自然顺序排序。

思路：

1 ，字符串变成字符数组。

2 ，对数组排序，选择，冒泡，Arrays.sort();

3 ，将排序后的数组变成字符串。

"vcz1bdAa+cs" -->abccdsvz

//===================================================================

作业：

"12 0 99 -7 30 4 100 13"

要求对字符串中的数值进行排序。生成一个数值从小到大新字符串。

"-7 0 4 12 13 30 99 100"

//===================================================================

4. StringBuffer-----子符串缓冲区java.lang.StringBuffer

是一个容器

特点：

1，长度是可变化的。数组也是容器，但长度固定

2，可以直接操作多个数据类型。

3，最终会通过toString方法变成字符串。

是容器就可以对数据进行操作： CRUD

C-create--U-update--R-read--D-delete；

1，存储。

StringBuffer append():将指定数据作为参数添加到已有数据结尾处。

StringBuffer insert(index,数据):可以将数据插入到指定index位置。

1

2

3

4

5

6

7

8

StringBuffer sb = new StringBuffer();

StringBuffer sb1 = sb.append( 34 );

sop( "sb==sb1:" +(sb==sb1)); //true,脸盆原理(蒸馒头发面,加上面，再加上水，面盆没换)

//******************************************

StringBuffer sb = new StringBuffer();

sb.append( "abc" ).append( true ).append( 34 ); //方法调用列,对象调用完方法返回的还是对象本身

sop(sb.toString()); //abctrue34

sb.insert( 1 , "qq" ); //aqqctrue34

2，删除。

StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。

StringBuffer deleteCharAt(index):删除指定位置的字符。

1

2

3

4

StringBuffer sb  = new StringBuffer( "abcde" );

sb.delete( 1 , 3 ); //包含头不包含尾部

sb.delete(0,sb.length());//**清空缓冲区。

sb.deleteCharAt( 2 ); //一个形式sb.delete(2,3);

3，获取。

char charAt(int index)

int indexOf(String str)

int lastIndexOf(String str)

int length()

String substring(int start, int end) ； //此方法返回的还是String类型，不是StringBuffer

4，修改。

StringBuffer   replace(start,end,string);

void   setCharAt(int index, char ch) ;// 这个比较特殊，返回的是空

1

2

3

StringBuffer sb  = new StringBuffer( "abcde" );

sb.replace( 1 , 4 , "java" ); //结果ajavae

sb.setCharAt( 2 , 'k' ); //结果abkde

5，反转。

StringBuffer reverse();// 自己可以写

//练习二：将字符串反转。

     思路：

     1，将字符串变成数组。

     2，对数组反转。

     3，将数组变成字符串。

6, 将缓冲区中指定数据存储到指定字符数组中。

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

1

2

3

StringBuilder sb = new StringBuilder( "abcdef" );

char [] chs = new char [ 6 ];

sb.getChars( 1 , 4 ,chs, 1 );/从 1 到 4 的字符串存到chs中去，从chs的 1 角标开始的

5,StringBuilder

JDK1.5 版本之后出现了StringBuilder.

StringBuffer是线程同步.<------- (安全的，因为有锁)

StringBuilder是线程不同步。

单线程StringBuilder效率高;

以后开发，建议使用StringBuilder，对于多线程，可以自己加锁

将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。

***********************************************************************************************

***********************************************************************************************

java的所有升级大体围绕这三个因素：

1，提高效率。

2，简化书写。

3，提高安全性。

6，基本数据类型对象包装类

封装成类后的一些属性值：

1

2

//整数类型的最大值。

sop( "int max :" +Integer.MAX_VALUE);//MIX_VALUE

byte

Byte

short

short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

6.1.基本数据类型转成字符串

1.1，String str = 基本数据类型+“”；

1.2 ，Integer.toString( 34 ); //将整数34变成“34"

1.3，String.valueOf(3);//特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

********************************************************************

6.2.字符串转成基本数组类型

1

2

3

4

5

int a = Integer.parseInt( "123" );

Integer i = new Integer("123");

int num = i.intValue(); //先包装成对象，在调用方法转换

double b = Double.parseDouble( "12.23" );

boolean b = Boolean.parseBoolean( "true" );

对于Char型本身就是String的组成单位，不用转换课直接使用一些方法

**************************************************************************

6.3十进制转成其他进制

static String toBinaryString();

toHexString();

toOctalString();

1

2

3

sop(Integer.toBinaryString( 6 )); //结果110

sop(Integer.toHexString( 60 )); //结果3c

sop(Integer.toOctalString( 60 )); //结果74

***************************************************************

6.4其他进制转成十进制。

parseInt(string,radix);

1

2

3

4

5

6

7

8

9

10

11

parseInt( "0" , 10 ) 返回 0

parseInt( "473" , 10 ) 返回 473

parseInt( "-0" , 10 ) 返回 0

parseInt( "-FF" , 16 ) 返回 - 255

parseInt( "1100110" , 2 ) 返回 102

parseInt( "2147483647" , 10 ) 返回 2147483647

parseInt( "-2147483648" , 10 ) 返回 - 2147483648

parseInt( "2147483648" , 10 ) 抛出 NumberFormatException

parseInt( "99" , 8 ) 抛出 NumberFormatException

parseInt( "Kona" , 10 ) 抛出 NumberFormatException

parseInt( "Kona" , 27 ) 返回 411787

7，基本数据类型对象包装类新特性

7.1

1

2

3

4

Integer x = new Integer( "123" )

Integer y = new Integer( 123 );

System.out.println(x==y); //false

System.out.println(x.equals(y)); //true，重载只比较数值

7.2

1

2

3

4

5

6

7

//Integer x = new Integer(4);

Integer x = 4 ; //4是对象，自动装箱。//new Integer(4)

            //注意:x的值除了为整数，还可以是null，小心空指针异常，是runtime异常会停掉

x = x + 2 ; //x+2: x进行自动拆箱。变成成了int类型。和2进行加法运算。

           //再将和进行装箱赋给x。

           //代码如下x = x.intValue() + 2;

7.4********

1

2

3

4

5

6

7

8

Integer m = 128 ;

Integer n = 128 ;

sop( "m==n:" +(m==n)); //结果false

Integer a = 127 ;

Integer b = 127 ;

sop( "a==b:" +(a==b)); //结果为true。因为a和b指向了同一个Integer对象。

//因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间

一枚用户

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVASE_13_#JavaAPI_String和StringBuffer

1.String概述------>一旦被初始化就不可改变(final常量的特性)【放在常量池中】见CDDN/kkopophttp://blog.csdn.net/kkopopo/article/details/20207495String s1 = "";String s2 = null;
复制链接

扫一扫