class StringDemo
{
public static void main(String[] args)
{
String s1 = "abc";//s1是一个类类型变量，..."abc"是一个对象
//字符串最大特点，一旦被初始化就不可以被改变
//s1 = "kk";//s1指向了"kk"对象,"abc"对象的值并没有改变
//System.out.println("s1="+s1);//打印结果:kk
String s2 = new String("abc");//和上面的等效
/*
s1和s2有什么区别？
s1在内存中有一个对象，
s2在内存中有两个对象，
*/
System.out.println(s1==s2);//结果false,因为地址值不同
System.out.println(s1.equals(s2));//结果：true，【字符串内容】相同//String类复写了Object类中的equals方法，
//该方法用于判断字符串是否相等
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------
/*
--------------------------------------------------------------------------------------------------------------------------------------------------
/*
String类适用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作。
常见的操作有哪些？
"abcd"
1，获取。
1.1 字符串中的包含的字符数，也就是字符串的长度。
int 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) ：
2，判断。
2.1 字符串中是否包含某一个子串。
boolean contains(str)://只为判断有没有，用contains
特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。
所以，也可以用于对指定判断是否包含。
if(str.indexOf("aa")!=-1)//包含aa
而且该方法即可以判断，有可以获取出现的位置。
2.2 字符中是否有内容。
boolean isEmpty(): 原理就是判断长度是否为0.
2.3 字符串是否是以指定内容开头。
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾。
boolean endsWith(str);
2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals(str);
2.6 判断内容是否相同，并忽略大小写。
boolean equalsIgnoreCase();
3，转换。
3.1 将字符数组转成字符串。
构造函数：String(char[])//字符数组全部转换成字符串
String(char[],//offset,count):将字符数组中的一部分转成字符串。offset->起始位，count->个数
静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[] data, int offset, int count)
static String valueOf(char[])://见3.5
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);
*/
class StringMethodDemo
{
public static void method_7()
{
String s = " Hello Java ";
sop(s.toUpperCase());
sop(s.toLowerCase());
sop(s.trim());//去除两边的空格
String s1 = "a1c";//1的ascci码是49
String s2 = "aaa";//a的assci码是97
sop(s1.compareTo(s2));//结果：-48//相等返回0------小于返回负数------大于返回正数
}
public static void method_sub()
{
String s = "stone_s";
sop(s.substring(2));//结果：one_s，从指定位置开始到结尾//如果角标不存在，会出现字符串角标越界异常
sop(s.substring(2,4));//结果：on，包含头(2)，不包含尾(4)，//s.substring(0,s.length());从头到尾
}
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_replace()
{
String s = "hello java";
//String s1 = s.replace('a','o');//替换字符
String s1 = s.replace("java","grils");//替换字符串
sop("s="+s);
sop("s1="+s1);
}
public static void method_trans()
{
char[] arr = {'S','t','o','n','e','_','S'};
//String s = new String(arr);//打印:s=Stone_S
String s = new String(arr,1,3);//打印：s=ton
sop("s="+s);
String s1 = "Candy_222";
char[] chs = s1.toCharArray();
for(int x=0; x<chs.length; x++)
{
sop("ch="+chs[x]);
}
}
public static void method_is()
{
String str = "ArrayDemo.java";
//判断文件名称是否是Array单词开头。
sop(str.startsWith("Array"));
//判断文件名称是否是.java的文件。
sop(str.endsWith(".java"));
//判断文件中是否包含Demo
sop(str.contains(".java"));
}
public static void method_get()
{
String str = "abcdeakpf";
//长度
sop(str.length());
//根据索引获取字符
sop(str.charAt(4));//从0开始索引,查找到第5个//若果输入40，会出现越界错误
//根据字符获取索引
//sop(str.indexOf('s');//第一个出现s的位置
sop(str.indexOf('s',3));//从第4位开始,第一个出现s的未知//不存在会出现-1
//反向索引一个字符出现的位置。
sop(str.lastIndexOf("a"));//反向查找第一个出现a的位置，结果:5
}
public static void main(String[] args)
{
method_7();
//method_sub();
//method_split();
//method_replace();
//method_trans();
//method_is();
//method_get();
/*
String s1 = "abc";
String s2 = new String("abc");
String s3 = "abc";
System.out.println(s1==s2);//比较地址：flase
System.out.println(s1.equals(s2));//比较对象中的内容：true
*/
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------
/*
1，模拟一个trim方法，去除字符串两端的空格。
思路：
1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。
结尾处判断空格也是如此。
2，当开始和结尾都判断到不是空格时，就是要获取的字符串。
2，将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg
思路：
1，曾经学习过对数组的元素进行反转。
2，将字符串变成数组，对数组反转。
3，将反转后的数组变成字符串。
4，只要将或反转的部分的开始和结束位置作为参数传递即可。
*/
class StringTest1_2
{
public static void sop(String str)
{
System.out.println(str);
}
/*
//练习一，去除字符串两端空格。
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);//截取字符串，包头不包尾，所以end+1
}
*/
public static void main(String[] args)
{
/*
String s = " ab cd ";//------------------练习一
sop("("+s+")");
s = myTrim(s);
sop("("+s+")");
*/
String s = " ab cd ";//------------------练习二
sop("("+s+")");
sop("("+reverseString(s)+")");//全部反转
//sop("("+reverseString(s,6,10)+")");//结果:ab c---->c ba
}
//练习二：将字符串反转。
/*
思路：
1，将字符串变成数组。
2，对数组反转。
3，将数组变成字符串。
*/
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)//字符串从头到尾反转
{
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--)//包头不包尾，所以y-1
{
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，当获取不到时，计数完成。
*/
class StringTest3
{
/*
练习三。
*/
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());//截取字符串，从kk后截取
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();//第一次出现kk的位置，加上kk长度，就是下一次开始的位置
count++;
}
return count;
}
public static void main(String[] args)
{
String str = "kkabkkcdkkefkks";
///sop("count====="+str.split("kk").length);//不建议使用。
sop("count="+getSubCount_2(str,"kk"));
}
public static void sop(String str)
{
System.out.println(str);
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------
/*
4，获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。
"abcwerthelloyuiodef"
"cvhellobnm"
思路：
1，将短的那个子串按照长度递减的方式获取到。
2，将每获取到的子串去长串中判断是否包含，
如果包含，已经找到！。
*/
class StringTest4
{
/*
练习四。
*/
public static String getMaxSubString(String s1,String s2)//设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++)
{
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))//或者：max.indexOf(temp)!=-1;
return temp;
}
}
return " ";
}
public static void main(String[] args)
{
String s1 = "abcwerthelloyuiodef";
String s2 = "cvhellobnm";
sop(getMaxSubString(s2,s1));
}
public static void sop(String str)
{
System.out.println(str);
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------
/*--------------------------------------------------------------------------------------------------------------------------------------------------
StringBuffer是字符串缓冲区。---【面盆儿】
是一个容器。
特点：
1，长度是可变化的。
2，可以直接操作多个数据类型。
3，最终会通过toString方法变成字符串。
C create 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)
JDK1.5 版本之后出现了StringBuilder.
StringBuffer是线程同步。------【一次只能一个执行】-----安全的-----多线程(判断锁)
StringBuilder是线程不同步。---------------不安全的--------单线程(不判断锁)
以后开发，建议使用StringBuilder----!!
升级三个因素：
1，提高效率。
2，简化书写。
3，提高安全性。
*/
class StringBufferDemo
{
public static void main(String[] args)
{
//method_update();
StringBuilder sb = new StringBuilder("abcdef");//StringBuffer和StringBuilder基本一样，就是效率，同步，安全问题！
char[] chs = new char[6];
sb.getChars(1,4,chs,1);//【包头不包尾】将b,c,d存到数组中
for(int x=0; x<chs.length; x++)
{
sop("chs["+x+"]="+chs[x]+";");
}
draw(3,6);
draw(8,9);
//StringBuilder sb1 = new StringBuilder();
//sb1.append(new Demo()).append(new Demo());
//sop("sb1="+sb1);
}
public static void method_update()
{
StringBuffer sb = new StringBuffer("abcde");//角标0,1,2,3,4
//sb.replace(1,4,"java");//【包头不包尾】------结果：ajavae ("java替换bcd")
sb.setCharAt(2,'k');//结果：abkcd
sop(sb.toString());
}
public static void method_del()
{
StringBuffer sb = new StringBuffer("abcde");
//sb.delete(1,3);//结果：ade----【包头不包尾】
//清空缓冲区。清空StringBuffer
//sb.delete(0,sb.length());//全删光
//sb.delete(2,3);
sb.deleteCharAt(2);//删除第2个字符
sop(sb.toString());
}
public static void method_add()
{
StringBuffer sb = new StringBuffer();
//sb.append("abc").append(true).append(34);
//StringBuffer sb1 = sb.append(34);
//sop("sb==sb1:"+(sb==sb1));
sb.insert(1,"qq");
sop(sb.toString());//abctrue34
//sop(sb1.toString());
}
public static void sop(String str)
{
System.out.println(str);
}
public static void draw(int row,int col)
{
StringBuilder sb = new StringBuilder();
for(int x=0; x<row; x++)
{
for(int y=0; y<col; y++)
{
sb.append("*");
}
sb.append("\r\n");
}
sop(sb.toString());
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------
/*----操作数字的，都可以想到这个！！！！
基本数据类型对象包装类。
byteByte
shortShort
intInteger//---
longLong
boolean Boolean
floatFloat
doubleDouble
charCharacter//--
基本数据类型对象包装类的最常见作用，
就是用于---->基本数据类型和字符串类型<----之间做转换
基本数据类型转成字符串。
基本数据类型+""
基本数据类型.toString(基本数据类型值);
如： Integer.toString(34);//将34整数变成"34";
字符串转成基本数据类型。----【文本框中的数据几乎都是字符串！】
格式：xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("123");----(静态)----字符串转换为整形
double b = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
Integer i = new Integer("123");
int num = i.intValue();//----(非静态)----字符串转换成整形
十进制转成其他进制。
toBinaryString();
toHexString();
toOctalString();
其他进制转成十进制。
parseInt(string,radix);
字符串<-> 进制
*/
class IntegerDemo
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
//整数类型的最大值。
//sop("int max :"+Integer.MAX_VALUE);
//将一个字符串转成整数。
int num = Integer.parseInt("123");//必须传入数字格式的字符串!
//long x = Long.parseLong("123");
//sop("num="+(num+4));
//sop(Integer.toBinaryString(-6));//1111111...1101
//sop(Integer.toHexString(60));//3c
int x = Integer.parseInt("3c",16);//结果:转换成十进制60
sop("x="+x);
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------
/*
JDK1.5版本以后出现的新特性。
*/
class IntegerDemo1
{
public static void main(String[] args)
{
//Integer x = new Integer(4);
Integer x = 4;//自动装箱。//右边是对象。 4等同于new Integer(4)
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;//127在byte范围内-----【-128~127】
Integer b = 127;
sop("a==b:"+(a==b));//结果：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));//true，数值相同！
}
public static void sop(String str)
{
System.out.println(str);
}
}
浙公网安备 33010602011771号