[Java视频笔记]day13
String类
字符串是一个特殊的对象。
最大的特点：字符串一旦初始化就不可以被改变。
String s1 = “abc”; s1是一个类类型变量，”abc”是一个对象。
s1 = “kk”; 字符串”abc”没有改变，只是s1指向的对象变了，”abc”还在内存中
String s2 = new String(“abc”);
System.out.println(s1 == s2); 输出false
System.out.println(s1.equals(s2)); 输出true String类复写了Object类中的equals方法，该方法用于判断字符串是否相同。
s1和s2有什么区别？
s1在内存中有一个对象”abc”，s2有两个对象,new 和”abc”
String类适用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作。
常见的操作有哪些？
1. 获取
1.1字符串中包含的字符数，也就是字符串的长度。方法 int length();
1.2根据位置获取位置上的某个字符。方法char charAt(int index);
1.3 根据字符获取该字符在字符串中的位置。
int indexOf(intch) ; 返回的是ch在字符串中第一次出现的位置。
int indexOf(intch, int fromIndex): 从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int indexOf(Stringstr) ; 返回的是str在字符串中第一次出现的位置。
int indexOf(Stringstr, int fromIndex): 从fromIndex指定位置开始，获取str在字符串中出现的位置。
int lastIndexOf(intch); 返回的是ch在字符串中最后一次出现的位置
2. 判断
2.1 字符串中是否包含某一个子串。 boolean contains(str);特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1，表示该str不在字符串中出现，所以，也 可以用于对指定字符串的包含。if(str.indexOf(“aa”) != -1) 而且该方法既可以判断，又可以获取出现的位置。
2.2字符串中是否有内容 boolean isEmpty(); 原理就是判断长度是否为0
2.3字符串是否是以指定内容开头boolean startsWith(str);
2.4字符串是否是以指定内容结尾 boolean endsWith(str);
2.5判断字符串内容是否相同 boolean equals(str); 复写了Object类中的equals方法
2.6判断内容是否相同，并忽略大小写。 boolean equalsIgnoreCase();
3. 转换
3.1将字符数组转成字符串
构造函数： String(char[])
String(char[]data, int offset, int count):将字符数组一部分转成字符串
静态方法： static String copyValueOf(char[] data);
static String copyValueOf(char[] data, intoffset, int count);
3.2将字符串转成字符数组**
char[] toCharArray();
3.3将字节数组转成字符串
构造函数:String(byte[])
String(byte[] data, int offset, int count):将字节数组一部分转成字符串
3.4将字符串转成字节数组
byte[] getBytes();
3.5将基本数据转成字符串
static String valueOf(int) 3+”” 和 String.valueOf(3)是一样的
static String valueOf(double)
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
4. 替换
String replace(oldchar, newchar);
5. 切割
String[] split(regex);
6. 子串，获取字符串中的一部分
String substring(int begin);
String substring(int begin, int end);
7. 转换，去除空格，比较
7.1将字符串转成大写或者小写
String toUpperCase();
String toLowerCase();
7.2将字符串两端的多个空格去除
String trim();
7.3对两个字符串进行自然顺序的比较
int compareTo(string);
class day13
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void method_get()
{
String str = "abcdaef";
//长度
sop(str.length());//输出6
//根据索引获取字符
sop(str.charAt(3));//输出d
//根据字符获取索引
sop(str.indexOf('a'));//输出0
sop(str.indexOf('m'));//找不到，返回-1
sop(str.indexOf('a', 3));//输出4
//反向索引一个字符出现的位置
sop(str.lastIndexOf("a"));//输出4
}
public static void method_is()
{
String str = "ArrayDemo.java";
//判断文件名称是否是以Array开头
sop(str.startsWith("Array"));//输出true
//判断文件是否是.java的文件
sop(str.endsWith(".java"));//输出true
//判断文件是否包含Demo
sop(str.contains("Demo"));//输出true
}
public static void method_trans()
{
char[] arr = {'a', 'b', 'c', 'd', 'e', 'f'};
String s = new String(arr);
sop(s);//输出abcdef
String s1 = new String(arr, 1, 3);
sop(s1);//输出bcd
String s2 = "xyzeddf";
char[] chs = s2.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');//如果替换的不存在，返回原串
sop(s);//输出hello java因为字符串一旦初始化，不能被改变
sop(s1);//输出hello jnvn
String s2 = s.replace("java", "world");
sop(s2);
}
public static void method_split()
{
String s = "zhangsan,lisi,wangwu";
String[] arr = s.split(",");//切割成3个字符串
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
}
public static void method_7()
{
String s = " Hello Java ";
sop(s.toLowerCase());
sop(s.toUpperCase());
sop(s.trim());//输出Hello Java
String s1 = "abc";
String s2 = "aaa";
sop(s1.compareTo(s2));//输出大于0的数，因为abc字典序顺序大于aaa
}
public static void main(String[] args)
{
//method_get();
//method_is();
//method_trans();
//method_replace();
//method_split();
//method_sub();
method_7();
}
}
字符串练习：
①. 模拟一个trim方法，去除字符串两端的空格。
思路：
1.判断字符串第一个位置是否是空格，如果是继续判断，知道不是空格为止，结尾处判断空格也是如此。
2.当开始和结尾都判断不是空格时，就是要获取的字符串
②. 将一个字符串进行反转，将字符串中指定部分进行反转，”abcdefg” - > “abfedcg”
思路：
1.曾经学习过对数组元素进行反转
2.将字符串变成数组，对数组反转
3.将反转后的数组变成字符串
4.只要将要反转的部分的开始和结束为止作为参数传递即可
③. 获取一个字符串在另一个字符串中出现的次数。”abkkcdkkefkkskk”
思路：
1.定义一个计数器
2.获取”kk”第一次出现的位置。
3.从第一次出现位置后剩余的字符串中连续获取kk出现的位置，每获取一次就计数一次。
4.当获取不到时，计数完成。
④. 获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度依次递减的子串打印。“abcwerthelloyuiodef” “cvhellobnm”
思路：
1.将短的那个子串按照长度递减的方式获取到
2.将每次获取到的子串去长串中判断是否包含，如果包含，已经找到!退出即可。
class day13
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s1 = "abcwerthelloyuiodef";
String s2 = "dfdfdghellox";
sop(getMaxSubString(s1, s2));
}
//练习1，去除字符串两端空格
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，将字符串反转
public static String reverseString(String str, int start, int end)
{
//字符串变数组
char[] chs = str.toCharArray();
//反转数组
reverse(chs, start, end);
//将数组变成字符串
return new String(chs);
}
public static String reverseString(String s)
{
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
//方法1
public static int getSubCount(String str, String key)
{
int count = 0;
int index = 0;
while((index = str.indexOf(key)) != -1)
{
count ++;
str = str.substring(index + key.length());
}
return count;
}
//方法2
public static int getSubCount_2(String str, String key)
{
int index = 0;
int count = 0;
while((index = str.indexOf(key, index)) != -1)
{
count ++;
index = index + key.length();
}
return count;
}
//练习4
public static String getMaxSubString(String s1, String s2)
{
String max = "", min = "";
max = s1.length() > s2.length() ? s1 : s2;
min = max == s1 ? s2 : s1;
for(int x = 0; x < min.length(); x ++)
{
for(int y = 0, z = min.length() - x; z != min.length() + 1; y ++, z++)
{
String temp = min.substring(y, z);
if(max.contains(temp))
return temp;
}
}
return "";
}
}
StringBuffer 是字符串缓冲区，是一个容器。
特点：长度是可变化的，可以直接操作多个数据类型，最终会通过toString方法变成字符串。
操作数据 C create U update R read Ddelete
1. 存储
StringBufferappend();将指定数据作为参数添加到已有数据的结尾处
StringBufferinsert(index, 数据); 将数据插入到指定位置上去
2. 删除
StringBufferdelete(start, end); 删除缓冲区中的数据，包含start,不包含end
StringBufferdeleteCharAt(index); 删除指定位置的字符
3. 获取
charcharAt(int index); //获取单个字符
intindexOf(String str); //获取位置
intlastIndexOf(String str);
intlength();
Stringsubstring(int start, int end);
4. 修改（替换）
StringBufferreplace(start, end, String);
voidsetCharAt(int index, char ch);
5. 反转
StringBufferreverse();
6. void getChars(int srcBegin, int srcEnd,char[] dst, int dstBegin);
class day13
{
public static void main(String[] args)
{
StringBuffer sb = new StringBuffer("abcdef");
char[] chs = new char[4];
sb.getChars(1, 4, chs, 1);
for(int x = 0; x < chs.length; x++)
{
sop(chs[x]+"");//输出: bcd
}
}
public static void method_update()
{
StringBuffer sb = new StringBuffer("abcde");
sb.replace(1, 4, "java");
sop(sb.toString());//输出ajavae
sb.setCharAt(2, 'k');
sop(sb.toString());//输出ajkvae
}
public static void method_delete()
{
StringBuffer sb = new StringBuffer("abcde");
sb.delete(1, 3);//输出ade
//sb.delete(0, sb.length());//清空缓冲区
sb.deleteCharAt(2);//删除2位置上的字符
sop(sb.toString());
}
public static void method_add()
{
StringBuffer sb = new StringBuffer();
//StringBuffer sb1 = sb.append(34);
//sop(""+(sb == sb1));//输出true
//sop(sb.toString());//输出34
//sop(sb1.toString());//输出34,sb1,sb指向同一个对象
//不用上面这么麻烦
sb.append("abc").append(true).append(34);
sop(sb.toString());//输出abctrue34
sb.insert(1, "qq");//插入
sop(sb.toString());//输出aqqbctrue34
}
public static void sop(String str)
{
System.out.println(str);
}
}
在JDK 1.5 版本之后，出现了StringBuilder
不同之处：
StringBuffer 是线程同步的
StringBuilder 是线程不同步
以后开发，建议使用StringBuilder
版本升级三个因素：
1.提高效率
2.简化书写
3.提高安全性。
基本数据类型对象包装类。
byte(基本数据类型) Byte 类
short short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型对象包装类的最常见作用就是用于基本数据类型和字符串类型之间做转换。
基本数据类型转成字符串。
基本数据类型+””
基本数据类型.toString(基本数据类型值);
如 :Integer.toString(34);//将整数34变成字符串”34”
字符串转成基本数据类型。
xxxa = Xxx.parseXxx(String);
如: int a =Integer.parseInt(“123”);
double b = Double.parseDouble(“1.23”);
boolean b = Boolean.parseBoolean(“true”);
还有种非静态的形式 Integer I =new Integer(“123”); int num = i.intValue();
十进制转成其它进制。
toBinaryString();//2进制
toHexString();//16进制
toOctalString();//8进制
其它进制转成十进制。
parseInt(String,radix);//将String按照radix进制的数转成10进制数
class day13
{
public static void main(String[] args)
{
//整数类型的最大值
sop("int max : " + Integer.MAX_VALUE);
//将一个字符串转成整数
int num = Integer.parseInt("123");//如果传入"a123"，则提示数字格式异常
long x = Long.parseLong("123");
sop("num = "+(num + 4));//输出127
sop(Integer.toBinaryString(6));//输出110
sop(Integer.toHexString(60));//转成16进制，输出3c
x = Integer.parseInt("110", 10);//按10进制转成10进制数
sop("x = "+ x);//输出110
x = Integer.parseInt("110", 2);//按2进制转成10进制数
sop("x = " + x);//输出6，
x = Integer.parseInt("3c", 16);
sop("x = " + x);//输出60
}
public static void sop(String str)
{
System.out.println(str);
}
}
JDK 1.5版本以后出现的新特性.
class day13
{
public static void main(String[] args)
{
//Integer x = new Integer(4);
Integer x = 4;//自动装箱。 4 = new Integer(4)
x = x + 2;//对象+整数 x进行了自动拆箱，变成了int类型，和2进行
//加法运算，再将结果进行装箱赋给x
//拆箱的时候是 x.intValue()
//Integer x = null 可以为空,不为空才能运算
Integer m = 128;
Integer n = 128;
sop("m == n : "+ (m == n));//输出false
Integer a = 127;
Integer b = 127;
sop("a == b : "+ (a == b));//输出true，因为a,b指向了同一个Integer对象
//因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则
//不会再开辟新的空间 byte范围 -128 到 127
method();
}
public static void method()
{
Integer x = new Integer("123");
Integer y = new Integer(123);
int num = x.intValue();
int nums = y.intValue();
sop(num + "");//输出123
sop(nums + "");//输出123
sop("x == y: " + (x == y ));
sop("x.equals(y): "+ x.equals(y));
}
public static void sop(String str)
{
System.out.println(str);
}
}