学习常用类、集合、IO
打印文件:按键精灵
一、常用类
import org.junit.Test;
/**
*String的使用
* @author wangwu
* @create 2021.2.12
*/
public class StringTest {
/*
String:字符串,使用一对""来表示
1.String声明为final的，不可被继承
2.String实现了Serializable接口：表示字符串是支持序列化的。
实现了Comparable接口：表示String可以比较大小
3.String内部定义了final char[]value用于存储字符串数据（加了常量final表示数组不能被重新赋值了，数组的元素也不能被修改了）
4.String：代表不可变的字符序列。简称：不可变性
体现：
1.当字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
3.当调用String的replace（）方法修改指定的字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
5.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中
6.字符串常量池中是不会存储相同内容的字符串的。
*/
@Test
public void test1(){
String s1 = "abc";//字面量
String s2 = "abc";
s1 = "hello";
System.out.println(s1 == s2);//比较s1和s2的地址值
System.out.println(s1);//hello
System.out.println(s2);//abc
System.out.println("--------------------");
String s3 = "abc";
s3 += "def";
System.out.println(s3);//abcdef
System.out.println(s2);
System.out.println("--------------------");
String s4 = "abc";
String s5 = s4.replace('a', 'm');//replace:修改字符串中的字符
System.out.println(s4);//abc
System.out.println(s5);//mbc
}
}
/*
false
hello
abc
--------------------
abcdef
abc
--------------------
abc
mbc
*/
public class StringTest {
/*
String的实例化方式：
方式一：通过字面量定义的方式
方式二：通过new+构造器的方式
面试题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？
两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据"abc"
*/
@Test
public void test2(){
//通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量值中
String s1 = "javaEE";
String s2 = "javaEE";
//通过new+构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后
String s3 = new String("javaEE");
String s4 = new String("javaEE");
System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false
System.out.println(s1 == s4);//false
System.out.println(s3 == s4);//false
System.out.println("-------------------");
Person p1 = new Person("Tom",20);
Person p2 = new Person("Tom",21);
System.out.println(p1.name.equals(p2.name));//true
System.out.println(p2.name == p1.name);//true
p1.name = "jerry";
System.out.println(p2.name);//Tom
}
/*
true
false
false
false
-------------------
true
true
Tom
*/
public class StringTest {
/*
结论：
1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中有一个是变量，结果就在堆中。
3.如果拼接的结果调用intern()方法，返回值就在常量池中
*/
@Test
public void test3(){
String s1 = "javaEE";
String s2 = "hadoop";
String s3 = "javaEEhadoop";//字面量
String s4 = "javaEE" + "hadoop";//字面量
String s5 = s1 + "hadoop";//变量名参与，不在常量池，需要在堆空间中去开辟
String s6 = "javaEE" + s2;
String s7 = s1 + s2;
System.out.println(s3 == s4);//true
System.out.println(s3 == s5);//false
System.out.println(s3 == s6);//false
System.out.println(s3 == s7);//false
System.out.println(s5 == s6);//false
System.out.println(s5 == s7);//false
System.out.println(s6 == s7);//false
String s8 = s7.intern();//intern:调用String中的一个方法
//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
System.out.println(s3 == s8);//true
}
String的一道面试题
s=s+i s + = i
+=：为变量的拼接，在堆里面进行新造
public class StringTest {
String str = new String("good");//str的不可变性
char[] ch = {'t','e','s','t'};
public void change(String str,char ch[]){//参数的值传递机制：实际参数值的副本传入方法内，而参数本身不受影响
str = "test ok";
ch[0] = 'b';//数组改变
}
public static void main(String[] args){
StringTest ex = new StringTest();
ex.change(ex.str,ex.ch);
System.out.println(ex.str);//good
System.out.println(ex.ch);//best
}
}
三种 JVM
- Sun公司的HotSpot
- BEA公司的 JRockit
- IBM公司的 J9 VM
1、字符串常用的类
String的常用方法1
import org.junit.Test;
public class StringMethodTest {
/*
*/
@Test
public void test2(){
//boolean equalsIgnoreCase(String anotherString):与equals方法类似忽略大小写
String s1 = "LIsi";
String s2 = "lisi";
// String s3 = s1.equalsIgnoreCase();
System.out.println(s1.equals(s2));//false
System.out.println(s1.equalsIgnoreCase(s2));//true
System.out.println(s2);//lisi
System.out.println("---------------------");
//String concat(String str):将指定字符串连接到此字符串的结尾。等价于“+”
String s3 = "abc";
String s4 = s3.concat("def");
System.out.println(s4);//abcdef
System.out.println("---------------------");
//int compareTo(String anotherString):比较两个字符串的大小
String s5 = "abc";//c的十进制为99
String s6 = new String("abe");//e的十进制为101
System.out.println(s5.compareTo(s6));//-2 涉及到字符串排序
System.out.println(s6.compareTo(s5));//2
System.out.println(s6.compareTo(s6));//0
System.out.println("---------------------");
//String substring(int beginIndex):返回一个新的字符串，他是此字符串从beginIndex开始截取到最后的一个子字符串
String s7 = "光明教育出版社";
String s8 = s7.substring(4);
System.out.println(s7);//光明教育出版社
System.out.println(s8);//出版社
System.out.println("---------------------");
//String substring(int beginIndex,int endIndex):返回一个新的字符串，他是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串
String s9 = s7.substring(2, 4);
System.out.println(s9);//教育
}
@Test
public void test1(){
String s1 = "HelloWorld";
//int length():返回字符串的长度：return value.length
System.out.println(s1.length());//10
//char charAt(int index):返回某索引处的字符return value[index]
System.out.println(s1.charAt(0));//H
System.out.println(s1.charAt(9));//d
// System.out.println(s1.charAt(10));//String index out of range: 10
// s1 = "";//true
//boolean isEmpty():判断是否是空字符串：return value.length == 0
System.out.println(s1.isEmpty());//false
System.out.println("---------------------");
//String toLowerCase():使用默认语言环境，将String 中的所有字符转换为小写
String s2 = s1.toLowerCase();
System.out.println(s1);//s1不可变的，仍然为原来的字符串
System.out.println(s2);//改成小写以后的字符串
System.out.println("---------------------");
//String toUpperCase():使用默认语言环境，将String 中的所有字符转换为大写
String s3 = s1.toUpperCase();
System.out.println(s1);//HelloWorld
System.out.println(s3);//HELLOWORLD
System.out.println("---------------------");
String s4 = " he ll o w o r ld ";
//String trim():返回字符串的副本，忽略前导空白和尾部空白
String s5 = s4.trim();
System.out.println("------" + s4 + "--------");//------ he ll o w o r ld --------
System.out.println("------" + s5 + "--------");//------he ll o w o r ld--------
System.out.println("---------------------");
//boolean equals(object obj):比较字符串的内容是否相同
String A = "wangwu";
String B = "wangwu";
System.out.println(A.equals(B));//true
}
}
String的常用方法2
import org.junit.Test;
public class Demo01 {
/*
*/
@Test
public void test1(){
// boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
String str1 = "hello world";
boolean b1 = str1.endsWith("rld");//对末尾结束的字符没有特别要求，几个都可以
System.out.println(b1);//true
System.out.println("-------------------");
// boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
boolean b2 = str1.startsWith("HE");
System.out.println(b2);//false
System.out.println("-------------------");
// boolean startsWith(String prefix,int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
boolean b3 = str1.startsWith("ll",2);//在字符串hello world中从第二个字符开始是以ll开头的
System.out.println(b3);//true
System.out.println("-------------------");
// boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时，返回true
String str2 = "wo";
System.out.println(str1.contains(str2));//true 判断str1中是非包含str2中的内容
System.out.println("-------------------");
// int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
System.out.println(str1.indexOf("ld"));//9 在hello world中ld首次出现的数
System.out.println(str1.indexOf("lol"));//-1 找不到就显示-1错误，返回值类型为整形
System.out.println("-------------------");
// int indexOf(String str,int fromIndex):返回指定子字符串在此字符串中第一次出现的索引,从指定的索引开始
System.out.println(str1.indexOf("ld",5));//9 从第五个字符开始往后找ld
System.out.println("-------------------");
// int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
String str3 = "hellorwwwwworld";
System.out.println(str3.lastIndexOf("or"));//11 从后往前找查看or最右边出现的位置
System.out.println("-------------------");
// int lastIndexOf(String str,int formIndex):返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
System.out.println(str3.lastIndexOf("l",10));//3 从右往左搜索，最后一个字符10开始往左查找l的位置
//什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？
//情况一：存在唯一的一个str。 情况二：不存在str
}
}
String的常用方法3
import org.junit.Test;
public class Demo02 {
@Test
public void test(){
//String replace(char oldChar,char newChar):返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的
String str1 = "清华大学出版社清华";
String str2 = str1.replace('清', '菁');
System.out.println(str2);//菁华大学出版社菁华
//String replace(CharSequence target,CharSequence replacement):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串
String str3 = str1.replace("清华", "beijing");//返回值为str3
System.out.println(str3);//beijing大学出版社beijing
System.out.println("-------------------");
//String replaceAll(String regex,String replacement):使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串
String str = "12hello34world5java7891mysql456";
//把字符串中的数字替换成逗号，如果结果中开头和结尾有逗号的话去掉
String string = str.replaceAll("\\d+",",").replaceAll("^,|,$","");
//正则表达式 \\d+:一个或多个数字；出现数字的情况把它替换成逗号
//"^,|,$":表示开头有逗号，或者结尾有逗号；把开头或结尾的逗号都替换掉
System.out.println(string);
//String replaceFirst(String regex,String replacement):使用给定的replacement替换子字符串匹配给定的正则表达式的第一个子字符串
String s = str.replaceFirst("hello", "w");
System.out.println(s);//12w34world5java7891mysql456 直接将hello替换成w字符
System.out.println("-------------------");
//boolean matches(String regex):告知此字符串是否匹配给定的正则表达式
String s1 = "hello world";
System.out.println(s1.matches("hello world"));//true
str = "12345w";
//判断str字符中是否全部有数字组成，即有1-n个数字组成
boolean matches = str.matches("\\d+");
System.out.println(matches);//false
String tel = "0516-88290503";
//判断这是否 是一个徐州的固定电话
boolean matches1 = tel.matches("0516-\\d{7,8}");
System.out.println(matches1);//true
System.out.println("-------------------");
//String[] split(String regex):根据给定正则表达式的匹配拆分此字符串
str = "hello|world|java";
String[] strs = str.split("\\|");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
System.out.println();
System.out.println("-------------------");
//String[] split(String regex,int limit):根据匹配的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
str = "hello.world.java";
String[] strs1 = str.split("\\.");
for (int i = 0; i < strs1.length; i++) {
System.out.println(strs1[i]);
}
}
}
/*
菁华大学出版社菁华
beijing大学出版社beijing
-------------------
hello,world,java,mysql
12w34world5java7891mysql456
-------------------
true
false
true
-------------------
hello
world
java
-------------------
hello
world
java
*/
二、复习
import org.junit.Test;
/*
涉及到String类与其他结构之间的转换
*/
public class StringTest1 {
/*
String与基本数据类型、包装类之间的转换。
String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
基本数据类型、包装类 --> String:调用String重载的valueOf(xxx)
*/
/*
String 与char[]之间的转换
String --> char[]:调用String的toCharArray()
char[] -->String:调用String的构造器
*/
@Test
public void test2(){
String str1 = "abc123";
char[] charArray = str1.toCharArray();
for (int i = 0; i < charArray.length; i++) {
System.out.println(charArray[i]);
}
char[] arr = new char[]{'h','e','l','l','o'};
String str2 = new String(arr);
System.out.println(str2);//hello
}
@Test
public void test1(){
String str1 = "123";//在常量池中
// int num = (int)str1;//错误的 只有子父类关系才可以进行强制转换
//调用包装类的静态方法：parseXxx(str)
int num = Integer.parseInt(str1);
//String:调用String重载的valueOf(xxx)
String str2 = String.valueOf(num);//"123"
String str3 = num + "";//在堆中：有变量参与
System.out.println(str1 == str3);//false
}
}
import org.junit.Test;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class Demo03 {
/*
String 与byte[]之间的转换
String --> byte[]:调用String的getBytes()
byte[] --> String:调用String的构造器
编码：字符串 --> 字节（看的懂得 -->看不懂的二进制数据）
解码：编码的逆过程，字节 -->（看不懂的二进制数据 --> 看得懂的）
说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码
*/
@Test
public void test1() throws UnsupportedEncodingException {//抛出异常
String str = "abc123";
byte[] A = str.getBytes();//使用默认的字符集，进行转换
System.out.println(Arrays.toString(A));//输出ASCII的值： [97, 98, 99, 49, 50, 51]
String str1 = "abc清华";
byte[] B = str1.getBytes();
System.out.println(Arrays.toString(B));//报错： [97, 98, 99, -26, -72, -123, -27, -115, -114]
System.out.println("---------------");
byte[] gbks = str1.getBytes("gbk");//不支持的编码集 使用gbk字符集进行编码 一个汉字，两个字符
//在GBK中一个汉字占两个字节 在utf-8一个汉字占三个字节
System.out.println(Arrays.toString(gbks));//[97, 98, 99, -57, -27, -69, -86]
System.out.println("---------------");
String str2 = new String(B);//使用默认的字符集进行解码
System.out.println(str2);//abc清华
String str3 = new String(gbks);
System.out.println(str3);//abc�廪 出现乱码。原因：编码集和解码集不一致！
String str4 = new String(gbks, "gbk");
System.out.println(str4);//abc清华 没有出现乱码。原因：编码集和解码集一致！
}
}
@Test
public void test2(){
String s1 = "javaEEhadoop";
String s2 = "javaEE";
String s3 = s2 + "hadoop";
System.out.println(s1 == s3);//false
final String s4 = "javaEE";//s4:常量
String s5 = s4 + "hadoop";
System.out.println(s1 == s5);//true
}
常见的算法题
-
模拟一个trim方法，去除字符串两端的空格
-
将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为“abfedcg”
-
获取一个字符串在另一个字符串中出现的次数。
比如：获取“ab”在“abkkcadkabkebfkabkskab”中出现的次数
-
获取两个字符串中最大相同子串。比如：
str1 = “abcwerthelloyuiodef”;str2 = “cvhellobnm”
提示：将短的那个串进行长度依次递减的子串与较长的串比较。
-
对字符串中字符进行自然顺序排序。
提示：
- 字符串变成字符数组
- 对数组排序，选择，冒泡，Arrays.sort();
- 将排序后的数组变成字符串。
import org.junit.Test;
public class Demo04 {
/*
常见的算法面试题：
1.模拟一个trim方法，去除字符串两端的空格
2.将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为“abfedcg”
3.获取一个字符串在另一个字符串中出现的次数。
比如：获取“ab”在“abkkcadkabkebfkabkskab”中出现的次数
4.获取两个字符串中最大相同子串。比如：
str1 = “abcwerthelloyuiodef”;str2 = "cvhellobnm"
提示：将短的那个串进行长度依次递减的子串与较长的串比较。
5.对字符串中字符进行自然顺序排序。
提示：
1. 字符串变成字符数组
2. 对数组排序，选择，冒泡，Arrays.sort();
3. 将排序后的数组变成字符串。
*/
@Test
public void test1(){
//1.模拟一个trim方法，去除字符串两端的空格
String str = " hel lo,worl d ";
String trim = str.trim();
System.out.println("-----"+str+"-----");//----- hel lo,worl d -----
System.out.println("-----"+trim+"-----");//-----hel lo,worl d-----
System.out.println("~~~~~~~~~~~~~~~~");
//2.将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为“abfedcg”
/*String str1 = "abcdefg";
String replace = str1.replace("cdefg", "fedcg");//进行字符串的替换
System.out.println(replace);//abfedcg
String replace1 = str1.replace("abc", "asd");
System.out.println(replace1);//asddefg
*/
import org.junit.Test;
public class StringDemo {
//2.将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为“abfedcg”
//方式一：转换为char[]
public String reverse(String str,int startIndex,int endIndex){
if(str != null){
char[] arr = str.toCharArray();//字符串转换为char[]
for(int x = startIndex,y = endIndex;x < y;x++,y--){
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
return new String(arr);
}
return null;
}
//方式二：使用String的拼接
public String reverse1(String str,int startIndex,int endIndex){
if(str != null){
//第一部分
String reverseStr = str.substring(0,startIndex);
//第二部分
for (int i = endIndex; i > startIndex; i--) {
reverseStr += str.charAt(i);
}
//第三部分
reverseStr += str.substring(endIndex+1);
return reverseStr;
}
return null;
}
//方式三：使用StringBuffer/StringBuilder替换String
public String reverse2(String str,int startIndex,int endIndex){
if(str != null){
StringBuilder builder = new StringBuilder(str.length());
//第一部分
builder.append(str.substring(0,startIndex));
//第二部分
for (int i = endIndex; i >= startIndex ; i--) {
builder.append(str.charAt(i));
}
//第三部分
builder.append(str.substring(endIndex + 1));
return builder.toString();
}
return null;
}
@Test
public void testReverse(){
String str = "abcdefg";
String reverse = reverse2(str, 2, 5);
System.out.println(reverse);//abfedcg
}
}
System.out.println("~~~~~~~~~~~~~~~~");
//3.获取一个字符串在另一个字符串中出现的次数。
//比如：获取“ab”在“abkkcadkabkebfkabkskab”中出现的次数
String s1 = "abkkcadkabkebfkabkskab";
String s2 = "ab";
int counts = 0;
int site;
while((site = s1.indexOf(s2))!= -1){//indexOf:返回指定子字符串在此字符串中第一次出现的索引
s1 = s1.substring(site+s2.length());//substring:它是此字符串从beginIndex开始截取到最后一个子字符串，
counts++;
}
System.out.println("ab出现的次数为："+counts);//ab出现的次数为：4
// int ab = str2.indexOf("ab");
// System.out.println(ab);
/*
4.获取两个字符串中最大相同子串。比如：
str1 = “abcwerthelloyuiodef”;str2 = "cvhellobnm"
提示：将短的那个串进行长度依次递减的子串与较长的串比较。
*/
/*
5.对字符串中字符进行自然顺序排序。
提示：
1. 字符串变成字符数组
2. 对数组排序，选择，冒泡，Arrays.sort();
3. 将排序后的数组变成字符串。
*/
}
}
707
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
