java学习之路 之 Java常用类-字符串（String）类及练习题
字符串;
String类：构造字符串对象
常量对象：字符串常量对象是用双引号括起的字符序列。
例如："你好"、"12.97"、"boy"等。
字符串的字符使用Unicode字符编码，一个字符占两个字节
String类较常用构造方法:
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count);
String str = “abc”;与String str1 = new String(“abc”);的区别？
字符串的特性:
String是一个final类，代表不可变的字符序列
字符串是不可变的。一个字符串对象一旦被配置，其内容是不可变的。
判断：String s1 = "atguigu";
String s2 = "java";
String s4 = "java";
String s3 = new String("java");
System.out.println(s2 == s3);//false
System.out.println(s2 == s4);//true
System.out.println(s2.equals(s3));
String s5 = "atguigujava";
String s6 = (s1 + s2).intern();
System.out.println(s5 == s6);//true
System.out.println(s5.equals(s6));//true
字符串对象操作:
0123456789 11 14 17 21 25
" abcXXXyyyZZZ你好吗?我不好qqq "
public int length() // 26
public char charAt(int index) // 获取指定下标处的字符
public char[] toCharArray() // 把字符串转换为真的字符数组
public boolean equals(Object anObject)
public int compareTo(String anotherString)
public int indexOf(String s) // 判断参数中的子串在本字符串中首次出现的下标 indexOf("qqq"):21,indexOf("好"):15, indexOf("坏"):-1
public int indexOf(String s ,int startpoint) //indexOf("qqq", 10):21, indexOf("好", 18):20
public int lastIndexOf(String s) // lastIndexOf("qqq"):21, lastIndexOf("好"):20
public int lastIndexOf(String s ,int startpoint) // lastIndexOf("qqq", 5):-1, lastIndex("好", 17):15
public boolean startsWith(String prefix)//判断当前串是否是以参数中的子串为开始 statsWith("abc"):false,startsWith(" a"):true
public boolean endsWith(String suffix)
public String substring(int start,int end)//截取子串包含开始索引,不包含结束索引,获取子串,[start,end)
public String substring(int startpoint)
public String replace(char oldChar,char newChar) // 替换字符串中的全部老字符为新字符
public String replaceAll(String old,String new)
public String trim() // 去除字符串首尾的空白字符
public String concat(String str) // 连接当前串和参数中的串
public String[] split(String regex) // 把字符串以参数中的子串为切割器, 切割成若干部分 split("好");
字符串与基本数据的相互转化：
字符串转换为基本数据类型
Integer包装类的public static int parseInt(String s)：可以将由“数字”字符组成的字符串转换为整型。
类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。
基本数据类型转换为字符串
调用String类的public String valueOf(int n)可将int型转换为字符串相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double d)、
valueOf(boolean b)可由参数的相应类到字符串的转换
字符串与字符、字节数组：
String 类的构造方法：String(char[]) 和 String(char[]，int offset，int length) 分别用字符数组中的全部字符和部分字符创建字符串对象
String类提供了将字符串存放到数组中的方法：
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符串中的全部字符存放在一个字符数组中的方法：
public char[] toCharArray()
String(byte[])用指定的字节数组构造一个字符串对象。
String类：构造字符串对象
常量对象：字符串常量对象是用双引号括起的字符序列。
例如："你好"、"12.97"、"boy"等。
字符串的字符使用Unicode字符编码，一个字符占两个字节
String类较常用构造方法:
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count);
String str = “abc”;与String str1 = new String(“abc”);的区别？
字符串的特性:
String是一个final类，代表不可变的字符序列
字符串是不可变的。一个字符串对象一旦被配置，其内容是不可变的。
判断：String s1 = "atguigu";
String s2 = "java";
String s4 = "java";
String s3 = new String("java");
System.out.println(s2 == s3);//false
System.out.println(s2 == s4);//true
System.out.println(s2.equals(s3));
String s5 = "atguigujava";
String s6 = (s1 + s2).intern();
System.out.println(s5 == s6);//true
System.out.println(s5.equals(s6));//true
字符串对象操作:
0123456789 11 14 17 21 25
" abcXXXyyyZZZ你好吗?我不好qqq "
public int length() // 26
public char charAt(int index) // 获取指定下标处的字符
public char[] toCharArray() // 把字符串转换为真的字符数组
public boolean equals(Object anObject)
public int compareTo(String anotherString)
public int indexOf(String s) // 判断参数中的子串在本字符串中首次出现的下标 indexOf("qqq"):21,indexOf("好"):15, indexOf("坏"):-1
public int indexOf(String s ,int startpoint) //indexOf("qqq", 10):21, indexOf("好", 18):20
public int lastIndexOf(String s) // lastIndexOf("qqq"):21, lastIndexOf("好"):20
public int lastIndexOf(String s ,int startpoint) // lastIndexOf("qqq", 5):-1, lastIndex("好", 17):15
public boolean startsWith(String prefix)//判断当前串是否是以参数中的子串为开始 statsWith("abc"):false,startsWith(" a"):true
public boolean endsWith(String suffix)
public String substring(int start,int end)//截取子串包含开始索引,不包含结束索引,获取子串,[start,end)
public String substring(int startpoint)
public String replace(char oldChar,char newChar) // 替换字符串中的全部老字符为新字符
public String replaceAll(String old,String new)
public String trim() // 去除字符串首尾的空白字符
public String concat(String str) // 连接当前串和参数中的串
public String[] split(String regex) // 把字符串以参数中的子串为切割器, 切割成若干部分 split("好");
字符串与基本数据的相互转化：
字符串转换为基本数据类型
Integer包装类的public static int parseInt(String s)：可以将由“数字”字符组成的字符串转换为整型。
类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。
基本数据类型转换为字符串
调用String类的public String valueOf(int n)可将int型转换为字符串相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double d)、
valueOf(boolean b)可由参数的相应类到字符串的转换
字符串与字符、字节数组：
String 类的构造方法：String(char[]) 和 String(char[]，int offset，int length) 分别用字符数组中的全部字符和部分字符创建字符串对象
String类提供了将字符串存放到数组中的方法：
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符串中的全部字符存放在一个字符数组中的方法：
public char[] toCharArray()
String(byte[])用指定的字节数组构造一个字符串对象。
String(byte[]，int offset，int length) 用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。
public byte[] getBytes() 方法使用平台默认的字符编码，将当前字符串转化为一个字节数组。public byte[] getBytes(String charsetName) 使用参数指定字符编码，将当前字符串转化为一个字节数组。
String类练习题：
import org.junit.Test;
/** 字符串 :
* 是内容不可改变的Unicode字符序列
*
* 任何对于字符串内容的改变都将会产生新的字符串对象
*
* 0123456789 11 14 17 21 25
* " abcXXXyyyZZZ你好吗?我不好qqq "
* public int length() // 26
public char charAt(int index) // 获取指定下标处的字符
public char[] toCharArray() // 把字符串转换为真的字符数组
public boolean equals(Object anObject)
public int compareTo(String anotherString)
public int indexOf(String s) // 判断参数中的子串在本字符串中首次出现的下标 indexOf("qqq"):21, indexOf("好"):15, indexOf("坏"):-1
public int indexOf(String s ,int startpoint) //indexOf("qqq", 10):21, indexOf("好", 18):20
public int lastIndexOf(String s) // lastIndexOf("qqq"):21, lastIndexOf("好"):20
public int lastIndexOf(String s ,int startpoint) // lastIndexOf("qqq", 5):-1, lastIndex("好", 17):15
public boolean startsWith(String prefix)//判断当前串是否是以参数中的子串为开始 statsWith("abc"):false, startsWith(" a"):true
public boolean endsWith(String suffix)
public String substring(int start,int end)//截取子串包含开始索引,不包含结束索引,获取子串,[start,end)
public String substring(int startpoint)
public String replace(char oldChar,char newChar) // 替换字符串中的全部老字符为新字符
public String replaceAll(String old,String new)
public String trim() // 去除字符串首尾的空白字符
public String concat(String str) // 连接当前串和参数中的串
public String[] split(String regex) // 把字符串以参数中的子串为切割器, 切割成若干部分 split("好");
*/
public class StringTest {
@Test
public void exer7() {
String string3 = "张三,30,80;李四,40,70;王五,50,90;赵六,60,100";
String[] arr = string3.split(";");
Person[] persons = new Person[arr.length];
for (int i = 0; i < arr.length; i++) {
String[] arr2 = arr[i].split(",");
persons[i] = new Person(arr2[0], Integer.parseInt(arr2[1]), Integer.parseInt(arr2[2]));
}
for (Person person : persons) {
System.out.println(person);
}
}
@Test
public void test6() {
String string = "100,200,300,400,500,600";
String[] arr = string.split(",");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
String string2 = "张三,30,80";
String[] arr2 = string2.split(",");
Person person = new Person(arr2[0], Integer.parseInt(arr2[1]), Integer.parseInt(arr2[2]));
System.out.println(person);
}
//模拟一个trim方法，去除字符串两端的空白字符。
@Test
public void exer4() {
String string = " a ";
int begin = -1;
int end = string.length() - 1;
for (int i = 0; i < string.length(); i++) {
if (string.charAt(i) > 32) {
begin = i;
break;
}
}
for (int i = string.length() - 1; i >= 0; i--) {
if (string.charAt(i) > 32) {
end = i;
break;
}
}
if (begin == -1) {
System.out.println("");
} else {
String result = string.substring(begin, end + 1);
System.out.println(result);
}
}
@Test
public void test5() {
String string = " \n \t\t abcXXXyyyZZZ你好吗?我不好qqq \t\r\n";
System.out.println(string.substring(10, 21));
// 截取从Z开始到末尾
System.out.println(string.substring(11, string.length()));
System.out.println(string.substring(11)); // 和上面的效果一样
String newStr = string.replace(' ', '*');
System.out.println(newStr);
String newStr2 = string.replaceAll("好", "坏");
System.out.println(newStr2);
String newStr3 = string.trim();
System.out.println(newStr3);
String newStr4 = newStr3.concat("100");
System.out.println(newStr4);
}
@Test // 反例
public void test4() {
String string = "abc";
for (int i = 0; i < 10000000; i++) {
string += i;
}
System.out.println(string);
}
/**
* 求短串在长串中出现的次数
* @param string1
* @param string2
* @return
*/
public int getCountOfSubstring(String string1, String string2) {
if (string2.length() > string1.length()) {
String tmp = string1;
string1 = string2;
string2 = tmp;
}
int count = 0;
int index = 0;
while (true) {
// 去尝试查找子串
index = string1.indexOf(string2, index);
if (index == -1) {
break;
}
count++;
index++;
}
return count;
}
@Test
public void exer3() {
/*获取一个字符串在另一个字符串中出现的次数。
比如：获取"ab"在 "abkkcadkabkebfkabkskab"
中出现的次数*/
String string1 = "aaaaa";
String string2 = "aa";
int count = getCountOfSubstring(string2, string1);
System.out.println(count);
}
@Test
public void test3() {
//String(char[] value, int offset, int count)
char[] arr = {'a','b','你','他','嘿','来'};
String string = new String(arr);
System.out.println(string);
String string2 = new String(arr, 2, 3); // 2是开始下标,3是总共的字符数
System.out.println(string2);
String string3 = new String("abcccc");
System.out.println(string3);
String string4 = new String(arr, 0, arr.length);
System.out.println(string4);
}
@Test
public void test2() {
String string = " abcXXXyyyZZZ你好吗?我不好qqq ";
System.out.println(string.length());
System.out.println(string.charAt(18));
System.out.println("--------------------");
for (int i = 0; i < string.length(); i++) {
char ch = string.charAt(i);
System.out.println(ch);
}
// 把字符串变成全部大写的
}
@Test
public void exer2() {
// 把字符串反转成新的字符串
String string = " abcXXXyyyZZZ你好吗?我不好qqq ";
String newStr = "";
for (int i = string.length() - 1; i >= 0; i--) {
newStr += string.charAt(i);
}
System.out.println(newStr);
}
@Test
public void exer22() {
// 把字符串反转成新的字符串
String string = " abcXXXyyyZZZ你好吗?我不好qqq ";
String newStr = "";
for (int i = 0; i < string.length(); i++) {
newStr = string.charAt(i) + newStr;
}
System.out.println(newStr);
}
@Test
public void exer23() {
// 把字符串反转成新的字符串
String string = " abcXXXyyyZZZ你好吗?我不好qqq ";
char[] arr = string.toCharArray();
for (int i = 0; i < arr.length / 2; i++) {
char tmp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = tmp;
}
String newStr = new String(arr);
System.out.println(newStr);
}
@Test
public void exer1() {
// 把字符串变成全部大写的
String string = " abcXXXyyyZZZ你好吗?我不好qqq ";
String newStr = "";
for (int i = 0; i < string.length(); i++) {
char ch = string.charAt(i);
if (ch >= 'a' && ch <= 'z') {
// 变成大写
ch -= 32;
}
newStr += ch;
}
System.out.println(newStr);
}
@Test
public void test1() {
String string = "abc";
string += 100; // string = string + 100;
System.out.println(string);
}
}
public class Person {
private String name;
private int age;
private double weight;
public Person() {
}
public Person(String name, int age, double weight) {
super();
this.name = name;
this.age = age;
this.weight = weight;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", weight=" + weight
+ "]";
}
}
package com.guigu.javase.home;
import org.junit.Test;
public class HomeWork {
@Test
public void work1() {
String path = "D:\\MyWork\\jdk1.7.0_07\\bin;c:\\gtk\\bin;c:\\app\\Administrator\\product\\11.2.0\\dbhome_1\\bin;c:\\gtk\\bin;C:\\Windows\\system32;C:\\Windows;C:\\Windows\\System32\\Wbem;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\Program Files (x86)\\Intel\\OpenCL SDK\\3.0\\bin\\x86;C:\\Program Files (x86)\\Intel\\OpenCL SDK\\3.0\\bin\\x64;;C:\\Program Files\\Intel\\WiFi\\bin\\;C:\\Program Files\\Common Files\\Intel\\WirelessCommon\\;D:\\MyStudy\\maven\\apache-maven-3.3.9\\bin";
String[] pathArr = path.split(";");
for (String string : pathArr) {
System.out.println(string);
}
}
public String partReverse(String string, int begin, int end) {
String str1 = string.substring(0, begin);
String str2 = string.substring(begin, end);
String str3 = string.substring(end);
str2 = new StringBuilder(str2).reverse().toString();
return (str1 + str2 + str3);
}
@Test
public void work2() {
//将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”
System.out.println(partReverse("abcdefg22222cccc", 3, 6));
}
@Test
public void work3() {
//获取两个字符串中最大相同子串。比如：
String str1 = "abcwerthelloyuiodef";
String str2 = "cvhellobnm";
System.out.println(getMaxSameSub(str2, str1));
}
public String getMaxSameSub(String str1, String str2) {
int maxSubLen = str2.length();
while (maxSubLen > 0) {
for (int i = 0; i + maxSubLen <= str2.length(); i++) {
String subString = str2.substring(i, i + maxSubLen);
if (str1.indexOf(subString) != -1) {
return subString;
}
}
maxSubLen--;
}
return "";
}
}