Day 13 String
——String类、常见功能、StringBuffer、StringBuilder、基本数据类型对象包装类
String类
字符串是一个特殊的对象。
字符串一旦初始化就不可以被改变。
s1被改变,原先指向对象abc,后来指向对象kk,对象abc没有发生改变。s1的地址变了,但是abc对象的内容没有变。
String s1 = “abc”;//strhi一个类类型变量,"abc"是一个对象。
String s2 = new String(“abc”);//这两种方式使用起来是一样的
区别:s1在内存中有一个对象。s2在内存中有两个对象(new,abc)。
class StringDemo
{
public static void main(String[] args)
{
String s1 = "abc";
String s2 = new String("abc");
System.out.println(s1 == s2);//两个对象不是一个对象-->false
System.out.println(s1.equals(s2));
//比较的地址值,String 类复写了Object类中的equals方法,该方法用于判断字符串是否相同。
}
}
常见功能——获取和判断
class StringMethodDemo
{
public static void main(String[] args)
{
String s1 = "abc";
String s2 = new String("abc");
String s3 = "abc";
System.out.println(s1 == s2);//-->false
System.out.println(s1 == s3);//-->true
}
}
s1指向一个对象字符串,s3指向对象字符串,因为这个对象字符串已经在对象内存中存在了,作为字符串这种特殊的对象,在常量池中存在的数据,s3在进行初始化时发现abc已经在内存中存在了就不会再独立开辟空间了,因为再开辟空间浪费。abc已经存在且不能被改变。s1s3指向同一对象。
String类适用于描述字符串事物。那么它就提供了多个方法对字符串进行操作。
常见的操作有哪些?“abcd”
1.获取。
1.1 字符串中的包含的字符数,也就是字符串的长度。
int length():获取长度。
(注意与数组length的区别,数组的是属性没有括号,字符串的是方法)
1.2 根据位置获取位置上的某个字符。
char charAt(int index):
1.3 根据字符获取该字符在字符串中的位置。
int indexOf(int ch):返回的是ch在字符串中第一次存在的位置。
int indexOf(int ch,int fromIndex):从fromIndex指定位置开始,获取ch在字符串中第一次出现的位置。
int indexOf(String str):返回的是str在字符串中第一次存在的位置。
int indexOf(String str,int fromIndex):从fromIndex指定位置开始,获取str在字符串中第一次出现的位置。
反向索引
int lastIndexOf(int ch):返回的是ch在字符串中最后一次存在的位置。
int lastIndexOf(int ch,int fromIndex):从fromIndex指定位置开始,获取ch在字符串中最后一次出现的位置。
int lastIndexOf(String str):返回的是str在字符串中最后一次存在的位置。
int lastIndexOf(String str,int fromIndex):从fromIndex指定位置开始,获取str在字符串中最后一次出现的位置。
2.判断
2.1 字符串中是否包含某一个子串
boolean contains(str):(只判断是否包含)
特殊之处:indexOf(str):可以索引str第一次出现的位置,如果返回-1,表示该str不在字符串中存在。所以,也可以用于对指定判断是否包含。(判断是否包含和位置)
if(str.indexOf(“aa”) != -1)
而且该方法既可以判断,又可以获取出现的位置。
2.2 字符串是否有内容
boolea isEmpty():原理是判断长度是否为0。区别:""(对象)、null(指向空)
2.3 字符串是否是以指定内容开头
boolean startsWith(str)
2.4 字符串是否是以指定内容结尾
boolean endsWith(str)
2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals()
2.6 判断内容是否相同,并忽略大小写比较。
boolean equalsIgnoreCase()
3.转换
3.1 将字符数组转成字符串
构造函数:String(char[])
String(char[],offset,count):将字符数组中的一部分转成字符串。
静态方法:static String copyValueOf(char[])
static String copyValueOf(char[] data,int offset,int count)
static String valueOf(char[])
3.2 将字符串转成字符数组
char toCharArray()
3.3 将字节数组转成字符串
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串。
3.4 将字符串转成字节数组
byte[] getBytes()
3.5 将基本数据类型转成字符串
static String valueOf(int)
static String valueOf(double)
3+"";//String.valueOf(3);
特殊:字符串和字节数组在转换过程中是可以指定编码表的。
4.替换
String replace(oldchar,newchar)
5.切割
String[] split(regex)
6.子串。获取字符串中的一部分。
String substring(begin)
String substring(begin,end)
7.转换,去空格,比较
7.1 将字符串转成大写或者小写。
String toUpperCase()
String toLowerCase()
7.2 将字符串两端的多个空格去除。
String trim()
7.3 对两个字符串进行自然顺序的比较。
int compareTo(string)
如果参数字符串等于此字符串,则返回值0;如果此字符串按字典顺序小于字符串参数,则返回一个小于0的值;如果此字符串按字典顺序大于字符串参数,则返回一个大于0的值。
字符串忽略大小写比较:将参与比较的字符串全变成小写,再用equals比较。
class StringMethodDemo
{
public static void method_get()
{
String str = "abcdeakpf";
//长度
sop(str.length());
//System.ouy.println(str.length());
//根据索引获取字符
sop(str.charAt(4));
//当访问到字符串中不存在的角标时会发生
//StringIndexOutOfBoundsException角标越界异常
//根据字符获取索引
sop(str.indexOf('a',3));
//如果没有找到,返回-1。
//反向索引一个字符串出现的位置
sop(str.lastIndexOf("a"));
}
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_trans()
{
char[] arr = {'a','b','c','d','e','f'};
String s = new String(arr);
//String s = new String(arr,1,3);//bcd 从b开始,打印3个(个数)
sop("s = " + s);
String s1 = "zxcvbnm";
char[] chs = s1.toCharArray();
for (int x = 0; x<chs.length ; x++)
{
sop("ch = " + chs[x]);
}
}
public static void method_replace()
{
String s = "hello java";
String s1 = s.replace("a","n");
//String s1 = s.replace("q","n");如果要替换的字符不存在,返回的还是原串
//String s1 = s.replace("java","word");-->hello word
sop("s = " + s);//helle java-->字符串一旦被创建就不会被改变
sop("s1 = " + s1);//hello jnvn
}
public static void method_split()
{
String s = "zhangsan,lisi,wangwu";
String[] arr = s.split(",");
for (int x = 0; x<arr.length ; x++)
{
sop(arr[x]);
}
}
public static void method_sub()
{
String s = "abcdef";
sop(s.substring(2));//cdef 从指定位置开始到结尾
sop(s.substring(2,4));//cd 包含头,不包含尾
sop(s.substring(0,s.length()));
//如果角标不存在,会出现字符串角标越界异常
}
public static void method_7()
{
String s = " Hello Java ";
sop(s.toUpperCase());
sop(s.toLowerCase());
sop(s.trim());//去除两边空格
String s1 = "abc";
String s2 = "aaa";
sop(s1.compareTo(s2));
}
public static void main(String[] args)
{
//method_get();
//method_is();
//method_trans();
//method_replace();
//method_split();
//method_sub();
method_7();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
字符串练习
1.模拟一个trim方法,去除字符串两端的空格。
思路:
1.判断字符串第一个位置是否是空格,如果是继续向下判断,知道不是空格为止。结尾处判断空格也是如此。
2.当开始和结尾都判断到不是空格时,就是要获取的字符串。
class StringTest
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s = " ab cd ";
sop("["+s+"]");
s = myTrim(s);
sop("["+s+"]");
}
//练习一,去除字符串两端空格
public static String myTrim(String str)
{
int start = 0,end = str.length()-1;
while(start<=end && str.charAt(start) == ' ')
start++;
while(start<=end && str.charAt(end) == ' ')
end--;
return str.substring(start,end+1);
}
}
2.将一个字符串进行反转。将字符串中指定部分进行反转。“abcdefg”–>“abfedcg”
思路:
1.曾经学过对数组中的元素进行反转。
2.将字符串变成数组,对数组进行反转。
3.将反转后的数组变成字符串。
4.只要将或反转的部分的开始和结束为止作为参数传递即可。
class StringTest2
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s = " ab cd ";
sop("["+s+"]");
sop("["+reverseString(s,5,8)+"]");
}
//练习二,将字符串进行反转。
public static String reverseString(String s,int start,int end)//重载
{
//字符串变数组
char[] chs = s.toCharArray();
//反转数组一部分
reverse(chs,start,end);
//将数组变成字符串
return new String(chs);
}
public static String reverseString(String s)
{
/*
//字符串变数组
char[] chs = s.toCharArray();
//反转数组
reverse(chs);
//将数组变成字符串
return new String(chs);
*/
//return "";
return reverseString(s,0,s.length());
}
private static void reverse(char arr[],int x,int y)
{
for (int start = x,end = y-1; start<end; start++,end--)
{
swap(arr,start,end);
}
}
private static void swap(char[] arr,int x,int y)
{
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
3.获取一个字符串在另一个字符串中出现的次数。“abkkcdkkefkkskk”
思路:
1.定义一个计数器。
2.获取kk第一次出现的位置。
3.从第一次出现位置后剩余的字符串中继续获取kk出现的位置。没获取一次就计数一次。
4.当获取不到时,计数完成。
判断存在 contains,获取位置index
class StringTest3
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String str = "kkabkkcdkkefkks";
sop("count = " + getSubCount_2(str,"kk"));
sop("count ======= " + str.split("kk").length);
}
//练习三,方式一
public static int getSubCount(String str,String key)
{
int count = 0;
int index = 0;
while ((index = str.indexOf(key))!=-1)
{
sop("str = " + str);
str = str.substring(index + key.length());
count++;
}
return count;
}
//练习三,方式二
public static int getSubCount_2(String str,String key)
{
int count = 0;
int index = 0;
while((index = str.indexOf(key,index))!=-1)
{
sop("index = " + index);
index = index + key.length();
count++;
}
return count;
}
}
split方式和写getSubCount方法的区别:
当开头有kk字符串时,split切的方法会切出空字符串和abkkcdkkefkks,所以是5个。不通用,不建议使用切的方法。getSubCount是4个。
4.获取两个字符串中最大相同子串。第一个动作:将最短的那个串进行长度依次递减的子串打印。“abcwerthelloyuiodef”、“cvhellobnm”
思路:
1.将段的那个字符串按照长度递减的方式获取到。
2.将没获取到的子串去长串中判断是否包含,如果包含,已经找到。
大圈套小圈
class StringTest4
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s1= "abcwerthelloyuiodef";
String s2= "cvhellobnm";
sop(getMaxSubString(s2,s1));
}
//练习四
public static String getMaxSubString(String s1,String s2)
{
String max = "",min = "";
max = (s1.length()>s2.length())?s1:s2;
min = max ==s1?s2:s1;
sop("max = " + max + "...min = " + min);
for (int x = 0; x<min.length() ; x++)//假设s2是短的
{
for (int y = 0,z = min.length() - x ; z!=min.length()+1 ; y++,z++)
{
String temp = min.substring(y,z);
//sop(temp);
if(max.contains(temp))
//if(max.indexOf(temp)!=-1)
return temp;
}
}
return "";
}
}
StringBuffer Buffer缓冲区
String的字符串一旦初始化不能被改变,StringBuffer可以对字符串进行修改。
字符串的组成原理就是通过该类实现的。
StringBuffer可以对字符串内容进行增删。
StringBuffer是一个容器。
很多方法与String相同。
StringBuffer是可变长度的。可以直接添加多个数据类型。(数组一次只能操作一种数据类型)最终会通过toString方法变成字符串。
C creat U update R read D delete
1.存储
StringBuffer append():将指定数据作为参数添加到已有数据的结尾处。
StringBuffer insert(index,数据):可以将数据插入到指定index位置。
2.删除
StringBuffer delete(start,end):删除缓冲区中的数据,包含start,不包含end。
StringBuffer deleteCharAt(index):删除指定位置的字符。
3.获取
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start,int end)
4.修改(替换)
StringBuffer replace(start,end,string)
void setCharAt(int index,char ch)
5.反转
StringBuffer reverse()
6.将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
class StringBufferDemo
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
//method_add();
//method_del();
//method_update();
//StringBuffer sb = new StringBuffer("abcdef");
StringBuilder sb = new StringBuilder("abcdef");
char[] chs = new char[6];
sb.getChars(1,4,chs,1);
for (int x = 0; x<chs.length ; x++)
{
sop("chs["+x+"]="+chs[x]+";");
}
}
public static void method_add()
{
StringBuffer sb = new StringBuffer();
//方法调用链,一连串调用,返回的还是该对象还能调用方法
sb.append("abc").append(true).append(36);
//StringBuffer sb1 = sb.append(36);
//sop("sb == sb1:" + (sb == sb1));
sb.insert(1,"qq");
sop(sb.toString());//abctrue36
//sop(sb1.toString());
}
public static void method_del()
{
StringBuffer sb = new StringBuffer("abcde");
//sb.delete(1,3);
//清空缓冲区
//sb.delete(0,sb.length());
//删除一个字符
//sb.delete(2,3);
sb.deleteCharAt(2);//-->同上一句话,一般用这个
sop(sb.toString());
}
public static void method_update()
{
StringBuffer sb = new StringBuffer("abcde");
//sb.replace(1,4,"java");
sb.setCharAt(2,'k');
sop(sb.toString());
}
}
StringBuilder
JDK1.5版本之后出现了StringBuilder。
StringBuffer是线程同步(安全)。StringBuilder是线程不同步(不安全)。
单线程如果用StringBuffer同步每次都需要判断锁,效率低。StringBuilder提高效率。以后开发,建议使用StringBuilder。
Java升级:1.提高效率。2.简化书写。3.提高安全性。
基本数据类型对象包装类
byte (基本数据类型) Byte(自己定义的对象,类,引用数据类型) 首字母大写就是类,小写是关键字
short Short
int lnteger
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型对象包装类的常见作用:用于基本数据类型和字符串类型之间做转换。
基本数据类型转成字符串
基本数据类型 + “”
基本数据类型.toString(基本数据类型值);
例:Interger.toString(36);//将36整数变成"36"。
字符串转成基本数据类型
xxx a = Xxx.paresXxx(String);//静态转换方式
int a = Integer.parseInt(“123”);
double b = Double.parseDouble(“4.56”);
boolean b = Boolean.parseBoolean(“true”);
也可以把字符串或整数封装成Integer对象,intValue()也可以把一个Integer对象变成int型值
Integer i = new Integer(“123”);
int num = i.intValue();//非静态,对象调用方式
十进制转成其他进制
toBinaryString()
toHexString()
toOctalString()
其他进制转成十进制
paresInt(String,radix);//用后面的几进制表示前面的数,给10进制表示成其他进制,给其他进制表示成10进制
class IntegerDemo
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
//整数类型的最大值
//当判断是否超出运算范围时使用MAX_VALUE
//sop("int max : " + Integer.MAX_VALUE);
//将一个字符串转成整数。
int num = Integer.parseInt("123");//必须传入数字格式的字符串
//long x = Long.parseLong("123");
//sop("num = " + (num + 4));
//sop(Integer.toBinaryString(-6));//十进制-->二进制
//sop(Integer.toHexString(60));//shijinzhi-->十六进制
int x = Integer.parseInt("110",10);
sop("x = " + x);
}
}
基本数据类型对象包装类新特性
class IntegerDemo1
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
//JDK1.5版本以后的新特性
// Integer x = new Integer(4);
Integer x = 4;//自动装箱 //new Integer(4)
//1.5版本后x除了赋的值还会有null,在运算前先判断是否为空
x = x /*x.intValue()*/ + 2;
//x+2:x进行自动拆箱,变成了int类型和2进行加法运算,再讲和进行装箱赋给x。
Integer m = 128;
Integer n = 128;
sop("m == n : " + (m == n));//false
Integer a = 127;
Integer b = 127;
sop("a == b : " + (a == b));
/*
-128~127
结果为true。因为a和b指向了同一个Integer对象。因为当数值在
byte范围内,对于新特性,如果该数值已经存在,则不会在开辟新的空间。
*/
}
public static void method()
{
Integer x = new Integer("123");
Integer y = new Integer(123);
sop("x == y : " + (x == y));//false,因为连个对象
sop("x.equals(y) : " + x.equals(y));
//Integer比较数值是否相等,true
}
}