常用的Scanner&String

最新推荐文章于 2024-08-08 22:13:39 发布

原创最新推荐文章于 2024-08-08 22:13:39 发布 · 326 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Java学习之路(五)

Java基础学习专栏收录该内容

18 篇文章

订阅专栏

本文深入讲解Java中的Scanner类使用，探讨标准输入流的处理方法，分析String类的构造方法及其实现原理，详解String的各种功能如判断、获取、转换等，并提供多个实用代码示例。

Scanner

System.in作为一个参数传到Scanner对象中，其中的内部格式为：

class System{
	public static final InputStream in
}

本质上属于一个标准的输入流，是键盘录入的数据信息,Scanner(InputStream source)。
修改sc.nextInt()

package TestAa;
import java.util.Scanner;

public class CompareCc {
/**
 * @param args
 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("----------------");
		Scanner sc = new Scanner(System.in);
		if (sc.hasNextInt()) {
			int a = sc.nextInt();
			System.out.println("a = " + a);
		} else {
			System.out.println("Checking illgel Input!");
		}
	}

}
//显然不是所有的用户都是按照我们提示数据类型输入，所以需要增加判别。

Scanner获取

	package TestAa;
	import java.util.Scanner;
	
	public class CompareCc {
	/**
	 * @param args
	 */
		public static void main(String[] args) {
			// TODO Auto-generated method stub
			Scanner sc = new Scanner(System.in);
			/*
			 * 先输入Int，后输入String会导致回车符号被识别为String，导致第二个无法输入。
			 */
			int a = sc.nextInt();
			String aa = sc.nextLine();
			System.out.println("a:" + a + "aa:" + aa);
			/*
			 * 解决办法一，先获取第一个，再创建对象获取第二个。
			 * 解决办法二，全部当作字符串获取，然后转为自己想要的数据类型。
			 */
		}	
	}

显然程序的设计不是实现就可以了，更多的是考虑非法的输入和保持程序的健壮性问题。

String构造方法

描述：字符串的本质也是一个对象，其值是一个常量无法被修改，但是其缓冲区域是一个变量所以是可以重新赋值的。
- String是一个类，不只是简单的数据类型，常用的构造方法如下：
```
	public String() 空参构造.

	public String(byte[] bytes)

	public String(byte[] bytes,int offset,int length)

	public String(char[] value)		//String str = new String({97,98,99});

	public String(char[] value,int offset,int count)

	public String(String original)	//String str = new String("hello world");
```
- 功能是String str = new Function();通过构造函数生成String字符串，具体看参数接口…
- String作为一种数据类型
```
	String str = new String("hello");
	String stt = "hello";
	String srr = new String("hello");
	System.out.println(str == stt);			//false
	System.out.println(str.equals(stt));	//true
	System.out.println(str.equals(srr));	//true
```
- 特别提示：Java数据的存在区域以及访问规则。
  
  Java数据访问位置分为三类：栈，堆，方法区(包括常量池)。
  栈：计算机所有的流程序处理结构，都是以栈结构存放，研究生入学考试的基本知识点。Java中存放的每一条逻辑指令的位置都是栈结构。
  堆：用于New生成的一切对象都是堆位置。
  方法区：main函数以及，常量，比如类的static修饰数据。
```
String a = "aaa";
String aaa = new String("aaa");
String b = "bbb" 
String ab = "aaabbb"
System.out.println(a==aaa);				//false
System.out.println(a.equals(aaa));		//true
System.out.println(ab == (a+b));		//true
```

String函数

按照功能分为三种：判断，获取，转化。

判断

	boolean equals(Object obj)
	boolean equalsIgnoreCase(Object obj)
	boolean contains(String str)
	boolean startsWith(String str)
	boolean endsWith(String str)
	boolean isEmpty()

获取功能

	int length()
	char charAt(int index)
	int indexOf(int ch)
	int indexOf(String str)
	int indexOf(int ch,int fromIndex)
	String substring(int start)
	String substring(int start,in tend)

转换功能

	byte[] getBytes()		//遍历byte[]后显示的是数字.
	char[] toCharArray()	//遍历char[]后显示的字符.
	static String valueOf(char[] chs)//与上面的函数是相反操作，逆过程.
	static String valueOf(int i)
	String toLowerCase()
	String toUpperCase()  
	String concat(String str)//字符串拼接，s3=s1+s2,s3=s1.concat(s2);

替换功能

	String replace(char old, char new)
	String replace(String old,String new)
	String trim()		//去掉两端空格功能.

按照字典顺序比较两个字符串.

	int compareTo(String str);	//返回第一个不同字字母的ASCII差值,若第一个相同，返回不同字母长度..
	int compareToIgnoreCase(String str);//忽略大小写.

重要部分代码举例：

	String t1 = "hello";
	String t2 = "h";
	String t3 = "a";
	System.out.println(t1.compareTo(t2));	//4	
	System.out.println(t1.compareTo(t3));	//7
		
	/*将helloWORLD转化为Helloworld*/

	String str = "helloWORLD";
	String result = str.substring(0,1).toUpperCase().concat(str.substring(1).toLowerCase());
	System.out.println(result);
	System.out.println("---------------");
	System.out.println("  hello world  ".trim());
	System.out.println("---------------");
	Scanner sc = new Scanner(System.in);
	System.out.println("Input String：");
	String line = sc.nextLine();
	char[] ch = line.toCharArray();
	int length = line.length();
	System.out.println(length);
	for(int i = 0; i < length - i; ++i){
		char temp = ch[i];
		ch[i] = ch[length - i];
		ch[length - i] = temp;
	}
	//System.out.println("反转后ch:" + ch);
	String resultcc = new String(ch);
	System.out.println(resultcc);
	}
}

字符串由键盘输入且反转.

方法一：

package TestAa;		
import java.util.Scanner;

public class CompareCc {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		System.out.println("Input String：");
		String line = sc.nextLine();
		char[] ch = line.toCharArray();
		revertCharArray(ch);
		System.out.println(new String(ch));
	}

	public static void revertCharArray(char[] ch) {
		int length = ch.length;
		for (int i = 0; i < length - i; ++i) {
			char temp = ch[i];
			ch[i] = ch[length - 1 - i];
			ch[length - 1 - i] = temp;
		}
	}
}

方法二：利用内部的数据加法的强转，可以直接倒装拼接。

package TestAa;

import java.util.Scanner;

public class CompareCc {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		System.out.println("Input String：");
		String line = sc.nextLine();
		// 将length先存储起来是因为若串足够大的情况下会影响效率，尤其是在链表结构下。

		System.out.println("String :" + revertString(line));
	}		
	public static String revertString(String line) {
		char[] ch = line.toCharArray();
		int length = ch.length;
		String str = "";
		for (int i = length - 1; i >= 00; --i) {
			str += ch[i];
		}
		return str;
	}
}

String的模式匹配

/*个人认为该实现方式比较简单可行，用do...while是考虑至少执行一次的特性*/
/*思路分为两部分，do...while确定跳出的条件，
	内部确定循环的条件：继续为修改后的非-1的index，并且缩减mainStr，失败直接跳出。*/
package TestAa;

public class CompareCc {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String mainStr = "abababababccaba";
		String subStr = "ab";
		/*下部分也可以直接抽取成函数，以便重复使用.*/
		int index = -1, count = 0;	
		do {
			index = mainStr.indexOf(subStr);
			if (index != -1) {
				count++;
				mainStr = mainStr.substring(index + subStr.length());
			}
		} while (index != -1);
		System.out.println("count: " + count);
	}
}

/*网络上的另外实现方式。*/
package TestAa;

public class CompareCc {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String mainStr = "abababababccaba";
		String subStr = "ab";
		int result = getCount(mainStr, subStr);
		System.out.println("count: " + result);
	}

	public static int getCount(String mainStr, String subStr) {
		int index = mainStr.indexOf(subStr), count = 0;
		while (index != -1) {
			count++;
			int newIndex = index + subStr.length();
			mainStr = mainStr.substring(newIndex);
			index = mainStr.indexOf(subStr);
		}
		return count;
	}
}