Java通过程序中建立String类可以轻松管理字符串。字符串是一个或多个字符组成的连续序列，程序需要存储的大量文字，字符都使用字符串进行表示处理。
Java中定义了String和StringBuffer两个类来封装对字符串的各种操作，它们都放到了Java.lang包中，不需要用import java.lang这个语句导入该包就可以直接使用他们。
String类用于比较两个字符串，查找和抽取串中的字符或字串，进行字符串与其他类型之间的相互转换等。String类对象内容一旦初始化就不能再改变，对于String类的每次改变(例如字符串连接等)都会生成一个新的字符串，比较浪费内存。
StringBuffer类用于内容可以改变的字符串，可以将其他各种类型的数据增加，插入到字符串中，也可以转置字符串中原来的内容。一旦通过StringBuffer生成了最终想要的字符串，就应该使用StringBuffer.toString()方法将其转换成String类，随后就可以使用String类的各种方法操纵这个字符串了。StringBuffer每次都改变自身，不生成新的对象，比较节约内存。

String s; 。声明一个字符串s分配一个内存空间，因为没初始化，所以没有存入任何对象。s作为局部变量是不会自动初始化的，必须显式地赋初始值，在用System.out.println(s)时会报错。

用户可以通过创建String类来创建字符串，String对象既可以隐式的创建，也可以显式地创建，具体创建形式取决于字符串在程序中的用法，为了隐式地创建一个字符串，用户只要将字符串放在程序中，Java则会自动的创建String对象。

String类的两种实例化方式

1，使用字符串常量直接初始化，String对象名称="字符串";
String s="有志者事竟成";

2，使用构造方法创建并初始化(public String(String str))，String 对象名称=new String("字符串");
String s=new String("有志者事竟成");

通过String类实例化方式

class jdjd
{
    public static void main(String args[])
    {
        String str1="Hello";   //直接赋值建立对象str1
        System.out.println("ste1:"+str1);   //输出
        String str2=new String("有志者事竟成");   //构造方法创建并初始化对象str2
        System.out.println("str2:"+str2);
        String str3="new"+"String";        //采用串联方式生成新的字符串str3
        System.out.println("str3:"+str3);
    }
    }
//三种方式都完成了String对象的创建及初始化

String对象也可以先声明在赋值

String str1;     //声明字符串对象str1
str1=“hello”;    //字符串对象str1赋值为“hello”。

2，构造方法先声明在赋值
String sre2 =new String();     构造方法创建一个字符串str2，内容为空字符串。等同于String str2=new String(" ");
str2="有志者事竟成";   //字符串对象str2赋值为"有志者事竟成"

String内容的比较

Java中判断字符串一致方法有两种

1，调用equals(object)方法。
String1.equals(String2)，比较当前对象(String1)包含的值与参数对象(String2)包含的值是否相等，若相等则equals()返回true，否则false，equals()比较时考虑字符中字符大小写的区别。**equalslgnoreCase()可以忽略大小写的进行两个字符串的比较。

String str1="Hello Java";   //直接赋值实例化对象str1。
Boolean result=str1.equals("Hello Java");       //result=true
Boolean result=str1.equals("Hello java");      //result=false
Boolean result=str1.equalslgnoreCase("Hello java");      //result=true

2，使用运算符==
运算符==比较两个对象是否引用一个实例。

String str1="Hello";   //直接赋值实例化对象str1
String str2="Hello";   //直接赋值实例化对象str2
Boolean result=(str1==str2);    //result=true
String str3=new String("Hello");    //构造方法赋值
Boolean result2=("str1==str3");      //result=false

解析1，如果说String是一个类，那么str1一定是这个类的对象，对象名称一定要保存在栈内存之中，那么字符串"Hello"一定保存在栈内存之中；
2，任何情况下使用关键字new都会开辟一个新的堆内存空间；
3，String本身是一个类，所以String类的对象是一定可以进行引用传递的，引用传递的最终结果就是不同的栈内存将保存在同一块堆内存空间的地址;
4，栈内存像int型数据，里面保存的是数值，每一个栈内存只能够保存一块堆内存的物理地址数值。
"=="是对两个对象的堆内存地址的相等进行判断；对字符串内容判断使用equals()。

//判断字符串是否相同
class jdjd
{
    public static void main(String args[])
    {
        String str1="Hello";  //直接赋值
        String str2=new String("Hello");   //构造方法赋值
        String str3=str2;   //引用传递
        System.out.println(str1==str2);   //false
        System.out.println(str1==str3);   //false
        System.out.println(str2==str3);   //true
        System.out.println(str1.equals(str2));   //true
        System.out.println(str1.equals(str3));   //true
        System.out.println(str2.equals(str3));   //true
    }
    }

Java中判断字符串大小
如果希望知道字符串大小情况，需要调用compareTo()方法
字符串对象小于给定字符串：compareTo()方法返回小于0的值；
字符串对象等于给定字符串：compareTo()方法返回小于0的值；
字符串对象大于给定字符串：compareTo()方法返回大于0的值；
比较是根据字母顺序，严格来讲是根据字符的ASCII码值进行比较的，返回结果是第一个不同字符ASCII码的差值。

class jdjd
{
    public static void main(String args[])
    {
    String str1="This is a string";   //直接赋值建立对象str1
    String str2=new String("this is a string");  //构造方法建立对象str2
    int result=str1.compareTo("That is another string");   // result=8
    int result1=str1.compareTo("This is a string");  //result=0
    int result2=str1.compareTo(str2);    //resutl=-32
    System.out.println(result);
    System.out.println(result1);
    System.out.println(result2);
    }
    }

字符串常量是String类的匿名对象
任何语言实际上都不会提供字符串类型，但是在Java里面为了简化用户开发难度专门提供了String类和使用“ " ”定义的字符串，但实际上每一个字符串严格来讲都是String类的匿名对象。
匿名对象特点：没有名字，而且可以调用类中相关方法

String str="Hello";
System.out.println(str.equals("Hello"));   //true，字符串对象调用equals()
System.out.println("Hello".equals(str));    //true，字符串常量调用equals()，"Hello"是String类的匿名对象。

判断某一用户输入的字符串内容是否等于指定的字符串内容，若采用字符串对象.equals("内容")的方式，如果用户没输入字符串，会出现NullPointerException警告，可以采用"字符串".equals(字符串对象)的方式解决这个问题。

String str=null;    //假设这个字符串由用户输入
if(str.equals("Hello"))   //true，字符串对象调用equals()
{
System.out.println("验证通过");
}
if("Hello".equals(str))   //equals()可自动处理null问题，正常判断
{
System.out.println("验证通过");
}

两种字符串实例化方式的区别
实例化字符串对象可以采用两种方式完成，不同方式在内存中呈现的方式不同的分配形式。
1，直接赋值方式
如果采用直接赋值形式，那么就好比将一个字符串的常量赋给了指定的字符串变量，而且每一个字符串都属于String的匿名对象。 ** String str="Hello";** //直接赋值
以直接赋值方式创建对象str，仅开辟一块堆内存和一块栈内存空间。

2，构造方法实例化
此时会开辟两块堆内存空间，其中一块堆内存将会成为垃圾，通过构造方法进行的String类对象也无法进入自动入池的操作，即，数据无法共享。
在String类中提供了一个方法，可以帮助用户手工入池。
手工入池：public String intern();

class ffff
{
    public static void main(String args[])
    {
        String str1="Hello";   //直接赋值
        String str2=new String("Hello").intern();   //手工入池
        String str3="Hello";   //直接赋值
        String str4=new String("Hello");   //构造方法赋值
        System.out.println(str1==str2);    //true
        System.out.println(str1==str3);    //true
        System.out.println(str2==str3);    //true
        System.out.println(str1==str4);   //false
    }
}

字符串一旦声明则不可改变
改变也只会改变String对象的引用。

-----------------------------分割线---------------------------
String类常用方法

//求字符串中的指定字符
public class Main
{
    public static void main(String[] args)
    {
        String str="hellojava";    //直接赋值
        System.out.println(str.charAt(0));   //取出字符串中的第一个字符
        System.out.println(str.charAt(3));   //取出字符串中的第4个字符
    }
}

字符串与字符数组互相转换

public class Main
{
    public static void main(String[] args)
    {
        String str="hellojava";
        char data[]=str.toCharArray();   //将字符串变为字符串数组
        for(int x=0;x<data.length;x++)
        {
            System.out.print(data[x]+" ");
            data[x]-=32;//小写变大写（str字符串中的内容为小写字符，同一个小写的ASCII码比大写大32）
        }
        System.out.println();
        System.out.println("将全部字符数组变为字符串:"+new String(data));
        //取得部分内容的时候需要设置起始点和长度（5为起始点，4为长度）
        System.out.println("将部分字符数组变为字符串:"+new String(data,5,4)); 
}
}

字节与字符串

//字符串与字节相互转换
public class Main
{
    public static void main(String[] args)
    {
        String str="hellojava";
        byte data[]=str.getBytes();  // 将字符串变为byte数组
        for(int i=0;i<data.length;i++)
        {
            data[i]-=32;
        }
        System.out.println(new String(data));  //将全部byte数组变为字符串
        System.out.println(new String(data,5,4));   //将部分byte数组变为字符串
    }
}

字符串查找方法

由一个字符串中若干字符按顺序形成的连续字符片段，就是字符串的子串
从一个指定的字符串之中查找某一个子字符串是否存在操作，称为字符串查找。查找操作方法如下

//字符串查找方法
public class Main
{
    public static void main(String[] args)
    {
        String str="**hello$$world##";
        if(str.contains("hello"))   //查找hello是否存在
        {
            System.out.println("内容存在，已经查到");
        }
        if(str.indexOf("r")!=-1)   //查找hello是否存在
        {
            System.out.println("内容存在，字符串位置:"+str.indexOf("r"));
        }
        if(str.indexOf("o",6)!=-1)   //由指定位置开始查找
        {
            System.out.println("内容存在，字符串位置:"+str.indexOf("o",6));
        }
        if(str.lastIndexOf("w",12)!=-1)   //由指定位置从后向前开始查找
        {
            System.out.println("内容存在，字符串位置:"+str.lastIndexOf("w",12));
        }
        System.out.println(str.startsWith("**"));//判断字符串的起始内容
        System.out.println(str.startsWith("$$",7));   //判断从索引7位置是否以$$开始
        System.out.println(str.endsWith("##"));   //判断是否以##结束
        }
        }

字符串替换

//字符串替换方法
public class Main
{
    public static void main(String[] args)
    {
        String str="helloworld";
        System.out.println(str.replaceAll("o","***"));   //所有子串出现的位置都替换
        System.out.println(str.replaceFirst("l","_"));    //替换第一次出现字符子串
    }
    }

字符串截取
从一个字符串中取出里面部分内容，即子串。从字符串截取子串方法如下

//字符串中取子串方法
public class Main
{
    public static void main(String[] args)
    {
        String str="Hellojava";
        System.out.println(str.substring(5));   //截取从指定位置到末尾的子串
        System.out.println(str.substring(0,5));   //截取从指定位置到结束位置子串
    }
    }

字符串拆分
字符串拆分指的是将一个字符串按照指定的字符串regex拆分为字符串，返回一个字符型数组，regex不作为任何数组元素的部分返回。操作方法如下

//字符串拆分方法
public class Main
{
    public static void main(String[] args)
    {
        String str="hello world hello java";
        String data[]=str.split(" ");  // 按照空格拆分
        for(int i=0;i<data.length;i++)
        {
            System.out.println(data[i]);
        }
        System.out.println("------我是分割线------");
        String data1[]=str.split(" ",3);   //按照空格拆分为3个字符数组元素
        for(int x=0;x<data1.length;x++)
        {
            System.out.println(data1[x]);
        }
    }
    }

如果用“.”或“|”作为分隔的话必须写法如下String split("\.") 或String split("\|")。如果用“\”作为分隔必须写成String split("\\")。如果在一个字符中有多个分隔符，可以用“|”作为连接符，比如str="account=8 and uu=45 or n=25"，把三个都分隔出来可以用Str.splitz"and|or)"，即用and或or进行分隔。

其他方法

//字符串常用方法
public class Main
{
    public static void main(String[] args)
    {
        String str="Hello World...";
        System.out.println("原始字符串内容【"+str+"】"+"，长度："+str.length());  //求字符串长度
        System.out.println("原始字符串内容【"+str+"】"+"，长度："+str.trim().length());  //去掉字符串前后空格的长度
        System.out.println("".isEmpty());  //判断字符串是否为空
        System.out.println(str.isEmpty());  //判断str字符串是否为空
        System.out.println("Hello World!!".toUpperCase());   //字符串字符全变大写
        System.out.println("Hello World!!".toLowerCase());   //字符串字符全变小写
        System.out.println(str.concat("java"));   //字符串连接
    }
}

总结

String str=new String("java");
1，创建String对象的个数是两个对象，一个是“java”，一个是指向“java”的引用对象str。
2，java中堆内容和栈内存区别
堆内容是一个子集。栈内存存取速度仅次于寄存器，栈内存里面的数据可共享，但其中数据大小和生存期必须在运行前确定。堆内容是运行时可动态分配的数据区，从速递看比堆内存慢，堆内容里面数据不共享，大小和生存期都可以运行时在确定。new关键字是运行时在堆内容里面创建对象。每new一次都一定会创建新对象，因为堆数据不共享。