2021-5-13-优快云博客

本文详细介绍了Java中字符串(String)的特性和用法，包括构造方法、判断功能、获取功能等，并对比了String与StringBuilder的区别。同时深入探讨了StringBuilder类的构造方法、添加功能、反转功能等，以及其在字符串拼接中的高效应用。

1.API概述

API（application Programming Interface）：应用程序编程接口。

如何使用API

打开帮助文档
点击显示，找到索引，看到输入框
你要找谁：在输入框里输入，然后回车
看包：java.lang下的类不需要导包，其他需要
看类的解释和说明
学习构造方法
使用成员方法

常用API

API概述
String
StringBuilder
ArrayList
FileWriter和FileReader
BufferedWriter和BufferedReader
常用API练习

String类的概述及构造方法不可变的

String类概述

字符串是由多个字符组成的遗传数据。
字符串可以看成是字符数组。

构造方法

public String (String original)
Public String(char[] value)
Public String(char[] value,int offset,int count)
直接赋值也可以是一个对象。

Public class MyString{

Public static void mian(String[] args){

String st=”abc”;//st在栈中，常量池若有abc则直接调用，若无则创建后调用。

String st2=”abc”;

st2=”abc”+”d”;//不能修改字符串本身的值，若修改会在常量池中创建新的对象，abcd

System.out.println(st==st2);//st st2地址相同

}

Public class MyString{

Public static void mian(String[] args){

String st=”abc”;

String st2=”ab”;

String st3=”c”;

String st4=st2+st3;//不相当于String st5=”abc”;编译器不会对字符串串变量进行预编译，会产生新的对象。

String st5=”ab”+”c”;//拼接相当于String st5=”abc”;编译器会对字符串的字面量进行预编译。

System.out.println(st5==st);//true

System.out.println(st4==st);//false

}

String类的构造器

第一种String类的构造器：

Public class MyString{

Public static void mian(String[] args){

String st= new String(original:“abc”);//String st=”abc”;这行代码创建几个对象 1或者2个。第一步：new String()会在堆内存中创建一个对象；（2）若abc在常量池中，则直接给堆内存，若没有，则常量池先创建abc在给堆内存。

String st2=”abc”; //abc在常量池

System.out.println(st);//abc

System.out.println(st2);//abc

System.out.println(st==st2);//错

String st3=new String(original:”abc”);//abc

System.out.println(st.equals(st2));//true; 比较内容是否相同

}

第二种String类的构造器：public String(char[] value)

Public class MyString{

Public static void mian(String[] args){

//将字符数组转换成字符对象

char[] arr={‘a’,’b’,’c’};

String st =new String(arr);

System.out.println(st);//abc

//第三种构造器：public String(char[] value,int offset,int count)

//将字符数组的一部分转换成字符串

char[] arr={‘a’,’b’,’c’,’d’};

String st =new String(arr,offset:0,count:3);

System.out.println(st);//abc从下标为0开始，每3个字符为一个字符串

}

3.String的特点

通过构造方法创建字符串对象 String s=new String(“Hello”);
直接赋值创建字符串对象(1) String s=”Hello”;(2)String st=new String(“Hello”);

4.String类的判断功能

boolean equals(Object obj)
boolean equals IgnoreCase(String str)
boolean startsWith(String str)
boolean endsWidth(String str)

//判断功能

（1）boolean equals(Object obj)判断字符串内容是否相等

Public class MyString{

Public static void mian(String[] args){

String st=”abc”;

String st2=”abc”; //String st2=new String(Original:”abc”);

System.out.println(st.equals(st2));//判断内容

System.out.println(st==st2);//判断地址像否相同

}

boolean equalsIgnoreCase(String str)//判断字符串内容是否相同，忽略大小写

Public class MyString{

Public static void mian(String[] args){

String st=”abc”;

String st2=”ABC”;

System.out.println(st.equalsIgnoreCase(st2));true//忽略大小写

}

boolean startWith(String str)//判断是否以str参数开头

String st=”abc”;

System.out.println(st.startsWith(“ab”));//ab true

boolean endsWith(String str)//是否以str结尾

String st=”abc”;

System.out.println(st.endsWith(“c”));//true

String类的获取功能

int length() //获取字符串的长度
char charAt(int index) //获取指定位置的字符 String类底层是用字符数组来实现的
int indexOf(String str) //获取指定字符串的下标
String substring(int start) //截取字符串
String substring(int start,int end) //截取字符串截取时左包右不包

Public class MyString{

Public static void mian(String[] args){

(1)//int length()

String st=”abc”;

System.out.println(st.length());//3

//char charAt(int index)

System.out.println()st.charAt(0);//abc和数组一样，下标从0开始。输出a

//int indexOf(String str)

System.out.println(st.indexOf(ab));//第一个字符的下标是0

//int substring(int strat)

String st2=st.substring(1);

System.out.println(st2);//bc

//String substring (int start,int end)

String st3= st.substring(1,2);//截取时左包右不包

System.out.println(st3);//b

补充：

String st=”abc”;

byte[] by=st.getBytes();//将字符串转换成字节数组

System.out.println(Arrays.toString(by));//[97,98,99]

将字节转换成一个字符串

String st2=new String(by);

System.out.println(st2);//abc

}

String类的转换功能

char[] toCharArray()//将字符串转换成字符数组
String toLowerCase()//把大写转换成小写
String toUpperCase()//把小写转换成大写

（1）

String st=”abc”;

Char[] arr=st.toCharArray();

System.out.println(Arrays.toString(arr));//[a,b,c]

(2)

String st=”abc”;

String st2=”ABC”;

System.out.println(st2.toLowerCase());

（3）

System.out.println(st2.toUpperCase());

7.String类的其他功能

去除字符串两端空格 String trim() //去掉字符串两端的空格不能去掉中间空格。
按照指定符号分割字符串 String[] split(String str)

String st=” ab c”;

System.out.println(st.trim());//ab c

String st=”a:b:c”;

String[] arr=st.split(regex:”:”);

System.out.println(Arrays.toString(arr));[a,b,c]

练习：将字符串我喜欢java的学习

英文部分转换成字节数组

将java去掉重写组成字符串 ”我喜欢的学习“

StringBuilder类概述及其构造方法线程不安全

StringBuffere和StringBuilder是一样的，但线程是安全的。

线程安全的没有线程不安全的效率高。

StringBuilder类概述：我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间，而StringBuilder就可以解决这个问题。
StringBuilder和String区别？一个是可变一个不可变
构造方法 public StringBuilder()

StringBuilder类的常用方法可变的字符序列

添加功能 public StringBuilder append(任意类型)
反转功能 public StringBuilder reverse()
A:构造方法
StringBuilder()
B:成员方法
Public int capacity() 返回当前容量（理论值）
Public int length() 返回长度（已经存储的字符个数）
Public StringBuilder append（任意类型）添加数据类型，并返回自身对象
Public StringBuilder reverse() 反转功能

对字符串频繁修改会造成的后果：

同前面的主方法

String st=”abc”;

for(int i=0;i<1000000;i++){

//System.out.print(i);运行速度很快

st+=”a”;//程序会变慢效率低了修改字符串会产生新的对象，严重时会造成内存溢出

}

//创建一个空的字符串

StringBuilder sb=new StringBuilder();

System.out.println(sb);

//创建一个长度为10的字符串容器

StringBuilder sb2=new StringBuilder(capacity:10);//初始容量是10 指字符串长度是10 若字符串长度超过10会自动扩容

StringBuilder sb3=new StringBuilder(“abc”);

System.out.println(sb3);//abc

添加功能 public stringBuilder append(任意类型)

StringBuilder sb= new StringBuilder(“abc”);

sb.append(“d”);//在末尾追加

sb.append(true);//abctrue 可以将任意类型的数据拼接到字符串末位

sb.insert(offset:2,str:”bbb”);//abbbbctrue 在指定位置插入数据

System.out.println(sb);//abcd

反转功能 public StringBuider everse()

sb.reverse();

System.out.println(sb);//将字符串反转eurtdcbbbba

返回当前容量（理论值）public int capacity()

System.out.println(sb.capacity());//19

探索：

StringBuilder sb= new StringBuilder();

System.out.println(sb.capacity());//默认的初始容量是16

StringBuilder sb= new StringBuilder(capacity:5);

System.out.println(sb.capacity());//5 当指定长度时，默认的长度就是指定值

sb.append(“abcdef”);//扩容当添加的字符串长度超过初始容量时会进行扩容扩容后的长度是是原来长度的2倍加2.

System.out.println(sb.capacity());//12

StringBuilder sb= new StringBuilder(“abc”);

System.out.println(sb.capacity());//19

返回长度（已经存储的字符个数）public int length()

System.out.println(sb.length());//6

//底层维护的是一个可变的字符数组

StringBuider sb=new StringBuilder();

String sb2=new StringBuilder(caoacity:5);

StringBuider sb3=new StringBuilder(“abc”);

sb3.append(“asfsdfsd”);

//扩容的原理是新添入的字符串长度+原有的字符个数如果大于容量就扩容，扩容之后的长度是原来长度的2倍加2.

如果插入的长度非常长（这种情况不可能有），那么扩容之后的长度要么是数组下标越界，要么是int的最大值-8.