8：String类
String类
String类的特点： 字符串对象一旦被初始化就不会被改变。
字符串是最常用的类型之一，所以为了使用方便java就给封装成了对象方便使用
public static void stringDemo2() { String s = "abc";//创建一个字符串对象在常量池中。 String s1 = new String("abc");//创建两个对象一个new一个字符串对象在堆内存和常量池中。 System.out.println(s==s1);//false System.out.println(s.equals(s1));
string类中的equals复写Object中的equals建立了string类自己的判断字符串对象是否相同的依据。
其实就是比较字符串内容。
演示字符串定义的第一种方式，并明确字符串常量池的特点.
池中没有就建立，池中有，直接用。
private static void stringDemo1() { String s = "abc";//"abc"存储在字符串常量池中。// s = "nba"; String s1 = "abc"; System.out.println(s==s1);//true// System.out.println("s="+s);/输出nab，s和s1是俩个字符串对象，s一开始指向了abc，又指向了nba，abc不变说的是这个意思}常量池：
因为String类型一旦被初始化是不能被改变的，所以存放在常量池，存放在常量池中还有个很重要的原因：String s1 = “abs”；String s2=“abs”，这时s2并没有新建立一个对象，而是指向了s1这个对象。也就是说每当创建一个字符串时，并不是直接创建而是先到常量池中区找需要创建的对象是否存在，如果存在就不会再创建了。常量池中的元素是不会重复的，这也就是所谓的享元模式，例如当已经存在abs，这时需要创建ahk，这时常量池中只会增加两个字符h和k，然后在从常量池中抽出ahk对象。
特点：
1、String是一种特殊的数据类型，可创建对象。
2、通过String创建的对象分别可存在于常量池和堆内存中
3、String是一个final的类型，即不可被继承修改，一经初始化就终生不可改变。（要改变也是改变的引用）
4、常量池中的数据可共享，即两个引用变量可指向同一个字符串池中的字符串
5、Java中的任何对象都可写成字符串的形式。
6、既然String是对象，那就不得不说说null和“”的区别了。null是String对象指向为空，就是没有指向。而“”代表的是String对象指向的是一个空的字符串。
匿名对象
匿名对象就是表示没有名字的对象，那么什么叫对象的名字了？
一个字符串就是一个string的匿名对象
String类的构造器
将字节数组或者字符数组转成字符串可以通过String类的构造函数完成。
private static void stringConstructorDemo2() { char[] arr = {'w','a','p','q','x'};//字符串转换成数组 String s = new String(arr,1,3);//字符的一部分转换成数组，从1角标取 System.out.println("s="+s); 输出s=apq } public static void stringConstructorDemo() { String s = new String();//等效于String s = ""内容一样，地址不一样，都是指向空字符串; 但不等效String s = null;一般用String s = ""，就行了，能被共享,当需要用构造器传数据，需要用new， byte[] arr = {97,66,67,68}; String s1 = new String(arr); //将数组变为字符，输出了abcd,编码转成了字节存储起来 System.out.println("s1="+s1); } String类的方法（常见功能）
按照面向对象的思想对字符串进行功能分类
字符串常见的操作方法：（String str = "hello java"）
1、获取。 1.1 字符串中的包含的字符数，也就是字符串的长度。 int length():获取长度。str.length()//结果为10 1.2 根据位置获取位置上某个字符。 char charAt(int index)://charAt(1)，结果是e 1.3 根据字符获取该字符在字符串中位置。//indexOf(’l‘)结果是2 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) ：从后往前找，但是字符串中的角标是没有变的。
System.out.println("substring:"+s.substring(2,4));//cd
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 判断字符串内容是否相同。复写了Object类中的equals方法。 boolean equals(str); 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，小于返回负数，且值为ASSII值之差。
private static void stringMethodDemo_4() { System.out.println("abc".compareTo("aqz")); } stringMethodDemo_4(); }
public class StringObjectDemo { public static void main(String[] args) { // String s1 = "abc"; // String s2 = "abc"; // intern():对字符串池进行操作的 String s1 = new String("abc"); String s2 = s1.intern(); System.out.println(s1 == s2); // false }}/*
* 提示：该行代码过长，系统自动注释不进行高亮。一键复制会移除系统注释
* public class StringDemo { public static void main(String[] args) { String str = "asdfghjaszxsa.java"; method_get(str); print("------------------------------------------"); method_is(str); print("------------------------------------------"); method_transform(str); print("------------------------------------------"); method_replace(str); print("------------------------------------------"); method_split(str); print("------------------------------------------"); method_sub(str); print("------------------------------------------"); method_change(); } /* * String获取方法 凡是获取的字符或者是字符串不存在，就返回-1 */ private static void method_get(String str) { // 获取字符串的长度 int length = str.length(); print("length: " + length); // 根据位置获取位置上的某个字符 char ch = str.charAt(1); print("ch: " + ch); // 根据字符获取该字符在字符串中的位置 int index = str.indexOf("index: " + 'a');// 获取该字符第一次出现的位置 print("index: " + index); // int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。 int indexf = str.indexOf('a', 2); print("indexf: " + indexf); // int indexOf(String str):返回的是str在字符串中第一次出现的位置。 int indexs = str.indexOf("as"); print("indexs: " + indexs); // int indexOf(String str, int fromIndex) // :从fromIndex指定位置开始，获取str在字符串中出现的位置。 int indexsf = str.indexOf("as", 3); print("indexsf: " + indexsf); // int lastIndexOf(int ch) int indexlast = str.lastIndexOf('a'); print("indexlast: " + indexlast); } /* * String中的判断 */ private static void method_is(String str) { // 字符串中是否包含某一个子串 /* * 特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。 * 所以，也可以用于对指定判断是否包含。 if(str.indexOf("aa")!=-1) 而且该方法即可以判断，有可以获取出现的位置。 */ boolean iscon = str.contains("asd"); print("iscon: " + iscon); // 字符中是否有内容。boolean isEmpty(): 原理就是判断长度是否为0. boolean isemp = str.isEmpty(); print("isemp: " + isemp); // 字符串是否是以指定内容开头。boolean startsWith(str); boolean start = str.startsWith("asd"); boolean startoffset = str.startsWith("sd", 1); print("start: " + start); print("startoffset: " + startoffset); // 字符串是否是以指定内容结尾。boolean endsWith(str); boolean end = str.endsWith(".java"); print("end: " + end); // 判断字符串内容是否相同。复写了Object类中的equals方法。boolean equals(str); boolean equal = str.equals("asdfghjaszxsa.java"); print("equal: " + equal); // 判断内容是否相同，并忽略大小写。boolean equalsIgnoreCase(); boolean equ = "AASD".equalsIgnoreCase("Aasd"); print("equ: " + equ); } /* * 转换 */ private static void method_transform(String str) { char[] chs = { 'a', 's', 'd', 'f', 'g' }; byte[] bts = { 'a', 's', 'd', 'f', 'g' }; // 将字符数组转成字符串 String trChStr = new String(chs); String trChStrO = new String(chs, 1, 3); print("trChStr: " + trChStr + "....trChStrO: " + trChStrO); String copyvalueof = String.copyValueOf(chs); print("copyvalueof: " + copyvalueof); // 将字符串转成字符数组**** char[] tochar = str.toCharArray(); for (int x = 0; x < tochar.length; x++) { print("char[" + x + "] = " + tochar[x]); } // 将字节数组转成字符串。 String trBtStr = new String(bts); String trBtStrO = new String(bts, 1, 3); print("trBtStr: " + trBtStr + "....trBtStrO: " + trBtStrO); // 将字符串转成字节数组。byte[] getBytes(): // 特殊：字符串和字节数组在转换过程中，是可以指定编码表的。 byte[] getBts = str.getBytes(); for (int x = 0; x < getBts.length; x++) { print("byte[" + x + "] = " + getBts[x]); } // 将基本数据类型转成字符串。static String valueOf(数据类型) // 3+"";//String.valueOf(3); String num = String.valueOf(2); print("num: " + num); } /* * 替换 */ private static void method_replace(String str) { // 如果要替换的字符不存在，返回的还是原串。 String newStr = str.replace('a', 'm');// 替换掉所有的该字符 print(str); print(newStr); String newSt = str.replace("asd", "qqq"); print(str); print(newSt); } /* * 切割 */ private static void method_split(String str) { // String[] split(regex); String[] strs = str.split("s"); for (int x = 0; x < strs.length; x++) { print("String[" + x + "] = " + strs[x]); } } /* * 获取字符串中的一部分 */ private static void method_sub(String str) { print(str.substring(2));// 从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。 print(str.substring(2, 4));// 包含头，不包含尾。s.substring(0,s.length()); } /* * 转换，去除空格，比较。 */ private static void method_change() { String s = " Hello Java "; print(s.toLowerCase());// 转小写 print(s.toUpperCase());// 转大写 print(s.trim());// 去空格 // 对两个字符串进行自然顺序的比较 String s1 = "aaa"; String s2 = "aaa"; print(s1.compareTo(s2));// 大于返回正数，小于返回负数，相等返回0 } private static void print(Object obj) { System.out.println(obj); }
*/System.out.println("abc".concat("kk"));连接字符串，没什么用，直接连就行
System.out.println("abc"+"kk");
System.out.println(String.valueOf(4)+1)；//41将基本数据类型变为字符串，再连接
System.out.println(""+4+1);和上一样
练习
* 1，给定一个字符串数组。按照字典顺序进行从小到大的排序。
* {"nba","abc","cba","zz","qq","haha"}
*
* 思路：
* 1,对数组排序。可以用选择，冒泡都行。
* 3,问题：以前排的是整数，比较用的比较运算符，可是现在是字符串对象。
* 字符串对象怎么比较呢？对象中提供了用于字符串对象比较的功能。
public class StringTest_1 { public static void main(String[] args) { String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" }; printArray(arr); // 原来的 sortString(arr); printArray(arr); // 比较后的 } public static void sortString(String[] arr) { for (int i = 0; i < arr.length - 1; i++) { for (int j = i + 1; j < arr.length; j++) { if (arr[i].compareTo(arr[j]) > 0)// 字符串比较用compareTo方法 swap(arr, i, j); } } } private static void swap(String[] arr, int i, int j) { String temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } public static void printArray(String[] arr) { System.out.print("["); for (int i = 0; i < arr.length; i++) { if (i != arr.length - 1) System.out.print(arr[i] + ", "); else System.out.println(arr[i] + "]"); } }}2，一个子串在整串中出现的次数。
* "nbaernbatynbauinbaopnba"
* 思路：
* 1，要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。
* 2，如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，
* 而剩余字符串的起始位是出现位置+子串的长度.
* 3,以此类推，通过循环完成查找，如果找不到就是-1，并对 每次找到用计数器记录。
public class StringTest_2 { public static void main(String[] args) { String str = "nbaernbatnbaynbauinbaopnba"; String key = "nba"; int count = getKeyStringCount_2(str, key); System.out.println("count=" + count); } public static int getKeyStringCount_2(String str, String key) { int count = 0; int index = 0; while ((index = str.indexOf(key, index)) != -1) { index = index + key.length(); count++; } return count; } /** * 获取子串在整串中出现的次数。 */ public static int getKeyStringCount(String str, String key) { // 1,定义计数器。 int count = 0; // 2，定义变量记录key出现的位置。 int index = 0; while ((index = str.indexOf(key)) != -1) { str = str.substring(index + key.length());//这个前面的str别不写 count++; } return count; }}* 3，两个字符串中最大相同的子串。
* "qwerabcdtyuiop"
* "xcabcdvbn"
*
* 思路：
* 1，既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。
* 如果存在，短的那个字符串就是最大子串。
* 2，如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。
* 如果存在就已找到，就不用在找了。
public class StringTest_3 { public static void main(String[] args) { String s1 = "qwerabcdtyuiop"; String s2 = "xcabcdvbn"; String s = getMaxSubstring(s2, s1); System.out.println("s=" + s); } /** * 获取最大子串 * * @param s1 * @param s2 * @return */ public static String getMaxSubstring(String s1, String s2) { String max = null, min = null; max = (s1.length() > s2.length()) ? s1 : s2; min = max.equals(s1) ? s2 : s1; System.out.println("max=" + max); System.out.println("min=" + min); for (int i = 0; i < min.length(); i++) { for (int a = 0, b = min.length() - i; b != min.length() + 1; a++, b++) { String sub = min.substring(a, b); // System.out.println(sub); if (max.contains(sub)) return sub; } } return null; }}* 4，模拟一个trim功能一致的方法。去除字符串两端的空白
* 思路：
* 1，定义两个变量。
* 一个变量作为从头开始判断字符串空格的角标。不断++。
* 一个变量作为从尾开始判断字符串空格的角标。不断--。
* 2,判断到不是空格为止，取头尾之间的字符串即可。
public class StringTest_4 { public static void main(String[] args) { String s = " ab c "; s = myTrim(s); System.out.println("-" + s + "-"); } public static String myTrim(String s) { int start = 0, end = s.length() - 1; while (start <= end && s.charAt(start) == ' ') { start++; } while (start <= end && s.charAt(end) == ' ') { end--; } return s.substring(start, end + 1); }}练习五：将字符串反转。
/* 思路： 1，将字符串变成数组。 2，对数组反转。 3，将数组变成字符串。 */ public class ReverseString { public static void main(String[] args) { String str = "shag klh"; String out = reverseString(str); System.out.println(out); } /* * 将字符串反转 */ private static String reverseString(String str) { // 将字符串变成数组 char[] chs = str.toCharArray(); // 将数组反正，也就是收尾调换 reverseArray(chs); return new String(chs); } private static void reverseArray(char[] chs) { char temp; for (int start = 0, end = chs.length - 1; start < end; start++, end--) { temp = chs[start]; chs[start] = chs[end]; chs[end] = temp; } } StringBuffer
* StringBuffer:就是字符串缓冲区。
* 用于存储数据的容器。
* 特点：
* 1，长度的可变的。
* 2，可以存储不同类型数据。
* 3，最终要通过toString方法变成字符串进行使用。
* 4，可以对字符串进行修改。
Stringbuffer类：可以被修改的字符序列
* 既然是一个容器对象。应该具备什么功能呢？
1、存储。 StringBuffer append():将指定数据作为参数添加到已有数据结尾处。不支持byte和char，需要对其进行转换才能操作。 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)//第一个参数是说StringBuffer 从哪开始取值，第二个就是在哪结束啦，第三个参数是插入到哪个数据，第四个是说从数组中的哪个索引开始插入。
*
* 增删改查 C(create)U(update)R(read)D(delete)
*
public class StringBufferDemo { public static void main(String[] args) { bufferMethodDemo_2(); } private static void bufferMethodDemo_2() { StringBuffer sb = new StringBuffer("abce"); // sb.delete(1, 3);//ae // 清空缓冲区 // sb.delete(0,sb.length()); // sb = new StringBuffer(); // sb.replace(1, 3, "nba"); // sb.setCharAt(2, 'q'); // sb.setLength(10); // System.out.println("sb:"+sb); // System.out.println("len:"+sb.length()); System.out.println(sb.reverse()); } private static void bufferMethodDemo_1() { StringBuffer sb = new StringBuffer("abce"); // sb.append("xixi"); sb.insert(2, "qq"); System.out.println(sb.toString()); } public static void bufferMethodDemo() { // 创建缓冲区对象。 StringBuffer sb = new StringBuffer(); sb.append(4).append(false);// .append("haha");输出4falsehahh，连起来了 sb.insert(1, "haha")；//4hahhfalse // sb.append(true);//4hahhfalsetru，一个一个append和.append效果一样 System.out.println(sb); }}StringBuilder
* jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder
* 不同的是：
* StringBuffer是线程同步的。通常用于多线程。
* StringBuilder是线程不同步的。通常用于单线程。 它的出现提高效率。
*
* jdk升级：
* 1，简化书写。
* 2，提高效率。
* 3，增加安全性。
eg：
public class StringBuilderTest { public static void main(String[] args) { int[] arr = { 3, 1, 5, 3, 8 }; String s = arrayToString_2(arr); System.out.println(s); } public static String arrayToString_2(int[] arr) { StringBuilder sb = new StringBuilder(); sb.append("["); for (int i = 0; i < arr.length; i++) { if (i != arr.length - 1) sb.append(arr[i] + ", "); else sb.append(arr[i] + "]"); } return sb.toString(); } /** * * 将一个int数组变成字符串。 */ public static String arrayToString(int[] arr) { String str = "["; for (int i = 0; i < arr.length; i++) { if (i != arr.length - 1) str += arr[i] + ", "; else str += arr[i] + "]"; } return str; }}public class StringBuilderTest { public static void main(String[] args) { StringBuilder s1 = new StringBuilder("hello"); StringBuilder s2 = new StringBuilder("java"); show(s1, s2); System.out.println(s1 + "......." + s2); } private static void show(StringBuilder s1, StringBuilder s2) { s1.append(s2); s1 = s2;//输出hellojava.......java
}}基本数据类型对象包装类
* 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。
* 用于描述该对象的类就称为基本数据类型对象包装类。
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* char Character
* boolean Boolean
* 该包装对象主要用基本类型和字符串之间的转换。
- 基本类型--->字符串
- 基本类型数值+""
- 用String类中的静态方法valueOf(基本类型数值);
- 用Integer的静态方法valueO(基本类型数值);
- 字符串--->基本类型
- 使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串");*****
* int parseInt("intstring");
* long parseLong("longstring");
* boolean parseBoolean("booleanstring");
* 只有Character没有parse方法
2.如果字符串被Integer进行对象的封装。
* 可使用另一个非静态的方法，intValue();
* 将一个Integer对象转成基本数据类型值。
System.out.println(Integer.MAX_VALUE);System.out.println(Integer.toBinaryString(-6)); int num = 4;Integer i = new Integer(5);int x = Integer.parseInt("123");System.out.println(Integer.parseInt("123")+1); Integer i = new Integer("123");
System.out.println(i.intValue());* 整数具备不同的进制体现。
*
* 十进制-->其他进制。
* toBinaryString
* toOctalString
* toHexString
*
* 其他进制-->十进制。
* parseInt("string",radix)
*
十进制-->其他进制。
System.out.println(Integer.toBinaryString(60)); System.out.println(Integer.toOctalString(60)); System.out.println(Integer.toHexString(60));// System.out.println(Integer.toString(60,16));其他进制-->十进制。
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)); // sop(Integer.toHexString(60)); int x = Integer.parseInt("3c",16); //后面传入前面是什么进制的 sop("x="+x);自动装箱拆箱
class IntegerDemo1 { public static void main(String[] args) { // Integer x = new Integer(4); Integer x = 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; 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)); sop("x.equals(y):"+x.equals(y)); }