黑马程序员_Java基础_字符串_13
------- android培训、java培训、期待与您交流！ ----------
导读：String概述，获取，判断，字符串转换，替换，切割，子串，大小写转换，去除空格，比较，字符串练习，基本数据类型（对象包装类），包装类新特性
1、String(概述)
l 什么是API呢？API是Java提供给我们的应用程序接口，暴露出来的能让我们直接使用的部分。查API先想有什么功能，这功能运算完后有什么结果，按结果的类型查找的话，会比较方便。虽然有重复，但也能缩小范围。
l 把字符串定义成功能以便于操作这些字符串。很多种语言都有都有对于字符串的描述。在JAVA中描述字符串，用的是java.lang包中的类，叫做String。该类为final表示不能有子类，也就是说，它里面的操作字符串的功能是不能覆写的。任何一个用“”引起来的字符串，都是String的一个具体对象。
l String s = newString();和String s1=＂＂是一回事。因此在建字符串的时候，这种new的方式不多见。
String s1 = “abc”//s1
l class StringDemo
{
publicstatic void main(String[] args)
{
/*
Strings1 = "abc";//s1是一个类类型变量， "abc"是一个对象。
//字符串最大特点：一旦被初始化就不可以被改变。
Strings2 = new String("abc");//这两个使用起来是一样的，但是有区别。
//s1和s2有什么区别？s1在内存中有一个对象。s2在内存中有两个对象。
System.out.println(s1==s2);
System.out.println(s1.equals(s2));//String类复写了Object类中equals方法，复写了之后，它建立了自己对象独特的判断判断字符串内容是否相同的方法。字符串在内存中有一个常量池，存放abc这样的字符。
*/
Strings = "abcde";
method_1(s);
}
/*
String类是对字符串事物的描述。该类定义了专门用于操作字符串的方法。"abc":
*/
publicstatic void method_1(String s)
{
charch = s.charAt(3);
System.out.println("ch="+ch);
intnum = s.codePointAt(3);
System.out.println("num="+num);
Strings1 = "qq";
s1= s1.concat("mm");
System.out.println("s1="+s1);
System.out.println("qq"+"mm");
Stringa = "opq";
Stringb = "opq";
System.out.println("a==b:"+(a==b));
}
}
2、常见功能-获取和判断
l 方法区中不仅有静态区（静态数据），动态区（方法数据），还有常量池。
l 我们学习字符串，主要学习两个，一个是字符串的特性，一但被初始化，就再改变。第二个，就是对于其方法的使用。
l String类适用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作。
常见的操作有哪些？
"abcd"：1、它有长度。2、它由字符组成。3、某个字符在什么位置上。4、这个位置上有什么字符。
l 1>获取。（重要）
1.1 字符串中的包含的字符数，也就是字符串的长度。
intlength():获取长度，通过方法完成。（数组也有length,但他那个是属性没有括号）
1.2 根据位置获取位置上某个字符。
charcharAt(int index):
1.3 根据字符获取该字符在字符串中位置。（不是char ch是因为它接收的是ASCII码）
intindexOf(int ch):返回的是ch在字符串中第一次出现的位置。
intindexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。
intindexOf(String str):返回的是str指定子字符串在字符串中第一次出现的位置。
intindexOf(String str, int fromIndex) :从fromIndex指定位置开始，获取str在字符串中出现的位置。
intlastIndexOf(int ch) ： lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
int codePointAt(int index)：返回指定索引处的ASCII码。
l 2>判断。
2.1 字符串中是否包含某一个子串。
booleancontains(str):
特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。（因此contains和indexOf(str)都可以做这件事）所以，也可以用于对指定判断是否包含。if(str.indexOf("aa")!=-1) 说明包含。而且该方法即可以判断，有可以获取出现的位置。（只判断用contains(str)、如果即要做判断，又要拿位置的话，indexOf()最方便）
2.2 字符中是否有内容。
booleanisEmpty(): 原理就是判断长度是否为0. （区别“”指向对象。Null指向空。）
2.3 字符串是否是以指定内容开头。
booleanstartsWith(str);
2.4 字符串是否是以指定内容结尾。
booleanendsWith(str);
2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
booleanequals(str);
2.6 判断内容是否相同，并忽略大小写。
booleanequalsIgnoreCase();
3、常见功能—转换。
3.1 将字符数组转成字符串。
构造函数：String(char[]) （在字符串初始化的时候就可以完成这个操作）
String(char[],offset,count):将字符数组中的一部分转成字符串。
静态方法：
staticString copyValueOf(char[]); (静态数组，无特有数据)
staticString 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 将基本数据类型转成字符串。
staticString valueOf(int)
staticString valueOf(double)
//3+"";和String.valueOf(3);结果是一样的，但后面的一个显的比较专业，但麻烦。
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。（但凡你在想做编码操作的时候，你要变成字节数组才可以）
4、常见功能—替换、切割和子串
替换：Stringreplace(oldchar,newchar);
String replace(CharSequencetarget, CharSequence replacement);字符串替换。（String的父类是CharSequence接口，CharSequence还有一个子类StringBuffer）
切割
String[]split(regex); //split中用“”引起来的部分可以是字符“,” 也可是字母“aa”将字符串分隔成字符串数组
子串。(获取字符串中的一部分)
Stringsubstring(begin);
Stringsubstring(begin,end);
5、常见功能—大小写转换，去除空格，比较
5.1 将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();
5.2 将字符串两端的多个空格去除。
（在开发的时候很好用空格在有时不太注意就看不见，在登陆邮箱的时候把你的空格自动给我去了，不然会给我用户一种错觉，自己的账号被盗了。在注册邮箱的时候空格不能做为字符存在非法字符。）
Stringtrim();
5.3 对两个字符串进行自然顺序的比较。
intcompareTo(string); //为什么字符串可以忽略大小写比较？因为不管是大字还是小写，全把你变小写再比较。
class StringMethodDemo
{
publicstatic void method_5()
{
Strings = " Hello Java ";
sop(s.toLowerCase());
sop(s.toUpperCase());
sop(s.trim());
Strings1 = "a1c";
Strings2 = "aaa";
sop(s1.compareTo(s2)); //结果为48。返回的值是比较时相对应的第一个不相等的字符的ASC码值之差。（返回值：如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值）
}
publicstatic void method_sub()
{
Strings = "abcdef";
sop(s.substring(2));//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。
sop(s.substring(2,4));//包含头，不包含尾。s.substring(0,s.length()); Java但凡是取从头到尾的部分，一般的都是包含头，不包含尾。因为头是0尾一般定义成对应的长度，长度减1是最后一个角标。
}
publicstatic void method_split()
{
Strings = "zhagnsa,lisi,wangwu";//也可以取子串，也能把字符串都给取出来。但麻烦没有split快
String[]arr = s.split(",");
for(intx = 0; x
{
sop(arr[x]);
}
}
publicstatic void method_replace()
{
Strings = "hello java";
//Strings1 = s.replace('q','n');//如果要替换的字符不存在，返回的还是原串。
Strings1 = s.replace("java","world"); //s1是生成了一个新的字符串。
sop("s="+s); //它打印的还是"hellojava",字符串，一但被确定就不会被改变。
sop("s1="+s1);
}
publicstatic void method_trans()
{
char[]arr = {'a','b','c','d','e','f'};
Strings= new String(arr,1,3); //1是起始位，3是个数。
sop("s="+s);
Strings1 = "zxcvbnm";
char[]chs = s1.toCharArray();
for(intx=0; x
{
sop("ch="+chs[x]);
}
}
publicstatic void method_is()
{
Stringstr = "ArrayDemo.java";
//判断文件名称是否是Array单词开头。
sop(str.startsWith("Array"));
//判断文件名称是否是.java的文件。
sop(str.endsWith(".java"));
//判断文件中是否包含Demo
sop(str.contains(".java"));
}
publicstatic void method_get()
{
Stringstr = "abcdeakpf";
sop(str.length()); //长度
//根据索引获取字符。
sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。
//根据字符获取索引
sop(str.indexOf('m',3));//如果没有找到，返回-1.
//反向索引一个字符出现位置。
sop(str.lastIndexOf("a"));//从右边倒着开始数，数到第一个，字符a,但是角标还是正着的。返回结果为5。
}
publicstatic void main(String[] args)
{
method_7();
// method_trans();
// method_is();
// method_get();
/*
Strings1 = "abc";
Strings2 = new String("abc");
Strings3 = "abc";
System.out.println(s1==s2); //结果为false
System.out.println(s1==s3); //结果为true
*/
}
publicstatic void sop(Object obj)//也可以传入基本数据类型。是1.5之后，的新特性，自动进行类型的提升，装箱。
{
System.out.println(obj);
}
}
6、String字符串练习
l 字符串这些方法要求：必须会，会到什么程度？不查阅API文档，不借助Eclipce的高级联想功能。完全自己手写能写得出来。否则你给我别人说你有开发经验，鬼才相信。
l 写代码功能要尽量的细分，细分完之后呢，你修改起来会很方便。功能尽量独立出来，变成一个小的函数。被调用就可以了，它有很多好处，一，它可以被其他的很多的函数调用；二，里面怎么写我没有想到呢，但是我知道了思路是要反转的话，可以先把函数名定义出来。
/*
1．模拟一个trim方法，去除字符串两端的空格。
思路：
1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。
结尾处判断空格也是如此。
2，当开始和结尾都判断到不是空格时，就是要获取的字符串。
2．将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg
思路：
1，曾经学习过对数组的元素进行反转。
2，将字符串变成数组，对数组反转。
3，将反转后的数组变成字符串。
4，只要将或反转的部分的开始和结束位置作为参数传递即可。
*/
class StringTest
{
publicstatic void sop(String str)
{
System.out.println(str);
}
publicstatic void main(String[] args)
{
Strings = " ab cd ";
sop("("+s+")");
sop("("+reverseString(s)+")");
}
//练习二：将字符串反转。
/*
思路：
1，将字符串变成数组。
2，对数组反转。
3，将数组变成字符串。
*/
publicstatic String reverseString(String s,int start,int end) //函数重载
{
//字符串变数组。
char[]chs = s.toCharArray();
//反转数组。
reverse(chs,start,end);
//将数组变成字符串。
returnnew String(chs);
}
publicstatic String reverseString(String s) //这个函数里面调用它的重载的函数
{
returnreverseString(s,0,s.length());
}
privatestatic void reverse(char[] arr,int x,int y)
{
for(intstart=x,end=y-1; start
{
swap(arr,start,end);
}
}
privatestatic void swap(char[] arr,int x,int y)
{
chartemp = arr[x];
arr[x]= arr[y];
arr[y]= temp;
}
//练习一，去除字符串两端空格。
publicstatic String myTrim(String str)
{
intstart = 0,end = str.length()-1; //从最后一个数往前找
while(start<=end&& str.charAt(start)==' ')
start++;
while(start<=end&& str.charAt(end)==' ')
end--;
returnstr.substring(start,end+1);
}
}
/*
3，获取一个字符串在另一个字符串中出现的次数。
"abkkcdkkefkkskk"
思路：
1，定义个计数器。
2，获取kk第一次出现的位置。
3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
每获取一次就计数一次。
4，当获取不到时，计数完成。
*/
class StringTest2
{
//练习三。
publicstatic int getSubCount(String str,String key)
{
intcount = 0;
intindex = 0;
while((index=str.indexOf(key))!=-1)
{
sop("str="+str);
str= str.substring(index+key.length());
count++;
}
returncount;
}
//练习三，方式二。
publicstatic int getSubCount_2(String str,String key)
{
intcount = 0;
intindex = 0;
while((index=str.indexOf(key,index))!=-1)
{
sop("index="+index);
index = index + key.length();
count++;
}
returncount;
}
publicstatic void main(String[] args)
{
Stringstr = "kkabkkcdkkefkks";
///sop("count====="+str.split("kk").length);不建议使用。kk在开关结尾会切出一个空串出来
sop("count="+getSubCount_2(str,"kk"));
}
publicstatic void sop(String str)
{
System.out.println(str);
}
}
/*
4，获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。
"abcwerthelloyuiodef"
"cvhellobnm"
思路：
1，将短的那个子串按照长度递减的方式获取到。
2，将每获取到的子串去长串中判断是否包含，
如果包含，已经找到！。
*/
class StringTest3
{
//练习四。
publicstatic String getMaxSubString(String s1,String s2)
{
Stringmax = "",min = "";
max= (s1.length()>s2.length())?s1: s2; //获取字符串中长的和短的
min= (max==s1)?s2: s1;
for(intx=0; x
{
for(inty=0,z=min.length()-x; z!=min.length()+1; y++,z++)
{
Stringtemp = min.substring(y,z);
sop(temp);
if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
returntemp;
}
}
return"";
}
publicstatic void main(String[] args)
{
Strings1 = "ab";
Strings2 = "cvhellobnm";
sop(getMaxSubString(s2,s1));
}
publicstatic void sop(String str)
{
System.out.println(str);
}
}
7、StringBuffer常见功能添加、插入、删除、修改(这些方法要熟记)
l StringBuffer:String一旦被确定就不能被修改，而StringBuffer是可以对于字符串做修改的。
l StringBuffer是final的不能被继承。
l StringBuffer是字符串缓冲区。是一个容器。
l 其中的append()方法，short和byte类型的没有，其他的它都支持。为什么没有呢，因为有int类型提升了。
l 对于StringBuffer有一个面盆理论，加点面，还是这个盆，可点水还是这个盆。
l 我不想在后面添加，我想在前面添加，这个时候在StringBuffer中不叫添加而叫插入insert()；
l StringBuffer的特点：
1，长度是可变化的。（数组也是容器，但是它的长度是不可变化的）
2，可以直接操作多个数据类型。（数组一次只能操作一种数据类型）
3，最终会通过toString方法变成字符串。
l 什么时候用？
当数据类型不确定，个数不确定，而且最终要变成字符串的时候。
l C create U updateR read D delete
1，存储。
StringBufferappend():将指定数据作为参数添加到已有数据结尾处。
StringBufferinsert(index,数据):可以将数据插入到指定index位置。（index后面的顺延）
2，删除。
StringBufferdelete(start,end):删除缓冲区中的数据，包含start，不包含end。
StringBufferdeleteCharAt(index):删除指定位置的字符。
3，获取。
charcharAt(int index)
intindexOf(String str)
intlastIndexOf(String str)
intlength()
Stringsubstring(int start)
Stringsubstring(int start, int end) //这里访问的还是String而不是StringBuffer.
4，修改。（把原来串中的数据改变一下）
StringBufferreplace(start,end,String); //String是要替换成的字符串。
voidsetCharAt(int index, char ch) ; //注意它是替换完就完事了，它不返回。
5，反转。
StringBufferreverse();
6，将缓冲区中指定数据存储到指定字符数组中。
voidgetChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
l JDK1.5 版本之后出现了StringBuilder.
Ø StringBuffer是线程同步。（安全的，在操作的时候不会出现其他的操作，即使是多线程情况也不会，单线程，效率低，它要判断锁）
Ø StringBuilder是线程不同步。（不安全的，单线程，不需要判断锁，比较快捷）
以后开发，建议使用StringBuilder（它是后出来的）
StringBuilder一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。（多线程也可以用StringBuffer,要自己加锁lock()，unlock()）。
l JDK升级三个因素：
1，提高效率。
2，简化书写。
3，提高安全性。
l class Demo
{
}
class StringBufferDemo
{
public staticvoid main(String[] args)
{
//method_update();
StringBuildersb = new StringBuilder("abcdef");
char[]chs = new char[6];
sb.getChars(1,4,chs,1);//将bcd存到角标中，包含头不包含尾。
for(intx=0; x
{
sop("chs["+x+"]="+chs[x]+";");
}
draw(3,6);
draw(8,9);
// StringBuildersb1 = new StringBuilder();
// sb1.append(newDemo()).append(new Demo());
// sop("sb1="+sb1);
}
public staticvoid method_update()
{
StringBuffersb = newStringBuffer("abcde");
// sb.replace(1,4,"java"); //返回结果为：ajavae
sb.setCharAt(2,'k');
sop(sb.toString());
}
public staticvoid method_del()
{
StringBuffersb = newStringBuffer("abcde");//一初始化里面就有数据
//sb.delete(1,3); //bc没了，含头不含尾。
//sb.delete(0,sb.length()); //清空缓冲区。
sb.deleteCharAt(2); //删除一个字符，其实也就是这个语句：sb.delete(2,3);，比用delete更方便。
sop(sb.toString());
}
public staticvoid method_add()
{
StringBuffersb = new StringBuffer();
//sb.append("abc").append(true).append(34);//StringBuffer1返回的是本类缓冲区的对象，所以还能调用本类的方法，在后面再加上append();这叫做方法调用链。
// StringBuffersb1 = sb.append(34);
// sop("sb==sb1:"+(sb==sb1)); //sb和sb1指向的是同一个对象返回的结果是true.
sb.insert(1,"qq");
sop(sb.toString());//abctrue34
//sop(sb1.toString());
}
public staticvoid sop(String str)
{
System.out.println(str);
}
public staticvoid draw(int row,int col)
{
StringBuildersb = new StringBuilder();
for(intx=0; x
{
for(inty=0; y
{
sb.append("*");
}
sb.append("\r\n");
}
sop(sb.toString());
}
}
8、基本数据类型-对象包装类
l 按照JAVA面向对象的原则JAVA将万事万物都视为对象，包括基本数据类型。整数就是一个数值，你把它变为对象，到底想干什么呢？
l Int型有一定的取值范围，有多种表现形式，我怎样把Int型变成其他的表现形式呢？整数自己最清楚。把整数变成对象，里面如果定义这样的功能的话，我们指挥起整数来是不是很方便。
l 基本数据类型对象包装类。
byte Byte
short short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
l 基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换
l 基本数据类型转成字符串。
基本数据类型+""
基本数据类型.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"); //“true”和不一样
Integer i= new Integer("123"); //这个不是非静态的方法
int num =i.intValue();
l 十进制转成其他进制。
toBinaryString();
toHexString();
toOctalString();
其他进制转成十进制。
parseInt(string,radix);
class IntegerDemo
{
public staticvoid sop(String str)
{
System.out.println(str);
}
public staticvoid main(String[] args)
{
//整数类型的最大值。
//sop("intmax :"+Integer.MAX_VALUE); //静态的不用自己算231-1了。当你在运算的时候，当你要做一个安全性的判断，看是否超出了范围时用。
// 将一个字符串转成整数。
int num= Integer.parseInt("123");//必须传入数字格式的字符串。
//longx = Long.parseLong("123");
// sop("num="+(num+4));
// sop(Integer.toBinaryString(-6));
// sop(Integer.toHexString(60));
int x =Integer.parseInt("3c",16); //16为进制，它会按指定的进制转换“”中的数。
sop("x="+x);
}
}
9、基本数据类型对象包装类新特性
//JDK1.5版本以后出现的新特性。
class IntegerDemo1
{
publicstatic void main(String[] args)
{
// Integerx = new Integer(4);
Integerx = 4;//1.5自动装箱。//4相当于new Integer(4)。x是引用型类型，等号右边必然是一个对象。这个升级是为了简化书写。如果要使用1.5版本后的新特性的话，x除了取整数值以外，还多了一个值叫做null. 不要忘了要做判断，不为空的时候才能参于运算，为空要小心空指针异常，一抛异常程序会停掉，因为它是一个RuntimeException.
x =x/*拆箱原理：x.intValue() */ +2; //x+2:x 进行自动拆箱。变成成了int类型。和2进行加法运算。之后再将和进行装箱赋给x。
Integerm = 128;
Integern = 128;
sop("m==n:"+(m==n));//结果为false;两个对象
Integera = 127; //byte范围：-128~127，超过的话，会开辟新空间，不超过的话，为了节省空间，是不会开辟的，如果127在的话。
Integerb = 127;
sop("a==b:"+(a==b));//结果为true。因为a和b指向了同一个Integer对象。因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间。
}
publicstatic void method()
{
Integerx = new Integer("123");
Integery = new Integer(123);
sop("x==y:"+(x==y)); //两个对象，不相等
sop("x.equals(y):"+x.equals(y)); //重写了Object类中的equals方法。建立了本对象比较相同的特有的方式。比较的是数据是否相同。结果为true.
}
publicstatic void sop(String str)
{
System.out.println(str);
}
}
int compareTo(Integer anotherInteger)：跟字符串差不多，都是ASCII排序
------- android培训、java培训、期待与您交流！ ----------