"★里面有解题思路一样的没有全部解答，仅仅将题目列出，稍微改变即可得出结果★
"笔试题重点，
" 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();
}
}