一、 String —— 概述
API（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。(来自网络释义) ======字符串在日常使用中比较常见，所以将它封装成对象。 String 类被 final 修饰，不能有子类。 java.lang.Object -String public final class String extends Object implements Serializable,Comparable<String>,CharSequence 字符串是一个特殊的对象； 示例一： String s1 = new String(); 等同于 String s2 = ""; 示例二： String s1 = "abc"; s1是一个类类型变量(引用数据类型)， "abc"是一个对象。 字符串最大特点：一旦被初始化就不可以被改变。 ======字符串既是一个对象，又是一个常量，一旦被初始化就不可以被改变。 示例三： String s1 = "abc"; s1 = "kk"; System.out.println(s1);//结果是kk 注意"abc"未变化，变化的是s1: s1由指向对象"abc"变成了指向对象"kk"。 示例四：class StringDemo1 { public static void main(String[] args) { String s1 = "abc"; String s2 = new String("abc"); /* s1和s2有什么区别？ s1在内存中有一个对象。 s2在内存中有两个对象。一个对象是new出来的，另一个对象是"abc" */ System.out.println(s1==s2);//false //==比较的是内存地址值 //s1和s2是不同对象，不相等。 System.out.println(s1.equals(s2));//true //String 类复写了 Object 类中 equals 方法，定义了自己独特的内容。该方法用于判断字符串中的内容是否相同。 } }
字符串在内存中有一个常量池，该常量池有一个数组。该数组存放的是字符串中的字符。字符串由字符组成。比如字符串"abc"，内存中就将字符'a','b','c'存在数组当中；当字符串"abc"建立时，就将数组中的字符'a','b','c'提取出来组成字符串"abc"。二、 String —— 常见功能——获取和判断
示例一：class StringDemo2 { public static void main(String[] args) { String s1 = "abc"; String s2 = new String("abc"); String s3 = "abc"; //此时s3不会重新开辟空间，而是和s1指向了同一个对象。 System.out.println(s1==s2);//false System.out.println(s1==s3);//true } }
方法区中有：方法数据；静态区；常量池。
String 类是用于描述字符串事物，那么它就提供了多个方法对字符串进行操作。
学习字符串：一是学习字符串的特性；二是学习对字符串方法的使用。
对字符串的常见操作：(一)、获取
1、字符串中包含的字符数，也就是字符串的长度:
int length(); 获取长度；
2、根据位置获取位置上的某个字符:
char charAt(int index); 获取字符；
3、根据字符获取字符在字符串中的位置:
int indexOf(int ch); 返回的是ch在字符串中第一次出现的位置；
int indexOf(int ch, int fromIndex); 从fromIndex指定位置开始，获取ch在字符串中第一次出现的位置；
int lastIndexOf(int ch); 反向索引
int lastIndexOf(int ch,int fromIndex); 反向索引
===以上四个方法，如果没有找到，返回-1 。
======当ch参数传进去为 char 类型时，会自动转为 int 类型.
4、根据子字符串获取子字符串在字符串中的位置:
int indexOf(String str); 返回是的str在字符串中第一次出现的位置；
int indexOf(String str, int fromIndex); 从fromIndex指定位置开始，获取str在字符串中第一次出现的位置；
int lastIndexOf(String str); 反向索引
int lastIndexOf(String str, int fromIndex); 反向索引(二)、判断
1、字符串中是否包含某一个子字符串:
contains(CharSequence s); 当且仅当此字符串包含指定的 char 值序列时，返回 true 。
特殊之处: int indexOf(String str)可以索引str第一次出现的位置；如果返回-1，表示该字符串不存在；所以 int indexOf(String str)也可以用于判断是否包含子串。而且该方法既可以判断，又可以获取出现的位置。
示例:
if(str.indexOf(str)!=-1),则包含子串。
2、字符串中是否有内容:
boolean isEmpty(); 当且仅当 length() 为 0 时返回 true 。
3、字符串中是否以指定内容开头:
boolean startsWith(String prefix); 测试此字符串是否以指定的前缀开始。
boolean startsWith(String prefix, int toffset); 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
4、字符串中是否以指定内容结尾:
boolean endsWith(String suffix); 测试此字符串是否以指定的后缀结束。
5、判断字符串的内容是否相同:
boolean equals(Object anObject); 将此字符串与指定的对象比较。(其复写了 Object 类中的 equals 方法)。
6、判断内容是否相同，并忽略大小写。
equalsIgnoreCase(String anotherString); 将此 String 与另一个 String 比较，不考虑大小写。
示例代码:class StringMethodDemo { public static void main(String[] args) { method_get(); method_is(); } public static void method_is() { String str = "ArrayDemo.java"; sop(str.startsWith("Array")); sop(str.endsWith(".java")); sop(str.contains("Demo")); sop(str.isEmpty()); sop(str.equalsIgnoreCase("arraydemo.java")); } public static void method_get() { String str = "abcdeabcde"; sop(str.length()); sop(str.charAt(40));//当访问到字符串中不存在的角标时，就出现: StringIndexOutOfBoundsException sop(str.indexOf('m'));//当查找字符串中不存在的字符是，返回-1； sop(str.indexOf('a',3)); sop(str.indexOf("bc")); sop(str.indexOf("bc",3)); sop(str.lastIndexOf('a')); sop(str.lastIndexOf("ab")); } public static void sop(Object obj)//如果传入的是基本数据类型，那么基本数据类型会提升——自动装箱 { System.out.println(obj); } }三、 String —— 常见功能——转换
1、将字符数组转成字符串:
构造函数:
String(char[] value) 将字符数组转成字符串；
String(char[] value, int offset, int count) 将字符数组中的一部分转成字符串；
静态方法:
static String copyValueOf(char[] data); 返回指定数组中表示该字符序列的 String 。
static String copyValueOf(char[] data, int offset, int count); 返回指定数组中表示该字符序列的 String 。
static String valueOf(char[] data); 返回 char 数组参数的字符串表示形式。
static String ValueOf(char[] data, int offset, int count); 返回 char 数组参数的特定子数组的字符串表示形式。
2、将字符串转成字符数组:
char[] toCharArray(); 将此字符串转换为一个新的字符数组。
3、将字节数组转成字符串:
构造函数:
String(byte[] bytes)
String(byte[] bytes, int offset, int length)
4、将字符串转成字节数组:
byte[] getBytes();
5、将基本数据类型转成字符串:
static String valueOf(boolean b);
static String valueOf(char c);
static String valueOf(int i); 相当于(3+"")
static String valueOf(long l);
static String valueOf(double d);
static String valueOf(float f);
static String valueOf(Object obj); 返回 Object 参数的字符串表示形式。
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
注意：
System.out.println("5+5="+5+5);//5+5=55
System.out.println(5+5+"=5+5");//10=5+5
示例代码：class StringMethodDemo { public static void main(String[] args) { method_trans(); } public static void method_trans() { byte[] bytes = {100,101,102,103}; String str = "abcde"; char[] arr = {'a','b','c','d','e','f'}; String s = new String(arr); sop("s="+s);//s=abcdef String s1 = new String(arr,1,3); sop("s1="+s1);//s1=bcd String s2 = new String(); sop("s2="+s2.copyValueOf(arr));//s2=abcdef sop("s2="+s2.copyValueOf(arr,1,3));//s2=bcd sop("s2="+s2.valueOf(new Object()));//s2=java.lang.Object@2013706e arr = str.toCharArray(); printArray(arr);//[a, b, c, d, e] byte[] bt = {}; bt = str.getBytes(); printArray(bt);//[97, 98, 99, 100, 101] String ss = new String(bytes); sop("ss="+ss);//ss=defg } public static void printArray(char[] arr) { System.out.print("["); for (int x=0 ;x<arr.length ;x++ ) { if(x!=arr.length-1) System.out.print(arr[x]+", "); else System.out.println(arr[x]+"]"); } } public static void printArray(byte[] arr) { System.out.print("["); for (int x=0 ;x<arr.length ;x++ ) { if(x!=arr.length-1) System.out.print(arr[x]+", "); else System.out.println(arr[x]+"]"); } } public static void sop(Object obj) { System.out.println(obj); } }四、 String —— 常见功能 —— 切割和替换
(一)替换
1、替换字符：
String replace(char oldChar, char newChar); 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
2、替换字符串：
String replace(CharSequence target, CharSequence replacement);
(二)切割
String[] split(String regex);
(三)子串
获取字符串中的一部分
String substring(int beginIndex); 从指定位置开始到结尾；
String substring(int beginIndex, int endIndex); 从指定位置开始，到指定结尾前一个；也就是包含头，不包含尾。
如果角标不存在，会出现角标越界异常。
示例代码:class StringMethodDemo { public static void main(String[] args) { method_replace(); method_split(); method_substring(); } public static void method_substring() { String s = "abcdefg"; String s1 = s.substring(1); String s2 = s.substring(1,4); sop("s="+s);//s=abcdefg sop("s1="+s1);//s1=bcdefg sop("s2="+s2);//s2=bcd } 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+"]="+arr[x]); } //arr[0]=zhangsan //arr[1]=lisi //arr[2]=wangwu } public static void method_replace() { String s = "hello java"; String s1 = s.replace('a','n');//如果要替换的字符不存在，结果还是原串。 sop("s="+s);//结果未变，因为字符串一旦初始化不能被改变。s=hello java sop("s1="+s1);//结果为替换后s1=hello jnvn String s2 = s.replace("java","world"); sop("s2="+s2);//s2=hello world } public static void sop(Object obj) { System.out.println(obj); } }五、 String —— 常见功能——比较和去除空格
1、将字符串转成大写或者小写:
String toUpperCase();
String toLowerCase();
2、将字符串两端的多个空格去除:
String trim();
3、对两个字符串进行自然顺序的比较:
int compareTo(String anotherString);
示例代码：class StringMethodDemo { public static void main(String[] args) { method_7(); } public static void method_7() { String s = " Hello Java "; sop(s.toUpperCase()); sop(s.toLowerCase()); sop(s.trim()); String s1 = "adc"; String s2 = "aaa"; sop(s1.compareTo(s2));//结果是3 } public static void sop(Object obj) { System.out.println(obj); } }六、 String —— 字符串练习1
(一)、模拟一个trim方法，去除字符串两端的空格。
思路：
1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。结尾处判断空格也是如此。
2，当开始和结尾都判断到不是空格时，就是要获取的字符串。
代码：class StringTest1 { public static void main(String[] args) { String s = " abc de "; sop("("+s+")"); s = myTrim(s); sop("("+s+")"); } public static String myTrim(String str) { int start = 0; int end = str.length()-1; while(start<=end && str.charAt(start)==' ') start++; while(start<=end && str.charAt(end)==' ') end--; return str.substring(start,end+1); } public static void sop(String str) { System.out.println(str); } }七、 String —— 字符串练习2
(一)、将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";
思路：
1，曾经学习过对数组的元素进行反转。
2，将字符串变成数组，对数组反转。
3，将反转后的数组变成字符串。
4，只要将反转的部分的开始和结束位置作为参数传递即可。
代码:class ReverseString { public static void main(String[] args) { String s = "abcdefg"; String ss = reverse(s,1,4); System.out.println(ss); } //反转字符串的指定部分 public static String reverse(String str, int start, int end) { //将字符串变数组 char[] chs = str.toCharArray(); //将数组反转 reverse(chs,start,end-1); //数组变字符串并返回 return new String(chs); } //反转整个字符串 public static String reverse(String str) { return reverse(str,0,str.length()); } //反转数组 private static void reverse(char[] arr, int x, int y) { for (int start=x, end=y ;start<end ;start++, end-- ) { swap(arr,start,end); } } //数组中元素置换位置 public static void swap(char[] arr, int x, int y) { char temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } }八、 String —— 字符串练习3
(一)、获取一个字符串在另一个字符串中出现的次数。
"abkkcdkkefkkskk"
思路：
1，定义个计数器。
2，获取kk第一次出现的位置。
3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
每获取一次就计数一次。
4，当获取不到时，计数完成。
代码:class StringTest3 { public static void sop(String str) { System.out.println(str); } public static void main(String[] args) { String str = "abkkdkksdekka"; int count = getSubCount_2(str,"kk"); sop("count="+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; } public static int getSubCount(String str, String key) { int count = 0; int index = 0; //sop("str="+str); while((index=str.indexOf(key))!=-1) { str = str.substring(index+key.length()); //sop("index="+index); //sop("str="+str); count++; } return count; } }九、 String —— 字符串练习4
4，获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度依次递减的子串打印。
"abcwerthelloyuiodef"
"cvhellobnm"
思路：
1，将短的那个子串按照长度递减的方式获取到。
2，将每获取到的子串去长串中判断是否包含，
如果包含，已经找到。
代码:class StringTest4 { public static void main(String[] args) { sop(getMaxSubString("hellojavahehe","lajavake")); } public static String getMaxSubString(String s1, String s2) { String max="",min=""; max = (s1.length()>s2.length())?s1:s2; min = (s1==max)?s2:s1; for (int x=0 ;x<min.length() ;x++ ) { for (int y=0,z=min.length()-x ;z<=min.length() ;y++,z++ ) { String temp = min.substring(y,z); if (max.contains(temp)) return temp; } } return ""; } public static void sop(String str) { System.out.println(str); } }十、 StringBuffer —— 常见功能——添加
StringBuffer 是字符串缓冲区，是一个容器。
特点：
A、 StringBuffer 是可变长度的。
B、可以直接操作多个数据类型。
C、最终会通过 toString 方法变成字符串。
CURD: create ; update ; read ; delete ;
功能：
1、存储：
StringBuffer append() 将指定数据作为参数添加到已有数据的结尾处。(注意：不支持 byte 和 short 类型的添加)
StringBuffer insert(index,任意数据) 将数据插入到指定index位置。
代码：class StringBufferDemo { public static void main(String[] args) { StringBuffer sb = new StringBuffer(); StringBuffer sb1 = sb.append(34);//append方法返回的是一个StringBuffer对象，这时sb和sb1指向了同一个对象。 sop(sb==sb1);//true sb.append("abc").append(true).append(24.2);//方法调用链：该方法返回值还是本类对象，所以还可以调用本类方法。 sop(sb.toString());//abctrue24.2 sb.insert(2,'x'); sop(sb.toString());//34xabctrue24.2 } public static void sop(Object obj) { System.out.println(obj); } }十一、 StringBuffer —— 常见功能——删除和修改
2、删除：
StringBuffer delete(int start, int end) 删除缓冲区中的数据，包含start，不包含end。
StringBuffer deleteCharAt(int index) 删除index角标数据。
3、获取：
char charAt(int index) 获取index角标位字符；
int indexOf(String str); 获取位置
int lastIndexOf(String str); 反向获取
int length() 获取长度
String substring(int start);
String substring(int start, int end);
4、修改：
StringBuffer replace(int start, int end, String str) 将start到end替换成str 。
void setCharAt(int index, char ch) 将index角标位的数据变成ch字符。
5、反转：
StringBuffer reverse();
6、将缓冲区中指定数据存储到指定字符数组中：
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将srcBegin到srcEnd角标的数据存到dst数组中的dstBegin角标。
代码：class StringBufferDemo { public static void main(String[] args) { method_del(); method_update(); method_getChars(); } public static void method_del() { StringBuffer sb = new StringBuffer("abcde"); sb.delete(1,3); sop(sb.toString());//ade sb.deleteCharAt(1); sop(sb.toString());//ae //清空缓冲区 sb.delete(0,sb.length()); sop("sb: "+sb.toString());//sb: } public static void method_update() { StringBuffer sb = new StringBuffer("abcde"); sb.replace(1,2,"ooo"); sop(sb.toString());//aooocde sb.setCharAt(2,'M'); sop(sb.toString());//aoMocde } public static void method_getChars() { StringBuffer sb = new StringBuffer("abcde"); char[] chs = new char[4]; sb.getChars(1,4,chs,1);//如果存入时超出数组角标，会发生角标越界异常 for (int x=0 ;x<chs.length ;x++ ) { System.out.println("chs["+x+"]="+chs[x]+";"); }//chs[0]= ; chs[1]=b; chs[2]=c; chs[3]=d; } public static void sop(Object obj) { System.out.println(obj); } }十二、 StringBuilder
StringBuilder 比 StringBuffer 更快，但不保证同步；
在单线程中建议使用 StringBuilder ，在多线程中建议使用 StringBuffer 。
小知识：
java升级的三个因素：
1、提高效率；
2、简化书写；
3、提高安全性。十三、基本数据类型对象包装类
int Integer
char Character
java.lang.Integer
字段: MAX_VALUE ; MIN_VALUE
构造方法:
Integer(int value);
Integer(String s);
基本数据类型对象包装类最常见的作用：
就是用于基本数据类型和字符串类型之间做转换；
1、基本数据类型转成字符串：
A、基本数据类型+""
B、基本数据类型包装类.toString(基本数据类型);
如: Integer.toString(34); 将34变成"34";
2、字符串转成基本数据类型：
xxx a = Xxx.parseXxx(String);
如: int i = Integer.parseInt("123");//必须传入数字格式的字符串
double d = Double.parseDouble("12.12");
boolean b = Boolean.parseBoolean("true");
注意：
字符串不能转换成 char 类型。因为字符是字符串的一个单位。
3、十进制转成其他进制：
String Integer.toBinaryString();
String Integer.toHexString();
String Integer.toOctalString();
其他进制转成十进制：
static int parseInt(String s, int radix)
如:
int x = Integer.parseInt("110",2); //6
int x = Integer.parseInt("110",10); //110
int x = Integer.parseInt("3c",16); //60
以上都是静态调用方式；除此之外，还可以先将基本数据数据封装成对象，再用该对象调用对应方法。十四、基本数据类型对象包装类新特性
JDK1.5版本后出现的新特性：
//Integer x = new Integer(4); 可简写为：
Integer x = 4;//自动装箱
//Integer x = null;//会发生空指针异常，所以在运算之前要进行判断。
x = x/* x.intValue() */ + 2;//右边x+2时，x进行了自动拆箱，变成int类型，再和2进行加法运算得到和；然后再将该和进行装箱赋给左边x;
还可以定义成以下方式：
Integer y = null;
示例一：class IntegerDemo1 { public static void main(String[] args) { Integer m = 128; Integer n = 128; System.out.println("m==n : "+(m==n)); //结果为 false ; Integer a = 127; Integer b = 127; System.out.println("a==b : "+(a==b)); //结果为 true ; //因为当数值在 byte 范围内时，如果该数值已经存在，则不会开辟新的空间。 } }
示例二：class IntegerDemo2 { public static void main(String[] args) { Integer x = new Integer("123"); Integer y = new Integer(123); sop(x==y);//false sop(x.equals(y));//true } }
3738
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
