java小程序（3）

【文章标题】java小程序（3）

【文章作者】曾健生

【作者邮箱】zengjiansheng1@126.com

【作者QQ】190678908

【作者声明】本人水平有限，失误之处，敬请各位指出。本人以前写的一些小程序，分享一下希望对各位学习java有帮助 ^-^

*******************************************************************************

题目：

 

 

/*====第十七题==================================

客户端向服务端上传图片。将客户端封装成线程。

*/

 

/*====第十八题==================================

在java中，字符串“abcd”与字符串“ab你好”的长度是一样，都是四个字符。

但对应的字节数不同，一个汉字占两个字节。

定义一个方法，按照最大的字节数来取子串。

如：对于“ab你好”，如果取三个字节，那么子串就是ab与“你”字的半个，

那么半个就要舍弃。如果去四个字节就是“ab你”，取五个字节还是“ab你”.

*/

 

/*====第二十题==================================

将一个图片切割成多个文件。在将多个文件合并成该图片

 

 

/*====第二十一题==================================

编写一个方法。去除Vector集合中的重复元素。

*/

 

/*====第二十二题==================================

取出一个字符串中字母出现的次数。如："abcdekka27qoq"  a(2)b(1)k(2)...

*/

 

 

 

 

 

 

/*====第十七题==================================

客户端向服务端上传图片。将客户端封装成线程。

*/

 

import java.net.*;

import java.io.*;

 

//服务端程序

class ServerJpg

{

       public static void main( String args[] ) throws Exception

       {

              ServerSocket ser =new ServerSocket( 9999 );

              Socket s=ser.accept();

              InputStream in=s.getInputStream();

              byte buf[]=new byte[1024];

              int num=0;

              //写入到一个JPG文件中

              FileOutputStream fis=new FileOutputStream( "2.jpg" );

              while( ( num=in.read(buf) )!=-1 )

              {

                     fis.write( buf, 0, num );

              }

              s.close();

              ser.close();

              in.close();

              fis.close();

       }

}

 

//客户端程序，封装成一个线程

class clientJpg implements Runnable

{

       public void run()

       {

              Socket s=null;

              OutputStream os=null;

              FileInputStream fis=null;

              try

              {

                     s=new Socket( "10.1.15.124", 9999 );

                     os=s.getOutputStream();

                     fis=new FileInputStream( "1.jpg" );

                     byte buf[]=new byte[1024];

                     int num=0;

                     while( (num=fis.read(buf))!=-1 )

                     {

                            os.write( buf,0, num );

                     }

              }

              catch( Exception e )

              {

                     e.printStackTrace();

              }

              finally

              {

                     try

                     {

                            s.shutdownInput();

                            os.close();

                            fis.close();

                     }

                     catch( Exception e )

                     {

                            e.printStackTrace();

                     }

              }

       }

}

 

class Demo

{

       public static void main(String args[])

       {

              new Thread( new clientJpg()).start();

       }

}

 

 

/*====第十八题==================================

在java中，字符串“abcd”与字符串“ab你好”的长度是一样，都是四个字符。

但对应的字节数不同，一个汉字占两个字节。

定义一个方法，按照最大的字节数来取子串。

如：对于“ab你好”，如果取三个字节，那么子串就是ab与“你”字的半个，

那么半个就要舍弃。如果去四个字节就是“ab你”，取五个字节还是“ab你”.

 

思路：

首先要知道汉字是由连个字节所组成。而且这两个都是负数。

1，先将该字符串变成字节数组（getBytes）

2，通过要截取的长度位。来判断该位置是正数还是负数。

       只要为负数。就往回判断前一个字节是正还是负。以此类推。

       定义一个计数器，记录负数出现的次数。如果该数为偶数。那么就将要去长度的字节数。转成字符串（说明没有半个汉字存在。）

       如果是奇数。就将最后一个字节舍弃。在转成字符串。

*/

 

import java.io.*;

 

class Demo

{

       public static void main(String args[])

       {

              byte buf[]="ab你好".getBytes();

              int num=0;//记录是第几个数字

              int count=0;    //记录负数的个数

             

              try

              {

                     BufferedReader br=new BufferedReader(

                            new InputStreamReader(System.in));

                    

                     num=Integer.parseInt( br.readLine() );

              }

              catch( Exception e )

              {

                     e.printStackTrace();

                     System.out.println( "输入有误" );

                     return;                  

              }

             

              for(int i=0; i<num-1; i++ )

              {

                     if( buf[i]<0 )

                     {

                            count++;

                     }

              }

             

              if( count%2==0 )

              {

                     System.out.println( num );

                     System.out.println( new String( buf,0, num-1 ));

              }           

              else

              {

                     System.out.println( num );

                     System.out.println( new String( buf,0, num ));

              }

       }

      

 

}

 

 

 

/*====第十九题==================================

利用LinkedList去实现一个队列的效果.

自定该功能类.(队列的特点是元素先进先出,去查看LinkList中的方法)

*/

class DuiLie<T>

{

       private LinkedList<T> ll;

       DuiLie()

       {

              ll = new LinkedList<T>();

       }

       public void myAdd(T t)

       {

              ll.addFirst(t);

       }

       public T myGet()

       {

              return ll.removeLast();

       }

       public boolean isNull()

       {

              return ll.isEmpty();

       }

}

 

class TD

{

       public static  void main(String[] args)

       {

              DuiLie dl = new DuiLie();

              dl.myAdd("hahah");

              dl.myAdd("kkkk");

              dl.myAdd("qqq");

              while(dl.isNull())

              {

                     System.out.println(dl.myGet());

              }

       }

}

/*====第二十题==================================

 

 

将一个图片切割成多个文件。在将多个文件合并成该图片

 

 

1，通过字节流读取该图片。定义一个缓冲区数组该数组的大小 是要生成的切割后的文件大小。

通过输出流将该数组中的数据，写到一个文件中（文件名要有规律。1.haha  2.haha...）

（可以通过一个自定义配置文件保存原文件的基本属性信息。如：源文件的名字 已经切割出来的碎片文件的个数。方便合并。）

 

2,合并，首先要知道碎片文件的目录，列出该目录当前的所有.haha文件。（遍历时可以通过配置文件中的信息确定循环的次数。）

并按照顺序把每一个碎片文件用流读取。（一个文件对应一个流。）

将这些流存入集合。（why？因为要通过序列流进行合并。（SequenceInputStream）该流会接受一个Enumeration）

 

3，读取序列流中的数据，并把该数据都写入到一个（图片）文件中。

*/

 

import java.io.*;

 

/*文件分割类，

1.通过流的形式读取源数据

2.通过定义一个固定的字节数组，实现文件分割

  a，用FileInputStream读取源文件

  b，通过一个字节数组作为中介存储

  c，把读取到的数据写入到一个新文件

3.把原来的文件名和分割的个数写入到一个配置文件中

*/

 

import java.io.*;

 

/*文件分割类，

1.通过流的形式读取源数据

2.通过定义一个固定的字节数组，实现文件分割

  a，用FileInputStream读取源文件

  b，通过一个字节数组作为中介存储

  c，把读取到的数据写入到一个新文件

3.把原来的文件名和分割的个数写入到一个配置文件中

*/

import java.io.*;

 

/*文件分割类，

1.通过流的形式读取源数据

2.通过定义一个固定的字节数组，实现文件分割

  a，用FileInputStream读取源文件

  b，通过一个字节数组作为中介存储

  c，把读取到的数据写入到一个新文件

3.把原来的文件名和分割的个数写入到一个配置文件中

*/

 

import java.io.*;

import java.util.*;

 

/*文件分割类，

1.通过流的形式读取源数据

2.通过定义一个固定的字节数组，实现文件分割

  a，用FileInputStream读取源文件

  b，通过一个字节数组作为中介存储

  c，把读取到的数据写入到一个新文件

3.把原来的文件名和分割的个数写入到一个配置文件中

*/

class FileSplit

{

       private File f;

       private FileInputStream fis;

       private FileOutputStream fos;

       private String fileName;

       int count;

      

       //传入要分割的文件路径

       FileSplit( String s )

       {

              f=new File( s );

              fileName=s;

              count=0;

       }

      

       public void split()

       {

              try

              {                  

                     fis=new FileInputStream( f );

                     byte buf[]=new byte[1024*256];

                     int num=0;

                     while( ( num=fis.read( buf ) )!=-1 )

                     {

                            //创建一个临时的分割文件对象

                            if( createSplitFile( buf, 0, num )==-1 )

                            {

                                   return;

                            }

                            count++;                                                        

                     }                                                     

              }

              catch( IOException e )

              {

                     e.printStackTrace();

              }

              finally

              {

                     //关闭输入流

                     if( fis!=null )

                     {

                            try

                            {

                                   fis.close();

                            }

                            catch( IOException e )

                            {

                                   e.printStackTrace();

                            }

                     }

              }

             

              //创建配置文件“file.ini”，其中格式为“文件个数>文件名”

              createInfoFile();

             

              System.out.println( "文件分割成功" );

       }

      

       创建一个临时的分割文件对象，如果返回-1表示创建失败，

       //程序退出

       private int createSplitFile( byte buf[],int zero,int num )

       {

              //创建临时的文件对象

              FileOutputStream fosTemp=null;

              try

              {

                     fosTemp=new FileOutputStream( count+".haha" );

                     fosTemp.write( buf,zero,num );

                     fosTemp.flush();

              }

              catch( IOException e )

              {

                     System.out.println( "文件"+count+".haha创建失败" );

                     return -1;

              }

              finally

              {

                     //关闭输出流

                     try

                     {

                            fosTemp.close();

                     }

                     catch( IOException e )

                     {

                            e.printStackTrace();

                     }

              }

              return 1;        

       }

      

       //创建配置文件“file.ini”，其中格式为“文件个数>文件名”

       private void createInfoFile()

       {

              File infoFile=new File( "file.ini" );

              BufferedWriter br=null;

              try

              {

                     //如果文件不存在就创建一个新的的文件

                     if( !infoFile.exists() )

                     {

                            infoFile.createNewFile();

                     }

             

                     br=new BufferedWriter(

                            new FileWriter(infoFile) );

                     br.write( count+">"+fileName );

                     br.newLine();

                     br.flush();

              }

              catch( IOException e )

              {

                     e.printStackTrace();

              }

              finally

              {

                     if( br!=null )

                     {

                            try

                            {

                                   br.close();

                            }

                            catch( IOException e )

                            {

                                   e.printStackTrace();

                            }

                     }

              }

       }

      

}

 

/*

文件合并类

1.通过枚举获取配置文件对象

2.通过输入流获取文件个数和源文件名称

3.把各个文件对象存放在序列流中

4.把通过序列流合并成一个文件

*/

class FileMerge

{

       File fileDir; //配置文件目录

      

       FileMerge( String s )

       {

              this.fileDir=new File( s );

       }

      

      

       public void startMerge()

       {

              //获取配置文件对象

              File f=getFile( fileDir );

             

              //获取文件的配置信息

              String fileInfo=getFileInfo( f );

             

              //获取文件的个数

              int count=getFileCount( fileInfo );

             

              //获取分割前的文件名

              String fileName=getFileName( fileInfo );

             

              //获取枚举集合

              Vector<FileInputStream> v=getAllFile( count );

             

              //如果集合不为空就合并文件

              if( v!=null  )

              {

                     merge( v,fileName );

              }

       }

      

       //获取配置文件对象

       private File getFile( File fileDir )

       {

              File fileList[]=fileDir.listFiles();

              for( int i=0; i<fileList.length; i++ )

              {

                     if( fileList[i].getName().equals("file.ini"))

                     {

                            return fileList[i];

                     }

              }

              return null;

       }

      

       //获取文件的配置信息

       private String getFileInfo( File f )

       {

             BufferedReader br=null;

             String s=null;

            

             try

             {

                    //读取配置信息

                    br=new BufferedReader( new FileReader( f ) );

                    s=br.readLine();

             }

             catch( IOException e )

             {

                    System.out.println( "读取配置文件失败" );

                    e.printStackTrace();

             }

             finally

             {

                    //关闭输入流

                    if( br!=null )

                    {

                           try

                           {

                                  br.close();

                           }

                           catch( IOException e )

                           {

                                  e.printStackTrace();

                           }

                    }

             }

            

             return s;

       }

      

       //获取文件的个数

       private int getFileCount( String fileInfo )

       {

              String num=null;

              if( fileInfo!=null )

              {

                     num=fileInfo.substring( 0,fileInfo.indexOf('>') );

              }

             

              return Integer.parseInt(num) ;

       }

             

       //获取分割前的文件名

       private String getFileName( String fileInfo )

       {

              String fileName=null;

              if( fileInfo!=null )

              {

                     fileName=fileInfo.substring( fileInfo.indexOf('>')+1 );

              }

             

              return fileName;

       }    

      

       //获取枚举集合

       private     Vector<FileInputStream> getAllFile( int count )

       {

              Vector<FileInputStream> v=new Vector<FileInputStream>();

              for( int i=0; i<count; i++ )

              {

                     File f=null;

                     try

                     {

                            f=new File( fileDir, i+".haha" );

                            if( !f.exists() )

                            {

                                   System.out.println( i+".haha文件不存在，合并失败" );

                                   return null;

                            }

                            v.add(new FileInputStream( f ));

                     }

                     catch( IOException e )

                     {

                            e.printStackTrace();

                     }

                    

                    

              }

              return v;

       }

      

       //用序列流合并文件

       //V为枚举接口，count为文件数

       private void merge( Vector<FileInputStream> v ,String fileName )

       {

              Enumeration<FileInputStream> e=v.elements();

              SequenceInputStream sis=new SequenceInputStream(e);

              FileOutputStream fos=null;

              byte buf[]=new byte[1024];

             

              try

              {

                     //输出到文件fileName

                     fos=new FileOutputStream( fileName );

                     int num=0;

                    

                     //读取文件的内容

                     while( (num=sis.read(buf))!=-1 )

                     {

                            fos.write( buf,0,num );

                            fos.flush();

                     }

              }

              catch( IOException e1 )

              {

                     e1.printStackTrace();

              }

              finally

              {

                     //关闭流

                     try

                     {

                            sis.close();

                            fos.close();

                     }

                     catch( IOException e1 )

                     {

                            e1.printStackTrace();

                     }

              }

             

       }

             

}

 

class Demo

{

       public static void main(String arsg[])

       {

              //分割文件

              new FileSplit( "1.bmp" ).split();

             

              //合并文件

              new FileMerge( "e://test" ).startMerge();

       }

}

 

 

/*====第二十一题==================================

编写一个方法。去除Vector集合中的重复元素。

思路：

1，自定义一个Vector集合。对原有的Vector集合进行迭代。

把迭代出来的元素存入到新集合中。在存的时候进行判断新的集合中是否有该元素。‘

如果有，就不要进行存储。

迭代完成 。新的Vector集合中就不存在重复元素了。

*/

 

import java.util.*;

class Demo

{

       public static void main( String args[] )

       {

              Vector<Integer> v=new Vector<Integer>();

              Vector<Integer> ve=new Vector<Integer>();

              int num=0;

              v.add( 45 );

              v.add( 45 );

              v.add( 46 );

              v.add( 49 );

             

              Enumeration<Integer> e=v.elements();

              while( e.hasMoreElements() )

              {

                     num=e.nextElement();

                     if( !( ve.contains( num )) )

                     {

                            ve.add( num );

                     }

              }

             

              Enumeration<Integer> e1=ve.elements();

              while( e1.hasMoreElements() )

              {

                     System.out.println( e1.nextElement() );

              }

             

             

       }

}

 

 

/*====第二十二题==================================

取出一个字符串中字母出现的次数。如："abcdekka27qoq"  a(2)b(1)k(2)...

思路：

1，先将字符串转换成字符数组。

2，定义一个计数器，记录每一个字母出现的次数。

3，将字母作为key。该字母出现的次数作为value。将两者存入map集合中。

（为什么要用map集合呢？因为字母有很多，数据多了就要想到用容器多存入。方便操作。而每一个字母都有对应的次数。正好有映射关系。而map集合正好符合这个特点。map集合可以同时存入两个对象。key会保证唯一性。只要不断改变该key对应的值就可以了。）

4，在遍历字符数组进行存储的时候要判断，该字母是否已经存在于map集合。如果已存在。就取出它所对应的次数，并++.在次存入到集合中。

5，遍历该集合就可以得到结果。

 

（注意，如果只取字母的话，要进行字符'a'-'z'的判断。其他字符比如数字或者符号就没有必要存入map集合了。）

*/

 

import java.util.*;

import java.io.*;

class CountMaxNum

{

       private String s;

       private HashMap<Character,Integer> map;

       CountMaxNum( String s )

       {

              this.s=s;

              map=new HashMap<Character,Integer>();

       }

      

       public void start()

       {

              inputSet();

              printString();

       }

      

       /*

       利用了map容器"不允许重复元素"和"键和值一一对应"的特点

       1.遍历字符串中的每个元素

       2.检查遍历到的元素是否已在map容器中

       3.如果元素不在容器中，初始化出现次数为1，把"元素，出现次数"放入容器中

       4.如果元素在容器中，把出现的次数取出来加1后再把"元素，出现次数"放入容器中

       */

       private void inputSet()

       {

              for( int i=0; i<s.length(); i++ )

              {

                     if( (s.charAt(i)>='a'&&s.charAt(i)<='z')

                            ||(s.charAt(i)>='A'&&s.charAt(i)<='Z') )

                     {

                            //如果元素在容器中，把出现的次数取出来加1后再把"元素，出现次数"放入容器中

                            if( map.containsKey( s.charAt(i) ))

                            {

                                   map.put( s.charAt(i), map.get( s.charAt(i) )+1 );

                            }

                            else //元素不在容器中，初始化出现次数为1，把"元素，出现次数"放入容器中

                            {

                                   map.put( s.charAt(i),1 );

                            }

                     }

              }

       }

      

       private void printString()

       {

              Iterator<Map.Entry<Character,Integer>> iter=map.entrySet().iterator();

              while( iter.hasNext() )

              {

                     Map.Entry<Character,Integer> i=iter.next();

                     System.out.println( i.getKey()+":"+i.getValue() );

              }

       }

}

 

class Demo

{

       public static void main(String agrs[])

       {

              new CountMaxNum( "abcdekka27qoq" ).start();        

       }

}