【文章标题】java小程序（2）
【文章作者】曾健生
【作者邮箱】zengjiansheng1@126.com
【作者QQ】190678908
【作者声明】本人水平有限，失误之处，敬请各位指出。本人以前写的一些小程序，分享一下希望对各位学习java有帮助 ^-^
*******************************************************************************
题目：
/*====第八题====================================
取出一个文本文件中所有的email地址，并存放到集合中。
*/
/*====第九题====================================
通过键盘录入的方式，进行猜数字的游戏。
要求：输入一个1~100之间的数字，
与预先给定数字不同，要给出大或者小的提示。
*/
/*====第十题====================================
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
*/
/*====第十一题==================================
字符串由多个数字和空格组成“20 8 0 -1 32 14”，
将字符串中的数字按数值大小升序排列，获取排序后的字符串。
*/
/*====第十二题==================================
写一个程序，允许用户依次输入多个姓名和住址，
并能将用户的输入保存到文件中。
用户输入 ”quit” 表示输入完毕，程序退出。
*/
/*====第十三题==================================
找出一个整数数组{2,4,1,4,3,2,4,3,2}出现次数最多的数。
*/
/*====第十四题==================================
给定两个字符串，比较两个字符串中最大相同的子串.
*/
/*====第十五题==================================
编写一个程序，记录该程序运行次数。运行满足30次，就提示用户“软件试用期限已到”；
*/
/*====第十六题==================================
已知文件a.txt文件中的内容为“bcdeadferwplkou”，
请编写程序读取该文件内容，并按照自然顺序排序后输出到b.txt文件中。
即b.txt中的文件内容应为“abcd…………..”这样的顺序。
/*====第八题====================================
取出一个文本文件中所有的email地址，并存放到集合中。
思路：
1，通过字符流（FileReader）来读取一个文件。比较高效的方式是一行一行读。
就通过BufferedReader的readLine方法。
2，通过正则规则来对一行文本进行规则的取出。
a,先把规则封装成对象。Pattern.compile（reg）返回一个正则对象。
让该对象与该行字符串建立联系。调用该对象的一个matcher方法。将所要匹配的字符串传给matcher方法。
该方法返回一个匹配器对象。该对象可以通过find（）找到所匹配的内容，在通过group方法取出该内容。
3，将匹配的内容存入集合（建立用hashset，因为可以保证email的唯一性。）。
*/
import java.util.*;
import java.util.regex.*;
import java.io.*;
class FindEmail
{
TreeSet<String> set;
BufferedReader br;
String filePath;
FindEmail( String filePath )
{
this.filePath=filePath;
set=new TreeSet<String>();
}
public void start()
{
listFile() ;
printEmailAddress();
}
//遍历文件的每一行
private void listFile()
{
try
{
br=new BufferedReader( new FileReader("1.txt"));
String s=null;
while( (s=br.readLine())!=null )
{
matchRegex(s);
}
}
catch( Exception e)
{
e.printStackTrace();
}
finally
{
if( br!=null )
{
try
{
br.close();
}
catch( IOException e )
{
e.printStackTrace();
}
}
}
}
//找出每一行中的邮件地址
private void matchRegex( String str)
{
Pattern pa = Pattern.compile( "//b//w+@[a-zA-Z0-9]+(//.[a-zA-Z]+)+//b" );
Matcher matcher=pa.matcher( str );
while( matcher.find() )
{
String s=matcher.group();
//System.out.println(s);
set.add( s );
}
}
//把遍历到的邮件地址输出
private void printEmailAddress()
{
Iterator<String> i=set.iterator();
while( i.hasNext())
{
System.out.println( i.next());
}
}
}
class Demo
{
public static void main(String args[] )
{
new FindEmail("1.txt").start();
}
}
/*====第九题====================================
通过键盘录入的方式，进行猜数字的游戏。
要求：输入一个1~100之间的数字，
与预先给定数字不同，要给出大或者小的提示。
思路：
1，建立随机数。
通过Random类。nextInt方法
2，读取键盘，获取键盘录入数字。
一行一行的读很方便。通过将System.in。进行转换并包装。使用readLine方法。
3，将获取数字与随机数进行比较。
4，进行相关判断。
通过NubmerFormatException确定是否是数字。
*/
import java.util.*;
import java.io.*;
class GuessNumber
{
private int num=0;
BufferedReader br;
String input;
int inputNum;
GuessNumber()
{
num=new Random().nextInt(100);
br=new BufferedReader( new InputStreamReader(System.in));
}
//游戏开始进入无限循环，直到猜中为止
public void startGuess()
{
while( true )
{
System.out.print("请输入数字：");
try
{
input=br.readLine();
}
catch( IOException e )
{
e.printStackTrace();
continue;
}
//判断输入的是否是数字
try
{
inputNum=Integer.parseInt( input );
}
catch( NumberFormatException e )
{
System.out.println("输入的不是数字，请重新输入");
continue;
}
if( judgeWin( inputNum ) )
{
break;
}
}
closeInput();
}
//判断结果，如果没猜中则给出相关的提示并返回假，如果猜中就返回真
private boolean judgeWin( int inputNum )
{
boolean flag=false;
if( num>inputNum )
{
System.out.println("小了");
}
else if( num<inputNum )
{
System.out.println("大了了");
}
else
{
System.out.println("恭喜猜中了");
flag=true;
}
return flag;
}
//关闭输入流
private void closeInput()
{
if( br!=null )
{
try
{
br.close();
}
catch( Exception e )
{
e.printStackTrace();
}
}
}
}
class Demo
{
public static void main(String args[] )
{
new GuessNumber().startGuess();
}
}
/*====第十题====================================
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
思路：
员工分普通员工和经理。
1，首先将两个共性的东西向上抽取。（姓名，age，id,工资。有一个工作方法。）
因为普通和经理工作内容不同。需要这两个子类自己去实现。那么该方法是抽象的。（好处，普通和经理只要是员工就必须工作，强制性。）
2，在定义经理类，除了拿到父类中共性的东西，他还有特性的东西。（奖金）
*/
//工作类的抽象
abstract class Worker
{
private String name;
private String ID;
private double pay;
Worker( String name, String ID, double pay )
{
this.name=name;
this.ID=ID;
this.pay=pay;
}
public void setName( String name )
{
this.name=name;
}
public String getName()
{
return name;
}
public void setID( String ID )
{
this.ID=ID;
}
public String getID()
{
return ID;
}
public void setPay( double pay )
{
this.pay=pay;
}
public double getPay()
{
return pay;
}
abstract public void work();
}
//这是工人类
class Employee extends Worker
{
Employee( String name, String ID, double pay )
{
super( name,ID,pay );
}
//强制实现了工作方法
@Override
public void work()
{
System.out.println( "Employee work" );
}
}
//这是经理类
class Manager extends Worker
{
private double bouse;
Manager( String name, String ID, double pay, double bouse )
{
super( name,ID,pay );
this.bouse=bouse;
}
//强制实现了工作方法
@Override
public void work()
{
System.out.println( "Manager work" );
}
}
/*====第十一题==================================
字符串由多个数字和空格组成“20 8 0 -1 32 14”，
将字符串中的数字按数值大小升序排列，获取排序后的字符串。
思路:
1,将给定字符串按照规则(空格)进行切割变成字符串数组.
2,将字符串数组中的元素转成int型的值存入int数组中.
3,对数组进行排序.
4,将数组在变成字符串.
a.整型数组变成字符串可以同临时定义一个容器(StringBuffer),
对元素进行存储.
b.在将StringBuffer.toString变成字符串.
*/
import java.util.*;
class Demo
{
public static void main(String agrs[]) throws Exception
{
String s="20 8 0 -1 32 14";
TreeSet<Integer> set=new TreeSet<Integer>();
StringBuffer sb=new StringBuffer();
String charArray[]=s.split(" ");
for( int i=0; i< charArray.length; i++ )
{
set.add( Integer.parseInt( charArray[i] ));
}
Iterator<Integer> i=set.iterator();
while( i.hasNext() )
{
sb.append( i.next()+" " );
}
System.out.println( sb.toString() );
}
}
/*====第十二题==================================
写一个程序，允许用户依次输入多个姓名和住址，
并能将用户的输入保存到文件中。
用户输入 ”quit” 表示输入完毕，程序退出。
*/
import java.util.*;
import java.io.*;
class Demo
{
public static void main(String agrs[])
{
BufferedReader br=new BufferedReader(
new InputStreamReader( System.in ));
String s=null; //保存输入的数据
HashSet<String> set=new HashSet<String>();
//输入的格式为"姓名,地址“
try
{
while( (s=br.readLine())!=null )
{
if( s.equals("quit") )
{
break;
}
set.add( s );
}
}
catch( IOException e )
{
e.printStackTrace();
}
saveData( set );
}
//把信息保存到文件上
static void saveData( HashSet<String> set )
{
BufferedWriter bw;
try
{
bw=new BufferedWriter( new FileWriter("log.txt"));
}
catch( IOException e )
{
System.out.println("文件写入错误");
return;
}
String s[]=null;
String inputStr=null;
Iterator<String> i=set.iterator();
while( i.hasNext() )
{
inputStr=i.next();
s=inputStr.split(",");
try
{
bw.write( "姓名："+s[0] +" 地址"+s[1] );
bw.newLine();
}
catch( IOException e )
{
e.printStackTrace();
System.out.println("文件写入错误");
}
}
try
{
bw.close();
}
catch( IOException e )
{
e.printStackTrace();
}
}
}
/*====第十三题==================================
找出一个整数数组{2,4,1,4,3,2,4,3,2}出现次数最多的数。
*/
import java.util.*;
import java.io.*;
class CountMaxNum
{
private int num[];
private int maxNum; //记录最大出现的数字
private int countNum; //记录最大出现的数字出现的次数
private HashMap<Integer,Integer> map;
CountMaxNum( int num[] )
{
this.num=num;
map=new HashMap<Integer,Integer>();
maxNum=0; //记录最大出现的数字
countNum=0; //记录最大出现的数字出现的次数
}
public void start()
{
inputSet();
printString();
}
/*
利用了map容器“不允许重复元素”和“键和值一一对应”的特点
1.遍历数组中的每个元素
2.检查遍历到的元素是否已在map容器中
3.如果元素不在容器中，初始化出现次数为1，把“元素，出现次数”放入容器中
4.如果元素在容器中，把出现的次数取出来加1后再把“元素，出现次数”放入容器中
5.用计数器记录最大出现次数
*/
private void inputSet()
{
for( int i=0; i<num.length; i++ )
{
//如果元素在容器中，把出现的次数取出来加1后再把“元素，出现次数”放入容器中
if( map.containsKey( num[i] ))
{
map.put( num[i], map.get( num[i] )+1 );
}
else //元素不在容器中，初始化出现次数为1，把“元素，出现次数”放入容器中
{
map.put( num[i],1 );
}
}
}
//用遍历的方法，定义一个计数器记录出现次数最大的数
private void printString()
{
ArrayList<Integer> arr=new ArrayList<Integer>(); //记录出现最多的数字
Iterator<Map.Entry<Integer,Integer>> iter=map.entrySet().iterator();
while( iter.hasNext() )
{
Map.Entry<Integer,Integer> i=iter.next();
if( countNum<i.getValue() )
{
countNum=i.getValue();
maxNum=i.getKey();
}
}
Iterator<Map.Entry<Integer,Integer>> it=map.entrySet().iterator();
//根据maxNum取出次数最多的元素
while( it.hasNext() )
{
Map.Entry<Integer,Integer> i=it.next();
if( countNum==i.getValue() )
{
System.out.println( i.getKey() );
}
}
}
}
class Demo
{
public static void main(String agrs[])
{
int num[]={ 12,14,11,14,13,12,14,13,12 };
new CountMaxNum( num ).start();
}
}
/*====第十四题==================================
给定两个字符串，比较两个字符串中最大相同的子串.
*/
import java.util.*;
class Demo
{
public static void main(String agrs[])
{
String str="dsadfdfdsf";
String findstr="sdfd" ;
String find=null;
HashSet<String> set=new HashSet<String>(); //记录最大相同子集
for( int i=0; i<str.length(); i++ )
{
boolean flag=false; //定义标记，记录是否有最大子串
for( int j=0,z=findstr.length()-i;
z<=findstr.length();j++,z++)
{
if( str.contains(
findstr.substring( j,z )))
{
flag=true;
set.add(findstr.substring( j,z ) );
}
}
if( flag )
{
break;
}
}
//遍历集合，取出最大相同子集
Iterator<String> i=set.iterator();
while( i.hasNext() )
{
System.out.println( i.next() );
}
}
}
/*====第十五题==================================
编写一个程序，记录该程序运行次数。运行满足30次，就提示用户“软件试用期限已到”；
思路：
原理是通过一个配置文件来实现运行次数的记录。每一次运行后都将该配置文件中的数值进行更改。
通常这种配置文件都是以 属性=属性值 的形式。这样可以记录多个属性信息。
1，在应用程序第一次运行前该文件是不存在的。所以第一运行时要先对该文件进行判断。不存在就创建，
2，既然要读取硬盘上的文件。就通过流和该文件关联。
3，既然又有属性又有值，就是键值对的形式。可以想到map集合。那么使用哪个map集合的子类呢？
如何能把流中的数据存入到集合中呢？Map集合的子类HashTable有一个子类Properties.正好可以做这件事。
该对象有一个方法load.可以直接加载流。并把流中的数据按照键值对的形式存入Properties集合中.
(注意:流中的数据必须要有固定的格式如:)
*/
import java.io.*;
import java.util.*;
class Demo
{
public static void main(String arsg[])
{
Properties pro=new Properties( );
File f=null;
FileInputStream fis=null;
FileOutputStream fos=null;
try
{
f=new File( "info.ini" );
if( !f.exists() )
{
f.createNewFile();
}
fis=new FileInputStream( f );
pro.load( fis );
}
catch( Exception e )
{
System.out.println( "文件读写有误" );
}
int count=Integer.parseInt( pro.getProperty("runtimes") );
//判断是否运行过期
if( count>30 )
{
System.out.println( "软件已过期，请注册" );
}
else //软件没过期，输入新的运行次数
{
count++;
try
{
pro.setProperty( "runtimes",
new Integer(count).toString() );
fos=new FileOutputStream( f );
pro.store( fos,"" );
}
catch( Exception e )
{
e.printStackTrace();
}
finally
{
try
{
fis.close();
fos.close();
}
catch( IOException e )
{
e.printStackTrace();
}
}
}
}
}
/*====第十六题==================================
已知文件a.txt文件中的内容为“bcdeadferwplkou”，
请编写程序读取该文件内容，并按照自然顺序排序后输出到b.txt文件中。
即b.txt中的文件内容应为“abcd…………..”这样的顺序。
思路：
1，将该文件读取将数据取出，变成字符串
a.因为是文本文件。可以直接用字符流（FileReader）
b.为了提高效率，并方便获取数据。对其进行包装（BufferedReader）使用readLine方法一行一行读。
2，把字符串变成字符数组，对该数组进行排序。
a.通过字符创的toCharArray方法，将字符串变成字符数组。
b.自定义排序功能函数（冒泡，选择都可以）对字符数组进行排序。
3，把排序后的数组变成字符串，并通过流将字符串写入b.txt文件中。
a.通过String类的构造函数将字符数组变成字符串。
b.通过FileWriter把字符串写入到b.txt文件中。
*/
import java.io.*;
//对字符数组进行排序的类
class SortChar
{
private String str;
private char arrayList[];
private BufferedReader br; //字符流
private File f; //读取的文件
SortChar( String s )
{
f=new File( s );
}
public void start()
{
if( inputData()==-1 )
{
return;
}
//对字符数组进行冒泡排序
sortChar( );
//把排序后的数组变成字符串，并通过流将字符串写入b.txt文件中。
outputString();
}
//通过BufferedReader读取文本中的字符串
//读取文件失败返回-1,成功返回1
private int inputData()
{
try
{
br=new BufferedReader( new FileReader(f));
//读取文本的内容
while( (str=br.readLine())!=null )
{
//把所有字母转换为小写
str.toLowerCase();
arrayList=str.toCharArray();
}
}
catch( IOException e )
{
System.out.println( "读取文件出错!" );
e.printStackTrace();
return -1;
}
finally
{
//关闭输入流
if( br!=null )
{
try
{
br.close();
}
catch( IOException e )
{
e.printStackTrace();
}
}
}
return 1;
}
//对字符数组进行冒泡排序
private void sortChar( )
{
char temp=0;
for( int i=0; i<arrayList.length-1; i++ )
{
for( int j=0; j<arrayList.length-i-1; j++ )
{
if( arrayList[j]>arrayList[j+1] )
{
temp=arrayList[j];
arrayList[j]=arrayList[j+1];
arrayList[j+1]=temp;
}
}
}
}
/*
把排序后的数组变成字符串，并通过流将字符串写入b.txt文件中。
a.通过String类的构造函数将字符数组变成字符串。
b.通过FileWriter把字符串写入到b.txt文件中。
*/
private void outputString()
{
BufferedWriter bw=null;
try
{
FileWriter fw = new FileWriter("b.txt");
bw = new BufferedWriter(fw);
//把排序完成后的字符串重新写入到文件中
bw.write( new String( arrayList,0,arrayList.length ));
bw.flush();
}
catch( IOException e )
{
e.printStackTrace();
}
finally
{
//关闭输入流
if( bw!=null )
{
try
{
bw.close();
}
catch( IOException e )
{
e.printStackTrace();
}
}
}
}
}
class Demo
{
public static void main(String arsg[])
{
new SortChar( "a.txt" ).start();
}
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
