几道面试小题目，拿来大家一起做

Question

1.给定一个字符串，判断其是否以指定的前缀开始，忽略打小写。
2.实现一个通用的文件拷贝函数，给定要拷贝的文件和目标目录，如果目标目录下存在相同名称的文件则覆盖。
3.实现一个对元素类型为String 的List进行排序的函数，要求按照字符串的倒序进行排序。
4。请设计一个Utility类，要求不能够被其他的类继承，并且不能被其的对象实例化。

Answer 1

1,String str = "workgroup";
  str.startsWith("work");则为真2,这样的类好实现，就是调用File.exits()方法，判断一下就行了3,String str = "bacde"
  str.compareTo("boy")>0,str.compareTo("aba")>0,str.compareTo("abcde")=0;4,用final abstract 修饰类路过，学不久，不知对不对？

Answer 2

1，不区分大小写,用正则表达式
2,io流实现
3,list实现Comparable 重写compareTo
我也是半道出家。我的思路是这样的！

Answer 3

1楼的有一点说得不对，final和abstract不能同时修饰一个类，final说明类是不可以被继承的，abstract类必须被继承，所以他们两个不能同时被使用。

Answer 4

刚学JAVA不久,不知道做得如何,如有更好的做发请高手指点!!1.给定一个字符串，判断其是否以指定的前缀开始，忽略大小写。  public boolean startsWith(String str, String start){
    return str.toLowerCase().startsWith(start.toLowerCase());
  }
  2.实现一个通用的文件拷贝函数，给定要拷贝的文件和目标目录，如果目标目录下存在相同名称的文件则覆盖。  public void copy(String files, String directory){
File f = new File(files);
File d = new File(directory+ "/" + f.getName());
BufferedReader br = null;
BufferedWriter bw = null;
try{
br = new BufferedReader(new FileReader(f));
bw = new BufferedWriter(new FileWriter(d));
String str = null;
while((str = br.readLine()) != null){
bw.write(str,0,str.length());
bw.newLine();
}
} catch(FileNotFoundException e){
e.printStackTrace();
} catch(IOException e){
e.printStackTrace();
} finally{
try{
if(bw != null) bw.close();
if(br != null) br.close();
} catch(IOException e1){
e1.printStackTrace();
}
}
}
3.实现一个对元素类型为String 的List进行排序的函数，要求按照字符串的倒序进行排序。  public void sort(List<String> lists){
Object[] obj = lists.toArray();
for(int j = 0; j < obj.length; j++){
StringBuffer sb = new StringBuffer((String)obj[j]);
sb.reverse();
obj[j] = sb.toString();
}
Arrays.sort(obj);
ListIterator<String> i = lists.listIterator();
for(int j = 0; j < obj.length; j++){
i.next();
StringBuffer sb1 = new StringBuffer((String)obj[j]);
i.set(sb1.reverse().toString());
}
}
4。请设计一个Utility类，要求不能够被其他的类继承，并且不能被其的对象实例化。   申明Utility为final,并写一个private的构造方法

Answer 5

楼上第三题理解好像错了，题目应该就是让你对String类的List排列吧，你是不是还对字符串进行了字符排列啊？我看不太懂（本人太笨），下面是我的程序
import java.util.*;
public class Test {    public Test() {
    }
    
    public static void main(String[] args){
        ArrayList<String> strList=new ArrayList<String>(); 
        strList.add("Hello");
        strList.add("GoodBye");
        strList.add("nihao");
        strList.add("Thanks");
        strList.add("OK");
        strList.add("No");        Collections.sort(strList);
        Iterator it = strList.iterator();
        System.out.println("Reverse:");
        while(it.hasNext()){
 System.out.print(it.next()+"   ");
        }        Collections.sort(strList, Collections. reverseOrder());
        it = strList.iterator();
        System.out.println("Reverse:");
        while(it.hasNext()){ 
                     System.out.print(it.next()+"   ");
              }
    }
}

Answer 6

ListIterator<String> i = lists.listIterator();
while(i.hasNext()){
 System.out.print(i.next()+"   ");
}Iterator i = lists.Iterator();
while(i.hasNext()){
 System.out.print(i.next()+"   ");
}
这两个出来的顺序好像不一样，我们应该用哪种
注：楼上程序没错，不好意思

Answer 7

前三个题目都对了，我觉得，
但最后一道题目有点补充4。请设计一个Utility类，要求不能够被其他的类继承，并且不能被其的对象实例化。   申明Utility为final,并写一个private的构造方法,同时提供创建自身实例的方法,因为不能被其的对象实例化,自身的构造方法又是私有的，别人怎么调用这个类的方法呀,除非都是STATIC METHOD,所以需要提供创建自身实例的方法\
提供创建自身实例的方法
private static Utility instance = new Utility();
private Utility(){}
public Utility getInstance(){}

Answer 8

还是有问题 
 public void sort(List<String> lists){
Object[] obj = lists.toArray();
for(int j = 0; j < obj.length; j++){//所有字符串自身反序如： Hello－>olleH
StringBuffer sb = new StringBuffer((String)obj[j]);
sb.reverse();
obj[j] = sb.toString();
}
Arrays.sort(obj);//按反序后的字符串排序  
//如：Hello、nihao、goodbye 会变成      eybdoog->oahin->olleH
ListIterator<String> i = lists.listIterator();
for(int j = 0; j < obj.length; j++){//再翻转每个字符串goodbye->nihao->Hello,所以错了
i.next();
StringBuffer sb1 = new StringBuffer((String)obj[j]);
i.set(sb1.reverse().toString());
}
}

Answer 9

实际的要求的结果应该是 Hello->goodbye->nihao

Answer 10

下面是一个将一个目录下的所有文件拷贝到另一个目录下的程序：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.io.File;
import java.io.*;/**
 *
 * <p>Title: 将一个目录下的所有文件复制到另一个目录下</p>
 *
 * <p>Description: 将一个目录下的所有文件复制到另一个目录下 </p>
 *
 * <p>Copyright: Copyright (c) 2006</p>
 *
 * <p>Company: </p>
 *
 * @author not attributable
 * @version 1.0
 */
public class TestFile
{
    public TestFile()
    {
    }    public static void main(String[] args)
    {
        //在当前目录下创建一个FileTest目录
        File file = new File(".//FileTest");
        file.mkdir();        //调用方法复制文件
        getFileList(".//classes", ".//FileTest");
    }    /**
     * 执行复制操作
     * @param nameFile String 源目录
     * @param nameDirectory String 目标目录
     */
    private static void getFileList(String nameFile, String nameDirectory)
    {
        File file1 = null;
        File file5 = null;
        FileInputStream fileInput = null;
        DataInputStream dateInput = null;        File file4 = null;
        FileOutputStream fileOutput = null;
        DataOutputStream dateOutput = null;        try
        {
            //创建源文件对象
            file1 = new File(nameFile);            //获得文件列表
            File[] file2 = file1.listFiles();            for (int i = 0; i < file2.length; i++)
            {
                //判断是否为目录
                if (file2[i].isDirectory())
                {
                    //创建目录
                    File file3 = new File(nameDirectory + "//" +
                                          file2[i].getName());
                    file3.mkdir();                    //继续执行文件复制
                    getFileList(nameFile + "//" + file2[i].getName(),
                                nameDirectory + "//" + file2[i].getName());
                }
                else
                {
                    //创建源目录下的文件对象
                    file5 = new File(file2[i].toString());
                    fileInput = new FileInputStream(file5);
                    dateInput = new DataInputStream(fileInput);                    //创建目标目录下的文件对象
                    file4 = new File(nameDirectory + "//" +
                                          file2[i].getName());
                    fileOutput = new FileOutputStream(file4);
                    dateOutput = new DataOutputStream(
                            fileOutput);
                    int temp = 0;
                    while ((temp = dateInput.read()) != -1)
                    {
                        //将源目录下的文件内容复制到目标目录下的文件中
                        dateOutput.write(temp);
                    }
                    System.out.println("[" + nameDirectory + "//" +
                                       file2[i].getName() + "]");
                }
            }
        }
        catch (IOException ex)
        {
            System.out.println(ex.toString());
        }
        finally
        {
            try
            {
                dateInput.close();
                dateOutput.close();
            }
            catch (IOException ex1)
            {
                System.out.println(ex1.toString());
            }
        }
    }
}