JAVA_String_字符串操作

1:Scanner的使用(了解)
(1)在JDK5以后出现的用于键盘录入数据的类。
(2)构造方法：
A:讲解了System.in这个东西。
它其实是标准的输入流,对应于键盘录入
B:构造方法
InputStream is = System.in;

Scanner(InputStream is)
C:常用的格式
Scanner sc = new Scanner(System.in);
(3)基本方法格式：
A:hasNextXxx() 判断是否是某种类型的
B:nextXxx()返回某种类型的元素
(4)要掌握的两个方法
A:public int nextInt()
B:public String nextLine()
(5)需要注意的小问题
A:同一个Scanner对象，先获取数值，再获取字符串会出现一个小问题。

Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
String s=sc.nextLine();
System.out.println(n+"\t"+s);
//输入5回车后直接输出结果 5
//换行符号已经占据字符串输入的位置

B:解决方案：
a:重新定义一个Scanner对象
b:把所有的数据都用字符串获取，然后再进行相应的转换

2:String类的概述和使用(掌握)
(1)多个字符组成的一串数据。
其实它可以和字符数组进行相互转换。
(2)构造方法：
A:public String() //空构造
直接输出对象名，输出的是对象名的原始toString（）方法。

String s=new String();
System.out.println("s:"+s);
System.out.println("s.length:"+s.length());

输出：

s:
s.length:0
B:public String(byte[] bytes) 字节数组转换成字符串

byte[] bys={97,98,99,45,105};
String s=new String(bys);
System.out.println("s:"+s);
System.out.println("s.length:"+s.length());

输出：
s:abc-i
s.length:5
将字节通过ASC码转换成字符后输出

C:public String(byte[] bytes,int offset,int length) 字节数组的一部分转换成字符串

byte[] bys={97,98,99,45,105};
String s=new String(bys,1,3);//从1号元素开始截取长度3的内容
System.out.println("s:"+s);
System.out.println("s.length:"+s.length());

输出：
s:bc-
s.length:3

D:public String(char[] value) 字符数组转换成字符串

char[] chs={'a','b','c','d','f','牛'};
String s=new String(chs);
System.out.println("s:"+s);
System.out.println("s.length:"+s.length());

输出：
s:abcdf牛
s.length:6

E:public String(char[] value,int offset,int count) 字符数组的一部分转换成字符串

char[] chs={'a','b','c','d','f','牛'};
String s=new String(chs,2,4);
System.out.println("s:"+s);
System.out.println("s.length:"+s.length());

输出：
s:cdf牛
s.length:4
F:public String(String original) 字符串常量转换为字符串
String s = new String( "ABCDE" );

相当于
String s = "ABCDE";

下面的这一个虽然不是构造方法，但是结果也是一个字符串对象
G:String s = "hello";

(3)字符串的特点
A:字符串一旦被赋值，就不能改变。
注意：这里指的是字符串的内容不能改变，而不是引用不能改变。
“Hello”不可变，对应的内存地址可以变

B:字面值作为字符串对象和通过构造方法创建对象的不同
String s = new String("hello");和String s = "hello"的区别?
s+= "World";

直接赋值：String s = "hello"
创建一个对象（方法区）或不需创建（方法区已有对象）。

先到方法区字符常量池里面找，如果有就直接返回，没有就创建并返回“hello”的内存地址。

先创建“Hello”地址，之后创建“World”地址，最后重新开一个地址储存“HelloWorld”

创建对象：String s = new String("hello");
创建两个（堆内存和方法区）对象或一个对象（方法区内已有对象）。
new String()先在堆内存中开空间，然后到方法区找，类似直接赋值，地址返回堆内存，堆内存地址再返回栈内存。所以和直接赋值相比，接收到的“Hello”对应的内存地址不同

(4)字符串的面试题(看程序写结果)
== 比较引用类型比较的是地址值是否相同
equals 比较引用类型也是比较地址值是否相同，而String类重写了equals（）方法，比较的是内容是否相同
#################################################################################
A:==和equals()

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);// false 两个对象都在堆内存，地址不同
System.out.println(s1.equals(s2));// true 内容相同

String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3 == s4);// false一个是堆内存地址，一个是方法区内存地址
System.out.println(s3.equals(s4));// true内容相同

String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6);// true s5以创建方法区内存，s6直接使用，所以内存地址相同
System.out.println(s5.equals(s6));// true 内容相同

B:字符串的拼接
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1 + s2);// false s3已有方法区内存地址，s1+s2 会重新开方法区内存，所以内存地址不同
System.out.println(s3.equals((s1 + s2)));// true内容相同

System.out.println(s3 == "hello" + "world");// true 先将两个常量“hello”和“world”相加后发现有s3，所以等同于s3的方法区内存地址
字符串变量相加： 先开空间，再拼接；
字符串常量相加：先拼接，然后在方法区常量池找，如果有就直接使用，没有的话再创建
System.out.println(s3.equals("hello" + "world"));// true内容相同

(5)字符串的功能(自己补齐方法中文意思)
A:判断功能
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； 无对象，无法调方法

B:获取功能
int length()
获取字符串长度

char charAt(int index)
获取指定位置的字符

int indexOf(int ch)
返回指定字符第一次出现的位置
为什么是int而不是char ‘a’和‘97’都可以表示‘a’，如果限定为char则需要由大到小强转

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)
从指定范围截取字符串

C:转换功能
byte[] getBytes()
字符串转换为字节数组
String s="admin";
byte[] b=s.getBytes();//输出的是每个字符的字节码

char[] toCharArray()
字符串转换为字符数组
String s="admin";
char[] c=s.toCharArray();

static String valueOf(char[] chs)
字符数组转换成字符串
String s="admin"
char[] chs=s.toCharArray();
String ss = String.valueOf(chs);
System.out.println(ss)

static String valueOf(int i)
int转换为字符串
valueOf（）方法可以将任意类型的数据转换为字符串
int i = 100;
String sss = String.valueOf(i);
System.out.println(sss);

String toLowerCase()
字符串转换为小写

String s="admin";
System.out.println("toLowerCase:" + s.toLowerCase());
System.out.println("s:" + s);

String toUpperCase()
字符串转换为大写

String concat(String str)
字符串拼接

D:其他功能
a:替换功能
String replace(char old,char new)

public class Test {
public static void main(String[] args) {
String s="helloWorld";
String s2=s.replace('l', 'k');
System.out.println(s);
System.out.println(s2);
}
}

输出：
helloWorld
hekkoWorkd

String replace(String old,String new)
新字符即使更长也可直接拼接进去

public class Test {
public static void main(String[] args) {
String s="helloWorld";
String s2=s.replace("ell", "WWW");
System.out.println(s);
System.out.println(s2);
}
}

输出：

helloWorld
hWWWoWorld

b:去空格功能
String trim()
去除字符串两边的空格

c:按字典比较功能
int compareTo(String str) 区分大小写

public class Test {
public static void main(String[] args) {
String s="456";
String s2="456";
String s3="123";
String s4="789";
System.out.println(s.compareTo(s2));
System.out.println(s.compareTo(s3));
System.out.println(s.compareTo(s4));
}
}

输出：
0
3
-3
字符串长度不同时，
从前往后依次对比字符是否相同，相同为0，不同时得出的结果是不同的字符字节码的差数
private final char value[];

字符串会自动转换为一个字符数组。

public int compareTo(String anotherString) {
//this -- s1 -- "hello"
//anotherString -- s2 -- "hel"

//获取第一个字符数组的长度
int len1 = value.length; //this.value.length--s1.toCharArray().length--5
//获取第二个字符数组的长度
int len2 = anotherString.value.length;//s2.value.length -- s2.toCharArray().length--3

//获取两个字符数组长度中较小的值
int lim = Math.min(len1, len2); //Math.min(5,3); -- lim=3;

char v1[] = value; //s1.toCharArray()
char v2[] = anotherString.value;

//char v1[] = {'h','e','l','l','o'};
//char v2[] = {'h','e','l'};

//以较短字符数组长度为界限，依次对比，找出不同时返回字节码的差
int k = 0;
while (k < lim) {
char c1 = v1[k]; //c1='h','e','l'
char c2 = v2[k]; //c2='h','e','l'
if (c1 != c2) {
return c1 - c2;
}
//前面都相同时，比较完较短字符数组的全部元素即跳出
k++;
}
//对比完较短数组后返回两个数组长度的差
return len1 - len2; //5-3=2;
}

String s1 = "hello";
String s2 = "hel";
System.out.println(s1.compareTo(s2)); // 2

int compareToIgnoreCase(String str) 不区分大小写

(6)字符串的案例
A:模拟用户登录

import java.util.Scanner;

public class Test {
public static void main(String[] args) {
String name="admin";
int pass=123456;
Scanner sc=new Scanner(System.in);
System.out.println("请输入用户名：");
String uname=sc.nextLine();
System.out.println("请输入密码：");
int upass=sc.nextInt();
for(int i=0;i<3;i++){
if(name.equals(uname)&&pass==upass){
System.out.println("恭喜，登录成功！");
break;
}else if(name.equals(uname)){
System.out.println("登录失败，密码输入错误，你还有"+(3-i)+"次机会。");
System.out.println("请输入用户名：");
Scanner sc2=new Scanner(System.in);
uname=sc2.nextLine();
System.out.println("请输入密码：");
upass=sc.nextInt();
}else if(upass==pass){
System.out.println("登录失败，用户名输入错误，你还有"+(3-i)+"次机会。");
System.out.println("请输入用户名：");
Scanner sc2=new Scanner(System.in);
uname=sc2.nextLine();
System.out.println("请输入密码：");
upass=sc.nextInt();

}else{
System.out.println("登录失败，你还有"+(3-i)+"次机会，请重新输入：");
System.out.println("请输入用户名：");
Scanner sc2=new Scanner(System.in);
uname=sc2.nextLine();
System.out.println("请输入密码：");
upass=sc.nextInt();
}
if(i==2){
System.out.println("登录失败，次数已使用完毕");
}
}
sc.close();
}
}

有BUG 关于close()待解决

另一种方法：

import java.util.Scanner;

public class Test {
public static void main(String[] args) {
String name = "admin";
String pass = "123456";
for (int i = 0; i < 3; i++) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String uname = sc.nextLine();
System.out.println("请输入密码：");
String upass = sc.nextLine();
if (uname.equals(name) && upass.equals(pass)) {
System.out.println("登录成功！");
sc.close();
break;
} else {
if ((2 - i) == 0) {
System.out.println("登录失败，请联系管理员！");
sc.close();
} else {
System.out.println("登录失败，还有" + (2 - i) + "次机会");
}
}
}
}
}

B:字符串遍历

String s="Hello World!";
for(int i=0;i<s.length();i++){
System.out.println(s.charAt(i));
}

输出：
H
e
l
l
o

W
o
r
l
d
!

C:统计字符串中大写，小写及数字字符的个数

public class Test {
public static void main(String[] args) {
String s = "Hello123World!";
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//遍历字符串，得到每一个字符
//通过 length（）和charAt（）结合取出每个字符
// char ch = s.charAt（i）；
for(int i=0;i<s.length();i++){
char ch=s.charAt(i);
if(ch>='0'&&ch<='9'){
numberCount++;
}else if(ch>='a'&&ch<='z'){
smallCount++;
}else if(ch>='A'&&ch<='Z'){
bigCount++;
}
}
System.out.println("numberCount:"+numberCount);
System.out.println("smallCount:"+smallCount);
System.out.println("bigCount:"+bigCount);
}
}

输出：
numberCount:3
smallCount:8
bigCount:2

改进：将字符串换成接收用户输入的字符串。

import java.util.Scanner;

public class Test {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s=sc.nextLine();
Show(s);
sc.close();
}

//创建一个获取指定字符串各项值数量的方法
public static void Show(String s){
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//遍历字符串，得到每一个字符
//通过 length（）和charAt（）结合取出每个字符
// char ch = s.charAt（i）；
for(int i=0;i<s.length();i++){
char ch=s.charAt(i);
if(ch>='0'&&ch<='9'){
numberCount++;
}else if(ch>='a'&&ch<='z'){
smallCount++;
}else if(ch>='A'&&ch<='Z'){
bigCount++;
}
}
System.out.println("numberCount:"+numberCount);
System.out.println("smallCount:"+smallCount);
System.out.println("bigCount:"+bigCount);
}
}

输出：
请输入一个字符串：
ADSDF12345sgsg
numberCount:5
smallCount:4
bigCount:5

D:把字符串的首字母转成大写，其他小写

public class Test {
public static void main(String[] args) {
//将首字符转换为大写，其余小写
String s="helloWorld";
//获取第一个字符
String s1=s.substring(0,1);
//获取1之后的字符串
String s2=s.substring(1);
//首字符大写
String s3=s1.toUpperCase();
//其余字符转小写
String s4=s2.toLowerCase();
//拼接字符串
String s5=s3.concat(s4);
System.out.println(s5);
}
}

输出：
Helloworld

另一种方法：通过链式编程不断调方法解决

String s="helloWorld";
String ss=s.substring(0,1).toUpperCase().concat(s.substring(1).toLowerCase());
System.out.println(ss);

输出：
Helloworld

E:把int数组拼接成一个指定格式的字符串

public class Test {
public static void main(String[] args) {
//新建一个空字符串
String s = "";
int[] num = { 1, 2, 3, 4, 5, 6 };
//字符串添加一个【符号
s += "[";
for (int i = 0; i < num.length; i++) {
//判断元素是否为数组最后一个
if (i == num.length - 1) {
//如果是最后一个就直接拼接元素和】符号
s += num[i];
s += "]";
} else {
//如果不是就拼接元素和逗号，空格
s += num[i];
s += ", ";
}
}
System.out.println(s);
}
}

输出：
[1, 2, 3, 4, 5, 6]

F:字符串反转

import java.util.Scanner;

/*
* 字符串反转
* 举例：键盘录入”abc”
* 输出结果：”cba”
*
* 分析：
* 		A:键盘录入一个字符串
* 		B:定义一个新字符串
* 		C:倒着遍历字符串，得到每一个字符
* 			a:length()和charAt()结合
* 			b:把字符串转成字符数组
* 		D:用新字符串把每一个字符拼接起来
* 		E:输出新串
*/
public class StringTest3 {
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;
}
}

另一种：

import java.util.Scanner;

public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = sc.nextLine();
Change(s);
sc.close();
}

public static void Change(String s) {
// 字符串转换为字符数组
char[] ch = s.toCharArray();
char temp = ch[0];
// for循环翻转字符数组
for (int i = 0; i < ch.length / 2; i++) {
temp = ch[i];
ch[i] = ch[ch.length - i - 1];
ch[ch.length - i - 1] = temp;
}
// 字符数组转化为字符串
String ss = String.valueOf(ch);
System.out.println(ss);
}
}

G:统计大串中小串出现的次数

public class Test {
public static void main(String[] args) {
String s = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
String str = "java";
int count = Search(s, str);
System.out.println("子字符串" + str + "共出现" + count + "次");
String s1="123456789123456789";
String s2="123";
System.out.println(s1.contains("9"));
System.out.println(Search(s1,s2));
}

public static int Search(String s1, String s2) {
//s1为原始字符串，s2为待检索的子字符串
int count = 0;
// contains（）方法判断是否包含字串
while (s1.contains(s2)) {
// substring（）方法截取搜索后剩余部分的字符串
// indexOf（）方法获取子串第一次出现的位置
// length（）方法得到字串的长度
// 第一次出现的坐标加上字串长度即为剩余字符串的起始坐标
s1 = s1.substring((s1.indexOf(s2) + s2.length()));
// 当包含字串时，此时加一
count++;
}
return count;
}
}

输出：
子字符串java共出现5次
true
2