stringbuilder

1.可变性 　　String类中使用final关键字，字符数组保存字符串，private final char value[]; ，使用String对象是不可变的。 　　StringBuffer和StringBuider都是继承 AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串 char[] value，但是没有用final关键字修饰，所有这里个对象都是可变的。 　　　　StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，可查看源码。 abstract class AbstractStringBuilder implements Appendable, CharSequence { /** * The value is used for character storage. */ char[] value; /** * The count is the number of characters used. */ int count; /** * This no-arg constructor is necessary for serialization of subclasses. */

浅谈对String,StringBuilder,StringBuffer的认识 String类是final修饰的类，final修饰的类不能够被继承。String类是字符串类，常常被用来进行字符串的操作，但是String的值是不可变的，这就导致每次对String的操作都会产生新的对象，效率低下，而且浪费了大量的内存空间。 由于对字符串的操作产生了大量的对象，浪费空间，为了解决这种状况StringBuilder应运而生，StringBuilder是可变字符串，能够解决字符串操作浪费空间的问题,并且不产生新的对象。但是StringBuilder线程不安全。 为了解决线程安全的问题StringBuffer应运而生，StringBuffer之所有线程安全是因为StringBuffer几乎所有的方法都加入了Synchronized,但是正是因为加入了Synchronized同步锁，使得速度速度变慢，而StringBuilder没有同步锁，所以它的访问速度要比StringBuffer快。 String：使用与少量字符串操作的情况，大量的操作浪费空间，效率低下。 StringBuilder:使用与单线程下在字符缓冲进行大量的操作的情况，它是线程不安全的。 StringBuffer：使用多线程下在字符缓冲区进行大量的操作的情况，它是线程安全的 来源： https://www.cnblogs.com

Consider the below struts Action class in which, I am using a StringBuilder variable inside the execute method. My question: Is the variable sb threadsafe or not? public DemoAction extends Action { ...... public ActionForward execute(.....) { StringBuilder sb = new StringBuilder(); } } What if the same variable sb declared outside the execute(). Remember there will be only one object for DemoAction in WebContainer.? Local variables are thread safe, as long as no other thread somehow gets a reference to the same string builder instance, it’s thread safe. It is threadsafe because you only create

ContainerBuilder builder = new ContainerBuilder(); ////builder.RegisterType<GetTest>().As<IBufrTest>(); //builder.RegisterType<GetTest>().AsImplementedInterfaces(); //builder.RegisterType<gettest2>().As<IBufrTest>(); string dllFIle = System.IO.Directory.GetCurrentDirectory() + "\\DemoBufr.dll"; builder.RegisterAssemblyTypes(Assembly.LoadFile(dllFIle)).AsImplementedInterfaces(); IContainer resorlver = builder.Build(); var test = resorlver.Resolve<IEnumerable<IBufrTest>>(); StringBuilder sbtext = new StringBuilder(); foreach (var item in test) { sbtext.Append(item.getstring()).Append("\r\n"); }

Is it true that StringBuilder is slower than concatenate a dozen of strings? How does compiler optimize the string concatenation so that joining a dozen of strings using "+" will be better than StringBuilder? From a book (written by Ben Watson) it says that: String Concatenation: For simple concatenation of a known (at compile time) quantity of strings, just use the ‘+’ operator or the String.Concat method. This is usually more efficient than using a StringBuilder. string result = a + b + c + d + e + f; Do not consider StringBuilder until the number of strings is variable and likely larger

Today I was reading Antonio's Blog about toString() performance and there is a paragraph: What used to be considered evil yesterday (“do not concatenate Strings with + !!!“), has become cool and efficient! Today the JVM compiles the + symbol into a string builder (in most cases) . So, do not hesitate, use it. Now I am confused, because he is saying Today the JVM compiles the + symbol into a string builder (in most cases) , but I have never heard or seen(code) anything like this before. Could someone please give example where JVM does this and in what conditions it happens ? The rule “do not