"★里面有解题思路一样的没有全部解答，仅仅将题目列出，稍微改变即可得出结果★

"笔试题重点，

"       1、复制文件

"       2、多线程

"       3、集合

"       4、反射

/

"1

/*

Collection集合体系图

Collection

|----List 元素有序，可重复

|----ArrayList   底层数据结构是数组，查询快，增删慢，线程不安全，效率高

|----Vector   底层数据结构是数组，查询快，增删慢，线程★安全★，效率低

|----LinkedList 底层数据结构是链表，查询慢，增删快，线程不安全，效率高

|----Set 元素无序，唯一。

|----HashSet

|----TreeSet

遍历集合的两种方式：

1、通过获取键的集合，遍历键的集合，通过键获取值

2、通过键值对集合，遍历键值对对象，分别取得键值

*/

import java.util.HashMap;

import java.util.Set;

import java.util.Map.Entry;

import java.util.Map;

class ForMap

{

public static void main(String[] args)

{

//创建一个map对象

HashMap<String,String> map = new HashMap<String,String>();

//向map中添加元素

map.put("A","101");

map.put("B","102");

map.put("C","103");

map.put("D","104");

//获取键的集合

Set<String> set = map.keySet();

//循环遍历键集合

for (String str : set) {

//通过键获取值

System.out.println(str+"---"+map.get(str));

}

System.out.println("----------------------");

//获取map的键值对集合

Set<Entry<String, String>> mset = map.entrySet();

//循环遍历键值对集合

for(Entry<String, String> me : mset)

{

//用键值对对象分别获取键和值

System.out.println(me.getKey()+"---"+me.getValue());

}

System.out.println("----------------------");

}

}

"2

/*

题目1：

创建ArrayList对象，添加5个元素，使用Iterator遍历输出。*/

"******************************************************************************

/*题目2：

两个集合{“a”，“b”，“c”，“d”，“e”}和{“d”，“e”，“f”，“g”，“h”},

把这两个集合去除重复项合并成一个

思路：

这道题主要是考察集合的知识的，可以用ArrayList解决问题

1、先创建这两个集合

2、向这两个集合分别添加元素

3、用第二个集合的调用iterator()方法获取Iterator对象

4、遍历第二个集合，并用第一个集合判断是否包含第一个

集合的元素，如果不包含就向集合一添加元素

5、打印集合1，就是想要的结果

*/

//导包

import java.util.List;

import java.util.ArrayList;

import java.util.Iterator;

class Test {

public static void main(String args[])

{

//创建集合1

List<String> list1 = new ArrayList<String>();

//向集合1添加元素

list1.add("a");

list1.add("b");

list1.add("c");

list1.add("d");

list1.add("e");

//创建集合2

List<String> list2 = new ArrayList<String>();

//向集合2添加元素

list2.add("d");

list2.add("e");

list2.add("f");

list2.add("g");

list2.add("h");

//获取集合2的迭代器

Iterator it = list2.iterator();

//遍历集合2

while(it.hasNext())

{

String str = (String) it.next();

//如果不包含就向集合1添加此元素

if(!list1.contains(str))

{

list1.add(str);

}

}

System.out.println(list1);

}

}

/

"3

/*

题目：

已知文件a.txt文件中的内容为“bcdeadferwplkou”,请编写程序读取该文件内容，

并按照自然排序顺序后输出到b.txt文件中。即b.txt文件内容应为"abc......"这样的顺序

思路：

1、先将a.txt文件内容读取出来并存到字符数组中

2、用Arrays.sort(字符数组) 将这个字符数组排序

3、将字符数组输出到b.txt文件中

*/

import java.io.IOException;

import java.io.File;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.util.Arrays;

class ReadFileAndSortString {

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

{

//封装数据源及目的地File

File afile = new File("a.txt");

File bfile = new File("b.txt");

//调用复制方法

copyFile(afile, bfile);

}

public static void copyFile(File afile, File bfile) throws IOException

{

//高效字符输入流得到数据源

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

//高效字符输出流得到目的地

BufferedWriter bw = new BufferedWriter(new FileWriter(bfile));

String line =“”;

//循环读取文件

while((line = br.readLine())!=null)

{

//得到读取一行字符串的长度

int len = line.length();

char[] chrs = new char[len];

//转换成字符数组

chrs = line.toCharArray();

//通过Arrays的sort方法排序

Arrays.sort(chrs);

System.out.println("字符串："+new String(chrs));

//写到文件中

bw.write(chrs);

bw.newLine();

//刷新缓冲区

bw.flush();

}

//关闭资源

br.close();

bw.close();

System.out.println("复制成功");

}

}

/

"4

/*

题目：

编写一个程序，将指定目录下所有.java文件拷贝到另一个目录中，

并将扩展名改为.txt

思路:

1、用File对象封装目录

2、通过listFiles()方法获取该目录下所有的文件或者文件夹的File对象数组

3、遍历这个File数组，得到每一个File对象

4、判断该File对象是否是文件

a、如果是文件

b、继续判断是否以.java结尾

是：先改名后复制文件

否：不复制

*/

//导包

import java.io.IOException;

import java.io.File;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

class Test

{

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

{

//用File对象封装目录

File srcfile = new File("D:\\demos\\");

//用File对象封装目录

File destFile = new File("D:\\copyTo\\");

//调用复制的方法

copyFile(srcfile,destFile);

}

//复制方法

public static void copyFile(File srcFile, File destFile) throws IOException

{

//通过listFiles()方法获取该目录下所有的文件或者文件夹的File对象数组

File[] fileArray = srcFile.listFiles();

//遍历这个File数组，得到每一个File对象

for(File file : fileArray)

{

//判断该File对象是否是文件

if(file.isFile())

{

//如果不是以java为后缀的不复制，执行下次循环

if(!file.getName().endsWith(".java"))

{

continue;

}

//新文件File对象

File newFile = new File(destFile,file.getName().replace(".java",".txt"));

//用高效的字节输入流封装数据源

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));

//用高效的字节输出流封装目的地

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));

byte[] bys= new byte[1024];

int len = 0;

//判断是否读到文件结尾

while( (len = bis.read(bys)) != -1 )

{

//将数据写到文件中

bos.write(bys,0,len);

//刷新缓存流

bos.flush();

}

//关闭流对象

bis.close();

bos.close();

}

}

}

}

///

"5

/*

题目1：

将项目路径下java_all目录下所有的.java文件复制到项目路径下Java_jad

文件夹下，并将文件名从原来的.java修改成.jad*/

"******************************************************************************

/*题目2：

编写一个程序，把一个目录里边的所有带.java文件拷贝到另一个目录中，

拷贝成功后，把后缀名是.java的文件改为.txt文件。（注意事项：是先拷贝，

拷贝成功后才可以改后缀名的）*/

"(★将以下代码改改路径和扩展名即可★)

/*

思路:

1、用File对象封装目录

2、通过listFiles()方法获取该目录下所有的文件或者文件夹的File对象数组

3、遍历这个File数组，得到每一个File对象

4、判断该File对象是否是文件

a、如果是文件

b、继续判断是否以.java结尾

是：复制文件

在复制完成后改名

否：不复制

*/

//导包

import java.io.IOException;

import java.io.File;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

class FileCopySingleFolderByByte

{

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

{

//用File对象封装目录

File srcfile = new File("D:\\demos\\");

//用File对象封装目录

File destFile = new File("D:\\copyTo\\");

//调用复制的方法

copyFile(srcfile,destFile);

}

//复制方法

public static void copyFile(File srcFile, File destFile) throws IOException

{

//通过listFiles()方法获取该目录下所有的文件或者文件夹的File对象数组

File[] fileArray = srcFile.listFiles();

//遍历这个File数组，得到每一个File对象

for(File file : fileArray)

{

//判断该File对象是否是文件

if(file.isFile())

{

//如果不是以java为后缀的不复制，执行下次循环

if(!file.getName().endsWith(".java"))

{

continue;

}

//新文件

File newFile = new File(destFile, file.getName());

//用高效的字节输入流封装数据源

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));

//用高效的字节输出流封装目的地

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));

byte[] bys= new byte[1024];

int len = 0;

//判断是否读到文件结尾

while( (len = bis.read(bys)) != -1 )

{

//将数据写到文件中

bos.write(bys,0,len);

//刷新缓存流

bos.flush();

}

//关闭流对象

bis.close();

bos.close();

//得到新文件名

String newName = newFile.getName().replace(".java",".txt");

//根据新文件名创建新文件对象

File tempFile = new File(destFile,newName);

//改名

newFile.renameTo(tempFile);

}

}

}

}

/

"6

/*

题目：

统计一个文件夹下的txt文件个数，包括所有子文件夹内，

并将它们全部复制到D盘任意目录下

思路：

（★提示★）用高效字节流可以用来复制任意类型文件

1、定义一个统计变量

2、用File对象封装目录

3、通过listFiles()方法获取该目录下所有的文件或者文件夹的File对象数组

4、遍历这个File数组，得到每一个File对象

5、判断该File对象是否是文件夹

a、如果是文件夹回到第3步

b、继续判断是否以.txt结尾

是：复制文件并将统计文件变量加1

否：不复制

*/

//导包

import java.io.IOException;

import java.io.File;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

class FileCopyMultiFolderByByte

{

//用来统计复制文件的总个数

public static int count =0;

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

{

//用File对象封装目录

File srcfile = new File("D:\\demos\\");

//用File对象封装目录

File destFile = new File("D:\\copyTo\\");

//调用复制的方法

copyFolder(srcfile,destFile);

System.out.println("文件复制完毕，共复制文件 "+count+" 个");

}

//复制方法

public static void copyFolder(File srcFile, File destFile) throws IOException

{

//通过listFiles()方法获取该目录下所有的文件或者文件夹的File对象数组

File[] fileArray = srcFile.listFiles();

//遍历这个File数组，得到每一个File对象

for(File file : fileArray)

{

//判断该File对象是否是文件夹

if(file.isDirectory())

{

//多级目录递归

copyFolder(file,destFile);

}

else

{

//文件

File newFile = new File(destFile, file.getName());

copyFile(file , newFile);

}

}

}

//复制文件并计数的方法

public static void copyFile(File srcFile, File newFile) throws IOException

{

//如果不是以txt为后缀的不复制，跳出循环

if(!srcFile.getName().endsWith(".txt"))

{

return;

}

//统计文件个数的变量加1

count++;

//用高效的字节输入流封装数据源

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));

//用高效的字节输出流封装目的地

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));

byte[] bys= new byte[1024];

int len = 0;

//判断是否读到文件结尾

while( (len = bis.read(bys)) != -1 )

{

//将数据写到文件中

bos.write(bys,0,len);

//刷新缓存流

bos.flush();

}

//关闭流对象

bis.close();

bos.close();

}

}

/

"7

/*

题目：

创建多线程的方式有几种？请代码实现

解答：

一共两种。

1、通过实现Runnable接口，重写run()方法

2、通过继承THread类，重写run()方法。

*/

//

class ThreadTest

{

public static void main(String [] args)

{

//创建RunnableImpl类对象

RunnableImpl ri = new RunnableImpl();

//创建Thread类的对象，并把ri作为参数传递

Thread t1 = new Thread(ri);

//给线程设置名字

t1.setName("Runnable线程");

//启动线程

t1.start();

//创建ThreadImpl类对象

ThreadImpl ti = new ThreadImpl();

ti.setName("Thread线程");

//启动线程

ti.start();

}

}

//1、通过实现Runnable接口，重写run()方法

class RunnableImpl implements Runnable

{

@Override

public void run()

{

System.out.println(Thread.currentThread() .getName()+"正在执行任务");

}

}

//2、通过继承THread类，重写run()方法。

class ThreadImpl extends Thread

{

@Override

public void run()

{

System.out.println(getName()+"正在执行任务");

}

}

/

"8

/*

题目：

定义一个类实现Runnable接口，卖票100张，四个线程，输出格式为“窗口1,还剩10张票”

，指定窗口3卖第10张票。

思路：

1、定义一个资源类实现Runnable接口

2、资源类重写run()方法，并加锁卖票

3、在测试类中创建线程并启动

*/

class SellTicket

{

public static void main(String[] args)

{

//创建一个资源对象

Tickets ticket = new Tickets();

//创建线程对象并传入资源对象

Thread t1 = new Thread(ticket);

Thread t2 = new Thread(ticket);

Thread t3 = new Thread(ticket);

Thread t4 = new Thread(ticket);

//设置线程名称

t1.setName("窗口1");

t2.setName("窗口2");

t3.setName("窗口3");

t4.setName("窗口4");

//启动线程

t1.start();

t2.start();

t3.start();

t4.start();

}

}

class Tickets implements Runnable

{

private int ticket = 100;

@Override

public void run()

{

while(true)

{

//加锁

synchronized(this)

{

//剩余票数不大于0就退出循环

if(ticket > 0)

{

try

{

Thread.sleep(100);

} catch (InterruptedException e)

{

e.printStackTrace();

}

//让窗口3卖第十张票

if(ticket == 10)

{

if(!Thread.currentThread().getName().equals("窗口3"))

{

continue;

}

}

System.out.println(Thread.currentThread().getName()+",还剩"+ ( --ticket )+"张票");

}

else

{

break;

}

}

}

}

}

"9

/*

写一个线程类MyThread，该线程实现了Runnable接口，写一个main方法，

用for循环创建5个线程对象。需求如下：

① 利用线程类的构造函数输出："创建线程4"。

（备注：当创建一个线程的时候，标记为1，再次创建一个线程的时候，标记为2，所以输出的"创建线程4"就是创建的第四个线程）

② 在run方法中输出：“线程X ：计数Y”，当执行次数达到6次的时候，退出。

（备注：其中“线程X”为第X个线程，“计数Y”为该线程的run方法执行了多少次）

*/

class SellTicket

{

public static void main(String[] args)

{

//用for循环创建5个线程对象

for(int i = 1; i <= 5 ;i ++)

{

new Thread(new MyThread (i) ).start();

}

}

}

class MyThread implements Runnable

{

private int count;

public MyThread(){}

public MyThread(int count)

{

this.count = count;

System.out.println("创建线程"+count);

}

@Override

public void run()

{

for(int i = 1 ; i <=6; i++)

{

System.out.println("线程"+(this.count)+":计数"+i);

}

}

}

///

"10

/*

题目：

编写一个Java程序实现多线程，在线程中输出多线程名字，隔300毫秒输出一次，

共输出20次。

思路:

1、用实现Runnable接口并重写run方法

2、创建线程

*/

class Test

{

public static void main(String[] args)

{

//创建线程对象

Thread t1 = new Thread(new MyThread () );

Thread t2 = new Thread(new MyThread () );

//设置线程名称

t1.setName("我是线程1");

t2.setName("我是线程2");

//启动线程

t1.start();

t2.start();

}

}

//实现Runnable接口

class MyThread implements Runnable

{

@Override

public void run()

{

//循环20次

for(int i = 1 ; i <=20; i++)

{

try

{

//休眠300毫秒

Thread.sleep(300);

} catch (InterruptedException e)

{

e.printStackTrace();

}

//打印线程名称

System.out.println("线程名称："+Thread.currentThread().getName());

}

}

}

/

"11

/*

题目：

输出一个字符串，怎样判断是否是aba,abcba,abffba,的字符串

思路：

1、首先判断是奇数个还是偶数个（字符串的长度%2，1为基数，0为偶数）

2、是0就是偶数个

//得到前半部分子字符串

字符串.substring(0,字符串的长度/2  )

//得到前后半部分子字符串

字符串.substring(字符串的长度/2 ,字符串的长度 )

字符串.toCharArray()分别得到两个字符数组

在循环字符数组

一个正序一个倒序的

用对比字符是否equals

3、是1就是奇数个

//得到前半部分子字符串

字符串.substring(0,字符串的长度/2  )

//得到前后半部分子字符串

字符串.substring(字符串的长度/2+1 ,字符串的长度 )

字符串.toCharArray()分别得到两个字符数组

*/

import java.util.Scanner;

class StringDemo

{

public static void main(String[] args)

{

while(true)

{

show();

}

}

public static void show()

{

System.out.print("请输入要判断的字符串：");

Scanner sc = new Scanner(System.in);

String line = sc.nextLine();

System.out.println("你输入的是："+line);

int length = line.length();

//先判断字符串的字符个数是奇数还是偶数

//偶数时

if(length%2==0)

{

//截取成前后两个子字符串

String s1 = line.substring(0,length/2);

String s2 = line.substring( length/2 , length); //注意偶数个和奇数个的不同在此：偶数不加1

//将两个字符串转换成字符数组

char[] chs1 = s1.toCharArray();

char[] chs2 = s2.toCharArray();

int chsLength = chs1.length;

//统计对比次数和数组长度一致就是符合，否则不符合

int count = 0;

//遍历数组

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

{

//对比字符是否相同

if(chs1[ i ] !=chs2[ chsLength - i - 1 ])

{

System.out.println("这个字符串不符合aba");

break;

}

//统计对比次数

count ++;

if(count == chsLength )

{

System.out.println("符合aba");

}

}

}

else

{

//截取成前后两个子字符串

String s1 = line.substring(0,length/2);

String s2 = line.substring( length/2 + 1, length);  //注意偶数个和奇数个的不同在此：奇数加1

//将两个字符串转换成字符数组

char[] chs1 = s1.toCharArray();

char[] chs2 = s2.toCharArray();

int chsLength = chs1.length;

//统计对比次数和数组长度一致就是符合，否则不符合

int count = 0;

//遍历数组

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

{

//对比字符是否相同

if(chs1[i] !=chs2[chsLength-i-1])

{

System.out.println("这个字符串不符合aba");

break;

}

//统计对比次数

count ++;

if(count == chsLength )

{

System.out.println("符合aba");

}

}

}

}

}

"12

/*

题目：

如何用反射创建一个对象。用两种方式，要求写代码

思路：

一共有三种方式

1、调用Object类的getClass()方法

2、数据类型的静态的class属性

3、通过Class类的静态方法forName(String className)

（注意：使用这种方式的时候要用全路径名）

*/

import java.lang.reflect.Constructor;

class Test

{

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

{

//第一种：获取字节码文件对象

Class<?> c1 = Class.forName("Person");

//获取构造器对象

Constructor<?> con1 = c1.getConstructor(String.class,int.class);

//创建对象

con1.newInstance("张三",26);

//第二种：获取字节码文件对象

Class<Person> c2 = Person.class;

//获取构造器对象

Constructor<Person> con2 = c2.getConstructor(String.class,int.class);

//创建对象

con2.newInstance("李四",25);

}

}

//用来测试反射的类

class Person

{

private String name;

private int age;

public Person(){};

public Person(String name,int age)

{

this.name = name;

this.age = age;

System.out.println(name+"****"+age);

}

}

//

"13

/*

题目：

编写一个类，增加一个实例方法，用于打印一条字符串，

并使用反射手段创建该类的对象，并调用对象的方法。

思路：

1、通过Class.forName()方法获取字节码文件对象

2、获取构造器对象

3、创建对象

4、获取成员方法对象

*/

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

class Test

{

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

{

//获取字节码文件对象

Class<?> c = Class.forName("Demo");

//获取构造器对象

Constructor<?> con = c.getConstructor();

//创建对象

Object obj = con.newInstance();

//获取成员方法对象

Method m = c.getMethod( "sayHello" );

m.invoke(obj);

}

}

class Demo

{

public Demo(){}

public void sayHello( )

{

System.out.println("这是打印的方法");

}

}

"14

/*

题目：

编写程序，生成5个1至10之间的随机整数，存入一个List集合，

编写方法对List集合进行排序（自定义排序算法，禁用Collections.sort

方法和TreeSet），然后遍历集合输出。

思路：

1、用Math的random()方法生成五个随机整数

2、用ArrayList集合存储随机数

3、遍历ArrayList集合并对其排序

4、遍历输出

*/

import java.util.ArrayList;

class Test

{

public static void main(String[] args)

{

//创建ArrayList集合

ArrayList<Integer> list = new ArrayList<Integer>();

//用循环的方式，生成五个随机整数并存入ArrayList集合中

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

{

//生成随机整数

int  rand = (int)(Math.random() * 10 ) + 1;

//向List集合添加元素

list.add(rand);

}

//冒泡排序，外层控制对比次数

for(int i = 0; i < list.size() - 1; i ++)

{

//内存控制比较过程

for(int k = 0;k < list.size() - i - 1; k ++)

{

//调整顺序

if(list.get(k) > list.get(k+1))

{

int max = list.get(k);

list.set( k ,list.get(k + 1));

list.set( k + 1 ,max);

}

}

}

//遍历集合

for(int i = 0; i < list.size(); i ++)

{

System.out.println(list.get(i));

}

}

}

"15

/*

题目：

接收用户输入的一句英文，将其中的单词以反序输出。例如：

“I love you” →"I evol uoy"

思路：

1、获取用户输入，调用String的split()方法用空格将其分割成

字符串数组

2、遍历这个字符串数组，通过StringBuffer构造方法，将

字符串数组转换成StringBuffer对象，并调用reverse() 方法，

将字符串倒序

3、通过String的构造方法再将StringBuffer对象转换成String

并输出该新字符串

*/

import java.util.Scanner;

class Test

{

public static void main(String[] args)

{

//创建Scanner对象

Scanner sc = new Scanner(System.in);

System.out.println("请输入您要反序输出的一句英文：");

//获取控制台输入

String line = sc.nextLine();

//将其用空格分割成字符串数组

String[] lines = line.split(" ");

System.out.println("反序输出的结果：");

//遍历字符串数组

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

{

//将数组中的字符串转换成StringBuffer对象

StringBuffer sb = new StringBuffer(lines[i]);

//通过StringBuffer对象的reverse()方法得到反序单词

String newStr = new String(sb.reverse()) ;

//直接输出反序单词

System.out.print(newStr+" ");

}

System.out.println();

}

}

"16

/*

题目：

编写一个可以获取文件扩展名的函数。形参接收一个文件名字符串，返回一个扩展字符串。

思路：

1、用String类的lastIndexOf(string s) 方法获取最后一个点的位置

2、根据用String的substring（开始索引，结束索引)取得扩展名

*/

import java.util.Scanner;

class Test

{

public static void main(String[] args)

{

Scanner sc = new Scanner(System.in);

System.out.println("请输入文件名：");

String filename = sc.nextLine();

String extend = getExtend(filename);

}

public static String getExtend(String filename)

{

//取得最后一个点的索引

int beginindex = filename.lastIndexOf(".") ;

int endindex = filename.length();

//根据用String的substring（开始索引，结束索引)取得扩展名

String extend = filename.substring(beginindex + 1, endindex);

return extend;

}

}

"17

/*

题目：

用ArrayList存入Student自定义对象，Student类有name，age两个属性

按照age倒序排序。

思路：

1、创建ArrayList集合，并向集合中添加Student对象

2、新建一个Comparator比较器接口的实现类，重写compare方法，

按年龄倒序排序

3、调用Collections的sort方法传入Comparator比较器实现类

*/

import java.util.ArrayList;

import java.util.Iterator;

import java.util.Collections;

import java.util.Comparator;

class  Test

{

public static void main(String[] args)

{

//创建集合

ArrayList<Student> list=new ArrayList<Student>();

//向集合中添加元素

list.add(new Student("张三",20));

list.add(new Student("李四",23));

list.add(new Student("王二",19));

//调用Collections的sort方法进行排序

Collections.sort(list, new MyComparator());

//遍历集合

Iterator it=list.iterator();

while(it.hasNext())

{

Student s=(Student)it.next();

System.out.println("name:"+s.getName()+",age:"+s.getAge());

}

}

}

//实现了Comparator比较器接口的自定义类

class MyComparator implements Comparator<Student>

{

@Override

public int compare(Student s1 ,Student s2)

{

//按年龄排序，从大到小

int num = s2.getAge() - s1.getAge();

return num;

}

}

//标准学生类

class Student

{

private String name;

private int age;

Student(){}

Student(String name,int age)

{

this.name=name;

this.age=age;

}

// set和get方法

public void setName( String name )

{

this.name=name;

}

public String getName()

{

return this.name;

}

public void setAge( int age )

{

this.age=age;

}

public int  getAge()

{

return this.age;

}

}

"18

/*

题目：

编程列出一个字符串的全部字符组合情况。原始字符串中没有重复字符。

例如：

原始字符串是“abc”，打印得到下列所有组合情况：

“a” “b” “c”

"ab" "ac" "ba" "bc" "ca"  "cb"

"abc"  "acb"  "bac" "bca"  "cab" "cba"

*思路：

*1，发现组合的最小长度是单个字符，且就是原始字符串的每个字符，而最长长度则和字符串一样

*2，每行新组合都是在前一行旧组合的基础上，将每个旧组合与原始字符串中每个不同字符单独组合一次，获得新组合

*3，新一行组合有多少个，无法马上确定，因为都是字符串，

*        所以可以先用StringBuilder接收每个新组合，最后再切割获得每个新组合

* */

public class Test {

public static void main(String[] args) {

//调用方法，传入字符串

show("abc");

}

//编写方法，接收字符串

public static void show(String str){

//将原始字符串转成原始字符数组

char[] chs=str.toCharArray();

//获得原始字符串数组，即每个字符串只有一个字符

String[] strs=chsToStrs(chs);

//按指定格式输出原始字符串数组，即单个字符的组合情况

printString(strs);

//x为每行单个字符串的长度，第一行已经输出，所以从2开始，最长为原始字符串长度，循环输出每行组合

for(int x = 2;x<=str.length();x++){

//调用方法，传入 原始字符数组 和 前一次的字符串数组，获得新的字符串数组

strs=addChar(chs,strs);

//按指定格式输出新的字符串数组

printString(strs);

}

}

//定义方法，接收 原始字符数组 和 前一次的字符串数组，并返回新字符串数组

public static String[] addChar(char[] chs,String[] oldStrs){

//因为新字符数组长度暂时无法确定，也为了转换方便，所以使用StringBuilder来接收每个新字符串

StringBuilder sb=new StringBuilder();

//定义新字符串数组

String[] newStrs=null;

//外循环，遍历每个字符串数组

for(int x=0;x<oldStrs.length;x++){

//内循环，遍历每个原始字符，将每个字符串把每个不同字符都单独添加一次

for(int y=0;y<chs.length;y++){

//判断字符串是否包含该字符，通过indexOf()的返回值>=0来确定已包含

if(oldStrs[x].indexOf(chs[y])>=0)

//已包含该字符，则不操作，继续下次循环

continue;

//不包含该字符，则添加该字符

String s=oldStrs[x]+chs[y];

//添加新字符串到StringBuilder对象并用','隔开

sb.append(s).append(',');

}

}

//删除StringBuilder对象最后的一个','，并转成字符串，再将字符串按','切割，获得新字符串数组

newStrs=sb.deleteCharAt(sb.length()-1).toString().split(",");

//返回新字符串数组

return newStrs;

}

//将指定字符串数组按指定格式输出并换行

public static void printString(String[] strs){

for(String s:strs){

System.out.print("\""+s+"\"");

}

System.out.println();

}

//将指定字符数组转成字符串数组，即每个字符串只有一个字符，并返回

public static String[] chsToStrs(char[] chs){

//字符串数组长度和字符数组长度一致

String[] strs=new String[chs.length];

for(int x=0;x<chs.length;x++)

//将单个字符转成单个字符的字符串

strs[x]=chs[x]+"";

return strs;

}

}

"19

/*

题目：

看这个数列，找出规律和出口，然后计算出第12项的数值，数列如下：

1，2，3，4，6，9，13，19，28...

思路：

1、找规律，发现从第四项开始n=(n-1) + (n-3)

2、找出口，n = 1 , 2 , 3 是已知的

3、用递归解决问题

*/

//导包

class Test

{

public static void main(String[] args)

{

//求第十二项的数值

int num = getSum(12) ;

System.out.println( num );

}

//递归方法

public static int getSum(int n)

{

//当n=1，2，3时是出口

if( n == 1)

{

return 1;

}

if( n == 2)

{

return 2;

}

if( n == 3)

{

return 3;

}

else

{

//递归调用

return getSum( (n-1) ) + getSum( (n-3) );

}

}

}

"20

/*

题目：

谈谈你对匿名内部类的理解。

（要求有思路，有注释，有代码）

思路：

这道题就是考察你对匿名内部类的理解，就写出

1、匿名内部类的定义

指没有名字的局部内部类。

2、前提

必须存在一个类，抽象类，或者接口。

3、格式

new 类名或者接口名(){

覆盖类或者接口中的代码

也可以是自定义内容

}

4、什么时候使用

1、当接口或者抽象类中的方法在3个以下的时候

2、当一个方法接收的形式参数是一个抽象类或者接口的时候

（所有父类或者父接口出现的地方，完全可以使用子类对象替代）

至于代码这块儿，没有标准答案，我没有写出来，其实，我还没有理解,

下面是老师课上的代码，注释自己加吧

*/

//必须存在一个类，抽象类，或者接口。

interface Inter

{

public abstract void show();

}

class Outer

{

public void method()

{

//没有名字的局部内部类

new Inter()

{

//覆盖类或者接口中的代码

public void show()

{

System.out.println("show");

}

}.show();

}

}

class InnerTest

{

public static void main(String[] args)

{

Outer o = new Outer();

o.method();

}

}

"21

/*

题目：

首先介绍一下，字符流，字节流，转换流的应用场景？

把C盘里边的一个MP3文件拷贝到D盘里边，尽量用

高效的方法去拷贝（要求有思路，有注释，有代码）

解答：

字符流：读取文本文件

字节流：读取二进制文件

转换流：指定编码表 或将字节流转换成字符流

（打印流：也可以指定编码表，★★这个和原题无关）

思路：

用字节流可以用来复制任意类型文件，因为要复制MP3文件，所以用高效字节流

1、用File对象封装数据源

2、用File对象封装目的地

3、判断该File对象是否存在

不存在就不复制，★★面试老师说有漏洞，或许这个可以加分呢？！

4、用高效的字节输入流读取

5、用高效的字节输出流写出

*/

//导包

import java.io.IOException;

import java.io.File;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

class CopyMP3

{

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

{

//用File对象封装目录

File srcfile = new File("D:\\demos\\和兰花在一起.mp3");

//用File对象封装目录

File destFile = new File("D:\\copyTo\\和兰花在一起.mp3");

//调用复制的方法

copyFile(srcfile,destFile);

}

public static void copyFile(File srcFile, File destFile) throws IOException

{

//判断该File对象是否存在

if(!srcFile.exists())

{

//不存在就不复制

return;

}

//用高效的字节输入流读取

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));

//用高效的字节输出流写出

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

byte[] bys= new byte[1024];

int len = 0;

//判断是否读到文件结尾

while( (len = bis.read(bys)) != -1 )

{

//将数据写到文件中

bos.write(bys,0,len);

//刷新缓存流

bos.flush();

}

//关闭流对象

bis.close();

bos.close();

}

}