NO10.Java笔记【String、StringBuilder、StringBuffer】

最新推荐文章于 2024-10-22 18:43:39 发布

吴湘东

最新推荐文章于 2024-10-22 18:43:39 发布

阅读量1k

点赞数

本文链接：https://blog.csdn.net/wxd2014/article/details/18768845

版权

一、String

/*
字符串是一个特殊的对象
字符串一旦初始化就不可以被改变
String str = "abc"
String str1 = new String("abc");

String类适用于描述字符串事物。
那么它就提供了多个方法对字符长操作。

常见的操作方法有哪些？
1.获取
  1.1 字符串中的包含的字符数，也就是字符串的长度。
      int length()返回字符串的长度（获取长度）。
  1.2 根据位置获取位置上某个字符。
      char charAt(int index)返回指定索引的字符值。
  1.3 根据字符获取该字符在字符串中的位置。 
      int indexOf(int ch) 接收的是ASCII码。返回的ch在字符串中第一次出现的位置。
      int indexOf(int ch, int fromIndex) 从fromIndex指定位置开始，获取ch在字符串中出现的位置。

2.判断
  2.1 字符串中是否包含某一子串。
      boolean contains(str);
	  特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1，表示该str不在字符串中存在。
	     所以，也可以用于对指定判断是否包含。
	     if(str.indexOf("aa"!=-1))
		 而且该方法即可以判断又可以获取出现的位置。
  2.2 字符中是否有内容
      boolean isEmpty(); 原理就是判断长度是否为0。注意值为："" null
  2.3 字符串是否是以指定内容开头
      boolean startsWith(str);
  2.4 字符串是否是以指定内容结尾。
      boolean endsWith(str);
  2.5 判断字符串内容是否相同，复写了Object类中的equals方法。
      boolean equals(str)
  2.6 判断内容是否相同，并忽略大小写
      boolean equalsIgnoreCase();

3.转换
  3.1 将字符数组转换成字符串
       构造函数：String(char[])
	             String(char[],offset,count):将字符数组中的一部分转成字符串
       静态方法：static String copyValueOf(char[]);
	             static String copyValueOf(char[],int offset,int count);

				 static String valueOf(char[])
  3.2 将字符串转成字符数组
      char[] toCharArray():将字符串变成数组
  3.3 将字节数组转成字符串
      String(bybe[]):
      String(bybe[],int offset,int count):将字节数组中的一部分转成字符串
  3.4 将字符串转成字节数组
      byte[] getBytes()
  3.5 将基本数据类型转成字符串。
      String valueOf(int)
      String valueOf(double)
	  3+"";//String.valueOf(3)

	  特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

 4.替换
    String replace(oldchar,newchar)
	String replace(oldString,newString)

 5.切割
    String[] split(regex);

 6.子串。获取字符串中的一部分。
    Stirng substring(int begin);
    Stirng substring(int begin,int end);

 7.转换，去除空格，比较
    7.1 将字符串转成大写或者小写
	    String toUpperCase(); 大写
		String toLowerCase(); 小写
	7.2 将字符串两端的多个空格去除
	    String trim();
	7.3 对两个字符串进行自然顺序的比较
	    int compareTo(String);  //等于返回0   大于返回正数、小于返回负数【不同字符之差】  
*/
class StringDemo
{
	public static void method_7()
	{
		String s = "  Hello Java  ";
		sop(s.toLowerCase());
		sop(s.toUpperCase());
		sop(s.trim());

		String s1 = "atc";
		String s2 = "aaa";
		sop(s1.compareTo(s2));
	}
	public static void method_sub()
	{
		String s = "abcdef";
		sop(s.substring(2));//从指定位置开始到结尾，如果角标不存在，会出现字符串角标越界异常。
		sop(s.substring(2,4));//包含头，不包含尾  s.substring(0,s.length)
	}
	public static void method_split()
	{
		String s = "zhangsan,lisi,wangwu";
		String[] arr = s.split(",");
		for(int i=0; i<arr.length; i++)
		{
			sop(arr[i]);
		}
	}
	public static void method_replace()
	{
		String s = "hello java";
		//String s1 = s.replace('a','e'); //如果要替换的字符不存在，就返回原串。
		String s1 = s.replace("java","world");//hello world
		sop("s="+s);
		sop("s1="+s1);
	}
	public static void method_trans()
	{
		char[] arr = {'a','b','c','d','e','f'};
		String s = new String(arr,1,3); //中间值代表下标  尾值代表个数
		sop("s="+s);

		String s1 = "wxdgefs";
		char[] chs = s1.toCharArray();
		for(char c:chs)
		{
			System.out.println(c);
		}
	}
	public static void method_is()
	{
		String str = "ArrayDemo.java";
		//判断文件名称是否是以Array单词开头
		sop(str.startsWith("Array"));
		//判断文件是否是java文件
		sop(str.endsWith(".java"));
		//判断文件名称是否包含Demo
		sop(str.contains("Demo"));
	}
	public static void method_get()
	{
		String str = "abcsdfiudfdef";
		//长度
		//System.out.println(str.length);
		sop(str.length());

		//根据索引获取字符
		sop(str.charAt(4));//当访问到字符串不存在的角标会发生角标越界。
		//根据字符获取索引
		sop(str.indexOf('c'));
		sop(str.indexOf('i',7));//如果没有找到返回-1
		sop(str.indexOf('f',6));

		//反向索引一个字符出现的位置，从后面向前查询。
		sop(str.lastIndexOf('f'));
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{  
		method_7();
		//method_sub();
		/*
		method_split();
		method_replace();	
		method_trans();
		method_is();
		method_get();
		
		String s1 = "abc";//s1是一个类类型变量，“abc”是一个对象
		                  //字符串最大的特点：一旦被初始化就不可以被改变
						  //常量池
        //

        String s2 = new String("abc");
		//s1和s2有啥区别：
		//s1在内存中有一个对象。
		//s2在内存中有两个对象。
		String s3 = "abc";
		System.out.println("s1==s2:"+(s1==s2));      //地址是否相等
		System.out.println("s1==s2:"+s1.equals(s2));  //内容是否相等

		//String类复写了Object类中equals方法，该方法用于判断字符串是否相同。
		System.out.println(s1==s2); //false
		System.out.println(s1==s3); //true
	    */
	}

}

public class StringMethodDemo {

	public static void main(String[] args) {
		/*
		 * 按照面向对象的思想对字符串功能分类。
		 * "abcd"
		 * 一、获取：
		 * 1.1 获取字符串中字符的个数（长度）
		 *    int length() 返回此字符串的长度 
		 * 1.2 根据位置获取字符
		 *    char charAt(int idnex) 
		 * 1.3 根据字符获取在字符串中第一次出现的位置
		 *    int indexOf(int ch) 
		 *    int indexOf(int ch,int fromIndex)从指定位置进行ch的查找第一次出现的位置
		 *    int indexOf(String str);
		 *    int indexOf(String str,int fromIndex)
		 *    int lastIndexOf(int ch)返回在字符串中最后一次出现处的索引。
		 *    int lastIndexOf(String str);
		 * 1.4 获取字符串中一部分字符串
		 *    String substring(int beginIndex,int endIndex) 前包含后不包含
		 *    String substring(itn beginIndex);
		 *    
		 * 二、转换
		 * 2.1  将字符串变成字符串数组（字符串的切割）
		 *    String[] split(String regex) ：涉及正则表达式
		 * 2.2 将字符串变成字符数组
		 *    char[] toCharArray():将此字符串装换成一个新的字符数组
		 * 2.3 将字符数组
		 *    byte[] getBytes();
		 * 2.4 将字符串中的字母装成大小写
		 *    String toUpperCase();大写
		 *    String toLowerCase();小写
		 * 2.5 将字符串中的内容进行替换
		 *    String replace(char oldChar,char newChar)
		 *    String replace(String s1,String s2)
		 * 2.6 将字符串两端的空格去除
		 *    String trim();
		 * 2.7 将字符串进行连接
		 *    String concat(String str) 
		 * 2.8 String valueOf() 能将资本数据类型转换成字符串类型。
		 * 
		 * 三、判断
		 * 3.1 两个字符串的内容时候相同
		 *    boolean equals(object obj);
		 *    boolean equalsIgnoreCase(String str);忽略大写比较字符串的内容
		 * 3.2 字符串中是否包含指定字符串
		 *    boolean contains(String str)
		 * 3.3字符串是否以指定字符串开头。是否以指定字符串结尾。
		 *    boolean startsWith(String str)
		 *    boolean endsWith(String str)
		 *    boolean contains(String str)
		 *    
		 *    int compareTo(Tring antherString); //比较字符串 0：等于   小于：负数  大于：整数   两个数组的差距
		 *    int compareToIgnoreCase(String str) 比较字符串，但不考虑大小写。
		 *    
		 *    public String inter() 返回字符串对象的规范表示形式。
		 *    一个初始为空的字符串池，它由类String私有地维护。
		 *    当调用intern方法时，如果池已经包含一个等于此String对象的字符串（equals(Object)方法确定），则返回池中的字符串，
		 *    否则将此String对象添加到池中，并返回String对象的引用。
		 *    
		 */
		stringMethodDemo_4();
	}

	private static void stringMethodDemo_4() {
		System.out.println("abc".compareTo("aqz")); //字符串对象比较
	}

	private static void stringMethodDemo_3() {
		String s = "abc";
		System.out.println(s.equals("ABC".toLowerCase()));
		System.out.println(s.equalsIgnoreCase("abC"));
		
		System.out.println(s.contains("bc"));
		System.out.println(s.contains("cc"));
		
		String str = "ArrayDemo.java";
		System.out.println(str.startsWith("Array"));
		System.out.println(str.endsWith(".java"));
		System.out.println(str.contains("Demo"));
	}

	private static void stringMethodDemo_2() {
		String s ="张三,李四,王五";
		String[] arr = s.split(",");  
		//String[] arr = s.split("//.");转义字符
		for(int i=0;i<arr.length;i++)
		{
			System.out.println(arr[i]);
		}
		
		char[] chs = s.toCharArray();
		for(char ch:chs)
		{
			System.out.println(ch);
		}
		
		s = "ab你";//一个中文两个字节
		byte[] bytes = s.getBytes();
		for(int i=0;i<bytes.length;i++)
		{
			System.out.println(bytes[i]);
		}
		
		System.out.println("ABc".toUpperCase());
		System.out.println("ABc".toLowerCase());
		
		System.out.println("jovo".replace('o','a'));
		
		String s1 = "java";
		String s2 = s1.replace('a','o');
		System.out.println("s1="+s1);  //java
		System.out.println("s2="+s2);   //jojo
		System.out.println(s1==s2);       //false
		System.out.println(s1.equals(s2));//false
		
		String s3 = "java";
		String s4 = s3.replace('q','z' );
		System.out.println("s3="+s3);
		System.out.println("s4="+s4);
		System.out.println(s3==s4); //ture
		
		System.out.println("-"+"abc".trim());               //-abc
		System.out.println("-"+"      abc    ".trim()+"-"); //-abc-
		
		System.out.println("abc".concat("dd"));
		System.out.println("abc"+"dd");
	}

	private static void stringMethodDemo_1() {
		String s = "abcdae";
		System.out.println("length:"+s.length());
		System.out.println("char:"+s.charAt(2));
		System.out.println("index:"+s.indexOf('c'));
		//如果没有找到则返回-1，根据取值判断字符或者字符串是否存在。
		System.out.println("LastIndex:"+s.lastIndexOf('a'));
		System.out.println(s.substring(2,4));
	}

}

二、StringBuffer和StringBuider

public class StringBufferDemo {

	public static void main(String[] args) {
		/*
		 * StringBuffer:就是字符串缓冲区，线程安全的可变字符序列。
		 * 用于存储数据的容器
		 * 特点：
		 * 1.长度的可变的。
		 * 2.可以存储不同类型的数据
		 * 3.最终都要转成字符串使用。
		 * 既然是一个容器兑现个，应该具备什么功能呢？
		 * 1.添加
		 *   StringBuffer append(类型) c byte short
		 *   StringBuffer insert(index,data)
		 * 2.删除
		 *   StringBuffer delete(start,end):包含头，不包含尾
		 *   StringBuffer deleteCharAt(int index):删除指定位置的元素
		 * 3.查找
		 *   char charAt(index)
		 *   int indexOf(string)
		 *   int lastIndexOf(string)
		 * 4.修改
		 *   StringBuffer replace(start,end,string)
		 *   void setCharAt(int index,char ch)
		 *   
		 * StringBuffer(int capacity)//指定初始容量的字符串缓冲区
		 * StringBuffer()构造一个其中不带字符串缓冲区，初始容易为16字符。
		 * 
		 * StringBuilder 不保证同步,单线程，它的出现提高效率。
		 * 与StringBuffer功能一样  单线程使用StringBuider   多线程建议使用StringBuffer
		 * 
		 * JDK升级：1.简化书写  2.提高效率 3.增加安全性
		 */
		bufferMethodDemo_3();
	}
	
	
	private static void bufferMethodDemo_3() 
	{
		StringBuffer sb = new StringBuffer("abce");
		//sb.delete(1, 3);//ae
		//sb.setCharAt(1,'q');
		
		//sb.setLength(0);//清空缓冲器
		sb.setLength(10);
		System.out.println(sb);
		System.out.println(sb.reverse());//是sb逆向
		System.out.println(sb);
		
		//清空缓冲区
		//sb.delete(0,sb.length());
		//sb = new StringBuffer();  //创建一个新对象
	}

	
	private static void bufferMethodDemo_2() 
	{
		StringBuffer sb = new StringBuffer("abce");
		//sb.append("haha");
		sb.insert(2, "qq");  //abqqce
		System.out.println(sb.toString());
	}

	public static void bufferMethodDemo_1()
	{
		//创建缓冲区对象。
		StringBuffer sb = new StringBuffer();
		StringBuffer s1 = sb.append(44).append("haha");
		System.out.println(sb==s1);
		StringBuffer sb1 = new StringBuffer();
		sb1.append("haha");
		sb1.insert(1,"dddd");
		System.out.println(sb1);
	}

}

基本数据类型对象包装类.
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character

基本数据类型对象包装类的最常见作用：
就是用于基本数据类型和字符串类型之间做转换

基本数据类型转字符串
基本数据类型+""
基本数据类型.toString(基本数据类型值)
如：Integer.toString(34);//将34整数变成"34".

字符串转成基本数据类型
parseInt(String str);
xxx a = Xxx.parseXxx(String);
boolean b = Boolean.parseBoolean("true");
Integer i = new Integer("123");

十进制转成其他进制
toBinaryString();
toHexString();
toOctalString();

其他进制转成十进制
parseInt(String,radix); //代表现在是多少进制的