java学习笔记——字符串和可变字符串

字符串和可变字符串

---

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的问题

   1）StringBuilder的效率比StringBuffer要快，但是它是线程不安全的；反之StringBuffer安全，但是效率没有StringBuilder高。

   2）平时用什么比较好？

   一般把StringBuilder写在方法中，而不是写成成员变量。建议大家用这个。当使用成员变量的时候用StringBuffer
   3）关于StringBuffer与StringBuilder的方法都是相同的