字符串类String:
它是由字符构成的一个序列，在Java当中字符串是一个对象
构造一个字符串
String newString = new String(StringLiteral);
Java当中会把字符串直接量当作是一个String对象所以可以直接如下：
String message = “Hello”;
同时可以使用一个字符数组来创建一个字符串
char[] charArray = {‘G’,’o’,’o’,’d’};
String message = new String(charArray);
String变是存储的是一个String对象的引用，String对象里存储的才是字符串的值
对于String对象来说它是不可变的，它的内容是不变的比如：
String s = “Hello”;
s = “Good”;
在这里创建了两个字符串对象一个是”Hello”首选把引用给s,接下来又创建了一个对象”Good”，这时又把它的引用给了s，这时s指向的是”Good”,原来对”Hello”的引用已不再存要，但对于Hello对象来说它是存在的只是没有一个变量引用它而已。
由于字符串的以上的特性则JVM为了减少内存的使用则有如下的限定：
如果是用的字符串常量则会从字符串池中去找有没有存在这样一个对象有的话则直接把引用指向它，没有才会去创建一个并把这个放到字符串池中，如果明确的去new一个字符串对象的话则不会去考虑从池中去取而是直接去创建一个
publicclass TestString1 {
publicstaticvoid main(String[] args) {
String s1 = new String("Welcome to Java");
String s2 = "Welcome to Java";
String s3 = "Welcome to Java";
System.out.println("s1==s2 is " + (s1 == s2));
System.out.println("s2==s3 is " + (s2 == s3));
}
}
比较字符串的内容是否相等不能使用==，这样比较的是两个字符串引用变量是否是引用同一个对象，当然如果这样相等内容一定是相等的但是String s1 = new String("Welcome to Java");String s2 = "Welcome to Java";这样的两个字符串这样比较变是不相等的因为不是引用的同一个对象，但它们中的内容是相等的。
比较两个字符串的内容是否相等应该是使用equals方法来比较
if(string1.equals(string2)){
System.out.println(“string1 and string2 have the same content.”)
}else{
System.out.println(“string1 and string2 are not equal.”)
}
compareTo方法也可以用来比较两个字符串
s1.compareTo(s2);
对于这个函数如果s1与s2相等则返回0，如果按字典顺序s1大于s2则返回值大于0否则返回值小于0
方法compareTo这个方法的返回值实际是从s1和s2从左到右第一个不同字符之间的距离得出的比如”ac”为s1,”ag”为s2则s1.compareTo(s2)返回值是-4
对于字符串不可以使用>,>=,<,<=进行比较而是使用方法compareTo方法来进行比较
String类还提供了对字符串的比较方法equalsIgnoreCase,compareToIgnoreCase,regionMatches,前两个比较的时候会忽略大小写，最后一个比较两个字符串是否部分相等
还可以使用str.startWith(prefix)来检测字符串str是否以指定的前缀来开头
str.endWith(suffix)来检测字符串str是否以指定的后缀来结束
String类型字符串的长度：
可以调用字符串中的方法length()来获得它的长度，注意在数组中length是一个属性而在这里它是字符串的一个方法比如可以像如下调用message.length()得到message这个字符串的长度。
s.charAt(index)可以获得字符串s中某个指定位置的字符，这里index的范围是 0~s.length()-1
通常还可以直接使用字符串的字接量来作为一个对象来调用相应的方法比如：
“Hello”.charAt(0);
注意：在底层字符串的值是用私有数组变量来表示的，这个数组是不可以从String类外部访问的，而是在类当中提供了比哪length(),charAt()这些公共的方法来访问
对于字符串的越界访问的时候会产生一个异常StringIndexOutOfBoundsException
比如s.charAt(s.length());这个就越界访问了
使用concat()方法可以连接两个字符串比如下面
String s3 = s1.concat(s2);
Java当中还有一种简便的方法可以连接字符串,使用+号
String s3 = s1+s2;
对于+号也可以连接数字与字符串，这个时候会先把数字转为一个字符串然后进行相应的连接
从字符串中获取子串：
charAt()方法可以获得字符串中相应的单个字符，如果要想获得字符串中的相应的子串可以通过substring()方法来从字符串中提取
它有两个重载的方法
substring(int beginIndex);表示从beginIndex开始一直取到字符串的结尾
substring(int beginIndex,int endIndex);表示从beginIndex开始一直取到下标为endIndex-1的下标为止的子串
那么有一个特殊的地方就是如果beginIndex与endIndex相等则取到的是一个长度为0的空串
字符串的转换：
一旦创建了字符串则它的内容是不可改变的，但是方法toLowerCase,toUpperCase,trim,replace,replaceFirst,replaceAll会返回一个来自于原始字符串的一个新串，这个时候源始的字符串还是没有改变的
toLowerCase,toUpperCase把字符串整个串转为小写或是大写
trim通过删除字符串两端的空格字符返回一个新的字符串
replace,replaceFirst,replaceAll会用新的字符串或子串替换原来字符串中的字符或子串
比如”Welcome”.toLowerCase()返回的是一个新串是”welcoome”
“Welcome”.toUpperCase()返回的是”WELCOME”
“ Welcome ”.trim()返回的是”Welcome”
“Welcome”.replace(‘e’,’A’)返回的是”WAlcomA”
“Welcoome”.replaceFirst(“e”,”AB”)返回的是”WABlcome”
“Welcome”.replaceAll(“e”,”AB”)返回的是”WABlcomAB”
“Welcome”.replace(“el”,”AB”)返回的是”WABlcome”
split方法可以从一个带特定限定符的字符串中提取标志
String[] tokens = “Java#HTML#Perl”.split(“#”,0);
for(int i=0;i<tokens.length;i++)
System.out.print(tokens[i]+” ”);
那么这个时候显示的就是Java HTML Perl
Java中可以通过一个模式来匹配、替换或分隔一个字符串，这里的模式常常叫做正则表达式。
matches()方法
“Java”.matches(“Java”);这个返回的是true,这里匹配的是定长的字符串，而且还可以匹配按一种模式的字符串
“Java is fun”.matches(“Java.*”)这个返回的结果也是true
Java.*是一个正则表达式，它表示字符串以Java开头并且后面有0个或是多个字符
注意在replaceAll,replaceFirst,split当中也可以使用正则的
String s = “a+b#$C”.replaceAll(“[$+#]”,”NNN”);
这个表示把字符串中的$,#,+这三个字符都换为NNN再返回新的字符串
String[] tokens = “Java.C?C#,C++”.split(“[.,:?]”);
这个就表示拆分的时候只要匹配[.,:?]中的任何一个就拆分最后的结果就是Java,c,C#,C++组成的字符串数组
Java中提供了几个重载方法可以找出一个字符或字符串的位置
indexOf,lastIndexOf
indexOf(char ch);找出字符串串第一个出现ch字符的位置如果没有找到则返回-1
indexOf(char ch,int fromIndex);返回字符串中fromIndex后第一个出现ch字符的位置如果没有找到则返回-1
indexOf(String s)
indexOf(String s,int fromIndex);
lastIndexof(String s);返回字符串中最后一次出现s子串的位置，没有找到则返回-1
lastIndexOf(String s,int fromIndex);返回字符串fromIndex之前最后一次出现s子串的位置
lastIndexOf(char ch);
lastIndexOf(char ch,int fromIndex);
字符串与数组之间的转换：
字符串不是一个数组但是可以把字符串与数组之前形成一种转化
toCharArray方法可以把一个字符串传为一个字符数组
char[] chars = “Java”.toCharArray();
可以使用getChars(int srcBegin,int srcEnd,char[] dest,int destBegin);这个方法是把从srcBegin开始到srcEnd-1的子串复制到dest字符数组下标从destBegin开始的位置。
可以把一个字符数组转为一个字符串可以使用String(char[] var);或者是valueOf(char[]);
使用静态方法valueOf可以把这个字符数组转换成字符串，而且这个方法有几个重载版本
这样就可以把数值型或是boolean型的值转为一个字符串，可以通过Double.parseDouble(Str)或是Integer.parseInteger(str)把字符转成相应的数值
格式化字符串：
String类包含静态方法format，可以创建一个格式化的字符串
String.format(format,item1,item2,…itemn);
这个方法就是前面参数是一个格式化的串，后面是格式化串中对应的值
String s = String.format(“%5.2f”,45.678);
这个最后字符串的结果是”45.68”
检测回文串
回文串就是一个串从前往后读和从后往前读是相同的”mom”,”noon”,”dad”等都是回文串
判断是否是回文串：
用使用两个下标一个从前往后移low,一个从后往前移high
判断在这两个下标下的字符是否相等，不相等则不是回文串，如果相等则low+1，high-1之后再判断这时的两个字符是否相等，不相等则不是回文串，相等则low再加1，high再减1直到low>=high时都没有出现两个字符不相等的情况则这个是一个回文串
import java.util.Scanner;
publicclass CheckPalindrome {
publicstaticvoid main(String[] args) {
Scanner input = new Scanner(System.in);
// 提示用户进行输入
System.out.print("请输入一个字符串：");
String s = input.nextLine();
if (isPalindrome(s))
System.out.println("这个字符串是一个回文串");
else
System.out.println("这个字符串不是一个回文串");
}
privatestaticboolean isPalindrome(String s) {
int low = 0;
int high = s.length() - 1;
while (low < high) {
if (s.charAt(low) != s.charAt(high))
returnfalse;
low++;
high--;
}
returntrue;
}
}
在上面的程序中使用Scanner类中nextLine()这样可以读取一行文本以回车作为输入的结束。
十六进制转为十进制：
把一个十六进制转为十进制的方法如下：
int decimalValue = 0;
for(int i=0;i<hex.length();i++){
char hexChar = hex.charAt();
decimalValue = decimalValue*16+hexCharToDecimal(hexChar);
}
完整程序如下：
publicclass HexToDecimalConversion {
publicstaticvoid main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Enter a hex number:");
String hex = input.nextLine();
System.out.println("十六进制数 " + hex + "转为十进制的结果是:"
+ hexToDecimal(hex.toUpperCase()));
}
privatestaticint hexToDecimal(String hex) {
int decimalValue = 0;
if (hex.charAt(0) == '-') {
for (int i = 1; i < hex.length(); i++) {
char hexChar = hex.charAt(i);
decimalValue = decimalValue * 16 + hexCharToDecimal(hexChar);
}
return 0 - decimalValue;
} else {
for (int i = 0; i < hex.length(); i++) {
char hexChar = hex.charAt(i);
decimalValue = decimalValue * 16 + hexCharToDecimal(hexChar);
}
return decimalValue;
}
}
privatestaticint hexCharToDecimal(char hexChar) {
if (hexChar >= 'A' && hexChar <= 'F')
return 10 + hexChar - 'A';
return hexChar - '0';
}
}
字符类Character
Java为每一种基本类型都提供了一种包装类：Character,Boolean,Integer,Long,Float,Double,Byte,Short
这些类都是在java.lang包中的，它们把基本类型数据值当作一个对象来处理
Character是一个字符的包装类：它提供了多种确定字符的类别的方法（大写字母、小写字母、数字）以及把大写字母转为小写字母或者小写字母转为大写字母的方法
可以使用char值来创建一个Character对象
Character character = new Character(‘a’);
charValue方法可以返回包装在Character对象中的字符值
compareTo可以把这个字符与另一个字符进比较，返回一个整数值，这个返回的值就是两个字符之间的统一码之间的差值，当且仅当两个字符相同的时候equals方法才返回true
可以使用isDigit(char ch)判断一个字符是否是数字
isLetter(char)判断一个字符是否是字母
isLetterOrDigit(char ch)判断一个字符是否是数字或是字母
isLowerCase(char ch)判断字符是否为小写字母
isUpperCase(char ch)判断字符是否为大写字母
toLowerCase(char ch)返回这个字符的小写字母
toUpperCase(char ch)返回这个字符的大写字母
统计字符串中每个字母出现的次数：
1， 使用String类的toLowerCase方法把要统计的字符串转为小写
2， 创建一个int类型的数组counts，这个数组中总共有26个元素每一个元素代表了一字母的出现次数
3， 分解字符串中的每一个字符相应的为counts中的元素累加
import java.util.Scanner;
publicclass CountEachLetter {
publicstaticvoid main(String[] args) {
// 输入一个字符串
Scanner input = new Scanner(System.in);
System.out.print("输入一个字符串：");
String s = input.nextLine();
// 创建一个数组来
int[] counts = countLetters(s.toLowerCase());
for (int i = 0; i < counts.length; i++) {
if (counts[i] != 0) {
System.out.println((char) ('a' + i) + "出现" + counts[i] + "次！");
}
}
}
privatestaticint[] countLetters(String lowerCase) {
int[] counts = newint[26];
for (int i = 0; i < lowerCase.length(); i++) {
if (Character.isLetter(lowerCase.charAt(i)))
counts[lowerCase.charAt(i) - 'a']++;
}
return counts;
}
}
StringBuilder/StringBuffer类：
这两个类是程序中常用到的类，可以用来代替String类，并且比String类更加的灵活，可以给StringBuilder/StringBuffer类添加、插入或追加新的内容而不像String类一旦创建则不可以改变。
StringBuilder类与StringBuffer不同之处是StringBuffer是线程安全的如果是在单线程程序中StringBuilder类效率更加的高。
StringBuilder类有三个构造方法
StringBuilder();
StringBuilder(int capacity);//指定容量
StringBuilder(String s);//指定字符串
修改StringBuilder中的字符串：
append(char[] data);追加一个char数组
append(char[] data, int offset,int len);追加char数组中的子数组
append(基本类型值);把一个基本类型值作为字符串追加
delete(int startIndex,int endIndex);删除从startIndex到endIndex-1的字符
delete(int index);删除指定下标为index的字符
insert(int index,char[] data,int offset,int len);把指定的char数组中的子数组插入到指定的index位置
insert(int offset,char[] data);字符数组插入到相应的偏移量处
insert(int offset,基本类型值);把基本类型值插入到指定的偏移量处
insert(int offset,String s);把字符串插入到指定的偏移量处
replace(int startIndex,int endIndex,String s);把从startIndex到endIndex-1处使用String类型值s代替
reverse();把StringBuilder类型的值进行颠倒
setCharAt(int index,char ch);把指定的位置使用ch来代替
注意对于setCharAt方法返回的是一个void，而其它的都会返回字符串生成器的引用如：
StringBuilder stringBuilder1 = stringBuilder.reverse();
这里会把倒值后生成的引用赋给stringBuilder1这样的话这个时候stringBuilder1与stringBuilder都指向同一个StringBuffer对象
注意：如果一个字符串不需要任何的改变可以使用String而不是使用StringBuilder,因为Java对String类进行了相应的优化
capacity();这个方法会返回生成器当前的容量
length();返回字符串生成器中实际存储的字符数量
setLength(int newLength);设置字符串生成器的长度，这个时候newLength必须要>=0
如果参数newLength小于字符串生成器的当前长度则字符串生成器会被截断到恰好能包含由参数newLength给定的字符个数
如果newLength大于或等于当前长度，则给字符串生成器追加足够多的null字符，这样使其长度length为newLength
charAt(int index);方法返回字符串生成器中下标为index的字符，注意下标是从0开始计的
注意：长度：指的是字符串生成器中的字符串的实际长度，容量是生成器的当前大小如果有更的字符加到字符串生成器当中超出它的容量，则生成器的容量会自动增加
可以使用new StringBuilder(initialCapacity)创建指定初始容量的StringBuilder
可以使用trimToSize()方法把容量降到实际的大小
检测一个字符串在忽略掉非字母和非字符时它是否是一个回文串
1， 第一步要把非字母和非数字的字符过滤掉，创建一个空的字符串生成器把字符串中每一个字母或数字字符添加到字符串生成器当中，然后从这个字符串生成器返回所求的字符串
2， 到置这个过滤后的字符串得到一个新串如果这个时候新串与原来的相等equals判断返回true则说明是一个回文串
import java.util.Scanner;
publicclass FsFzPanduanhwc {
publicstaticvoid main(String[] args) {
Scanner input = new Scanner(System.in);
// 提示输入一个字符串
System.out.print("输入一个字符串：");
String s = input.nextLine();
// 对字符串进行处理删除非字母非数字后判断是不是回文串
System.out.println("把非数字非字母的字符除掉后这个字符串" + (ishw(s) ? "是回文串" : "不是回文串"));
}
privatestaticboolean ishw(String s) {
// 先进行过滤
String s1 = filter(s);
// 对这个过滤后的字符串进行倒置
String s2 = reverse(s1);
// 返回这两个字符串是否相等的比较
return s1.equals(s2);
}
privatestatic String reverse(String s1) {
StringBuilder sb = new StringBuilder(s1);
return sb.reverse().toString();
}
privatestatic String filter(String s) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if (Character.isLetterOrDigit(s.charAt(i)))
sb.append(s.charAt(i));
}
return sb.toString();
}
}
文件类File：
早期我们程序的数据是存在文件当中的而不是在数据库当中。
文件系统当中，每一个文件都存放在一个目录下，绝对文件名：就是完整的文件路径包括磁盘的路径，但对于不同的系统这种绝对的路径表示的方式还是不一样的的比如在Window系统与unix系统中表示的方式就是不一样的
File类特意提供了一种抽象使其不依赖于具体的系统来表示一个文件
File类中包括了很多的获得文件的属性的方法及重命名及删除文件的方法。
注意：File类没有对文件读写的方法。
File(String pathName);通过指定的路径来创建一个文件
File(String parent,string child);为目录parent下的child创建一个File对象，这里的child可以是一个文件名也可以是一个目录名
File(File parent,String child);为目录parent下child创建一个File对象，parent是一个File对象
exists();判断一个文件是否存在返回一个boolean值
canRead();判断一个文件是否可读
canWrite();判断一个文件是否可写
isDirectory();判断File是否是一个目录
isFile();判断File对象是否是一个文件
isAbsolute();判断是否是用一个绝对路径创建的一个文件
isHidden();判断这个文件是否是隐藏的
getAbsolutePath();返回一个File对象的绝对路径名
getCanonicalPath();在Windows系统中与getAbsolutePath()返回的结果是一样的，它返回的结果可以除掉.,..这些冗余
getName();返回文件名中的最后一部分比如：C:\\base\\test.txt返回的就是test.txt
getPath();返回的是文件的整个路径比如：C:\\base\\test.txt返回的就是C:\base\test.txt
getParent();返回的就是文件的父目录比如：C:\\base\\test.text返回的是C:\base
lastModified();返回的文件的最后一次修改时间，返回的是一个long值
length();返回的是文件的大小如果文件不存在则返回0，如是目录则返回目录的大小，返回的是一个long值
listFiles();返回文件目录下的文件，返回的是一个File[]
delete();删除文件，如果删除成功则返回true
renameTo(File dest);重命名这个文件操作成功则返回true
文件名是一个字符串，File类是对文件名及其目录的包装类
注意：在Windows中目录的分隔符是一个反斜杠，而Java中它是一个特殊字符因而要进行转义也就是使用\\表示一个\
构造一个File实例并不会在机器上创建一个文件，不管文件是否存在都可以创建任意文件名的File实例可以使用exists()方法进行判断文件是否存在
new File(“Welcom.java”);这个表示为当前目录上Welcome.java创建一个File对象
newFile(“image/a.gif”);表示为当前目录下的image目录下的a.gif创建一个File对象
/在Java当中表示目录分隔符，这使得在windows和unix中都可以通用
import java.io.File;
import java.io.IOException;
import java.util.Date;
publicclass TestFile {
publicstaticvoid main(String[] args) {
File file = new File("image/a.gif");
System.out.println("这个文件是否存在？" + file.exists());
if (file.exists() == false) {
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("这个文件的大小：" + file.length() + "bytes");
System.out.println("这个文件是否可读？" + file.canRead());
System.out.println("这个文件是否可写？" + file.canWrite());
System.out.println("这个文件是否是一个目录？" + file.isDirectory());
System.out.println("这个文件是否是一个文件？" + file.isFile());
System.out.println("这个文件是一个绝对路径？" + file.isAbsolute());
System.out.println("这个文件是一个隐藏文件？" + file.isHidden());
System.out.println("这个文件的绝对路径是：" + file.getAbsolutePath());
System.out.println("这个文件的最后修改时间：" + new Date(file.lastModified()));
}
}
文件输入输出：
File类封装了文件或路径的所有属性，但是它不包括文件的创建读写方法，可以使用Scanner类或是PrintWriter类向文件中写字符中或数值
PrintWriter写数据：
java.io.PrintWriter类可以用于创建一个文件并向文本文件写入数据，第一步要为一个文本文件创建一个PrintWriter对象
PrintWriter output = new PrintWriter(filename);
接下来可以使用print,println,printf方法来向文件中写入数据
println写入数据后会写入一个分隔符，这个分隔符与系统有关在windows中是\r\n,在unix系统中是\r
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
publicclass WriteData {
publicstaticvoid main(String[] args) throws FileNotFoundException {
File file = new File("image/score.txt");
if (file.exists()) {
System.out.println("文件已存在！");
System.exit(0);
}
PrintWriter output = new PrintWriter(file);
output.print("谢声 ");
output.println(90);
output.print("xiaoxie ");
output.print(95);
// 最后要刷新缓冲区并关闭这个文件
output.flush();
output.close();
}
}
PrintWriter的构造方法会创建文件,对于PrintWriter可能会产生I/O异常Java要求对这种运行时异常进行处理在这里有两种处理办法一种是捕获，一种是抛给调用者去处理，这里是抛给JVM去处理
对文件进行写入数据后一定要调用close方法来关闭文件，如果没有调用这个方法则数据无法正确定入到文件当中
使用Scanner类读数据：
java.util.Scanner类用来从控制台读取字符串和基本数据，Scanner可以输入分为由空白字符分隔的有用信息，为了能从键盘读取需要为System.in创建一个Scanner对象
Scanner input = new Scanner(System.in);
那么为了从文件读取则要为文件创建一个Scanner
Scanner input = new Scanner(new File(filename));
这个类的方法：
hasNext();这个方法如果Scanner还有可读的数据则会返回true
next();Scanner返回下一个标志作为字符串，返回的是一个String
nextLine();读取一行用行分隔符作为一行的结束
nextByte();返回下一个byte值
nextShort();返回下一个short值
nextInt();返回下一个int值
nextLong();返回下一个long值
nextFloat();返回下一个float值
nextDouble();返回下一个double值
useDelimiter(String pattern);设置这个Scanner分隔模式返回一个Scanner
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
publicclass ReadData {
publicstaticvoid main(String[] args) throws FileNotFoundException {
File file = new File("image/score.txt");
Scanner input = new Scanner(file);
// 从这个文件中读取数据
while (input.hasNext()) {
String name = input.next();
double score = input.nextDouble();
System.out.println("名字: " + name + "\t分数: " + score);
}
// 关闭文件
input.close();
}
}
Scanner的工作原理：
nexByte(),nextShort(),nextInt(),nextLong(),nextFolat(),nextDouble(),next()这些都称为令牌读取方法，因为它们读取用分隔符分隔开的令牌默认的情况下分隔符是空格可以使用useDelimiter(String pattern)来设定分隔符模式
令牌读取方法：首先会跳过任意多个分隔符，然后读取一个以分隔符结束的令牌，对于相应的读取方法会把读到的令牌读转为相类型的数据，如果是next()方法则不会进行这个转换过程，如果在转换的过程无法转为相应的类型则会抛出一个异常
next(),nextLine()都会读取一个字符串而两者是有区别的，一个是读取由分隔符结束的字符串，一个是读取由行分隔符分隔的一行
注意：对于不同的系统来说行分隔符是不一样的比如Windows平台上是\r\n在unix不台上是\r
为了得到特定平台上的行分隔符可以使用下面的方法：
String lineSeparator = System.getProperty(“line.separator”);
由于nextLine()读取的时候是按行分隔符读的则它不会在读之前跳过多人分隔符如果选读取一个后后面的空隔也会被读入比如：
34 123
这个时候int i = input.nextInt();à34
接下来String line = input.nextLine();à这时读入的字符串中包含的字符是’ ’,’1’,’2’,’3’
文件对话框：
Java提供了javax.swing.JFileChooser类来显示文件对话框
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import javax.swing.JFileChooser;
publicclass ReadFileUseingDialg {
publicstaticvoid main(String[] args) throws FileNotFoundException {
JFileChooser fileChooser = new JFileChooser();
int flag = fileChooser.showOpenDialog(null);
if (flag == JFileChooser.APPROVE_OPTION) {
File file = fileChooser.getSelectedFile();
Scanner input = new Scanner(file); // 为文件创建一个Scanner
while (input.hasNext()) {
System.out.println(input.nextLine());
}
// 关闭文件
input.close();
} elseif (flag == JFileChooser.CANCEL_OPTION) {
System.exit(0);
} else {
System.out.println("文件没有找到！");
}
}
}
187
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
