Java从入门到放弃12---Scanner类/String类
Java从入门到放弃12—Scanner类/String类
01 Scanne 类
-
静态字段：public static final InputStream in;标准的输入流，标志着此流已打开并准备提供输入数据，通常此流对应着键盘录入。
-
System类：InputStream is = System.in;//static InputStream in 标准输入流
Scanner scanner = new Scanner(is);//scanner（InputStream source）构造一个新的scanner，它生成的值是从指定 的输入流扫描的。
注意事项：
- //当使用scanner先录入整数后录入字符串时，还没录入输入字符串程序就结束了。这是因为程序将录入整数时键入的回车符当做字符串数据录入了。解决方法1：在录字符串的时候创建一个新的scanner对象。解决方法2：用next();，这个方法不会单独录入换行符。两种方法的区别：方法2遇到空格便结束录入。
- //hasnextInt() 判断输入的数据类型是否是int类型，返回值为boolean类型
程序示例1：
public class ScannerDemo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int num = sc.nextInt();
System.out.println("你输入的数字是："+num);
System.out.println("请输入一个字符串");
String s = sc.nextLine();
System.out.println("你输入的字符串是:"+s);
}
}
//运行结果： 请输入一个整数
9
你输入的数字是：9
请输入一个字符串
你输入的字符串是:
程序示例2：
public class ScannerDemo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int num = sc.nextInt();
System.out.println("你输入的数字是："+num);
sc=new Scanner(System.in);
System.out.println("请输入一个字符串");
String s = sc.nextLine();
System.out.println("你输入的字符串是:"+s);
}
}
//运行结果: 请输入一个整数
9
你输入的数字是：9
请输入一个字符串
String ABC
你输入的字符串是:String ABC
程序示例3:
public class ScannerDemo3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int num = sc.nextInt();
System.out.println("你输入的数字是："+num);
System.out.println("请输入一个字符串");
String s = sc.next();//遇到空格便结束录入
System.out.println("你输入的字符串是:"+s);
}
}
//运行结果：请输入一个整数
9
你输入的数字是：9
请输入一个字符串
String ABC
你输入的字符串是:String
程序示例4：判断输入的数据类型
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个整数");
int num=ScannerUtils.getNumber(scanner);
System.out.println("您输入的整数是"+num);
}
}
class ScannerUtils{
private ScannerUtils() {
}
public static int getNumber(Scanner scanner) {
int num = 0;
while (true) {
scanner=new Scanner(System.in);//一定要在循环体内创建新对象，否则该循环会变成一个死循环。
boolean b = scanner.hasNextInt();
if (b) {
num = scanner.nextInt();
break;
} else {
System.out.println("您输入的不是整数，请重新输入");
}
}
return num;//一定要返回值，否则无法接受键入的值
}
}
02 String类
-
String类不能被继承，被final修饰。
-
String类代表字符串，Java程序中的所有字符串字面值都作为此类的实例实现
-
字符串是常量，它们的值在创建之后不能更改，这里指的是字符串的值不能被改变，引用会改变（即不能在同一引用空间进行字面值的覆盖）。
-
内存图详解：
-
-
String类重写了toString方法，打印的是字符串的内容。
-
String类重写了equals方法，比较的是字面值。
程序示例：
public class MyTest {
public static void main(String[] args) {
//初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
String s = new String(); //创建一个空的字符串对象
System.out.println(s.toString());
String s1 = new String("abc");
System.out.println(s1.toString());//字符串重写了toString方法，打印的是字符串的内容
int length = s1.length(); //获取字符串的长度
System.out.println(length);
}
}
//运行结果:
abc
3
- 程序示例:
public class MyTest {
public static void main(String[] args) {
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,该引用都指向常量池中的hello
System.out.println(s5.equals(s6)); //true
}
}
-
相关面试题
String s = new String(“hello”)和String s = “hello”;的区别答：前者创建的对象存贮在堆内存中并指向方法区常量池中的hello，后者的引用直接指向常量池中的hello。
内存图解：
- String类中的常用的构造方法（把字节类型或字符类型转换成字符串类型）
public String():空构造
public String(byte[] bytes):把字节数组转成字符串
public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串(index:表示的是从第几个索引开始, length表示的是长度)
public String(char[] value):把字符数组转成字符串
public String(char[] value,int index,int count):把字符数组的一部分转成字符串
public String(String original):把字符串常量值转成字符串
（以上方法采用了方法重载）
程序示例：
public class StringDemo {
public static void main(String[] args) {
byte[] bytes={97,98,99,100};
//可以将字节数组，转换成字符串
String s = new String(bytes); //按照ASCⅡ值转换
s=new String(bytes,2,2);//注意可能的异常，StringIndexOutOfBoundsException 字符串索引越界异常
System.out.println(s);
char[] chas={'a','b','c','你','好',100};
String s1 = new String(chas);
s1=new String(chas,3,3);
System.out.println(s1);
}
}
//运行结果：cd
你好d
程序示例：用户登录案例
import java.util.Scanner;
public class LoginDemo {
public static void main(String[] args) {
//写死一个数据库
String name="user01";
String password="123456789";
//只有三次机会，判断输入的用户名和密码是否正确
for (int i=2;i>=0;i--){
Scanner sc1 = new Scanner(System.in);
System.out.println("请输入用户名");
String nm=sc1.nextLine();
System.out.println("请输入密码");
String pwd=sc1.nextLine();
if (name.equals(nm)&&password.equals(pwd)) {
System.out.println("登陆成功");
break;
}else{
if (i==0){
System.out.println("您的账号异常，请两小时后再登录");
}else{
System.out.println("用户名或密码输入有误，您还有"+i+"次机会，请重新输入");
}
}
}
}
}
- String类中的常用判断功能
public boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
public boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
public boolean contains(String str):判断字符串中是否包含传递进来的字符串
public boolean startsWith(String str):判断字符串是否以传递进来的字符串开头
public boolean endsWith(String str):判断字符串是否以传递进来的字符串结尾
public boolean isEmpty():判断字符串的内容是否为空串""。
程序示例：
public class StringDemo2 {
public static void main(String[] args) {
boolean b = "abc".equals("ABC");//比较两个字符串的内容是否相同区分大小写
System.out.println(b);
b="abc".equalsIgnoreCase("ABC");//不区分大小写的比较
System.out.println(b);
boolean b1 = "abcdef".contains("ab");//判断一个字符串是否包含传入的字符串
System.out.println(b1);
b1="abcde".startsWith("ab"); //"判断一个字符串是不是以这个字符串开头"
System.out.println(b1);
boolean b2 = "139 9909 9098".endsWith("9098");//判断一个字符串，是否以这个字符串结尾
System.out.println(b2);
boolean b4 = " ".length() == 0 ? true : false;
System.out.println(b4);
boolean b5 = "".isEmpty();//判断字符串内容是否为空串
System.out.println(b5);
}
}
//运行结果： false
true
true
true
true
false
true
- String类中的获取功能
public int length():获取字符串的长度。
public char charAt(int index):获取指定索引位置的字符
public int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
public int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
public int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
public int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
public int lastIndexOf（String str，int fromIndex）：返回指定字符串在此字符串中指定位置前最后一次出现处的索引。
public String substring(int start):从指定位置开始截取字符串,默认到末尾。
public String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
程序示例:
public class StringDemo {
public static void main(String[] args) {
String str = "abcdef";
char ch = str.charAt(str.length() - 1);//截取最后字符串的最后一位字符
System.out.println(ch);
//查找这个字符串，中某个字符第一次出现索引
int index = str.indexOf('a');
System.out.println(index);
char ch1 = str.charAt(str.indexOf('b'));//通过indexof获取b的索引，再通过charAt传入索引截取b
System.out.println(ch1);
int index1= str.indexOf("g");//如果没有找到索引，默认返回 -1。
System.out.println(index1);
String str1="Everything is impossible";
int index2 = str1.indexOf("is", str1.indexOf("thing") + 1);//从指定的位置开始找，找这字符串第一次出现的索引
System.out.println(index2);
int index3 = str1.lastIndexOf('s',20);//l返回指定字符串在此字符串中指定位置前最后一次出现处的索引。
System.out.println(index3);
String str2 = "I can do all things";
String s1 = str2.substring(6); //从指定索引处截取到末尾，返回的是截取到的字符串
System.out.println(s1);
String s2 = str2.substring(0,9); //含头不含尾,截取脚标索引为0~8的索引
System.out.println(s2);
}
}
//运行结果： f
0
b
-1
11
19
do all things
I can do
程序示例：字符的遍历，大小写字母的统计案例
public class StringDemo{
public static void main(String[] args) {
String str = "AFDFDdfdfdfAFDFd2113232safsdfsdf0000asdfasdfAA";
int upper = 0;
int lower= 0;
int number= 0;
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
if (ch >= 'a' && ch <= 'z') {
lower++;
} else if (ch >= 'A' && ch <= 'Z') {
upper++;
} else if (ch >= '0' && ch <= '9') {
number++;
}
}
System.out.println("大写字母有"+upper+"个");
System.out.println("小写字母有" +lower+ "个");
System.out.println("数字字符有"+number+"个");
}
}
//运行结果：大写字母有11个
小写字母有24个
数字字符有11个
（选中一个类，ctrl+H，查看该类实现的接口。或右键选择diagram）
- String类的转换功能（把字符串转换为字节类型或字符数组/把int类型或字符数组转换为字符串）
public byte[] getBytes():把字符串转换为字节数组。
public char[] toCharArray():把字符串转换为字符数组。
public static String valueOf(char[] chs):把字符数组转成字符串。
public static String valueOf(int i):把int类型的数据转成字符串。//注意：String类的valueOf方法可以把任意类型的数据转成字符串。
public String toLowerCase():把字符串转成小写。
public String toUpperCase():把字符串转成大写。
public String concat(String str):把字符串拼接。
程序示例：把字符串转换为字节数组。
public class MyTest {
public static void main(String[] args) {
byte[] bytes = "abcd".getBytes();//把字符串转换为字节数组
for (int i = 0; i < bytes.length; i++) {//遍历字节数组
System.out.println(bytes[i]);
}
System.out.println(new String(bytes));//new String（）String类的构造方法，将传入的字节数组转换为字符串
byte[] bytes1 = "你好啊".getBytes();//UTF-8编码一个汉字占三个字节
System.out.println(bytes1.length);
for (int i = 0; i < bytes1.length; i++) {
System.out.println(bytes1[i]);
}
System.out.println(new String(bytes1));
}
}
//运行结果：97
98
99
100
abcd
9
-28
-67
-96
-27
-91
-67
-27
-107
-118
你好啊
程序示例：把字符串转换成字符数组/转换大小写
public class MyTest2 {
public static void main(String[] args) {
//把字符数组转换成字符串，通过string类的构造方法
String s = new String(new char[]{'a', 'b', 'c'},0,2);
System.out.println(s);
String str="abc";
//把字符串转换成字符数组
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]);
}
//转换大小写
String s1 = "abcd".toUpperCase();
System.out.println(s1);
String s2 = "ABCD".toLowerCase();
System.out.println(s2);
}
}
//运行结果:ab
a
b
c
ABCD
abcd
程序示例：
public class MyTest3 {
public static void main(String[] args) {
//利用拼接空串的方法，把任意基本类型转换成字符串
int num = 100;
String str = num + ""; //"100"
boolean b = false;
String str2 = b + ""; //"false"
System.out.println(str);
System.out.println(str2);
System.out.println("------------------------");
//把任意类型转换成字符串
String s = String.valueOf(100);
String s1 = String.valueOf(new char[]{'a', 'b'});
String s2 = new String(new char[]{'a', 'b'});
String s3 = String.valueOf(new Object());
System.out.println(s);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println("------------------------");
String str3="do"+"all"+"thing";
//concat("ccc") 拼接字符串，可以替代加号
String concat = "do".concat("all").concat("thing");
System.out.println(concat==str3);//
}
}
//运行结果：100
false
------------------------
100
ab
ab
java.lang.Object@1540e19d
------------------------
false
程序示例：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)/去除字符串左边的空格/去除字符串右边的空格
public class MyTest4 {
public static void main(String[] args) {
String str="aBCDEFGHIGK";
String s = str.substring(0, 1).toUpperCase().concat(str.substring(1).toLowerCase());//把一个字符串的首字母转成大写，其余为小写
System.out.println(s);
test01();
test02();
}
private static void test01() {//去除字符串左边的空格
String s1=" abc ";
String s2="";
for (int i = 0; i < s1.length(); i++) {
char c = s1.charAt(i);
if(c!=' '){
int i1 = s1.indexOf(c);
s2=s1.substring(i1);
break;
}
}
System.out.println(s2);
}
private static void test02(){//去除字符串右边的空格
String s1=" abc ";
String s2="";
for (int i = s1.length()-1; i >=0; i--) {
char c = s1.charAt(i);
if(c!=' '){
int i1 = s1.indexOf(c);
s2=s1.substring(0,i1+1);
break;
}
}
System.out.println(s2);
}
}
程序示例：统计字符串中某个字符串出现的次数
public class MyTest5 {
public static void main(String[] args) {
String maxStr="ilovejavaireallylovejavaireallyreallylovejava";
String minStr="java";
//把一段代码抽取到一个方法中 ctrl+alt+M
findStr(maxStr, minStr);
private static void findStr(String maxStr, String minStr) {
int count=0;
//查找java出现的索引
int index= maxStr.indexOf(minStr);
while (index!=-1){
count++;
maxStr= maxStr.substring(index+minStr.length());
//再次改变索引
index = maxStr.indexOf(minStr);
}
System.out.println("Java出现的次数"+count+"次");
}
}
//运行结果：Java出现的次数3次
- String类中的其他功能
public String replace(char old,char new)：将指定字符进行互换
public String replace(String old,String new)：将指定字符串进行互换
public String trim()：去除两端空格
public int compareTo(String str)：会对照ASCII 码表从第一个字母进行减法运算 返回的就是这个减法的结果。如果前面几个字母一样会根据两个字符串的长度进行减法运算返回的就是这个减法的结果。如果两个字符串一摸一样，返回的就是0。
public int compareToIgnoreCase(String str)：同上，但是忽略大小写
程序示例：去除一个字符两端和中间的空格，把数组中的数据按照指定个格式拼接成一个字符串
public class StringTest {
public static void main(String[] args) {
String str=" abcd edf ghi ";
String s=str.replace(" ","");//替换空格
System.out.println(s);
int[] arr={1,2,3};
String str1="[";
for (int i = 0; i < arr.length; i++) {
if (i==arr.length-1){
str1+=arr[i]+"]";
}else{
str1+=arr[i]+",";
}
}
System.out.println(str1);
}
}
运行结果：abcdedfghi
[1,2,3]
程序示例：对比字符串
public class StringDemo {
public static void main(String[] args) {
//通过字典顺序去比较 返回的值是 ASCII 码的差值 调用者减去传入者
int i = "abc".compareTo("Abc");
System.out.println(i);//a-A=32（任何字母的小写与大写的ASCⅡ值都相差32）
//通过长度去比
int i1 = "abc".compareTo("a");
System.out.println(i1);
//忽略大小写的比较
int abc = "abc".compareToIgnoreCase("ABC");
System.out.println(abc);
}
}
//运行结果：32
2
0