1. String类
java中用String类进行描述。对字符串进行了对象的封装。这样的好处是可以对字符串这种常见数据进行方便的操作。对象封装后，可以定义N多属性和行为。
字符串最大特点，一旦被初始化就不可以被改变。String是一个最终类，不能被继承。
String对象的特点
public class H_01StringDemo
{
public static void main(String[] args)
{
String s1="abc";//s1是一个引用地址，指向"abc"对象
//字符串最大特点，一旦被初始化就不可以被改变
String s2=new String("abc");
//s1在内存中有一个对象 abc
//s2在内存中有两个对象 new和abc
String s3="abc";
System.out.println(s1==s2);//结果false，s1在常量池，s2在堆内存
System.out.println(s1==s3);//结果true，都在常量池
System.out.println(s1.equals(s2));//结果true，String类复写了Object类中equals方法，用于判断字符串是否相同
}
}2. String类常见操作
1、 获取
1.1 获取字符串包含的字符数，也就是字符串的长度
int length()：获取长度
注意：数组的length是一个属性，而字符串的length()是一个方法
1.2 根据位置获取位置上的某个字符
charcharAt(int index)
1.3 根据字符获取该字符在字符串中的位置
intindexOf（int ch）：返回ch在字符串中第一次出现的位置
intindexOf（int ch，int fromIndex）：从fromIndex指定位置开始，返回字符在字符串的位置
intindexOf（String str）：返回str字符串中第一次出现的位置
intindexOf（String str，int fromIndex）：从fromIndex指定位置开始，返回str在字符串的位置
public static void method_get()
{
String str="dnfidojs";
sop(str.length());//结果是8
//根据索引获取字符
sop(str.charAt(4));//d
//根据字符获取索引
sop(str.indexOf('i',0));//3
sop(str.indexOf('a',0));//没有对应的值返回-1
//反向索引,从指定位置开始，从右往左找，返回该元素最后出现的脚标
sop(str.lastIndexOf('i',str.length()));//3
}2、判断
2.1 字符串是否包含某一个字串
booleancontains（str）;
indexOf(str);可以索引str第一次出现的位置，如果返回-1，表示不包含
if（str.indexOf(str)!=1）
可以判断，也可以获取出现的位置
2.2 字符串中是否有内容
boolean isEmpty();判断长度是否为0
2.3 字符串是否是以指定内容开头
boolean startsWith(str);(用于判断密码开头)
2.4 字符串是否是以指定内容结尾
boolean endsWith(str); 不忽略大小写
2.5 判断内容是否相同，并忽略大小写
booleanequalsIgnoreCase();
public static void method_is()
{
String str="ArrayDemo.java";
sop(str.startsWith("Array"));//true
sop(str.startsWith("array"));//false 区分大小写
sop(str.endsWith(".java"));//true
sop(str.contains("Demo"));//true
}3、转换
3.1 将字符数组转成字符串
构造函数：String(char[] value)
String(char[] value , int offset,int count):将字符串数组中的一部分转换成字符串
3.2 将字符串转换成字符数组
char[] toCharArray();
3.3 将字节数组转成字符串
String(byte[] value)
String(byte[] value , int offset,intcount):
3.4 将字符串转成字节数组
byte[] getBytes();
3.5 将基本类型转成字符串
staticString valueOf(int x)
staticString valueOf(double x)
3+""; String valueOf(3);
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
public static void method_trans()
{
char[] arr={'a','b','c','d','e','f','g','h','r'};
String s=new String(arr,1,3);//1位开始，数3个 结果bcd
sop("s="+s);
String s1="coioie";
char[] chs=s1.toCharArray();
for(inti=0;i<s1.length();i++)
{
sop("ch="+chs[i]);//ch=c ch=o ch=i ch=o ch=i ch=e
}
}4、替换操作
String replace(oldchar,newchar);
public static void method_replace()
{
String s="hello java";
String s1=s.replace('a','n');//如果要替换的字符不存在 返回原字符串
sop("s="+s);//s不变 s1是一个新字符串 hello java
sop("s1="+s1);//hellojnvn
String s2=s.replace("java","world");//替换整个字符串
sop(s2);//hello world
}5、切割
String split(regex)//以参数为分割
String s="zhangsan,lisi,mazi";
String[] arr=s.split(",");
public static void method_split()
{
String s="zhangsan,lisi,mazi";
String[] arr=s.split(",");
for(inti=0;i<arr.length;i++)
{
sop(arr[i]);
}
}结果：zhangsan lisi mazi
6、子串
String substring(begin);//指定位置开始到结束
String substring(begin,end);//指定位置开始，含头 不含尾
public static void method_sub()
{
String s="chicken";
sop(s.substring(3));//指定位置开始到结束cken
sop(s.substring(3, 5));//指定位置开始，含头不含尾 ck
}7、转换 去除空格 比较
7.1 将字符串转成大写或者小写
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除,中间的空格会保留
String trim();
7.3 对两个字符串进行自然顺序的比较
intcompareTo();//如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。
public static void method_7()
{
String s=" Hello Java ";
sop(s.toLowerCase());//hello java
sop(s.toUpperCase());//HELLO JAVA
sop(s.trim());//Hello Java
String s1="adc";
String s2="aaa";
sop(s1.compareTo(s2));//正数负数 0来表示大小 结果3 是d-a的ascii码值
}1、模拟trim方法
public static void Q1(String s)
{
int start=0;
int end=s.length()-1;
while(start<=end &&s.charAt(start)==' ')//多写了分号。。。。
start++;
while(start<=end &&s.charAt(end)==' ')//判断起始是否小于结束，并且判断结束位是否是空格
end--;
sop(s.substring(start,end+1));//注意end要+1
}2、统计一个字符串在另一个字符串中出现的位置
public static int getSubCount(String str,String key)
{
int count=0;
int index=0;
while((index=str.indexOf(key))!=-1)//判断是否具有该字符串
{
str=str.substring(index+key.length());//得到去除后的子串同时计数
count++;
}
return count;
}3、判断两个字符串的最大相同的字符串
/*循环嵌套
4.1 最大就是全部相同
4.2 其次是减掉一个f到f 和c到e
4.3 再减掉两个 从f到e c到f d到e
循环
第一次循环
起始 终点 次数
0 length()-1 1次
0/1 length()-2/ length()-1 2次
0/1/2 length()-3/2/1 3次
0~length()-1 length()-1~-length()+1 length()-1
*/
public class H_StringTest3 {
public static void main(String[] args) {
String s1="abcdefghijk";
String s2="ddffefefge";
sop(getMaxSubString(s1,s2));
}
public static String getMaxSubString(String s1,String s2)
{
String max="",min="";
max=(s1.length()>s2.length())?s1:s2;
min=(max==s1)?s2:s1;
for(intstart=0;start<min.length();start++)
{
for(intoffset=0,end=min.length()-start;end<=min.length();offset++,end++)
{
String temp=min.substring(offset,end);
if(max.contains(temp))//如果s1包含temp 返回。
returntemp;
}
}
return"";
}
public static void sop(Object obj)
{
System.out.print(obj+"\n");
}
}4. StringBuffer
特点：
1、长度是可以变化的（数组长度是固定的）
2、可以添加多种类型（数组只能操作一种类型）
3、最终通过toString变成字符串
1、存储
StringBuffer append() 将指定数据作为参数添加到已有数据的结尾处
StringBuffer insert（offset，data）：可以将数据插入到指定index的位置
public static void method_add()
{
StringBuffer sb=new StringBuffer();
StringBuffer sb1=sb.append(34);
sop(sb.toString());//34
sop(sb1.toString());//34
sop(sb==sb1);//指向地址相同
sb.append("de").append(true).append(0);//调用链，返回值还是本身 不停调用
sop(sb.toString());//不停在结尾处添加对象 。结果34ddfetrue0
sb.insert(1, "qq");//将数据插入指定位置
sop(sb.toString());//3qq4detrue0
}2、删除
StringBuffer delete(start,end):删除缓冲区中的数据，包含start 不包含end
StringBuffer deleteChatAt(index):删除指定位置
public static void method_del()
{
StringBuffer sb=new StringBuffer("abcdef");
sb.delete(1, 3);
//清空缓冲区
//sb.delete(0,sb.length());
sb.deleteCharAt(2);//调用delete（2,3）
sop(sb.toString());//adf
}3、查找
charAt(int index)
lastIndexOf(String str)
indexOf(String str)
indexOf(String str, int fromIndex)
String substring(int start, int end) //返回的是String
4、修改
StringBuffer replace(int start, int end,String str) //指定范围插入字符串，含头不含尾
void setCharAt(int index, char ch) //指定位置插入字符
5、反转
StringBufferreverse()
6、void getChars(intsrcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此序列复制到目标字符数组 dst。
StringBuffer sb=new StringBuffer("abcdef");
char[]chs=newchar[4];
sb.getChars(1, 5, chs, 0);
for(inti=0;i<chs.length;i++)
{
sop("chs("+i+")="+chs[i]+";");
}结果：chs(0)=b; chs(1)=c; chs(2)=d; chs(3)=e;
将abcde的1~5位，不包含5，即abcd存入chs数组中，从0位开始存。
5. StringBuilder
JDK1.5出现StringBuiler；构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候。
方法和StringBuffer一样；
StringBuffer和 StringBuilder 的区别：
StringBuffer线程安全（同步）。
StringBuilder线程不安全（不同步）。
单线程操作，使用StringBuilder 效率高。
多线程操作，使用StringBuffer 安全。
6. 包装类
1、包装类：把基本数据类型转换成对象，具有一些特殊方法。
2、基本数据类型 类类型
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
3、 基本数据类型对象包装类的最常见作用就是用于基本数据类型和字符串类型之间做转换。
4、基本数据类型转字符串
基本数据类型+""
基本数据类型.toString（基本数据类型值）
如：Integer.toString(34);将数字34转换成字符串"34"
5、字符串类型转换成基本数据类型
int a=Integer.parseInt("");
booleanb=Boolean.parseBoolean("true");
Character 没有parse方法 (不需要)
parse是静态方法
Integer i=new Integer("123");
int num=i.intValue();//效果相同 但是是非静态方法
6、十进制转成其他进制
toBinaryString()
toHexString()
toOctString()
其他进制转换成十进制
Integer.parseInt("1102",2);
public class H_BaoZhuangLei2 {
public static void main(String[] args) {
//Integer x=new Integer(4);
Integer x=4;//1.5版本新特性，自动装箱 等同于new Integer（4）
x=x+2;
//相当于 x先自动拆箱 x.intValue();再加上2.赋值后再自动装箱
//x现在是类对象，可能是null 使用的时候要注意增加判断
Integer m=128;
Integer n=128;
sop(m==n);
Integer a=127;
Integer b=127;
sop(a==b);//结果是true，当数值在byte范围内时，对于新特性 如果该数值已经存在 不会再开辟新空间 （享元设计模式）
}
public static void method()
{
Integer x=new Integer("123");
Integer y=new Integer(123);
sop(x==y);//结果是false 比较地址 必然不同
sop(x.equals(x));//重写了equals方法 比较对象的值 结果是true
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
