java小程序（2）

【文章标题】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();

             

       }

}