String中的编码/解码

编码表：由字符及其对应的数值组成的一张表。

常见的编码表

ASCII：美国标准信息交换表。
ISO8859-1：拉丁码表，欧洲码表。所有的符号一个符号按一个码值计算。
GB2312：中国的中文编码表，一个汉字两个字节。
GBK：中国的中文编码表升级，一个汉字两个字节。
GB18030：GBK的取代版本。
BIG5：通用于香港、台湾地区的繁体字编码方案。
UTF-8：最多用3个字节表示一个字符。
Unicode：国际标准码，融合了多种文字，所有的文字都用2个字节来表示，Java语言使用的就是该码表。

编码：一个码值的数组转换成一个字符串。

解码：将一个字符串转换为对应的码值数组。

编码的方法：String.getBytes()。

解码的方法：new String(byte[]…)。

import java.util.Arrays;
public class StrDemo {
    public static void main(String[] args) {
        String s1 = "abc";
        byte[] bs = s1.getBytes();//编码
        System.out.println(Arrays.toString(bs));//[97, 98, 99]

        //bs-->字符串
        String s2 = new String(bs);
        System.out.println(s2);//abc
    }
}

import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class StrDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //解决乱码的思路：保证编码使用的码表和解码使用的码表是同一个
        String s1 = "中国";
        byte[] bs = s1.getBytes();//编码，utf-8
        System.out.println(Arrays.toString(bs));
        //[-28, -72, -83, -27, -101, -67]

        //bs-->字符串  解码，默认用编译器的码表
        String s2 = new String(bs,"GBK");

        System.out.println(s2);//涓浗
    }
}

//部分解码
String s2 = new String(bs,0,3,"utf-8");
System.out.println(s2);//中

import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class StrDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //解决乱码的思路：保证编码使用的码表和解码使用的码表是同一个
        //自己的文件是GBK，utf-8
        String s1 = "中国";
        byte[] bs1 = s1.getBytes("utf-8");//编码，utf-8
        System.out.println(Arrays.toString(bs1));
        //[-28, -72, -83, -27, -101, -67]
        //解码    tomcat服务器iso8859-1
        String temp = new String(bs1,"iso8859-1");
        System.out.println(temp);//一定是乱码    //ä¸•å•½
        //码值组成的数组iso8859-1所有的符号一个符号与一个码值对应
        byte[] bs = temp.getBytes("iso8859-1");//编码
        System.out.println(Arrays.toString(bs));
        //[-28, -72, -83, -27, -101, -67]
        //bs-->字符串  解码，默认用编译器的码表
        String s2 = new String(bs,"utf-8");
        System.out.println(s2);//中国
    }
}

过滤重复字符串

import java.util.Scanner;

//过滤重复字符串
public class StringDemo {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String str = input.next();
        //开始过滤重复
        //1.str-->char[]
        char[] old = str.toCharArray();

        //2.保存过滤后的结果
        char[] newArr = new char[str.length()];

        //3.判断是否有重复
        for (int i = 0; i < old.length; i++) {
            boolean isFlag = false;//标记是否出现重复的符号，默认不重复
            for (int j = 0; j < newArr.length; j++) {
                if (old[i] == newArr[j]) {
                    isFlag = true;//表示重复字符串
                    break;
                }
            }

            //如果没有重复，就要将字符存放新数组
            if (isFlag == false) {
                for (int k = 0; k < newArr.length; k++) {
                    if (newArr[k] == '\u0000') {
                        //往新数组存放，放在没有符号的空位置
                        newArr[k] = old[i];
                        break;
                    }
                }
            }
        }
        //显示过滤后的结果
        String result = new String(newArr).trim();
        System.out.println(result);
        //请输入字符串：
        //aaabbbbcccsssssssssssss
        //abcs
    }
}

StringBuffer

概述

String作为字符串已经很方便用户的使用，为什么还出现了一个StringBuffer的类？

因为当多个字符串进行连接操作也就是用+进行操作的时候，会在常量池（方法区中）有过多的临时对象。这样内存中的垃圾很多。要解决该问题就需要有一个新的办法。

String的对象都是常量，具有不变性。而StringBuffer具有可变性，是具有缓冲的字符串。
线程安全的可变字符序列，其性能较差。
StringBuffer依然是数据类型，表示一个字符串。
String的方法StringBuffer都可以使用。

特点：可变性

适用场景：频繁需要修改值的字符串。 jdbc用来拼接sql语句。

//声明StringBuffer对象并初始化
StringBuffer sb = new StringBuffer("abc");

常用方法

toString()：转化为String类型。字符串.toString();
append()：等价于concat功能。字符串.append()使用：JDBC中所有的sql语句。
reverse()：倒序字符串。
insert()：插入字符串。字符串.insert(位置，插入的内容)

public static void main(String[] args) {
    StringBuffer sb=new StringBuffer();//相当于创建一个容器
    sb.append("abc");//将"abc"追加到StringBuffer容器中
    //把StrinBuffer容器中所有的内容取出来作为一个字符串
    System.out.println(sb.toString());//abc
    System.out.println(sb.reverse());//cba
    System.out.println(sb.insert(2,3));//cb3a
}

原理

StringBuffer的底层使用的是一个字符数组，所有添加到StringBuffer中的内容都会添加到底层的字符数组中，从StringBuffer中取出数据（toString()）会把字符数组中的内容转换成一个字符串。

public static void method03(){
    StringBuffer sb=new StringBuffer();//char[] value=new char[16]
    sb.append(true);//value={'t','r','u','e'}
    sb.append("ab");//向字符数组末尾追加  value={'t','r','u','e','a','b'}
    System.out.println(sb);//"trueab"
}

public static void method02(){
    StringBuffer sb=new StringBuffer();//char[] value=new char[16]
    sb.append(true);//会把true变成一个个字符,添加到value数组中
    //value={'t','r','u','e'}
    System.out.println(sb);//会把value字符数组转换为一个字符串 "true"
}

StringBuffer链式编程

由于append方法返回的又是一个StringBuffer对象（原有的StringBuffer不是新的），所以我们可以继续调用StringBuffer的方法。

public static void method(){
    StringBuffer sb=new StringBuffer();
    sb.append("abc").append(123).append("e");//链式编程,前提返回的是对象
    System.out.println(sb);
}

StringBuilder

StringBuilder又称为可变字符序列，它是一个类似于String的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

原来StringBuilder是个字符串的缓冲区，即就是它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

StringBuilder依然是数据类型，表示一个字符串。String的方法StringBuilder都可以使用。

特点：可变性。线程不同步，性能较Stringbuffer好，平常使用推荐Stringbuilder。

处理字符串的方法与StringBuffer基本一样。

String和StringBuffer、Stringbuilder的比较

1、String：字符串常量

String是不可变的对象，在每次对String类型进行改变时其实都等同于生成了一个新的String对象，然后指向新的String对象，所以经常改变内容的字符串最好不要用String类型，因为每次生成对象都会对系统性能产生影响

2、关于StringBuffer和StringBuilder的问题

StringBuilder的效率比StringBuffer要快，但是它是线程不安全的；反之StringBuffer安全，但是效率没有StringBuilder高。
平时用什么比较好？一般把StringBuilder写在方法中，而不是写成成员变量。建议大家用这个。当使用成员变量的时候用StringBuffer。
关于StringBuffer与StringBuilder的方法都是相同的。

目录CONTENT

字符串和可变字符串