[mqt_2003的专栏]String和StringBuilder（C#）

最新推荐文章于 2023-09-17 21:36:49 发布
最新推荐文章于 2023-09-17 21:36:49 发布
阅读量2.9k 收藏 3
点赞数
分类专栏： 学习学习再学习 文章标签： string c# 测试 class null system
         第一篇： 你真的了解.NET中的String

注：来自于网络

       String在任何语言中，都有它的特殊性，在.NET中也是如此。它属于基本数据类型，也是基本数据类型中唯一的引用类型。字符串可以声明为常量，但是它却放在了堆中。希望通过本文能够使大家对.NET中的String有一个深入的了解。
      
一：不可改变对象

在.NET中String是不可改变对象，一旦创建了一个String对象并为它赋值，它就不可能再改变，也就是你不可能改变一个字符串的值。这句话初听起来似乎有些不可思议，大家也许马上会想到字符串的连接操作，我们不也可以改变字符串吗？看下面这段代码：

 1 using System;
 2
 3 namespace Demo1
 4  {
 5      ///<summary>
 6     /// String连接测试
 7     /// </summary>
 8     public class Test
 9      {
10         public static void Main(string[] args)
11          {
12             string a = "1234";
13             Console.WriteLine(a);
14
15             a += "5678";
16             Console.WriteLine(a);
17             Console.ReadLine();
18         }
19     }
20 }
21
运行的结果：
 1234
 
 12345678
 
看起来我们似乎已经把MyStr的值从“1234”改为了“12345678”。事实是这样的吗？实际上并没有改变。在第5行代码中创建了一个String对象它的值是“1234”，MyStr指向了它在内存中的地址；第七行代码中创建了一个新的String对象它的值是“12345678”，MyStr指向了新的内存地址。这时在堆中其实存在着两个字符串对象，尽管我们只引用了它们中的一个，但是字符串“1234”仍然在内存中驻留。

二：引用类型

前面说过String是引用类型，这就是如果我们创建很多个相同值的字符串对象，它在内存中的指向地址应该是一样的。也就是说，当我们创建了字符串对象a，它的值是“1234”，当我们再创建一个值为“1234”的字符串对象b时它不会再去分配一块内存空间，而是直接指向了a在内存中的地址。这样可以确保内存的有效利用。看下面的代码：

 1 using System;
 2
 3 namespace Demo2
 4  {
 5      ///<summary>
 6     /// String引用类型测试
 7     /// </summary>
 8     public class Test
 9      {
10         public static void Main(string[] args)
11          {
12             string a = "1234";
13
14             Console.WriteLine(a);
15
16             Test.Change(a);
17
18             Console.WriteLine(a);
19             Console.ReadLine();
20         }
21
22         public static void Change(string s)
23          {
24             s = "5678";
25         }
26     }
27 }

运行结果：
 1234
 
 1234

做一个小改动，注意Change(ref string s)
 1 using System;
 2
 3 namespace Demo2
 4  {
 5      /// <summary>
 6     /// String引用类型测试
 7     /// </summary>
 8     public class Test
 9      {
10         public static void Main(string[] args)
11          {
12             string a = "1234";
13
14             Console.WriteLine(a);
15
16             Test.Change(ref a);
17
18             Console.WriteLine(a);
19             Console.ReadLine();
20         }
21
22         public static void Change(ref string s)
23          {
24             s = "5678";
25         }
26     }
27 }
28

运行结果：
 1234
 5678
 
 三：字符串的比较
 
在.NET中，对字符串的比较操作并不仅仅是简单的比较二者的值，==操作首先比较两个字符串的引用，如果引用相同，就直接返回True；如果不同再去比较它们的值。所以如果两个值相同的字符串的比较相对于引用相同的字符串的比较要慢，中间多了一步判断引用是否相同。看下面这段代码：

 1 using System;
 2
 3 namespace Demo3
 4  {
 5      /// <summary>
 6     /// String类型的比较
 7     /// </summary>
 8     public class Test
 9      {
10         public static void Main(string[] args)
11          {
12             string a = "1234";
13             string b = "1234";
14             string c = "123";
15             c += "4";
16
17             int times = 1000000000;
18             int start,end;
19            
20              ///测试引用相同所用的实际时间
21             start = Environment.TickCount;
22             for(int i=0;i<times;i++)
23              {
24                 if(a==b)
25                  {}
26             }
27             end = Environment.TickCount;
28             Console.WriteLine((end-start));
29            
30              ///测试引用不同而值相同所用的实际时间
31             start = Environment.TickCount;
32             for(int i=0;i<times;i++)
33              {
34                 if(a==c)
35                  {}
36             }
37             end = Environment.TickCount;
38             Console.WriteLine((end-start));
39
40             Console.ReadLine();
41         }
42     }
43 }
44
执行的结果（运行的结果可能有些不同）：
 1671
 
 4172
由此我们看出值相同时的比较用= =比引用相同时的比较慢了好多。这里仅仅是一个测试，因为做这样的比较并没有任何实际的意义。
有一点需要明确的是，.NET中==跟Equals()内部机制完全是一样的，==是它的一个重载。
1 public static bool operator ==(string a, string b)
2  {
3       return string.Equals(a, b);
4 }
5

 1 public static bool Equals(string a, string b)
 2  {
 3       if (a == b)
 4        {
 5             return true;
 6       }
 7       if ((a != null) && (b != null))
 8        {
 9             return a.Equals(b);
10       }
11       return false;
12 }
13

 

四：字符串驻留

看一下这段代码：

 1 using System;
 2
 3 namespace Demo4
 4  {
 5      ///<summary>
 6     /// String的驻留
 7     /// </summary>
 8     public class Test
 9      {
10         public static void Main(string[] args)
11          {
12             string a = "1234";
13             string s = "123";
14             s += "4";
15
16             string b = s;
17             string c = String.Intern(s);
18
19             Console.WriteLine((object)a == (object)b);
20             Console.WriteLine((object)a == (object)c);
21             Console.ReadLine();
22         }
23     }
24 }
25
执行的结果：
 False
 
 True
在这段代码中，比较这两个对象发现它的引用并不是一样的。如果要想是它们的引用相同，可以用Intern()函数来进行字符串的驻留（如果有这样的值存在）。


三：StringBuilder对象
通过上面的分析可以看出，String类型在做字符串的连接操作时，效率是相当低的，并且由于每做一个连接操作，都会在内存中创建一个新的对象，占用了大量的内存空间。这样就引出StringBuilder对象，StringBuilder对象在做字符串连接操作时是在原来的字符串上进行修改，改善了性能。这一点我们平时使用中也许都知道，连接操作频繁的时候，使用StringBuilder对象。但是这两者之间的差别到底有多大呢？来做一个测试：

 1 using System;
 2 using System.Text;
 3
 4 namespace Demo5
 5  {
 6      ///<summary>
 7     /// String和StringBulider比较
 8     /// </summary>
 9     public class Test
10      {
11         public static void Main(string[] args)
12          {
13             string a = "";
14             StringBuilder s = new StringBuilder();
15
16             int times = 10000;
17             int start,end;
18            
19              ///测试String所用的时间
20             start = Environment.TickCount;
21             for(int i=0;i<times;i++)
22              {
23                 a += i.ToString();
24             }
25             end = Environment.TickCount;
26             Console.WriteLine((end-start));
27            
28              ///测试StringBuilder所用的时间
29             start = Environment.TickCount;
30             for(int i=0;i<times;i++)
31              {
32                 s.Append(i.ToString());
33             }
34             end = Environment.TickCount;
35             Console.WriteLine((end-start));
36
37             Console.ReadLine();
38         }
39     }
40 }
41

运行结果：
 884
 
 0

通过上面的分析，可以看出用String来做字符串的连接时效率非常低，但并不是所任何情况下都要用StringBuilder，当我们连接很少的字符串时可以用String，但当做大量的或频繁的字符串连接操作时，就一定要用StringBuilder。

 


                                                           
                                                           
                                                           
                                                             第二篇  进一步了解String


今天看到了你真的了解.NET中的String吗？的文章,写的很不错,对string不错的说明,但是有几点我想补充一下,一旦你的string在堆中创建后,其在内存中都是以const存在,任何的修改都会使其被重新创建为新的string,而指向以前的string的引用将会指向这个新的string!!

测试1:
看下面的代码:
1 string s = "1";
2 Console.WriteLine( String.IsInterned(s)!=null );//这里输出true

这个代码很简单,声名一个string s并且赋予"1",这个时候s在CLR的内置池中表示为引用,再来看下面的代码:
1 string s = "1";                //初始化string
2 Console.WriteLine( String.IsInterned(s)!=null );//这里输出true
3            
4 s += "2";                    //追加string
5 Console.WriteLine( String.IsInterned(s)!=null );//这里输出false
6

这个时候你再看输出的结果:第一次的s="1"的时候,s在内置池中,但是当你修改了s的值之后,它已经不在内置池中!!
如果你需要将s再次放置到内置池中,可以这么做:
1 string s = "1";                //初始化string
2 Console.WriteLine( String.IsInterned(s)!=null );//输出true
3            
4 s += "2";                    //追加string
5 Console.WriteLine( String.IsInterned(s)!=null );//输出false
6
7 String.Intern(s);            //重新设置为引用
8 Console.WriteLine( String.IsInterned(s)!=null );//这个时候依然输出为true

测试2:

看下面的测试代码:
 1 string a = "1";//第一次内置string
 2 a += "2";//第二次分配,赋值第一次的1到新的地址中,需重新分配内存
 3 a += "3";//第三次分配,赋值前两次的1,2到新的地址中,需重新分配内存
 4 a += "4";//第四次分配,赋值前三次的1,2,3到新的地址中,需重新分配内存
 5
 6  /*  使用IL反编译后看的结果
 7  *
 8  * .method private hidebysig static void  Main(string[] args) cil managed
 9 {
10   .entrypoint
11   .custom instance void [mscorlib]System.STAThreadAttribute::.ctor() = ( 01 00 00 00 )
12   // 代码大小       43 (0x2b)
13   .maxstack  2
14   .locals init ([0] string a)
15   IL_0000:  ldstr      "1"
16   IL_0005:  stloc.0
17   IL_0006:  ldloc.0
18   IL_0007:  ldstr      "2"
19   IL_000c:  call       string [mscorlib]System.String::Concat(string,//注意这里,复制一次
20                                                               string)
21   IL_0011:  stloc.0
22   IL_0012:  ldloc.0
23   IL_0013:  ldstr      "3"
24   IL_0018:  call       string [mscorlib]System.String::Concat(string,//复制二次
25                                                               string)
26   IL_001d:  stloc.0
27   IL_001e:  ldloc.0
28   IL_001f:  ldstr      "4"
29   IL_0024:  call       string [mscorlib]System.String::Concat(string,//复制第三次
30                                                               string)
31   IL_0029:  stloc.0
32   IL_002a:  ret
33 } // end of method Class1::Main
34  *
35

相信通过上面的代码和反编译后的结果,大家可以看的很清楚,string如何被分配,而在你重新修改string的时候,是如何工作..既然发现了问题,当然也可以解决问题所在..解决和优化的办法很多,我只简单的列出几种,第一种,使用string[]数组来代替..看下面代码:
 1 string[] Arr1 = new string[4];//声名需要内置4个string
 2 Arr1[0] = "1";//内置了1
 3 Arr1[1] = "2";//内置了2
 4 Arr1[2] = "3";//内置了3
 5 Arr1[3] = "4";//内置了4
 6  /*数组赋值后,在IL反编译后的表现
 7  *
 8  *
 9  *.method private hidebysig static void  Main(string[] args) cil managed
10 {
11   .entrypoint
12   .custom instance void [mscorlib]System.STAThreadAttribute::.ctor() = ( 01 00 00 00 )
13   // 代码大小       40 (0x28)
14   .maxstack  3
15   .locals init ([0] string[] Arr1)
16   IL_0000:  ldc.i4.4
17   IL_0001:  newarr     [mscorlib]System.String
18   IL_0006:  stloc.0
19   IL_0007:  ldloc.0
20   IL_0008:  ldc.i4.0
21   IL_0009:  ldstr      "1"
22   IL_000e:  stelem.ref
23   IL_000f:  ldloc.0
24   IL_0010:  ldc.i4.1
25   IL_0011:  ldstr      "2"
26   IL_0016:  stelem.ref
27   IL_0017:  ldloc.0
28   IL_0018:  ldc.i4.2
29   IL_0019:  ldstr      "3"
30   IL_001e:  stelem.ref
31   IL_001f:  ldloc.0
32   IL_0020:  ldc.i4.3
33   IL_0021:  ldstr      "4"
34   IL_0026:  stelem.ref
35   IL_0027:  ret
36 } // end of method Class1::Main
37  *
38  * */

看看上面的代码,我想很明白,string[]是如何工作的了吧??可以这么理解:每个数组的子项都是一个被内置的string!!
第二种解决办法是char[],如果你知道你的字符串大小,可以这么写char[] c = new char[4]{'1','2','3','4'};这个做法在C/C++中是很不错的,但是在C#似乎用的不多,而且用起来也比较麻烦.因为它不能想C/C++这样: char[] c = {"1234"};不过我依然在做一个加密/解密类的时候用了char[]!!
最后一种也是最常用的:StringBuilder,既然string有重新分配地址的副作用.所以微软也为我们提供了StringBuilder来解决这个问题..

 

 

                                                         
                                                         
                                                         
                                                           第三篇： StringBuilder的实现与技巧


在上一篇进一步了解String 中,发现了string的不便之处,而string的替代解决方案就是StringBuilder的使用..它的使用也很简单System.Text.StringBuilder sb = new System.Text.StringBuilder();这样就初始化了一个StringBuilder ..之后我们可以通过Append()来追加字符串填充到sb中..在你初始化一个StringBuilder 之后,它会自动申请一个默认的StringBuilder 容量(默认值是16),这个容量是由Capacity来控制的.并且允许,我们根据需要来控制Capacity的大小,也可以通过Length来获取或设置StringBuilder 的长度..
先来看Length的用法:
1 System.Text.StringBuilder sb = new System.Text.StringBuilder();
2 sb.Append( "123456789" );//添加一个字符串
3 sb.Length = 3;//设置容量为3
4 Console.WriteLine( sb.ToString() );//这里输出:123
5
6 sb.Length = 30;//重新设置容量为30
7 Console.WriteLine( sb.ToString() + ",结尾");//这里在原来字符串后面补齐空格,至到Length的为30
8 Console.WriteLine( sb.Length );//这里输出的长度为30

通过上面的代码,我们可以看出如果StringBuilder 中的字符长度小于Length的值,则StringBuilder 将会用空格硬填充StringBuilder ,以满足符合长度的设置..如果StringBuilder 中的字符长度大于Length的值,则StringBuilder 将会截取从第一位开始的Length个字符..而忽略超出的部分..

再来看看最重要的部分Carpacity的用法:
 1 System.Text.StringBuilder sb = new System.Text.StringBuilder();//初始化一个StringBuilder
 2 Console.Write( "Capacity:" + sb.Capacity );//这里的Capacity会自动扩大
 3 Console.WriteLine( "/t Length:" + sb.Length );
 4
 5 sb.Append( '1',17 );//添加一个字符串,这里故意添加17个字符,是为了看到Capacity是如何被扩充的
 6 Console.Write( "Capacity:" + sb.Capacity );//这里的Capacity会自动扩大
 7 Console.WriteLine( "/t Length:" + sb.Length );
 8
 9 sb.Append( '2',32 );//添加一个字符串
10 Console.Write( "Capacity:" + sb.Capacity );//这里的Capacity会自动扩大
11 Console.WriteLine( "/t Length:" + sb.Length );
12
13 sb.Append( '3',64 );//添加一个字符串
14 Console.Write( "Capacity:" + sb.Capacity );//这里的Capacity会自动扩大
15 Console.WriteLine( "/t Length:" + sb.Length );
16
17 //注意这里:如果你取消Remove这步操作,将会引发ArgumentOutOfRangeException异常,因为当前容量小于
18
19 //Length,这在自己控制StringBuilder的时候务必要注意容量溢出的问题
20
21 sb.Remove(0,sb.Length);//移出全部内容,再测试
22 sb.Capacity = 1;//重新定义了容量
23 sb.Append( 'a',2 );
24 Console.Write( "Capacity:" + sb.Capacity );//这里的Capacity会自动扩大
25 Console.WriteLine( "/t Length:" + sb.Length );
26
27 sb.Append( 'b',4 );
28 Console.Write( "Capacity:" + sb.Capacity );//这里的Capacity会自动扩大
29 Console.WriteLine( "/t Length:" + sb.Length );
30
31 sb.Append( 'c',6 );
32 Console.Write( "Capacity:" + sb.Capacity );//这里的Capacity会自动扩大
33 Console.WriteLine( "/t Length:" + sb.Length

上面的代码输出的结果:
1 Capacity:16     Length:0    //输出第一次,默认的Capacity是16
2 Capacity:32     Length:17    //第二次,我们故意添加了17个字符,于是Capacity=Capacity*2
3 Capacity:64     Length:49    //继续超出,则Capacity=Capacity*2
4 Capacity:128     Length:113
5 Capacity:3     Length:2    //清空内容后,设置Capacity=1,重新添加了字符
6 Capacity:7      Length:6    //后面的结果都类似
7 Capacity:14     Length:12

从上面的代码和结果可以说明StringBuilder中容量Capacity是如何增加的:创建一个StringBuilder之后,默认的Capacity初始化为16,接着我们添加17个字符,以方便看到Capacity的扩充后的值..大家在修改Capacity的时候,一定要注意21行的注释,一定要确保Capacity >= Length,否则会引发ArgumentOutOfRangeException异常...看完结果,就可以推断出Capacity的公式:
if ( Capacity < Length && Capacity > 0 ){
      Capacity *= 2;
}
OK..看到公式就明白了..StringBuilder是以当前的Capacity*2来扩充的..所以,在使用StringBuilder需要特别注意,尤其是要拼接或追加N多字符的时候,要注意技巧的使用,可以适当的,有预见性的设置Capacity的值,避免造成过大内存的浪费,节约无谓的内存空间..例如,下列代码就可以根据情况自动的扩展,而避免了较大的内存浪费.
 1 System.Text.StringBuilder sb = new System.Text.StringBuilder();
 2 int i = 0;
 3 long StartTime  = DateTime.Now.Ticks;
 4  while ( i < 100000 ) {
 5 sb.Append( i.ToString() );
 6 i++;
 7 }
 8 long EndTime  = DateTime.Now.Ticks;
 9
10 Console.WriteLine( "时间:" + ( EndTime-StartTime ) + "/t Capacity:"+ sb.Capacity + "/t Length:"
11
12 + sb.Length);
13
14 System.Text.StringBuilder sb1 = new System.Text.StringBuilder();
15 i = 0;
16 StartTime  = DateTime.Now.Ticks;
17 while ( i < 100000 )
18  {
19 if ( sb1.Capacity <= sb1.Length )//先判断是否>Length
20 sb1.Capacity += 7;//这里一定要根据情况的增加容量,否则会有性能上的消耗
21 sb1.Append( i.ToString() );
22 i++;
23 }
24 EndTime  = DateTime.Now.Ticks;
25
26 Console.WriteLine( "时间:" + ( EndTime-StartTime ) + "/t Capacity:"+ sb1.Capacity + "/t
27
28 Length:" + sb1.Length);
需要特别说明的一点是,自动增加的容量,一定要根据实际预见的情况而改变,否则不但起不到优化的作用,反而会影响到程序的性能..


另外,如果有时间的话,可以测试一下下面的代码,用string和StringBuilder拼接字符串的区别..你会吓到的!!
 1 System.Text.StringBuilder sb = new System.Text.StringBuilder();
 2 int i = 0;
 3 long StartTime  = DateTime.Now.Ticks;
 4  while ( i < 100000 ) {
 5 sb.Append( i.ToString() );
 6 i++;
 7 }
 8 long EndTime  = DateTime.Now.Ticks;
 9
10 Console.WriteLine( "时间:" + ( EndTime-StartTime ) );
11
12 string sb1 = null;
13 i = 0;
14 StartTime  = DateTime.Now.Ticks;
15 while ( i < 100000 )
16  {
17 sb1 += i;
18 i++;
19 }
20 EndTime  = DateTime.Now.Ticks;
21 Console.WriteLine( "时间:" + ( EndTime-StartTime ));




Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=729295

MaybeHelios
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于MQTT协议的C#版客户端源码
03-23
该源码经过整理,整合形成一个完整的C#版本MQTT协议版本的工具,可以直接加入项目类库,添加引用后既可使用.
String类详细介绍
xuecde的博客
04-02 3785
size计算字符串长度。
String类详解
weixin_65278827的博客
05-21 1万+
String类算是比较特殊的类型了，作为初学者我们甚至把这个引用类型时不时当成基本类型来用，而且发现，竟然差不多。然而实际呢？我们太年轻，差的真的很多，今天就来详细讲一讲到底差在哪。 一、创建字符串的四种方式 1.直接赋值 直接赋值，在堆中的常量池中创建该字符串对象 String str1 = "HelloWorld"; 2.通过构造方法创建对象 在堆中创建对象，并把该对象的拷贝放到常量池中 String str2 = new String("HelloWorld"); 3.通过字符数组
String类型（详述）
挣钱买房买车的博客
07-18 6317
String类详细讲解
string类（详细描述）
最新发布
qq_55610255的博客
09-17 1764
string中文意思是字符串，string是一个类，在C++语言中，string类型不属于基础类型，string是一个模板类，实例化就是一个对象。也可以理解为他是一个可以操作字符串的类。基础类型有八种：byte、boolean、char、short、int、float、long、double定义了一个名为CharTTraits和Allocator。这些参数分别指定了字符类型、字符特性和分配器类型用于分配内存。CharT参数表示字符类型，通常使用char来表示普通的字符串。Traits。
mgn-mqt82.zip
05-22
QTP破解版工具，使用方法见：https://blog.csdn.net/qq_39652641/article/details/80402564； 希望能帮到你们。
破解文件mgn-mqt82.rar
12-30
QTP破解所需文件，破解方式和QTP8.2一样，安装完成后运行mgn-mqt82.rar ，再输入系列号：0123-2820602186 就可以了
mgn-mqt82.rar
03-10
qtp的破解文件，使用qtp必不可少的东东
MQt-LIBS.zip
05-24
网上找到的可供下载资源，csdn上看了下都要很高积分，所以自己保留一份，做activemq源码研究用。
String类的详解
m0_53677355的博客
09-25 1424
注意：replaceAll方法并不是在s的基础上替换的，而是将替换的结果作为一个新的字符串返回了，替换之后始终不变，因为String类在设计的时候，就严格限定了String类的对象是不可改变的，即字符串是不可变对象。2、将自定义类型的对象转换为String类型的字符串，类中需要重写Object类中的toString的方法，如果没有重写，将来转换完之后的结果：类全路径名+@+hashCode的十六进制的结果。注意：对于内置对象，==比较的是变量中的值，对于引用类型，==比较的是引用中的地址。
C# StringBuilder 的使用
熊思雨的博客
08-06 7876
字符串一旦创建就不可修改大小，每次使用System.String类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。在需要对字符串执行重复修改的情况下，与创建新的String对象相关的系统开销可能会非常昂贵。如果要修改字符串而不创建新的对象，则可以使用System.Text.StringBuilder类。所以对字符串添加或删除操作不频繁的话，就几个固定的string累加的时候就不需要StringBuilder了,毕竟StringBuilder的初始化也是需要时间的。...
String类型
qq_51510549的博客
09-27 1万+
一、String类型： 1.String类型定义： Java中数据类型分为基本数据类型和引用数据类型两大类，而String类型就属于引用数据类型，但是String类型并不是字符串，而是Java的一个类，Java通过String类型来操作字符串 String类是最终类用final修饰，不能被其他类继承 2.字符串特性： 字符串是操作系统上提供的一种可用于操作和表达多个字符类型组合的一种结构 a.面值内容不可以发生改变 b.同样的元素在内存中不会出现第二次 ...
C#（四十）之stringBuilder类
camellia的博客
07-20 4533
C#（四十）之stringBuilder类
二—10：字符串相关的类（String类）
qq_51318621的博客
08-21 394
常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。常量与字符串变量拼接会在堆内存创建对象如果拼接的结果调用intern()方法，返回值就在常量池中。
C#的StringBuilder 类使用说明
零点工程师的博客
09-05 3451
C#的StringBuilder 类使用说明
C# StringBuilder
weixin_44706943的博客
08-01 7881
string类型在进行运算的时候是重新生成了一个新的string对象，不适合大量频繁字符串的拼接或删除。StringBuilder进行运算时，是一直在已有对象操作的，适合大量频繁字符串的拼接或删除。
string是什么数据类型？
热门推荐
sulixu的博客
08-11 2万+
学习java有段时间了，今天复习回顾了之前学过的内容，在刚开始复习就发现了一个问题，string是什么数据类型？倒不是这个问题有多难，但是好像突然就把我问蒙住了，后来仔细思考了一下，好像悟了哈哈 1、前言 首先提出一个问题在 Java 中 String 属于那种数据类型？ 我的一个朋友是这么说的，「what？是不是有很多疑惑，int、double、String 不都是经常一起使用的么，应该都是同一种数据类型吧，基本数据类型？」 大家认为呢？ 对于初学者而言可能没有对数据类型没有很强的意识，没有特别的注意到这
android 使用mqt
06-08
您好，如果您想在 Android 应用程序中使用 MQTT 协议进行消息传输，可以使用 Eclipse Paho Android 客户端库。以下是使用 Paho Android 客户端库实现 MQTT 的基本步骤： 1. 添加 Paho Android 客户端库到您的项目中。 2. 连接到 MQTT 代理服务器。您需要指定代理服务器的地址和端口号。可以使用 `MqttConnectOptions` 类设置连接选项，例如设置连接的用户名和密码、清除会话标志等。 3. 订阅主题。您需要指定要订阅的主题和 QoS 等级。 4. 发布消息。您需要指定要发布的主题、消息内容和 QoS 等级。 5. 处理接收到的消息。您需要实现 `MqttCallback` 接口，并在回调方法中处理接收到的消息。 以下是使用 Paho Android 客户端库连接到 MQTT 代理服务器的示例代码： ```java String brokerUrl = "tcp://mqtt.eclipse.org:1883"; String clientId = MqttClient.generateClientId(); MqttAndroidClient client = new MqttAndroidClient(context, brokerUrl, clientId); MqttConnectOptions options = new MqttConnectOptions(); options.setUserName("username"); options.setPassword("password".toCharArray()); options.setCleanSession(true); client.connect(options); ``` 以下是订阅主题和发布消息的示例代码： ```java String topic = "my/topic"; int qos = 1; client.subscribe(topic, qos); String message = "Hello, MQTT!"; client.publish(topic, message.getBytes(), qos, false); ``` 您还需要实现 `MqttCallback` 接口并在回调方法中处理接收到的消息。例如： ```java client.setCallback(new MqttCallback() { @Override public void connectionLost(Throwable cause) { // 处理连接丢失事件 } @Override public void messageArrived(String topic, MqttMessage message) throws Exception { // 处理接收到的消息 String payload = new String(message.getPayload()); Log.d(TAG, "Received message: " + payload); } @Override public void deliveryComplete(IMqttDeliveryToken token) { // 处理消息发送完成事件 } }); ``` 希望这些信息能对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值