黑马程序员面试题

1、(黑马点招面试题)：有类似这样的字符串："1.2,3.4,5.6,7.8,5.56,44.55”请按照要求，

依次完成以下试题。

(1)以逗号作为分隔符，把已知的字符串分成一个String类型的数组，数

组中的每一个元素类似于"1.273.4"这样的字符串

(2)把数组中的每一个元素以"."作为分隔符，把"."左边的元素作为key,右

边的元素作为value,封装到Map中，M叩中的key和value都是Object类型。

(3)把map中的key封装的Set中，并把Set中的元素输出。

(4)把map中的value封装到Collection中，把Collection中的元素输出。

2、(黑马点招面试题)：现有如下两个已知条件：

在F盘有一个文件：a.txt,该文件内容如下：

test.Person,id:5

test.Student,id:6

(1)读取a.txt中为每一行，把每一行放入一个变量中

(2)用"，"分隔符把变量变成一个String类型的数组。

(3)读取数据中的第一个元素，利用java反射机制创建对象。

3、编写程序，循环接收用户从键盘输入多个字符串，直到输入“end”时循环结束，并

将所有已输入的字符串按字典顺序倒序打印。

4、编写一个程序，把指定目录下的所有的带.java文件都拷贝到另一个目录中，拷贝成

功后，把后缀名是.java的改成.txt。

5,编写一个类A,增加一个实力方法showString,用于打印一条字符串，在编写一个类

TestA,作为客户端，用键盘输入•个字符串，改字符串就是类A的全名，使用反射机制创

建该类的对象，并调用该对象中的方法showStringo

6、键盘录入5个数据，存储到一个数组中，取最大值和最小值。

7、取出个字符串中字母出现的次数。如：字符串："abcdekka27qoq"，输出格式为：

a(2)b(l)k(2)...

8、向泛型为Integer的AnayList中添加-,个String类型的元素

9、定义•个文件输入流，调用read(byte[]b)方法将exercise.txt文件中的所有内容打印

出来(byte数组的大小限制为5).

11、编写程序，循环接收用户从键盘输入多个字符串，直到输入“end”时循环结束，

并将所有已输入的字符串按字典顺序倒序打印。

12、一个ArrayList对象aList中存有若干个字符串元素，现欲遍历该ArrayList对象，

删除其中所有值为“abc”的字符串元素，请用代码实现。

13、编写一个类，增加一个实例方法用于打印一条字符串。并使用反射手段创建该类的

对象，并调用该对象中的方法。

14、编写一个程序，获取10个1至20的随机数，要求随机数不能重复。

15、声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，

给数组中添加数据，每•个线程为数组添加3个数据即可。

16、使用带缓冲功能的字节流复制文件。

17、求三位数的质数，只能被本身和1整除，倒序输出

18、用Math.random生成1,2,3,4,5,6,7,8,9,10

19、键盘录入5个数，存储到一个数组中，取最大值和最小值

20、通过反射创建•个对象，并且运行其中的私有方法

21、九九乘法表

22、冒泡排序

23、懒汉式

24、1-100中个位和十位不含7的数

25、从文本中读取在控制台显示

packagecom.itheima;

importjava.util.Collection;

importjava.utiLHashMap;

importjava.util.IdentityHashMap;

importjava.util.Map;

importjava.util.Set;

/*

*1、有类似这样的字符串：”1.2,3.4,5.6,7.8,5.56,44.55"请按照要求，依次完成以下试题。

*(1)以逗号作为分隔符，把已知的字符串分成一个String类型的数组，数组中的每

一个元素类似于"1.2",”3.4”这样的字符串

*(2)把数组中的每一个元素以作为分隔符，把".”左边的元素作为key,右边的元素

作为value,封装到Map中,Map中的key和value都是Object类型。

*(3)把map中的key封装至ljSet中，并把Set中的元素输出。

*(4)把map中的value封装至UCollection中,把Collection中的元素输出。

*

*思路：

求一定要明确的是：我们学的Map集合键是不可以重复的，所以我们做这个题的时候

就要考虑可以重复键的Map集合。IdentityHashMap

*考点：1.正则2.M叩集合3*.最重要的是要明确这个题的最重要的一点，

IdentityHashMap作为Map集合键可以重复。

*要知道，所有的题都是很简单的，不要想的太复杂，多问老师和百度。

*/

publicclassExamTestl{

publicstaticvoidmain(String[]args){

Stringstring="1.2,3.4,5.6,7.8,5.56,44.55”;〃定义一个字符串

Map<Object,Object>map=newIdentityHashMap<Object,Object>();//创建

M叩集合

Stringf]str=string.split(n,H);/Z将字符串以，”分割，用一个字符串str数组接收

//遍历str数组并将数组中的元素用”.“分割(使用了正则表达式内容)，用str2

接收。

for(inta=0;a<str.length;a++){

//创建一个字符串数组str2

String[]str2=str[a].split(n\\.n);

//遍历str2数组，将分割后的内容存入到map集合中

map.put(str2[0],str2[l]);

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

//打印set获取键

System.out.println(set);

Collection<Object>col=map.values();

〃打印col获取值

System.out.println(col);

)

packagecom.itheima;

importjava.io.BufferedReader;

importjava.io.FileReader;

/*

*2、现有如下两个已知条件：

*在F盘有一个文件：a.txt屋该文件内容如下：

*test.Person4d:5

*test.Student,id:6

*

*(1)读取a.txt中为每一行，把每一行放入一个变量中

*(2)用"，"分隔符把变量变成一个String类型的数组。

*(3)读取数据中的第一个元素，利用java反射机制创建对象。

*/

publicclassExamTest2{

publicstaticvoidmain(String[Jargs)throwsException{

//创建一个高效输入流，指向F盘下的a.txt文件

BufferedReaderbr=newBufferedReader(newFileReader(na.txt"));

//读取第一行

Stringstrl=br.readLine();

//读取第二行

Stringstr2=br.readLine();

//System.out.println(strl);

//System.out.println(str2);

//分别用字符串数组接收用“J隔开的两部分

String[]strsl=strl.split。J);

String[]strs2=str2.split(n,");

〃创建字节码对象

Classc=Class.forName(strs1[0]);

//c.getConstructor().newInstance();

〃用字节码文件创建对象

Objectobj=c.newlnstance();

packagecom.itheima;

importjava.utiLComparator;

importjava.util.Iterator;

importjava.util.Scanner;

importjava.util.TreeSet;

〃3、编写程序，循环接收用户从键盘输入多个字符串，直到输入“end”时循环结束,

并将所有)输入的字符串按字典顺序倒序打印。

//问乐飞去吧，思路对了，但是结果没有对

publicclassExamTest3{

publicstaticvoidmain(String[]args){

TreeSet<String>ts=newTreeSeto(newComparator<String>(){

©Override

publicintcompare(Stringsi,Strings2){

retum-(pareTo(s2));

}

})；

while(true){

Scannersc=newScanner(System.in);

Stringstring=sc.nextLine();

if(string.equals(nend")){

Iterator<String>it=ts.iterator();

while(it.hasNext()){

System.out.println(it.next());

}

break;

)

ts.add(string);

)

packagecom.itheima;

importjava.io.BufferedReader;

importjava.io.BufferedWriter;

importjava.io.File;

importjava.io.FileReader;

importjava.io.FileWriter;

importjava.io.FilenameFilter;

importjava.io.IOException;

〃4、编写一个程序，把这个目录下的所有的带.java文件都拷贝到另一个目录总，拷贝成功

后，把后缀名是.java的改成.txt

/*

*思路

*1、创建输入流对象，遍历目录，通过匿名内部类拿出。符合规则的文件

*2、通过高效字符流复制文件

*3、将.java改成.txt

*

*注意：如果是多级目录的话用递归，最好在过滤器方法中用，这是要注意，递归调用的

方法一定要try..catch不可以抛异常，原因是他爹没有，你懂得！

*/

publicclassExamTest4{

publicstaticvoidmain(String[]args)throwslOException{

//封装d:\\java这个目录

FilestartFile=newFile(,'d:\\javaM);

//获取该目录下的所有满足条件的数组

File[Jfiles=startFile.listFiles(newFilenameFilter(){

©Override

publicbooleanaccept(Filedir,Stringname){

returnnewFile(dir,name).isFile()&&name.endsWith(H.java");

)

})；

〃判断目的地是否存在，不存在就建立

FileendFile=newFile(Hd:\\jarn);

if(!endFile.exists()){

endFile.mkdir();

)

//遍历文件数组

for(Filef:files){

Stringname=f.getName();//得到文件名

FilenewFile=newFile(endFile,name);//将路径和文件名拼接

BufferedReaderbr=newBufferedReader(newFileReader(f))；

BulferedWriterbw=newBufferedWriter(newFileWriter(newFile));

Stringline=null;

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

bw.write(line);

bw.newLine();

bw.flush();

}

bw.close();

br.close();

)

//改名

File[]endFileArray=endFile.listFiles();

for(Filefile:endFileArray){

Stringname=file.getName();

Stringnewname=name.replace(u.javau,".jar");

FilenewFile=newFile(endFile,newname);

file.renameTo(newFile);

)

)

)

packagecom.itheima;

importjava.lang.reflect.Method;

importjava.util.Scanner;

〃5、编写一个类A,增加一个实力方法showString,用于打印一条字符串，在编写一个类TestA,

作为客户端，用键盘输入一个字符串，改字符

〃串就是类A的全名，使用反射机制创建该类的对象，并调用该对象中的方法showString。

publicclassExamTest5{

publicstaticvoidmain(String[]args)throwsException{

Scannersc=newScanner(System.in);

Stringstring=sc.nextLine();

Classc=Class.forName(nheima.mianshiti.A");//获取字节码对象

Methodm=c.getMethod(nshowString",String.class);

m.invoke(c.newlnstance(),string);

classA{

publicvoidshowString(Stringstr){

System.out.println(str);

)

)

packagecom.itheima;

importjava.util.Arrays;

importjava.util.Scanner;

〃6、键盘录入5个数据，存储到一个数组中，取最大值和最小值

//重点Arrays的sort方法忘了的看API

publicclassExamTest6{

publicstaticvoidmain(String[]args){

//键盘录入5个数

Scannersc=newScanner(System.in);

int[]arr=newint[5];

intcount=0;

for(inti=0;i<5;i++){

System.out.println("请输入第"+(count+1)+”个数据：");

inta=sc.nextlnt();

arr[countj=a;

count++;

)

get(arr);

)

publicstaticvoidget(int[]arr){

Arrays.sort(arr);

System.out.prinlln("最大值为："+arr[arr.length-1]);

System.out.println("最小值为："4-arr[0]);

packagecom.itheima;

importjava.util.Iterator;

importjava.util.Map;

importjava.util.Map.Entry;

importjava.util.Scanner;

importjava.util.Set;

importjava.util.TreeMap;

/*7、取出一个字符串中字母出现的次数。如：字符串：uabcdekka27qoq",输出格式为：

a(2)b(l)k(2)...

*

*这个不用解释了，老毕视频讲的很清楚不懂多问问会的同学

*/

publicclassExamTest7{

publicstaticvoidmain(String[]args){

Scannersc=newScanner(System.in);

System.out.println("请输入一个字符串：");

Stringstr=sc.nextLine();

char[]ch=str.toCharArrayO;//转换成字符数组

TreeMap<Character,Integer>map=newTreeMap<>();//创建一个TreeMap

for(charc:ch){//遍历

Characterkey=c;

Integervalue=map.get(c);

if(value==null){〃判断，如果值为空，则向集合中添加(key」),如果不为空则

添加(key,value+l)

map.put(key,1);

}else{

map.put(key,value+1);

)

)

//遍历集合

Set<Map.Entry<Character,Integer»set=map.entrySet();

Iterator<Entry<Character,Integer»it=set.iterator();

while(it.hasNext()){

Map.Entry<Character,Integer>me=it.next();

Characterkey=me.getKeyO;

Integervalue=me.getValue();

System.out.println(key+H("+value+")”);〃按规定的格式输出

)

packagecom.itheima;

/*8、ArrayList<Integer>list=newArrayList<Integer>();

在这个泛型为Integer的ArrayList中存放一个String类型的对象。

*/

importjava.lang.reflect.Method;

importjava.util.ArrayList;

publicclassExamTest8{

publicstaticvoidmain(String[]args)throwsException{

〃用反射跳过泛型，调用ArrayList类中的add方法添加string

ArrayList<Integer>list=newArrayList<Integer>();//定义Inleger泛型

Methodm=list.getClass().getMethod(nadd",Object.class);//得到add方法对象

m.invoke(list,"thisisaString"”/通过反射来执行list的第一个方法，第一个是list对

象，代表该对象的方法，第二个是方法参数

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

packagecom.itheima;

importjava.io.FilelnputStream;

importjava.io.lOException;

〃定义一个文件输入流，调用read(byte[]b)方法将exercise.txt文件中的所有

〃内容打印出来(byte数组的大小限制为5)o

publicclassExamTest9{

//@SuppressWamings(Munused")

publicstaticvoidmain(Stringl]args)throwslOException{

FilelnputStreamfis=newFileInputStream("E:\\a.java");

byte[]bys=newbyte[5];

intlen=0;

while((len=fis.read(bys))!=-1){

System.out.print(newString(bys));

packagecom.itheima;

importjava.util.HashMap;

importjava.util.Iterator;

importjava.util.Map;

importjava.util.Set;

/*

IS目:编写一个类，在main方法中定义一个Map对象(采用泛型)，加入若干个对象，然

后遍历并打印出各元素的key和valueo

分析：

L创建Map对象

2.加入若干对象

3.遍历Map对象

4.打印元素key和value

这要是不会不要怪别人，最基础的，但是如果不熟练在好好练练

*/

publicclassExamTestlO{

publicstaticvoidmain(String[]args){

//创建Map对象

Map<String,Integer>map=newHashMap<String,Integer>();

//加入若干对象

map.putC'小明”,21);

map.put(“小王”，18);

map.put(“小李”,45);

//遍历Map对象

Set<Map.Entry<String,Integer»set=map.entrySet();

Iterator<Map.Entry<String,Integer»it=set.iterator();

while(it.hasNext()){

Map.Entry<String,Integer>me=it.nextQ;

//打印元素key和value

System.out.println(”key:"+me.getKeyO+"-----”+nvalue:M

+me.getValueO);

)

packagecom.itheima;

importjava.io.BufferedReader;

importjava.io.IOException;

importjava.io.InputStreamReader;

importjava.util.ArrayList;

importjava.util.Collections;

importjava.util.Iterator;

importjava.util.List;

/*

题目：编写程序，循环接收用户从键盘输入多个字符串，直到输入“end”时循环结束，

并将所有已输入的字符串按字典顺序倒序打印。

分析：

1.字符串本身提供的比较性为字典顺序，可以使用工具类Collections.reverse()方法将原

来的比较性反序。

但也可以自定一个比较器，让集合自身必备比较性；

2.键盘录入的是字节流，操作的是字符流，可以使用转换流，并加入缓冲区技术，提

高效率；

3.录入的字符串存储到ArrayList集合中；

4.使用Collections工具类给ArrayList中元素排序

5.打印ArrayList集合中的元素

步骤：

1.List<String>list=newArrayList<String>();

2.BufferedReaderbufr=newBufferedReader(newInputStreamReader(System.in));

3.1ist.add(line);

4.Collections.sort(list,Collections.reverseOrder());

5.Iterator<String>it=list.iterator();

while(it.hasNext()){

System.out.println(it.next());

)

*/

publicclassExamTestll{

publicstaticvoidmain(String[]args){

//1、定义一个ArrayList集合

List<String>list=newArrayList<String>();

〃键盘录入字符串，转换流，缓冲区

System.out.println("请输入一些字符或者字符串，end结束!)

BufferedReaderbufr=newBufferedReader(newInputStreamReader(System.in));

Stringline=null;

try(

while((line=bufr.readLine())!=null){

if("end'^equalsCline))

break;

//往ArrayList集合中添加元素

list.add(line);

)

}catch(lOExceptione){

thrownewRuntimeException(nIO异常)

)

〃给ArrayList排序，字典倒序

Collections.sort(list,Collections.reverseOrderO);

//打印集合

Iterator<String>it=list.iterator();

while(it.hasNext()){

System.out.println(it.next());

)

)

)

packagecom.itheima;

importjava.util.ArrayList;

importjava.util.Iterator;

importjava.util.List;

/*

*3、一个ArrayList对象aList中存有若干个字符串元素，

*现欲遍历该ArrayList对象，删除其中所有值为“abc”的字符串元素,

*请用代码实现。

**/

@SuppressWarnings(,'unusedn)

publicclassExamTest12{

publicstaticvoidmain(String[]args){

List<String>aList=newArrayList<String>();

aList.add(nCSDN社区)

aList.add("abcM);

aList.add("黑马程序员)

aList.add("黑马论坛)

aList.add("黑马程序员——安卓)

aList.add("黑马程序员—云计算")；

aList.add("abc");

aList.add("我准备去黑马训练营了)

//通过普通的角标遍历，删除。要避免并发修改异常

for(inta=0;a<aList.size();a++){

if(aList.get(a).equals("abc")){

aList.remove(a);

}

)

System.out.println(aList);

packagecom.itheima;

importjava.lang.reflect.Method;

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

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

**/

〃对象的打印方法

classPrintin{

publicvoidprintln(Stringstr){

System.out.println(str);

)

)

publicclassExamTest13{

publicstaticvoidmain(String[]args)throwsException{

Classc=Class.forName(ucom.itheima.Println");//通过反射的方式获取该类的字节

码文件

Methodmethod=c.getMethod(uprintln",Slring.class);//获取字节码对象对应的方

法，并指定参数类型。

method.invoke(c.newlnstance(),”王荣荣好难看呀O(n_A)O哈哈〜”);〃运行对

象中的方法，并传入参数。

packagecom.itheima;

importjava.util.Random;

importjava.util.TreeSet;

/*

*编写一个程序，获取10个1至20的随机数，要求随机数不能重复。

*

*思路：

*1.定义一个集合，用于存储随机数

*2.产生随机数，并存储进集合中。

*3.对集合的长度进行判断。

*步骤：

*1.由于随机数不能重复，所以使用Set集合。为了保证值的唯一，所以使用HashSet

集合.

*2.通过Set集合的add方法，将生成的随机数存储进HashSet集合。

*3.通过Set集合的size方法对集合的长度进行判断，如果产生的随机数达到10个,

那么将退出循环。

**/

publicclassExamTestl4{

publicstaticvoidmain(String[]args){

//存储Integer的Set集合

TreeSet<Integer>set=newTreeSet<Integer>();

//判断集合的长度，如果符合了一定的长度，那么循环结束

while(set.size()<10){

//产生1〜20之间的随机数

inti=newRandom().nextlnt(20)+1;

〃添加进Set集合中

set.add(i);

)

//打印下集合的元素

System.out.println(set);

packagecom.itheima;

importjava.util.Arrays;

importjava.util.Random;

〃声明一个共享数组，起两个线程，

〃两个线程分别隔一段时间(可以写一个随机数)，给数组中添加数据，

〃每一个线程为数组添加3个数据即可。

publicclassExamTestl5{

〃写一个类实现Runnable接口，创建两个Thread对象传入该类

〃多线程操作共享数组需要同步synchronize

publicstaticvoidmain(String[]args){

FillArrayfa=newFillArrayO;

Threadtl=newThread(fa);

Threadt2=newThread(fa);

tl.start();

t2.start();

)

}

classFillArrayimplementsRunnable{

〃定义共享数组

int[]arr=newint[6];

〃创建random类的r对象

Randomr=newRandom();

//简单初始化

intcount=0;

publicvoidrun(){

//同步代码块

synchronized(r){

//控制长度

while(count<arr.length){

//Romdom类的nextlnt方法自己看API

intnum=r.nextInt(20);

〃System.out.println(Thread.currentThread().getName()+响数组中力I」入了

"+num);

arrfcount]=num;

count++;

//try{

//r.wait(500);

//}catch(Exceptione){

//e.printStackTrace();

//

System.out.println(AiTays.toString(arr));

packagecom.itheima;

importjava.io.BufferedlnputStream;

importjava.io.BufferedOutputStream;

importjava.io.FilelnputStream;

importjava.io.FileOutputStream;

importjava.io.IOException;

〃使用带缓冲功能的字节流复制文件。

〃只有一个要强调的写的时候要用实际长度因为字节控制在1024有可能里面的内

容没有这么大这时候会出现一些空格字节还是字符？？？

publicclassExamTestl6{

publicstaticvoidmain(String[]args){

BufferedlnputStreambis=null;

BufferedOutputStreambos=null;

try(

bis=newBufferedInputStream(newFileInputStream(ua.txtn));

bos=newBufferedOutputStream(newFileOutputStream("copya.txt"))；

byte[lbys=newbyte[1024];

intlen=0;

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

bos.write(bys,0,len);

)

}catch(Exceptione){

e.printStackTrace();

}finally{

try(

bos.close();

}catch(lOExceptione){

e.printStackTrace();

}

try(

bis.close();

}catch(lOExceptione){

e.printStackTrace();

packagecom.itheima;

importjava.util.ArrayList;

importjava.util.Collections;

〃求三位数的质数，只能被本身和1整除，倒序输出

publicclassExamTest17{

publicstaticvoidmain(String[]args){

ArrayList<Integer>al=newArrayList<>();

booleanflag=true;

for(inta=100;a<1000;a++){

flag=true;

for(intb=2;b<a;b++){

if(a%b==0){

flag=false;

break;

}

)

if(flag){

al.add(a);

)

)

//Collections工具类的方法，你懂得

Collections.reverse(al);

System.out.println(al);

packagecom.itheima;

importjava.util.TreeSet;

〃用Math.random生成1,2,3,4,5,6,7,8,9,10

//Math的random方法看API

publicclassExamTest18{

publicstaticvoidmain(String[]args){

TreeSet<Integer>ts=newTreeSet<Integer>();

//Randomrd=newRandom();

〃控制长度

while(ts.size()<10){

ts.add((int)(Math.random()*10+1));

)

System.out.println(ts);

packagecom.itheima;

importjava.util.Arrays;

importjava.utiLScanner;

〃键盘录入5个数，存储到一个数组中，取最大值和最小值

〃重点是Arrays的sort方法看API

publicclassExamTest19{

publicstaticvoidmain(String[]args){

int[]arr=newint[5];

Scannersc=newScanner(System.in);

System.out.println(nlogin");

for(inti=0;i<5;i++){

arr[i]=sc.nextlnt();

//System.out.println(arr[i]);

)

get(arr);

)

publicstaticvoidget(int[Jarr){

Arrays.sort(arr);

System.out.println(arrlOJ);

System.out.println(arr[arr.length-1]);

packagecom.itheima;

importjava.lang.reflect.Constructor;

importjava.lang.reflect.Method;

//通过反射创建一个对象，并且运行其中的私有方法

//掌握反射的原理机制和三种获取class字节码文件的方法

publicclassExamTest20{

publicstaticvoidmain(String[]args)throwsException(

Classc=Class.forName("com.itheima.Studetn");

Constructorcon=c.getConstructor();

Objectobj=c.newlnstance();

Methodm=c.getDeclaredMethod("show",null);

m.setAccessible(true);

m.invoke(obj,null);

)

packagecom.itheima;

〃九九乘法表自己琢磨吧解释就是对你最大的不尊重

publicclassExamTest21{

publicstaticvoidmain(String[]args){

for(intx=9;x>0;x—){

for(inty=1;y<=x;y++){

System.out.print(y++x+"="+x*y+

System.out.printlnO;

)

packagecom.itheima;

〃冒泡排序最基础的东西掌握4种简单的排序明白外循环和内循环的作用

publicclassExamTest22{

publicstaticvoidmain(String[]args){

int[]array={12,25,234,364,4,345,346,47);

for(inta=0;a<array.length-1;a++){

for(intb=0;b<array.length-1-a;b++){

if(arrayfb]>array[b+1]){

inttemp=array[b];

array[b]=array[b+1];

array[b+1]=temp;

)

)

)

for(inti:array){

System.out.println(i);

)

)

)

packagecom.itheima;

〃懒汉式(延迟加载的单例设计模式)

publicclassExamTest23{

}

classStudent{

privateStudent(){

privatestaticStudents=null;

〃注意在多线程程序中容易出现安全问题，所以我们写的时候最好加上synchronized

publicstaticsynchr