String
String s1="abc"; s1是一个类类型变量,"abc"是一个对象
字符串最大特点,一旦被初始化就不可以改变
String s2=new String("abc");
s1 s2的区别
s1在内存中有一个对象
s2在内存中有两个对象
s1.equals(s2); String 类覆写了Object类中的equals方法,该方法用于判断字符串是否相同
String 操作方法
1- 获取 ----
- length() ----返回此字符串的长度
- charAt(int index) -----返回指定位置的 char 值。
- indexOf(int ch) -----返回指定字符在此字符串中第一次出现的位置。不存在则返回-1
- indexOf(int ch, int fromIndex) -----从指定的位置开始搜索。
- indexOf(String str) ------返回指定子字符串在此字符串中第一次出现的位置。不存在则返回-1
- indexOf(String str, int fromIndex) ------从指定的位置开始搜索。
- lastIndexOf(int ch) ----返回指定字符在此字符串中最后一次出现的位置。
- indexOf前面可以加last,不一一列出了,
2 -判断 -----
- contains(String/char) -----判断字符串中是否包含某个字符串或字符
特殊之处 : indexOf 返回字符出现的位置,如果不存在则返回-1,所以也可以用来判断是否包含字符
if(str.indexOf(“xx”)!=-1) : 可以获取位置,又可以判断是否包含 - isEmpty() -----判断字符串是否有内容,原理是判断长度是否为0
- startsWith(String prefix) ------ 字符串是否以指定内容开头
- endsWith(String suffix) ------ 字符串结尾是否为指定内容
- equals(Object anObject) ----判断两个字符串内容相同
- equalsIgnoreCase(String anotherString) -------将此 String 与另一个 String 比较,不考虑大小写。
3 - 转换 -----
- 字符 数组 转换成字符串
构造函数 :
String(char[ ] value)
String(char[ ] value, int offset, int count) --指定范围
静态方法 :
copyValueOf(char[ ] data)
copyValueOf(char[ ] data, int offset, int count) -----指定范围
ValueOf(char[ ] data) - toCharArray() -----字符串转换为字符数组。
- getBytes() ------字符串转换成字节数组
- 字节数组 转换成字符串
String(byte[ ] bytes)
String(byte[ ] bytes, int offset, int count) -----指定范围 - 将基本数据类型转换成字符串
static | valueOf(int i)
static | valueOf(double d)
4 - 替换 -----
- replace(char oldChar, char newChar) -----返回一个新的字符串, newChar 替换此字符串中出现的所有 oldChar
5 -切割 -----
split(String regex) ----- 根据给定正则表达式的匹配拆分此字符串。返回一个字符串数组;
6 - 子串,获取字符串的一部分
- substring(int beginIndex)
substring(int beginIndex, int endIndex) —到指定位置结束,不包含endIndex位置
7 - 转换,去除空格,比较
- toLowerCase() -----将此 String 中的所有字符都转换为小写。
toUpperCase() ------将此 String 中的所有字符都转换为大写。 - trim() ------将字符串两端空格去除
- s1.compareTo(s2) -----两个字符串进行自然顺序比较
compareToIgnoreCase(String str) ------不考虑大小写。
代码演示-----
public class DEMO {
public static void method1() { //获取功能
String s = "abcdefc";
sop(s.length()); //打印字符串长度
sop(s.charAt(2)); //打印指定位置的字符,如果不存在该角标则发生异常
sop(s.indexOf("c", 3)); //从指定位置开始寻找指定字符位置,如果不存在该字符则返回-1
sop(s.indexOf("cd")); //打印该字符串的位置
sop(s.lastIndexOf("c", 1)); //从指定位置反方向寻找字符
}
public static void method2() { //判断功能
String s = "ArrayDemo.java";
String s1 = "arrayDemo.java";
sop(s.startsWith("Array")); //判断文件名是否以Array开头
sop(s.endsWith(".java")); //判断文件名是否.java的文件
sop(s.contains("Demo")); //判断文件名是否包含Demo
sop(s.equalsIgnoreCase(s1)); //比较字符中内容,字母不分大小写
}
public static void method3() { //转换功能
char[] ch = {'a', 'b', 'c', 'd'};
String s1 = new String(ch, 1, 3);//将字符数组转换成字符串,从角标1开始到角标3
sop(s1);
sop(String.copyValueOf(ch, 1, 3)); //将字符数组转换成字符串,从角标1开始到角标3
sop(String.valueOf(ch)); //将字符数组转成字符串
String s2 = "aaabbb";
char[] ch1 = s2.toCharArray(); //字符串转成字符数组
for (int i = 0; i < ch1.length; i++) { //打印字符数组
System.out.print(ch1[i]);
}
byte[] b = s2.getBytes(); //字符串转成字节数组
for (int i = 0; i < b.length; i++) {//打印字节数组
System.out.print(b[i] + " ");
}
byte[] b1 = {80, 98, 99}; //Pbc的字节
String ss = new String(b1);//字节数组转换成字符串
sop(ss);
sop(String.valueOf(3.5555)); //将基本类型double转成字符串
}
public static void method4() { //替换功能
String s = "hallo java";
String s1 = s.replace("hallo", "hehe"); //用指定字符串修改成指定字符串
String s2 = s.replace('a', 'n');//用指定字符修改成指定字符
sop(s1);
sop(s2);
}
public static void method5() { //分割功能
String s = "zhangsan,lisi,wangwu";
String[] s1 = s.split(","); //用","分割字符串 返回一个字符串数组
for (int i = 0; i < s1.length; i++) {
sop(s1[i]);
}
}
public static void method6() { //获取字符串一部分
String s = "javaisgood";
String s1 = s.substring(2); //从指定位置开始到结尾,
String s2 = s.substring(0, 4); //从指定位置开始到结尾,不包含结尾
sop(s1);
sop(s2);
}
public static void method7() {
String s1 = " Hallo Java ";
sop(s1.toLowerCase()); //转换成小写
sop(s1.toUpperCase()); //转换成大写
sop(s1.trim()); //去除两端空格
String s3 = "adc";
String s4 = "abc";
sop(s3.compareTo(s4)); //比较自然顺序,如果返回值大于0则s3比s4后;
}
public static void main(String[] args) {
method7();
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
练习
public static void myTrim(String s) { //去除字符串两端的空格
char[] ch = s.toCharArray(); //字符串转成字符数组
int start = 0; //头角标
int end = s.length() - 1; //尾角标
while (start <= end && ch[start] == ' ') { //前角标小于等于后角标
start++;
}
while (start <= end && ch[end] == ' ') {
end--;
}
String s1 = s.substring(start,end+1);
sop(s1);
sop(start+" "+end);
}
-------------------------------------------------------------------------------------
public static void reversal(String s,int x,int y){ //翻转指定部分字符串,不包含尾
char[] ch=s.toCharArray();
int d=ch[x],f=ch[y-1]; //检测角标是否越界,
for (int start=x,end=y-1;start<end;start++,end--){abcd
char c=ch[start];
ch[start]=ch[end];
ch[end]=c;
}
String s1=new String(ch);
sop(s1);
}
public static void reversalAll(String s){//反转全部字符串
reversal(s,0,s.length());
}
----------------------------------------------------------------------------------------
//获取一个字符串在另一个字符串出现的次数
public static void count(String s,String key){
int count=0; //指定字符串出现的次数
int i=0; //开始查找的位置
int index; //指定字符出现的位置
while ((index=s.indexOf(key,i))!=-1){ //判断字符串中是否有指定字符串
count++;
i=index+key.length(); //更新起始查找位置
sop(index); //打印指定字符串出现的位置
}
sop("该字符串出现的次数="+count);
}
-------------------------------------------------------------------------------
//获取两个字符串中最大的相同子串
public static String contanis1(String s1,String s2){
String max=((s1.length()>s2.length())?s1:s2); //获取长度最长的字符串
String min=((max==s1)?s2:s1); //获取长度最短的字符串
for (int i=0;i<min.length();i++){
for (int j=0,z=min.length()-i;z!=min.length()+1;j++,z++ ){ //min.lenght-1确定遍历最大范围....j++,z++移动最大范围,
//z!=min.length()+1,尾角标小于字符串长度+1,
String temp=min.substring(j,z); //使用substring获取该范围字符串
if (max.contains(temp)){
return temp;
}
}
}return "无";
}
StringBuffer/StringBuilder
StringBuffer 是字符串缓冲区,是一个容器
- 特点
1,长度是可变化的
2,可以直接操作多个数据类型
3,最终会通过 toString 变成字符串
Jdk1.5后出现了StringBuilder
StringBuilder功能跟StringBuffer一样
但是StringBuffer:线程是同步的…StringBuilder:线程不同步
- 1 - 存储
StringBuffer | append( ) ----将指定数据作为参数添加到已知数据结尾处
StringBuffer | insert(index , 基本数据类型) ----可以将数据插入指定位置index - 2 - 删除
StringBuffer | delete(int start, int end) -----删除缓冲区中的数据,包含 start ,不包含end
StringBuffer | deleteCharAt(int index) -----删除指定位置字符 - 3 -获取
charAt(int index) ------获取指定位置字符
indexOf(String str)
indexOf(String str, int fromIndex) ----返回指定字符串位置,从指定位置开始
String substring(int start, int end) -----获取子串,从start开始到end结束,不包含end - 4 - 修改
StringBuffer | replace(int start, int end, String str) -----指定范围中修改成指定字符串,不包含尾
setCharAt(int index, char ch) -----修改指定位置的字符 - 5 - 反转
StringBuffer | reverse() - 6 - 复制
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) -----将字符从此字符串复制到目标字符数组。
public static void method1() {
StringBuffer sb = new StringBuffer();
sb.append(36.5).append("aa"); //往StringBuffer中添加
sop(sb.toString());
sb.insert(4, "--"); //在指定位置存入字符串
sop("insert :" + sb.toString());
sb.delete(2, 3); //删除指定范围字符串,不包含尾
sop("delete :" + sb);
sb.deleteCharAt(3);
sop("deleteCharAt :" + sb); //删除指定位置字符
sb.replace(1, 3, "aa"); //修改指定范围字符串,不包含尾
sop("replace :" + sb);
sb.reverse(); //反转字符串
sop(sb.toString());
String s1 = sb.toString();
sop(s1);
char[] ch = new char[6];
sb.getChars(1, 4, ch, 1); //将Buffer中的字符串复制到字符数组
for (int i = 0; i < ch.length; i++) {
sop("ch[" + i + "]=" + ch[i]);
}
基本数据类型包装类
基本数据类型对象包装类
char ----- Character —16bit
int ----- Integer —32bit
byte ----- Byte —8bit
short ----- short —16bit
long ----- Long —64bit
boolean ----- Boolean —1bit
float ----- Float —32bit
double ----- Double —64bit
基本数据类型对象包装类的常见作用
就是用于基本数据类型和字符串之间的做转换
- 基本数据类型转成字符串
基本数据类型+""
基本数据类型.toString(基本数据类型值):
String s1=34+"";
String s1=Integer.toString(345);
String s1=String.valueOf(3645);
String s1=Double.toString(3.5);
- 字符串转成基本数据类型
int i=Integer.parseInt("98");
double d=Double.parseDouble("3.15");
boolean b=Boolean.parseBoolean("true");
Integer a=new Integer("168"); //非静态方法
int num=a.inValue();
- 十进制转成其他进制
sop(Integer.toBinaryString(6)); //转成2进制
sop(Integer.toHexString(60)); //转成16进制
sop(Integer.toOctalString(60)); //转成8进制
- 其他进制转成十进制
sop(Integer.parseInt("110",2));//radix:进制,什么的2进制是110
sop(Integer.parseInt("3C",16));//radix:进制,什么的16进制是3C
- JDK1.5新特性,自动装箱,自动拆箱
Integer x=4; //自动装箱,new Integer(4);
x=x+2; // x.intValue(),x 进行自动拆箱,变成int类型,和2进行运算;
//再进行装箱赋值给x
Integer z=128;
Integer y=128;
sop(z==y); //结果为flase
Integer a=127;
Integer b=127;
sop(a==b);//结果为true, a,b指向了同一个Integer对象
//因为当数值在bety范围内,对于新特性,如果该值已经存在,则不会开辟新空间