class StringDemo
{
        public static void main(String[] args)
        {
            String str1 = new String(new StringBuffer("abc"));
                //在视频里看到的他创建方法,想知道为什么会弄这么复杂，有什么区别。
            String str2 = new String("abc");
           // String str3 =(String)constructor.newInstance(new StringBuffer("abc"));


            System.out.println(str1==str2);
            //System.out.println(str1==str3);
            //System.out.println(str2==str3);
            System.out.println(str1);
            System.out.println(str2);
            //System.out.println(str3);
        }

}

String str1 = new String(new StringBuffer("abc"));这一句是建了一个带缓冲区的字符串对象abc,
   String str2 = new String("abc");这一句是建立了一个字符串对象abc
String str3 =(String)constructor.newInstance(new StringBuffer("abc"))这一句是利用反射通过得到String的构造方法String(StringBuffer buffer)所对应的字节码对象然后新建一个带缓冲区的字符串对象

String和StringBuffer就是一个常量和变量的关系
StringBuffer对象的内容可以修改
而String对象一旦产生后就不可以被修改，重新赋值其实是两个对象

比较
StringBuffer str = new StringBuffer("a");
str.append("bc");

String str2 = "a";
str2 = str2 + "bc";

str引用的一直是同一对象
而str2引用的在两句中是完全不同的对象

import java.lang.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/*Constructor类代表某个类中的一个构造方法
  得到某个类所有的构造方法：
  Constructor [] constructor  =
  得到某一个构造方法
  Constructor constructor =
  clsss,forName("java.lang.string")。getConstructor(stringBuffer。class)
  常见实例对象
  通常方式：String str =new String (new StringBuffer("abc"))
反射方式：String str=(String)constructor.newinstance(new StringBuffer("abc")) */
public class ReflectDemo {

        /**
         * @param args
         * @throws ClassNotFoundException
         * @throws NoSuchMethodException
         * @throws SecurityException
         * @throws InvocationTargetException
         * @throws IllegalAccessException
         * @throws InstantiationException
         * @throws IllegalArgumentException
         */
        public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
                // TODO Auto-generated method stub
                String          str1="abc";
                Class cls1=str1.getClass();
                Class cls2=String.class;
                Class cls3=Class.forName("java.lang.Math");
                System.out.println(cls1==cls2);
                System.out.println(cls3==cls2);
                System.out.println(cls1.isPrimitive());
                System.out.println(int.class.isPrimitive());
                System.out.println(Integer.class.isPrimitive());
                System.out.println(int.class==Integer.TYPE);
                System.out.println(int[].class.isPrimitive());
                System.out.println(int[].class.isArray());
                Constructor constructor1=String.class.getConstructor(StringBuffer.class);
                //创建一个Constructor类型的对象，该对象是String类的构造函数，该构造函数传入的是StringBuffer的一个参数
                String str2=(String) constructor1.newInstance(new StringBuffer(new StringBuffer（）);
                //获得String构造方法的一个新的实例对象，该构造方法传入的参数类型是StringBuffer
                 加（String）原因是该程序编译时并不知道该构造方法是谁的构造方法，所以要强制转换成String类的构造方法
        }

String是不可变对象，一但被创建就不能修改，若要操作已存在的String对象，就会创建新的对象，把新值保存然后销毁旧对象，对象的地址就变了，java不能获取对象地址，不容易看到。
StringBuffer是可变对象，只能通过构造方法来创建对象StringBuffer sb = new StringBuffer()。可以用 .append()方法对其操作并且对它操作不会改变其地址。
在应用中StringBuffer要比String的效率高的多。

从运行结果可以看出，打印的结果相同，而比较的结果不一样，说明，他们的地址不同。那么，最主要的就是StringBuffer了，StringBuffer类是创建了一个缓冲去，String str1 = new String(new StringBuffer("abc"));是创建了一个带缓冲区的对象。

String这个类是final的我们不可以对其进行修改的。我们使用字符缓冲区可以修改里面的数据。比如插入数据，删除数据.new String()只是创建一个字符串对象。而new Strin(new SringBuffer());它是在创建对象的时候使用了字符缓冲区。这个对象，我想我们应该可以执行插入数据的操作吧。我没有试过。但是还是希望能帮的上你。

楼主你好，如果问题已解决，请将帖子改为提问结束，如果没有解决请楼主继续提问，谢谢合作