字符串:就是由多个字符组成的一串数据。也可以看成是一个字符数组。
构造方法:
* public String():空构造* public String(byte[] bytes):把字节数组转成字符串
* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
* public String(char[] value):把字符数组转成字符串
* public String(char[] value,int index,int count):把字符数组的一部分转成字符串
* public String(String original):把字符串常量值转成字符串
*
* 字符串的方法:
* public int length():返回此字符串的长度。
-
package String;
-
-
/*
-
* 字符串:就是由多个字符组成的一串数据。也可以看成是一个字符数组。
-
* 通过查看API,我们可以知道
-
* A:字符串字面值"abc"也可以看成是一个字符串对象。
-
* B:字符串是常量,一旦被赋值,就不能被改变。
-
*
-
* 构造方法:
-
* public String():空构造
-
* public String(byte[] bytes):把字节数组转成字符串
-
* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
-
* public String(char[] value):把字符数组转成字符串
-
* public String(char[] value,int index,int count):把字符数组的一部分转成字符串
-
* public String(String original):把字符串常量值转成字符串
-
*
-
* 字符串的方法:
-
* public int length():返回此字符串的长度。
-
*/
-
public
class Demo1 {
-
public static void main(String[] args) {
-
// public String():空构造
-
String s1 =
new String();
-
System.out.println(
"s1:" + s1);
-
System.out.println(
"s1.length():" + s1.length());
-
System.out.println(
"--------------------------");
-
-
// public String(byte[] bytes):把字节数组转成字符串
-
-
String s2 =
new String(bys);
-
System.out.println(
"s2:" + s2);
-
System.out.println(
"s2.length():" + s2.length());
-
System.out.println(
"--------------------------");
-
-
// public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
-
// 我想得到字符串"bcd"
-
String s3 =
new String(bys,
1,
3);
-
System.out.println(
"s3:" + s3);
-
System.out.println(
"s3.length():" + s3.length());
-
System.out.println(
"--------------------------");
-
-
// public String(char[] value):把字符数组转成字符串
-
char[] chs = {
'a',
'b',
'c',
'd',
'e',
'爱',
'林',
'亲' };
-
String s4 =
new String(chs);
-
System.out.println(
"s4:" + s4);
-
System.out.println(
"s4.length():" + s4.length());
-
System.out.println(
"--------------------------");
-
-
// public String(char[] value,int index,int count):把字符数组的一部分转成字符串
-
String s5 =
new String(chs,
2,
4);
-
System.out.println(
"s5:" + s5);
-
System.out.println(
"s5.length():" + s5.length());
-
System.out.println(
"--------------------------");
-
-
//public String(String original):把字符串常量值转成字符串
-
String s6 =
new String(
"abcde");
-
System.out.println(
"s6:" + s6);
-
System.out.println(
"s6.length():" + s6.length());
-
System.out.println(
"--------------------------");
-
-
//字符串字面值"abc"也可以看成是一个字符串对象。
-
String s7 =
"abcde";
-
System.out.println(
"s7:"+s7);
-
System.out.println(
"s7.length():"+s7.length());
-
}
-
}
String s = new String(“hello”)和String s = “hello”;的区别?
有。前者会创建2个对象,后者创建1个对象。
*
* ==:比较引用类型比较的是地址值是否相同
* equals:比较引用类型默认也是比较地址值是否相同,而String类重写了equals()方法,比较的是内容是否相同。
-
package String;
-
/*
-
* String s = new String(“hello”)和String s = “hello”;的区别?
-
* 有。前者会创建2个对象,后者创建1个对象。
-
*
-
* ==:比较引用类型比较的是地址值是否相同
-
* equals:比较引用类型默认也是比较地址值是否相同,而String类重写了equals()方法,比较的是内容是否相同。
-
*/
-
public
class Demo2 {
-
public static void main(String[] args) {
-
String s1 =
new String(
"hello");
-
String s2 =
"hello";
-
-
System.out.println(s1 == s2);
// false
-
System.out.println(s1.equals(s2));
// true
-
}
-
}
字符串如果是变量相加,先开空间,在拼接。
字符串如果是常量相加,是先加,然后在常量池找,如果有就直接返回,否则,就创建
-
package String;
-
/*
-
* 看程序写结果
-
* 字符串如果是变量相加,先开空间,在拼接。
-
* 字符串如果是常量相加,是先加,然后在常量池找,如果有就直接返回,否则,就创建。
-
*/
-
public
class Demo3 {
-
public static void main(String[] args) {
-
String s1 =
"hello";
-
String s2 =
"world";
-
String s3 =
"helloworld";
-
System.out.println(s3 == s1 + s2);
// false
-
System.out.println(s3.equals(s1 + s2));
// true
-
-
System.out.println(s3 ==
"hello" +
"world");
// false 这个我们错了,应该是true
-
System.out.println(s3.equals(
"hello" +
"world"));
// true
-
-
// 通过反编译看源码,我们知道这里已经做好了处理。
-
// System.out.println(s3 == "helloworld");
-
// System.out.println(s3.equals("helloworld"));
-
}
-
}
String类的判断功能:
* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
* boolean contains(String str):判断大字符串中是否包含小字符串
* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
* boolean isEmpty():判断字符串是否为空。
-
package String;
-
/*
-
* String类的判断功能:
-
* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
-
* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
-
* boolean contains(String str):判断大字符串中是否包含小字符串
-
* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
-
* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
-
* boolean isEmpty():判断字符串是否为空。
-
*
-
* 注意:
-
* 字符串内容为空和字符串对象为空。
-
* String s = "";
-
* String s = null;
-
*/
-
public
class Demo4 {
-
public static void main(String[] args) {
-
// 创建字符串对象
-
String s1 =
"helloworld";
-
String s2 =
"helloworld";
-
String s3 =
"HelloWorld";
-
-
// boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
-
System.out.println(
"equals:" + s1.equals(s2));
-
System.out.println(
"equals:" + s1.equals(s3));
-
System.out.println(
"-----------------------");
-
-
// boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
-
System.out.println(
"equals:" + s1.equalsIgnoreCase(s2));
-
System.out.println(
"equals:" + s1.equalsIgnoreCase(s3));
-
System.out.println(
"-----------------------");
-
-
// boolean contains(String str):判断大字符串中是否包含小字符串
-
System.out.println(
"contains:" + s1.contains(
"hello"));
-
System.out.println(
"contains:" + s1.contains(
"hw"));
-
System.out.println(
"-----------------------");
-
-
// boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
-
System.out.println(
"startsWith:" + s1.startsWith(
"h"));
-
System.out.println(
"startsWith:" + s1.startsWith(
"hello"));
-
System.out.println(
"startsWith:" + s1.startsWith(
"world"));
-
System.out.println(
"-----------------------");
-
-
// 练习:boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾这个自己玩
-
-
// boolean isEmpty():判断字符串是否为空。
-
System.out.println(
"isEmpty:" + s1.isEmpty());
-
-
String s4 =
"";
-
String s5 =
;
-
System.out.println(
"isEmpty:" + s4.isEmpty());
-
// NullPointerException
-
// s5对象都不存在,所以不能调用方法,空指针异常
-
//System.out.println("isEmpty:" + s5.isEmpty());
-
}
-
}
String类的获取功能
* int length():获取字符串的长度。* char charAt(int index):获取指定索引位置的字符
* int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
* 为什么这里是int类型,而不是char类型?
* 原因是:'a'和97其实都可以代表'a'
* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
* String substring(int start):从指定位置开始截取字符串,默认到末尾。
* String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
*/
-
package String;
-
/*
-
* String类的获取功能
-
* int length():获取字符串的长度。
-
* char charAt(int index):获取指定索引位置的字符
-
* int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
-
* 为什么这里是int类型,而不是char类型?
-
* 原因是:'a'和97其实都可以代表'a'
-
* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
-
* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
-
* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
-
* String substring(int start):从指定位置开始截取字符串,默认到末尾。
-
* String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
-
*/
-
public
class Demo5 {
-
public static void main(String[] args) {
-
// 定义一个字符串对象
-
String s =
"helloworld";
-
-
// int length():获取字符串的长度。
-
System.out.println(
"s.length:" + s.length());
-
System.out.println(
"----------------------");
-
-
// char charAt(int index):获取指定索引位置的字符
-
System.out.println(
"charAt:" + s.charAt(
7));
-
System.out.println(
"----------------------");
-
-
// int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
-
System.out.println(
"indexOf:" + s.indexOf(
'l'));
-
System.out.println(
"----------------------");
-
-
// int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
-
System.out.println(
"indexOf:" + s.indexOf(
"owo"));
-
System.out.println(
"----------------------");
-
-
// int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
-
System.out.println(
"indexOf:" + s.indexOf(
'l',
4));
-
System.out.println(
"indexOf:" + s.indexOf(
'k',
4));
// -1
-
System.out.println(
"indexOf:" + s.indexOf(
'l',
40));
// -1
-
System.out.println(
"----------------------");
-
-
// 自己练习:int indexOf(String str,int
-
// fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
-
-
// String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
-
System.out.println(
"substring:" + s.substring(
5));
-
System.out.println(
"substring:" + s.substring(
0));
-
System.out.println(
"----------------------");
-
-
// String substring(int start,int
-
// end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引
-
System.out.println(
"substring:" + s.substring(
3,
8));
-
System.out.println(
"substring:" + s.substring(
0, s.length()));
-
}
-
}
需求:遍历获取字符串中的每一个字符
** 分析:
* A:如何能够拿到每一个字符呢?
* char charAt(int index)
* B:我怎么知道字符到底有多少个呢?
* int length()
-
package String;
-
/*
-
* 需求:遍历获取字符串中的每一个字符
-
*
-
* 分析:
-
* A:如何能够拿到每一个字符呢?
-
* char charAt(int index)
-
* B:我怎么知道字符到底有多少个呢?
-
* int length()
-
*/
-
public
class Demo6 {
-
public static void main(String[] args) {
-
// 定义字符串
-
String s =
"helloworld";
-
-
// 原始版本
-
// System.out.println(s.charAt(0));
-
// System.out.println(s.charAt(1));
-
// System.out.println(s.charAt(2));
-
// System.out.println(s.charAt(3));
-
// System.out.println(s.charAt(4));
-
// System.out.println(s.charAt(5));
-
// System.out.println(s.charAt(6));
-
// System.out.println(s.charAt(7));
-
// System.out.println(s.charAt(8));
-
// System.out.println(s.charAt(9));
-
-
// 只需要我们从0取到9
-
// for (int x = 0; x < 10; x++) {
-
// System.out.println(s.charAt(x));
-
// }
-
-
// 如果长度特别长,我不可能去数,所以我们要用长度功能
-
for (
int x =
0; x < s.length(); x++) {
-
// char ch = s.charAt(x);
-
// System.out.println(ch);
-
// 仅仅是输出,我就直接输出了
-
System.out.println(s.charAt(x));
-
}
-
}
-
}
需求:统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)
* 举例:* "Hello123World"
* 结果:
* 大写字符:2个
* 小写字符:8个
* 数字字符:3个
*
* 分析:
* 前提:字符串要存在
* A:定义三个统计变量
* bigCount=0
* smallCount=0
* numberCount=0
* B:遍历字符串,得到每一个字符。
* length()和charAt()结合
* C:判断该字符到底是属于那种类型的
* 大:bigCount++
* 小:smallCount++
* 数字:numberCount++
*
* 这道题目的难点就是如何判断某个字符是大的,还是小的,还是数字的。
* ASCII码表:
* 0 48
* A 65
* a 97
* 虽然,我们按照数字的这种比较是可以的,但是想多了,有比这还简单的
* char ch = s.charAt(x);
*
* if(ch>='0' && ch<='9') numberCount++
* if(ch>='a' && ch<='z') smallCount++
* if(ch>='A' && ch<='Z') bigCount++
* D:输出结果。
-
package String;
-
/*
-
* 需求:统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)
-
* 举例:
-
* "Hello123World"
-
* 结果:
-
* 大写字符:2个
-
* 小写字符:8个
-
* 数字字符:3个
-
*
-
* 分析:
-
* 前提:字符串要存在
-
* A:定义三个统计变量
-
* bigCount=0
-
* smallCount=0
-
* numberCount=0
-
* B:遍历字符串,得到每一个字符。
-
* length()和charAt()结合
-
* C:判断该字符到底是属于那种类型的
-
* 大:bigCount++
-
* 小:smallCount++
-
* 数字:numberCount++
-
*
-
* 这道题目的难点就是如何判断某个字符是大的,还是小的,还是数字的。
-
* ASCII码表:
-
* 0 48
-
* A 65
-
* a 97
-
* 虽然,我们按照数字的这种比较是可以的,但是想多了,有比这还简单的
-
* char ch = s.charAt(x);
-
*
-
* if(ch>='0' && ch<='9') numberCount++
-
* if(ch>='a' && ch<='z') smallCount++
-
* if(ch>='A' && ch<='Z') bigCount++
-
* D:输出结果。
-
*
-
* 练习:把给定字符串的方式,改进为键盘录入字符串的方式。
-
*/
-
public
class Demo7 {
-
public static void main(String[] args) {
-
//定义一个字符串
-
String s =
"Hello123World";
-
-
//定义三个统计变量
-
int bigCount =
0;
-
int smallCount =
0;
-
int numberCount =
0;
-
-
//遍历字符串,得到每一个字符。
-
for(
int x=
0; x<s.length(); x++){
-
char ch = s.charAt(x);
-
-
//判断该字符到底是属于那种类型的
-
if(ch>=
'a' && ch<=
'z'){
-
smallCount++;
-
}
else
if(ch>=
'A' && ch<=
'Z'){
-
bigCount++;
-
}
else
if(ch>=
'0' && ch<=
'9'){
-
numberCount++;
-
}
-
}
-
-
//输出结果。
-
System.out.println(
"大写字母"+bigCount+
"个");
-
System.out.println(
"小写字母"+smallCount+
"个");
-
System.out.println(
"数字"+numberCount+
"个");
-
}
-
}
-
String的转换功能:
* byte[] getBytes():把字符串转换为字节数组。* char[] toCharArray():把字符串转换为字符数组。
* static String valueOf(char[] chs):把字符数组转成字符串。
* static String valueOf(int i):把int类型的数据转成字符串。
* 注意:String类的valueOf方法可以把任意类型的数据转成字符串。
* String toLowerCase():把字符串转成小写。
* String toUpperCase():把字符串转成大写。
* String concat(String str):把字符串拼接。
-
package String;
-
/*
-
* String的转换功能:
-
* byte[] getBytes():把字符串转换为字节数组。
-
* char[] toCharArray():把字符串转换为字符数组。
-
* static String valueOf(char[] chs):把字符数组转成字符串。
-
* static String valueOf(int i):把int类型的数据转成字符串。
-
* 注意:String类的valueOf方法可以把任意类型的数据转成字符串。
-
* String toLowerCase():把字符串转成小写。
-
* String toUpperCase():把字符串转成大写。
-
* String concat(String str):把字符串拼接。
-
*/
-
public
class Demo8 {
-
public static void main(String[] args) {
-
// 定义一个字符串对象
-
String s =
"JavaSE";
-
-
// byte[] getBytes():把字符串转换为字节数组。
-
byte[] bys = s.getBytes();
-
for (
int x =
0; x < bys.length; x++) {
-
System.out.println(bys[x]);
-
}
-
System.out.println(
"----------------");
-
-
// char[] toCharArray():把字符串转换为字符数组。
-
char[] chs = s.toCharArray();
-
for (
int x =
0; x < chs.length; x++) {
-
System.out.println(chs[x]);
-
}
-
System.out.println(
"----------------");
-
-
// static String valueOf(char[] chs):把字符数组转成字符串。
-
String ss = String.valueOf(chs);
-
System.out.println(ss);
-
System.out.println(
"----------------");
-
-
// static String valueOf(int i):把int类型的数据转成字符串。
-
int i =
100;
-
String sss = String.valueOf(i);
-
System.out.println(sss);
-
System.out.println(
"----------------");
-
-
// String toLowerCase():把字符串转成小写。
-
System.out.println(
"toLowerCase:" + s.toLowerCase());
-
System.out.println(
"s:" + s);
-
// System.out.println("----------------");
-
// String toUpperCase():把字符串转成大写。
-
System.out.println(
"toUpperCase:" + s.toUpperCase());
-
System.out.println(
"----------------");
-
-
// String concat(String str):把字符串拼接。
-
String s1 =
"hello";
-
String s2 =
"world";
-
String s3 = s1 + s2;
-
String s4 = s1.concat(s2);
-
System.out.println(
"s3:"+s3);
-
System.out.println(
"s4:"+s4);
-
}
-
}
-
需求:把一个字符串的首字母转成大写,其余为小写。(只考虑英文大小写字母字符)
* 举例:* helloWORLD
* 结果:
* Helloworld
*
* 分析:
* A:先获取第一个字符
* B:获取除了第一个字符以外的字符
* C:把A转成大写
* D:把B转成小写
* E:C拼接D
-
package String;
-
/*
-
* 需求:把一个字符串的首字母转成大写,其余为小写。(只考虑英文大小写字母字符)
-
* 举例:
-
* helloWORLD
-
* 结果:
-
* Helloworld
-
*
-
* 分析:
-
* A:先获取第一个字符
-
* B:获取除了第一个字符以外的字符
-
* C:把A转成大写
-
* D:把B转成小写
-
* E:C拼接D
-
*/
-
public
class Demo9 {
-
public static void main(String[] args) {
-
// 定义一个字符串
-
String s =
"helloWORLD";
-
-
// 先获取第一个字符
-
String s1 = s.substring(
0,
1);
-
// 获取除了第一个字符以外的字符
-
String s2 = s.substring(
1);
-
// 把A转成大写
-
String s3 = s1.toUpperCase();
-
// 把B转成小写
-
String s4 = s2.toLowerCase();
-
// C拼接D
-
String s5 = s3.concat(s4);
-
System.out.println(s5);
-
-
// 优化后的代码
-
// 链式编程
-
String result = s.substring(
0,
1).toUpperCase()
-
.concat(s.substring(
1).toLowerCase());
-
System.out.println(result);
-
}
-
}
-
String类的其他功能:
** 替换功能:
* String replace(char old,char new)
* String replace(String old,String new)
*
* 去除字符串两空格
* String trim()
*
* 按字典顺序比较两个字符串
* int compareTo(String str)
* int compareToIgnoreCase(String str)
-
package String;
-
/*
-
* String类的其他功能:
-
*
-
* 替换功能:
-
* String replace(char old,char new)
-
* String replace(String old,String new)
-
*
-
* 去除字符串两空格
-
* String trim()
-
*
-
* 按字典顺序比较两个字符串
-
* int compareTo(String str)
-
* int compareToIgnoreCase(String str)
-
*/
-
public
class Demo10 {
-
public static void main(String[] args) {
-
// 替换功能
-
String s1 =
"helloworld";
-
String s2 = s1.replace(
'l',
'k');
-
String s3 = s1.replace(
"owo",
"ak47");
-
System.out.println(
"s1:" + s1);
-
System.out.println(
"s2:" + s2);
-
System.out.println(
"s3:" + s3);
-
System.out.println(
"---------------");
-
-
// 去除字符串两空格
-
String s4 =
" hello world ";
-
String s5 = s4.trim();
-
System.out.println(
"s4:" + s4 +
"---");
-
System.out.println(
"s5:" + s5 +
"---");
-
-
// 按字典顺序比较两个字符串
-
String s6 =
"hello";
-
String s7 =
"hello";
-
String s8 =
"abc";
-
String s9 =
"xyz";
-
System.out.println(s6.compareTo(s7));
// 0
-
System.out.println(s6.compareTo(s8));
// 7
-
System.out.println(s6.compareTo(s9));
// -16
-
}
-
}
-
需求:把数组中的数据按照指定个格式拼接成一个字符串
* 举例:* int[] arr = {1,2,3};
* 输出结果:
* "[1, 2, 3]"
* 分析:
* A:定义一个字符串对象,只不过内容为空
* B:先把字符串拼接一个"["
* C:遍历int数组,得到每一个元素
* D:先判断该元素是否为最后一个
* 是:就直接拼接元素和"]"
* 不是:就拼接元素和逗号以及空格
* E:输出拼接后的字符串
-
package String;
-
/*
-
* 需求:把数组中的数据按照指定个格式拼接成一个字符串
-
* 举例:
-
* int[] arr = {1,2,3};
-
* 输出结果:
-
* "[1, 2, 3]"
-
* 分析:
-
* A:定义一个字符串对象,只不过内容为空
-
* B:先把字符串拼接一个"["
-
* C:遍历int数组,得到每一个元素
-
* D:先判断该元素是否为最后一个
-
* 是:就直接拼接元素和"]"
-
* 不是:就拼接元素和逗号以及空格
-
* E:输出拼接后的字符串
-
*/
-
public
class demo11 {
-
public static void main(String[] args) {
-
// 前提是数组已经存在
-
int[] arr = {
1,
2,
3 };
-
-
// 定义一个字符串对象,只不过内容为空
-
String s =
"";
-
-
// 先把字符串拼接一个"["
-
s +=
"[";
-
-
// 遍历int数组,得到每一个元素
-
for (
int x =
0; x < arr.length; x++) {
-
// 先判断该元素是否为最后一个
-
if (x == arr.length -
1) {
-
// 就直接拼接元素和"]"
-
s += arr[x];
-
s +=
"]";
-
}
else {
-
// 就拼接元素和逗号以及空格
-
s += arr[x];
-
s +=
", ";
-
}
-
}
-
-
// 输出拼接后的字符串
-
System.out.println(
"最终的字符串是:" + s);
-
}
-
}
-
字符串反转
* 举例:键盘录入”abc”* 输出结果:” cba”
*
* 分析:
* A:键盘录入一个字符串
* B:定义一个新字符串
* C:倒着遍历字符串,得到每一个字符
* a:length()和charAt()结合
* b:把字符串转成字符数组
* D:用新字符串把每一个字符拼接起来
* E:输出新串
-
package String;
-
/*
-
* 字符串反转
-
* 举例:键盘录入”abc”
-
* 输出结果:”cba”
-
*
-
* 分析:
-
* A:键盘录入一个字符串
-
* B:定义一个新字符串
-
* C:倒着遍历字符串,得到每一个字符
-
* a:length()和charAt()结合
-
* b:把字符串转成字符数组
-
* D:用新字符串把每一个字符拼接起来
-
* E:输出新串
-
*/
-
public
class Demo12 {
-
public static void main(String[] args) {
-
// 键盘录入一个字符串
-
Scanner sc =
new Scanner(System.in);
-
System.out.println(
"请输入一个字符串:");
-
String line = sc.nextLine();
-
-
/*
-
// 定义一个新字符串
-
String result = "";
-
-
// 把字符串转成字符数组
-
char[] chs = line.toCharArray();
-
-
// 倒着遍历字符串,得到每一个字符
-
for (int x = chs.length - 1; x >= 0; x--) {
-
// 用新字符串把每一个字符拼接起来
-
result += chs[x];
-
}
-
-
// 输出新串
-
System.out.println("反转后的结果是:" + result);
-
*/
-
-
// 改进为功能实现
-
String s = myReverse(line);
-
System.out.println(
"实现功能后的结果是:" + s);
-
}
-
-
/*
-
* 两个明确: 返回值类型:String 参数列表:String
-
*/
-
public static String myReverse(String s) {
-
// 定义一个新字符串
-
String result =
"";
-
-
// 把字符串转成字符数组
-
char[] chs = s.toCharArray();
-
-
// 倒着遍历字符串,得到每一个字符
-
for (
int x = chs.length -
1; x >=
0; x--) {
-
// 用新字符串把每一个字符拼接起来
-
result += chs[x];
-
}
-
return result;
-
}
-
}
统计大串中小串出现的次数
-
package String;
-
-
-
/*
-
* 统计大串中小串出现的次数
-
* 举例:
-
* 在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
-
* 结果:
-
* java出现了5次
-
*
-
* 分析:
-
* 前提:是已经知道了大串和小串。
-
*
-
* A:定义一个统计变量,初始化值是0
-
* B:先在大串中查找一次小串第一次出现的位置
-
* a:索引是-1,说明不存在了,就返回统计变量
-
* b:索引不是-1,说明存在,统计变量++
-
* C:把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
-
* D:回到B
-
*/
-
public
class Demo13 {
-
public static void main(String[] args) {
-
// 定义大串
-
String maxString =
"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
-
// 定义小串
-
String minString =
"java";
-
-
-
// 写功能实现
-
int count = getCount(maxString, minString);
-
System.out.println(
"Java在大串中出现了:" + count +
"次");
-
}
-
-
-
/*
-
* 两个明确: 返回值类型:int 参数列表:两个字符串
-
*/
-
public static int getCount(String maxString, String minString) {
-
// 定义一个统计变量,初始化值是0
-
int count =
0;
-
-
-
/*
-
// 先在大串中查找一次小串第一次出现的位置
-
int index = maxString.indexOf(minString);
-
// 索引不是-1,说明存在,统计变量++
-
while (index != -1) {
-
count++;
-
// 把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
-
// int startIndex = index + minString.length();
-
// maxString = maxString.substring(startIndex);
-
maxString = maxString.substring(index + minString.length());
-
// 继续查
-
index = maxString.indexOf(minString);
-
}
-
*/
-
-
int index;
-
//先查,赋值,判断
-
while((index=maxString.indexOf(minString))!=-
1){
-
count++;
-
maxString = maxString.substring(index + minString.length());
-
}
-
-
-
return count;
-
}
-
}
字符串:就是由多个字符组成的一串数据。也可以看成是一个字符数组。
构造方法:
* public String():空构造* public String(byte[] bytes):把字节数组转成字符串
* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
* public String(char[] value):把字符数组转成字符串
* public String(char[] value,int index,int count):把字符数组的一部分转成字符串
* public String(String original):把字符串常量值转成字符串
*
* 字符串的方法:
* public int length():返回此字符串的长度。
-
package String;
-
-
/*
-
* 字符串:就是由多个字符组成的一串数据。也可以看成是一个字符数组。
-
* 通过查看API,我们可以知道
-
* A:字符串字面值"abc"也可以看成是一个字符串对象。
-
* B:字符串是常量,一旦被赋值,就不能被改变。
-
*
-
* 构造方法:
-
* public String():空构造
-
* public String(byte[] bytes):把字节数组转成字符串
-
* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
-
* public String(char[] value):把字符数组转成字符串
-
* public String(char[] value,int index,int count):把字符数组的一部分转成字符串
-
* public String(String original):把字符串常量值转成字符串
-
*
-
* 字符串的方法:
-
* public int length():返回此字符串的长度。
-
*/
-
public
class Demo1 {
-
public static void main(String[] args) {
-
// public String():空构造
-
String s1 =
new String();
-
System.out.println(
"s1:" + s1);
-
System.out.println(
"s1.length():" + s1.length());
-
System.out.println(
"--------------------------");
-
-
// public String(byte[] bytes):把字节数组转成字符串
-
-
String s2 =
new String(bys);
-
System.out.println(
"s2:" + s2);
-
System.out.println(
"s2.length():" + s2.length());
-
System.out.println(
"--------------------------");
-
-
// public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
-
// 我想得到字符串"bcd"
-
String s3 =
new String(bys,
1,
3);
-
System.out.println(
"s3:" + s3);
-
System.out.println(
"s3.length():" + s3.length());
-
System.out.println(
"--------------------------");
-
-
// public String(char[] value):把字符数组转成字符串
-
char[] chs = {
'a',
'b',
'c',
'd',
'e',
'爱',
'林',
'亲' };
-
String s4 =
new String(chs);
-
System.out.println(
"s4:" + s4);
-
System.out.println(
"s4.length():" + s4.length());
-
System.out.println(
"--------------------------");
-
-
// public String(char[] value,int index,int count):把字符数组的一部分转成字符串
-
String s5 =
new String(chs,
2,
4);
-
System.out.println(
"s5:" + s5);
-
System.out.println(
"s5.length():" + s5.length());
-
System.out.println(
"--------------------------");
-
-
//public String(String original):把字符串常量值转成字符串
-
String s6 =
new String(
"abcde");
-
System.out.println(
"s6:" + s6);
-
System.out.println(
"s6.length():" + s6.length());
-
System.out.println(
"--------------------------");
-
-
//字符串字面值"abc"也可以看成是一个字符串对象。
-
String s7 =
"abcde";
-
System.out.println(
"s7:"+s7);
-
System.out.println(
"s7.length():"+s7.length());
-
}
-
}
String s = new String(“hello”)和String s = “hello”;的区别?
有。前者会创建2个对象,后者创建1个对象。
*
* ==:比较引用类型比较的是地址值是否相同
* equals:比较引用类型默认也是比较地址值是否相同,而String类重写了equals()方法,比较的是内容是否相同。
-
package String;
-
/*
-
* String s = new String(“hello”)和String s = “hello”;的区别?
-
* 有。前者会创建2个对象,后者创建1个对象。
-
*
-
* ==:比较引用类型比较的是地址值是否相同
-
* equals:比较引用类型默认也是比较地址值是否相同,而String类重写了equals()方法,比较的是内容是否相同。
-
*/
-
public
class Demo2 {
-
public static void main(String[] args) {
-
String s1 =
new String(
"hello");
-
String s2 =
"hello";
-
-
System.out.println(s1 == s2);
// false
-
System.out.println(s1.equals(s2));
// true
-
}
-
}
字符串如果是变量相加,先开空间,在拼接。
字符串如果是常量相加,是先加,然后在常量池找,如果有就直接返回,否则,就创建
-
package String;
-
/*
-
* 看程序写结果
-
* 字符串如果是变量相加,先开空间,在拼接。
-
* 字符串如果是常量相加,是先加,然后在常量池找,如果有就直接返回,否则,就创建。
-
*/
-
public
class Demo3 {
-
public static void main(String[] args) {
-
String s1 =
"hello";
-
String s2 =
"world";
-
String s3 =
"helloworld";
-
System.out.println(s3 == s1 + s2);
// false
-
System.out.println(s3.equals(s1 + s2));
// true
-
-
System.out.println(s3 ==
"hello" +
"world");
// false 这个我们错了,应该是true
-
System.out.println(s3.equals(
"hello" +
"world"));
// true
-
-
// 通过反编译看源码,我们知道这里已经做好了处理。
-
// System.out.println(s3 == "helloworld");
-
// System.out.println(s3.equals("helloworld"));
-
}
-
}
String类的判断功能:
* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
* boolean contains(String str):判断大字符串中是否包含小字符串
* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
* boolean isEmpty():判断字符串是否为空。
-
package String;
-
/*
-
* String类的判断功能:
-
* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
-
* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
-
* boolean contains(String str):判断大字符串中是否包含小字符串
-
* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
-
* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
-
* boolean isEmpty():判断字符串是否为空。
-
*
-
* 注意:
-
* 字符串内容为空和字符串对象为空。
-
* String s = "";
-
* String s = null;
-
*/
-
public
class Demo4 {
-
public static void main(String[] args) {
-
// 创建字符串对象
-
String s1 =
"helloworld";
-
String s2 =
"helloworld";
-
String s3 =
"HelloWorld";
-
-
// boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
-
System.out.println(
"equals:" + s1.equals(s2));
-
System.out.println(
"equals:" + s1.equals(s3));
-
System.out.println(
"-----------------------");
-
-
// boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
-
System.out.println(
"equals:" + s1.equalsIgnoreCase(s2));
-
System.out.println(
"equals:" + s1.equalsIgnoreCase(s3));
-
System.out.println(
"-----------------------");
-
-
// boolean contains(String str):判断大字符串中是否包含小字符串
-
System.out.println(
"contains:" + s1.contains(
"hello"));
-
System.out.println(
"contains:" + s1.contains(
"hw"));
-
System.out.println(
"-----------------------");
-
-
// boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
-
System.out.println(
"startsWith:" + s1.startsWith(
"h"));
-
System.out.println(
"startsWith:" + s1.startsWith(
"hello"));
-
System.out.println(
"startsWith:" + s1.startsWith(
"world"));
-
System.out.println(
"-----------------------");
-
-
// 练习:boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾这个自己玩
-
-
// boolean isEmpty():判断字符串是否为空。
-
System.out.println(
"isEmpty:" + s1.isEmpty());
-
-
String s4 =
"";
-
String s5 =
;
-
System.out.println(
"isEmpty:" + s4.isEmpty());
-
// NullPointerException
-
// s5对象都不存在,所以不能调用方法,空指针异常
-
//System.out.println("isEmpty:" + s5.isEmpty());
-
}
-
}
String类的获取功能
* int length():获取字符串的长度。* char charAt(int index):获取指定索引位置的字符
* int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
* 为什么这里是int类型,而不是char类型?
* 原因是:'a'和97其实都可以代表'a'
* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
* String substring(int start):从指定位置开始截取字符串,默认到末尾。
* String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
*/
-
package String;
-
/*
-
* String类的获取功能
-
* int length():获取字符串的长度。
-
* char charAt(int index):获取指定索引位置的字符
-
* int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
-
* 为什么这里是int类型,而不是char类型?
-
* 原因是:'a'和97其实都可以代表'a'
-
* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
-
* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
-
* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
-
* String substring(int start):从指定位置开始截取字符串,默认到末尾。
-
* String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
-
*/
-
public
class Demo5 {
-
public static void main(String[] args) {
-
// 定义一个字符串对象
-
String s =
"helloworld";
-
-
// int length():获取字符串的长度。
-
System.out.println(
"s.length:" + s.length());
-
System.out.println(
"----------------------");
-
-
// char charAt(int index):获取指定索引位置的字符
-
System.out.println(
"charAt:" + s.charAt(
7));
-
System.out.println(
"----------------------");
-
-
// int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
-
System.out.println(
"indexOf:" + s.indexOf(
'l'));
-
System.out.println(
"----------------------");
-
-
// int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
-
System.out.println(
"indexOf:" + s.indexOf(
"owo"));
-
System.out.println(
"----------------------");
-
-
// int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
-
System.out.println(
"indexOf:" + s.indexOf(
'l',
4));
-
System.out.println(
"indexOf:" + s.indexOf(
'k',
4));
// -1
-
System.out.println(
"indexOf:" + s.indexOf(
'l',
40));
// -1
-
System.out.println(
"----------------------");
-
-
// 自己练习:int indexOf(String str,int
-
// fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
-
-
// String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
-
System.out.println(
"substring:" + s.substring(
5));
-
System.out.println(
"substring:" + s.substring(
0));
-
System.out.println(
"----------------------");
-
-
// String substring(int start,int
-
// end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引
-
System.out.println(
"substring:" + s.substring(
3,
8));
-
System.out.println(
"substring:" + s.substring(
0, s.length()));
-
}
-
}
需求:遍历获取字符串中的每一个字符
** 分析:
* A:如何能够拿到每一个字符呢?
* char charAt(int index)
* B:我怎么知道字符到底有多少个呢?
* int length()
-
package String;
-
/*
-
* 需求:遍历获取字符串中的每一个字符
-
*
-
* 分析:
-
* A:如何能够拿到每一个字符呢?
-
* char charAt(int index)
-
* B:我怎么知道字符到底有多少个呢?
-
* int length()
-
*/
-
public
class Demo6 {
-
public static void main(String[] args) {
-
// 定义字符串
-
String s =
"helloworld";
-
-
// 原始版本
-
// System.out.println(s.charAt(0));
-
// System.out.println(s.charAt(1));
-
// System.out.println(s.charAt(2));
-
// System.out.println(s.charAt(3));
-
// System.out.println(s.charAt(4));
-
// System.out.println(s.charAt(5));
-
// System.out.println(s.charAt(6));
-
// System.out.println(s.charAt(7));
-
// System.out.println(s.charAt(8));
-
// System.out.println(s.charAt(9));
-
-
// 只需要我们从0取到9
-
// for (int x = 0; x < 10; x++) {
-
// System.out.println(s.charAt(x));
-
// }
-
-
// 如果长度特别长,我不可能去数,所以我们要用长度功能
-
for (
int x =
0; x < s.length(); x++) {
-
// char ch = s.charAt(x);
-
// System.out.println(ch);
-
// 仅仅是输出,我就直接输出了
-
System.out.println(s.charAt(x));
-
}
-
}
-
}
需求:统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)
* 举例:* "Hello123World"
* 结果:
* 大写字符:2个
* 小写字符:8个
* 数字字符:3个
*
* 分析:
* 前提:字符串要存在
* A:定义三个统计变量
* bigCount=0
* smallCount=0
* numberCount=0
* B:遍历字符串,得到每一个字符。
* length()和charAt()结合
* C:判断该字符到底是属于那种类型的
* 大:bigCount++
* 小:smallCount++
* 数字:numberCount++
*
* 这道题目的难点就是如何判断某个字符是大的,还是小的,还是数字的。
* ASCII码表:
* 0 48
* A 65
* a 97
* 虽然,我们按照数字的这种比较是可以的,但是想多了,有比这还简单的
* char ch = s.charAt(x);
*
* if(ch>='0' && ch<='9') numberCount++
* if(ch>='a' && ch<='z') smallCount++
* if(ch>='A' && ch<='Z') bigCount++
* D:输出结果。
-
package String;
-
/*
-
* 需求:统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)
-
* 举例:
-
* "Hello123World"
-
* 结果:
-
* 大写字符:2个
-
* 小写字符:8个
-
* 数字字符:3个
-
*
-
* 分析:
-
* 前提:字符串要存在
-
* A:定义三个统计变量
-
* bigCount=0
-
* smallCount=0
-
* numberCount=0
-
* B:遍历字符串,得到每一个字符。
-
* length()和charAt()结合
-
* C:判断该字符到底是属于那种类型的
-
* 大:bigCount++
-
* 小:smallCount++
-
* 数字:numberCount++
-
*
-
* 这道题目的难点就是如何判断某个字符是大的,还是小的,还是数字的。
-
* ASCII码表:
-
* 0 48
-
* A 65
-
* a 97
-
* 虽然,我们按照数字的这种比较是可以的,但是想多了,有比这还简单的
-
* char ch = s.charAt(x);
-
*
-
* if(ch>='0' && ch<='9') numberCount++
-
* if(ch>='a' && ch<='z') smallCount++
-
* if(ch>='A' && ch<='Z') bigCount++
-
* D:输出结果。
-
*
-
* 练习:把给定字符串的方式,改进为键盘录入字符串的方式。
-
*/
-
public
class Demo7 {
-
public static void main(String[] args) {
-
//定义一个字符串
-
String s =
"Hello123World";
-
-
//定义三个统计变量
-
int bigCount =
0;
-
int smallCount =
0;
-
int numberCount =
0;
-
-
//遍历字符串,得到每一个字符。
-
for(
int x=
0; x<s.length(); x++){
-
char ch = s.charAt(x);
-
-
//判断该字符到底是属于那种类型的
-
if(ch>=
'a' && ch<=
'z'){
-
smallCount++;
-
}
else
if(ch>=
'A' && ch<=
'Z'){
-
bigCount++;
-
}
else
if(ch>=
'0' && ch<=
'9'){
-
numberCount++;
-
}
-
}
-
-
//输出结果。
-
System.out.println(
"大写字母"+bigCount+
"个");
-
System.out.println(
"小写字母"+smallCount+
"个");
-
System.out.println(
"数字"+numberCount+
"个");
-
}
-
}
-
String的转换功能:
* byte[] getBytes():把字符串转换为字节数组。* char[] toCharArray():把字符串转换为字符数组。
* static String valueOf(char[] chs):把字符数组转成字符串。
* static String valueOf(int i):把int类型的数据转成字符串。
* 注意:String类的valueOf方法可以把任意类型的数据转成字符串。
* String toLowerCase():把字符串转成小写。
* String toUpperCase():把字符串转成大写。
* String concat(String str):把字符串拼接。
-
package String;
-
/*
-
* String的转换功能:
-
* byte[] getBytes():把字符串转换为字节数组。
-
* char[] toCharArray():把字符串转换为字符数组。
-
* static String valueOf(char[] chs):把字符数组转成字符串。
-
* static String valueOf(int i):把int类型的数据转成字符串。
-
* 注意:String类的valueOf方法可以把任意类型的数据转成字符串。
-
* String toLowerCase():把字符串转成小写。
-
* String toUpperCase():把字符串转成大写。
-
* String concat(String str):把字符串拼接。
-
*/
-
public
class Demo8 {
-
public static void main(String[] args) {
-
// 定义一个字符串对象
-
String s =
"JavaSE";
-
-
// byte[] getBytes():把字符串转换为字节数组。
-
byte[] bys = s.getBytes();
-
for (
int x =
0; x < bys.length; x++) {
-
System.out.println(bys[x]);
-
}
-
System.out.println(
"----------------");
-
-
// char[] toCharArray():把字符串转换为字符数组。
-
char[] chs = s.toCharArray();
-
for (
int x =
0; x < chs.length; x++) {
-
System.out.println(chs[x]);
-
}
-
System.out.println(
"----------------");
-
-
// static String valueOf(char[] chs):把字符数组转成字符串。
-
String ss = String.valueOf(chs);
-
System.out.println(ss);
-
System.out.println(
"----------------");
-
-
// static String valueOf(int i):把int类型的数据转成字符串。
-
int i =
100;
-
String sss = String.valueOf(i);
-
System.out.println(sss);
-
System.out.println(
"----------------");
-
-
// String toLowerCase():把字符串转成小写。
-
System.out.println(
"toLowerCase:" + s.toLowerCase());
-
System.out.println(
"s:" + s);
-
// System.out.println("----------------");
-
// String toUpperCase():把字符串转成大写。
-
System.out.println(
"toUpperCase:" + s.toUpperCase());
-
System.out.println(
"----------------");
-
-
// String concat(String str):把字符串拼接。
-
String s1 =
"hello";
-
String s2 =
"world";
-
String s3 = s1 + s2;
-
String s4 = s1.concat(s2);
-
System.out.println(
"s3:"+s3);
-
System.out.println(
"s4:"+s4);
-
}
-
}
-
需求:把一个字符串的首字母转成大写,其余为小写。(只考虑英文大小写字母字符)
* 举例:* helloWORLD
* 结果:
* Helloworld
*
* 分析:
* A:先获取第一个字符
* B:获取除了第一个字符以外的字符
* C:把A转成大写
* D:把B转成小写
* E:C拼接D
-
package String;
-
/*
-
* 需求:把一个字符串的首字母转成大写,其余为小写。(只考虑英文大小写字母字符)
-
* 举例:
-
* helloWORLD
-
* 结果:
-
* Helloworld
-
*
-
* 分析:
-
* A:先获取第一个字符
-
* B:获取除了第一个字符以外的字符
-
* C:把A转成大写
-
* D:把B转成小写
-
* E:C拼接D
-
*/
-
public
class Demo9 {
-
public static void main(String[] args) {
-
// 定义一个字符串
-
String s =
"helloWORLD";
-
-
// 先获取第一个字符
-
String s1 = s.substring(
0,
1);
-
// 获取除了第一个字符以外的字符
-
String s2 = s.substring(
1);
-
// 把A转成大写
-
String s3 = s1.toUpperCase();
-
// 把B转成小写
-
String s4 = s2.toLowerCase();
-
// C拼接D
-
String s5 = s3.concat(s4);
-
System.out.println(s5);
-
-
// 优化后的代码
-
// 链式编程
-
String result = s.substring(
0,
1).toUpperCase()
-
.concat(s.substring(
1).toLowerCase());
-
System.out.println(result);
-
}
-
}
-
String类的其他功能:
** 替换功能:
* String replace(char old,char new)
* String replace(String old,String new)
*
* 去除字符串两空格
* String trim()
*
* 按字典顺序比较两个字符串
* int compareTo(String str)
* int compareToIgnoreCase(String str)
-
package String;
-
/*
-
* String类的其他功能:
-
*
-
* 替换功能:
-
* String replace(char old,char new)
-
* String replace(String old,String new)
-
*
-
* 去除字符串两空格
-
* String trim()
-
*
-
* 按字典顺序比较两个字符串
-
* int compareTo(String str)
-
* int compareToIgnoreCase(String str)
-
*/
-
public
class Demo10 {
-
public static void main(String[] args) {
-
// 替换功能
-
String s1 =
"helloworld";
-
String s2 = s1.replace(
'l',
'k');
-
String s3 = s1.replace(
"owo",
"ak47");
-
System.out.println(
"s1:" + s1);
-
System.out.println(
"s2:" + s2);
-
System.out.println(
"s3:" + s3);
-
System.out.println(
"---------------");
-
-
// 去除字符串两空格
-
String s4 =
" hello world ";
-
String s5 = s4.trim();
-
System.out.println(
"s4:" + s4 +
"---");
-
System.out.println(
"s5:" + s5 +
"---");
-
-
// 按字典顺序比较两个字符串
-
String s6 =
"hello";
-
String s7 =
"hello";
-
String s8 =
"abc";
-
String s9 =
"xyz";
-
System.out.println(s6.compareTo(s7));
// 0
-
System.out.println(s6.compareTo(s8));
// 7
-
System.out.println(s6.compareTo(s9));
// -16
-
}
-
}
-
需求:把数组中的数据按照指定个格式拼接成一个字符串
* 举例:* int[] arr = {1,2,3};
* 输出结果:
* "[1, 2, 3]"
* 分析:
* A:定义一个字符串对象,只不过内容为空
* B:先把字符串拼接一个"["
* C:遍历int数组,得到每一个元素
* D:先判断该元素是否为最后一个
* 是:就直接拼接元素和"]"
* 不是:就拼接元素和逗号以及空格
* E:输出拼接后的字符串
-
package String;
-
/*
-
* 需求:把数组中的数据按照指定个格式拼接成一个字符串
-
* 举例:
-
* int[] arr = {1,2,3};
-
* 输出结果:
-
* "[1, 2, 3]"
-
* 分析:
-
* A:定义一个字符串对象,只不过内容为空
-
* B:先把字符串拼接一个"["
-
* C:遍历int数组,得到每一个元素
-
* D:先判断该元素是否为最后一个
-
* 是:就直接拼接元素和"]"
-
* 不是:就拼接元素和逗号以及空格
-
* E:输出拼接后的字符串
-
*/
-
public
class demo11 {
-
public static void main(String[] args) {
-
// 前提是数组已经存在
-
int[] arr = {
1,
2,
3 };
-
-
// 定义一个字符串对象,只不过内容为空
-
String s =
"";
-
-
// 先把字符串拼接一个"["
-
s +=
"[";
-
-
// 遍历int数组,得到每一个元素
-
for (
int x =
0; x < arr.length; x++) {
-
// 先判断该元素是否为最后一个
-
if (x == arr.length -
1) {
-
// 就直接拼接元素和"]"
-
s += arr[x];
-
s +=
"]";
-
}
else {
-
// 就拼接元素和逗号以及空格
-
s += arr[x];
-
s +=
", ";
-
}
-
}
-
-
// 输出拼接后的字符串
-
System.out.println(
"最终的字符串是:" + s);
-
}
-
}
-
字符串反转
* 举例:键盘录入”abc”* 输出结果:” cba”
*
* 分析:
* A:键盘录入一个字符串
* B:定义一个新字符串
* C:倒着遍历字符串,得到每一个字符
* a:length()和charAt()结合
* b:把字符串转成字符数组
* D:用新字符串把每一个字符拼接起来
* E:输出新串
-
package String;
-
/*
-
* 字符串反转
-
* 举例:键盘录入”abc”
-
* 输出结果:”cba”
-
*
-
* 分析:
-
* A:键盘录入一个字符串
-
* B:定义一个新字符串
-
* C:倒着遍历字符串,得到每一个字符
-
* a:length()和charAt()结合
-
* b:把字符串转成字符数组
-
* D:用新字符串把每一个字符拼接起来
-
* E:输出新串
-
*/
-
public
class Demo12 {
-
public static void main(String[] args) {
-
// 键盘录入一个字符串
-
Scanner sc =
new Scanner(System.in);
-
System.out.println(
"请输入一个字符串:");
-
String line = sc.nextLine();
-
-
/*
-
// 定义一个新字符串
-
String result = "";
-
-
// 把字符串转成字符数组
-
char[] chs = line.toCharArray();
-
-
// 倒着遍历字符串,得到每一个字符
-
for (int x = chs.length - 1; x >= 0; x--) {
-
// 用新字符串把每一个字符拼接起来
-
result += chs[x];
-
}
-
-
// 输出新串
-
System.out.println("反转后的结果是:" + result);
-
*/
-
-
// 改进为功能实现
-
String s = myReverse(line);
-
System.out.println(
"实现功能后的结果是:" + s);
-
}
-
-
/*
-
* 两个明确: 返回值类型:String 参数列表:String
-
*/
-
public static String myReverse(String s) {
-
// 定义一个新字符串
-
String result =
"";
-
-
// 把字符串转成字符数组
-
char[] chs = s.toCharArray();
-
-
// 倒着遍历字符串,得到每一个字符
-
for (
int x = chs.length -
1; x >=
0; x--) {
-
// 用新字符串把每一个字符拼接起来
-
result += chs[x];
-
}
-
return result;
-
}
-
}
统计大串中小串出现的次数
-
package String;
-
-
-
/*
-
* 统计大串中小串出现的次数
-
* 举例:
-
* 在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
-
* 结果:
-
* java出现了5次
-
*
-
* 分析:
-
* 前提:是已经知道了大串和小串。
-
*
-
* A:定义一个统计变量,初始化值是0
-
* B:先在大串中查找一次小串第一次出现的位置
-
* a:索引是-1,说明不存在了,就返回统计变量
-
* b:索引不是-1,说明存在,统计变量++
-
* C:把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
-
* D:回到B
-
*/
-
public
class Demo13 {
-
public static void main(String[] args) {
-
// 定义大串
-
String maxString =
"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
-
// 定义小串
-
String minString =
"java";
-
-
-
// 写功能实现
-
int count = getCount(maxString, minString);
-
System.out.println(
"Java在大串中出现了:" + count +
"次");
-
}
-
-
-
/*
-
* 两个明确: 返回值类型:int 参数列表:两个字符串
-
*/
-
public static int getCount(String maxString, String minString) {
-
// 定义一个统计变量,初始化值是0
-
int count =
0;
-
-
-
/*
-
// 先在大串中查找一次小串第一次出现的位置
-
int index = maxString.indexOf(minString);
-
// 索引不是-1,说明存在,统计变量++
-
while (index != -1) {
-
count++;
-
// 把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
-
// int startIndex = index + minString.length();
-
// maxString = maxString.substring(startIndex);
-
maxString = maxString.substring(index + minString.length());
-
// 继续查
-
index = maxString.indexOf(minString);
-
}
-
*/
-
-
int index;
-
//先查,赋值,判断
-
while((index=maxString.indexOf(minString))!=-
1){
-
count++;
-
maxString = maxString.substring(index + minString.length());
-
}
-
-
-
return count;
-
}
-
}