Java基础面试题
1、取出一个字符串中字母出现的次数。如：字符串：”abcdekka27qoq” ，输出格式为：a(2)b(1)k(2)…
package com.itheima;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class Test1 {
/**
* 1、取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ，输出格式为：a(2)b(1)k(2)...
*
* 思路： 遍历字符串，拿每一个字符到TreeMap中去找，如果存在则把该字符和值加1作为键和值存储到集合中；
* 如果不存在则把该字符和1作为键和值存储到集合中。
*/
public static void main(String[] args) {
String str = "abcdekka27qoq";
char[] chs = str.toCharArray();
TreeMap tm = new TreeMap();
for (char ch : chs) {
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
if (!tm.containsKey(ch)) {
tm.put(ch, 1);
} else {
tm.put(ch, tm.get(ch) + 1);
}
}
}
Set> set = tm.entrySet();
for (Map.Entry entry : set) {
System.out.print(entry.getKey() + "(" + entry.getValue() + ")");
}
}
} 2、ArrayList list = new ArrayList();在这个泛型为Integer的ArrayList中存放一个String类型的对象。
package com.itheima;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class Test3 {
/**
* 3、ArrayList list = new ArrayList();
* 在这个泛型为Integer的ArrayList中存放一个String类型的对象。
*
* @throws SecurityException
* @throws NoSuchMethodException
* @throws InvocationTargetException
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static void main(String[] args) throws NoSuchMethodException,
SecurityException, InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
String str = "I am String";
ArrayList list = new ArrayList();
Method m = list.getClass().getDeclaredMethod("add", Object.class);
m.setAccessible(true);
m.invoke(list, str);
for (Object obj : list) {
System.out.println(obj);
}
}
} 3、有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息。输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称”stu.txt”文件中。 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
package com.itheima;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
import java.util.TreeSet;
/**
* 4、 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息。
* 输入格式为：name,30,30,30（姓名，三门课成绩），
* 然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。
* 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
*
* 涉及知识点：
* 1、IO流的相关操作
* 2、集合的运用
*
* 思路：
* 1、首先要定义学生类，定义基本的属性与方法，考虑到要使用集合存储，复写好hashCode，equals，compareTo等方法。
* 2、要求输入的信息按总分从高到低写入，所以选择TreeSet集合比较方便。
* 3、输入信息，读取字符串，按照","分割，封装到对象，存储到集合，再遍历集合输出到文件即可。
* @author AllenIverson
*
*/
public class Test4 {
public static void main(String[] agrs) throws IOException {
writeToFile(getSet());
}
public static void writeToFile(TreeSet ts) throws IOException {
BufferedWriter buf = new BufferedWriter(new FileWriter("stu.txt"));
for (Student stu : ts) {
buf.write(stu.toString());
buf.newLine();
buf.flush();
}
buf.close();
}
public static TreeSet getSet() {
TreeSet ts = new TreeSet();
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生数据：");
while (sc.hasNext()) {
String str = sc.nextLine();
if (str.equals("over")) {
sc.close();
break;
}
String[] s = str.split(",");
ts.add(new Student(s[0], Integer.parseInt(s[1]), Integer
.parseInt(s[2]), Integer.parseInt(s[3])));
}
return ts;
}
}
class Student implements Comparable {
//成员变量
private String name;
private int ch, math, en;
private int sum;
public Student(String name, int ch, int math, int en) {
super();
this.name = name;
this.ch = ch;
this.math = math;
this.en = en;
this.sum = ch + math + en;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getCh() {
return ch;
}
public void setCh(int ch) {
this.ch = ch;
}
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getEn() {
return en;
}
public void setEn(int en) {
this.en = en;
}
public int getSum() {
return sum;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ch;
result = prime * result + en;
result = prime * result + math;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + sum;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (ch != other.ch)
return false;
if (en != other.en)
return false;
if (math != other.math)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (sum != other.sum)
return false;
return true;
}
@Override
public String toString() {
return "姓名：" + name + " 语文：" + ch + " 数学：" + math + " 英语：" + en + " 总分"
+ sum;
}
@Override
public int compareTo(Student s) {//元素有比较性
if (!(s instanceof Student)) {
throw new RuntimeException("类型错误");
}
int num = new Integer(this.sum).compareTo(new Integer(s.sum));
if (num == 0) {
return this.name.compareTo(s.name);//成绩相同则比较姓名
}
return num;
}
} 4、定义一个文件输入流，调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5)
package com.itheima;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
* 5、定义一个文件输入流，调用read(byte[] b)方法将exercise.txt文件中的所有内容打印出来(byte数组的大小限制为5)。
*
* @author AllenIverson
*
*/
public class Test5 {
public static void main(String[] args) throws IOException {
File file = new File("stu.txt");
String str = readTxt(file);
System.out.println(str);
}
private static String readTxt(File file) throws IOException {
FileInputStream fis = new FileInputStream(file);
byte[] by = new byte[5];
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int len = 0;
while ((len = fis.read(by)) != -1) {
// 会把读到的内容全部存储到一个字节数组缓冲区中
bos.write(by, 0, len);
}
bos.close();
fis.close();
return bos.toString();
}
} 5、编写程序计算12+22+32+….+1002的和
package itheima.com;
public class Test1 {
/**
* 第1题：编写程序计算12+22+32+....+1002的和
*
* @author AllenIverson
*/
public static void main(String[] args) {
// 输出计算结果
System.out.println("12+22+32+....+1002 = "+sum());
}
private static int sum() {0
// 定义一个变量存储结果，并赋初始值为0
int sum = 0;
// 利用循环计算数列的和，i每循环一次递增10
for (int i = 12; i <= 1002; i += 10) {
sum += i;
}
return sum;
}
} 6、Collection和Collections有什么关系？List和Set有什么异同点？Map有哪些常用类，各有什么特点？
Collection和Collections有什么关系？
- Collections：java.util下的类，是针对集合类的一个工具类,提供一系列静态方法，实现对集合的查找、排序、替换、线程安全化等操作。–
- Collection：java.util下的接口，是集合类的顶层接口，有Set和List等子接口，提供了关于集合的一些通用方法,如增加、删除、查找、判断等方法。
List和Set有什么异同点？
- 相同点：他们都继承与Collection
- 不同点：List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引，元素可以重复。Set：无序(存入和取出顺序有可能不一致)，不可以存储重复元素，必须保证元素唯一性。
Map有哪些常用类，各有什么特点？
- Map常用类有：HashMap、Hashtable、LinkedHashMap、TreeMap、Properties
- Map集合是双列集合，存储的是键值对元素，其中键唯一，值可重复。
- HashMap：底层数据结构是哈希表，线程不同步，效率高，允许空的键和空的值
- HashTable：底层数据结构是哈希表，线程同步，效率低，不允许空的键值
- LinkedHashMap：是HashMap的子类，底层数据结构是哈希表和链表
- TreeMap：底层数据结构是二叉树，保证元素的排序性（自然排序、比较器排序）
- Properties:用来存储键值对类型的配置文件信息,可以和IO技术相结合
7、为什么需要配置path，什么时候需要classpath?
- 配置path为了让Widnows应用程序可以在dos命令下任意目录调用，如配置好JAVA环境变量后，javac.exe和java.exe在dos命令行中任意目录都可以使用。
- classpath的配置是为了让指定目录中的.class文件可以在dos命令行中任意目录的调用。jvm在查找class文件时如果没有设置classpath会在当前路径查找如果classpath的值前面加上.(代表当前目录)，会先查找当前目录下的class文件再查找指定目录中的class文件。如果不设置classpath我们在程序运行的时候会出现ClassNotFoundException
8、从键盘接受一个数字，打印该数字表示的时间，最大单位到天，例如：
键盘输入6，打印6秒；
键盘输入60，打印1分；
键盘输入66，打印1分6秒；
键盘输入666，打印11分6秒；
键盘输入3601，打印1小时1秒
package itheima.com;
import java.util.Scanner;
public class Test4 {
/**
* 第4题：从键盘接受一个数字，打印该数字表示的时间，最大单位到天，例如：
* 键盘输入6，打印6秒；
* 键盘输入60，打印1分；
* 键盘输入66，打印1分6秒；
* 键盘输入666，打印11分6秒；
* 键盘输入3601，打印1小时1秒
*
* @author AllenIverson
*/
public static void main(String[] args) {
// 创建Scanner对象，用于接收键盘输入的数字
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数字：");
int n = sc.nextInt();
// 根据键盘输入的数字，转换成相应的时间
printTime(n);
}
private static void printTime(int n) {
if (n >= 0) {
// 定义统计变量
int s = 0;// 秒
int m = 0;// 分
int h = 0;// 时
int day = 0;// 天
// 根据时间的换算进制计算天、时、分、秒的值
day = n / (3600 * 24);
n %= 3600 * 24;
h = n / 3600;
n %= 3600;
m = n / 60;
n %= 60;
s = n % 60;
// 如果天、时、分、秒的值不为0则输出
if (day != 0) {
System.out.print(day + "天");
}
if (h != 0) {
System.out.print(h + "小时");
}
if (m != 0) {
System.out.print(m + "分");
}
if (s != 0) {
System.out.println(s + "秒");
}
} else {
System.out.println("你输入的数字有误");
}
}
}9、分析运行结果，说明原理。(没有分析结果不得分)
package itheima.com;
public class Test5 {
/**
* 第5题：分析运行结果，说明原理。(没有分析结果不得分)
*
* 多态中的成员访问特点：
* A:成员变量
* 编译看左边，运行看左边。
* B:构造方法
* 创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
* C:成员方法
* 编译看左边，运行看右边。
* D:静态方法
* 编译看左边，运行看左边。
* (静态和类相关，算不上重写，所以，访问还是左边的)
*
* 由于成员方法存在方法重写，所以它运行看右边。
*
* @author AllenIverson
*/
public static void main(String[] args) {
B b = new B();// 创建B对象
b.fun1();// 输出456，
// B类继承A类，所以B类中的fun2()方法会覆盖A类中的fun2()方法
// 因此b.fun1();语句调用的是B类中的fun2()方法，故返回456
A a = b;// 将B类的对象赋值给父类即多态中的向上转型，a和b指向对内存中的同一对象
a.fun1();//输出456，由于成员方法存在方法重写，所以它运行看右边。
}
}
class A {
void fun1() {
System.out.println(fun2());
}
int fun2() {
return 123;
}
}
class B extends A {
int fun2() {
return 456;
}
} 10、编写一个延迟加载的单例设计模式。
package itheima.com;
public class Test6 {
/**
* 第6题：编写一个延迟加载的单例设计模式。
*
* 单例设计模式分两种，一种是懒汉式，一种是饿汉式。其中懒汉式就是延迟加载的单例设计模式
* 1、单例就是该类只能有一个唯一的对象，私有构造函数
* 2、在内部建立对象 提供公共访问方式访问
* 3、双重判断对对象的引用进行判断，加入同步更安全。
*
* @author AllenIverson
*/
private static Test6 t = null;//指向自己实例的私有静态引用
private Test6() {//私有化构造函数
}
public static Test6 getInstance() {//以自己实例为返回值的静态的公有的方法
if (t == null) {
synchronized (Test6.class) // 懒汉式多线程容易出问题 ，加双重判断解决了这个问题
{
if (t == null)
t = new Test6();
}
}
return t;
}
} 11、定义一个包含私有成员变量和函数的类，再定义一个内部类，在内部类函数中访问外部成员变量，并调用外部函数。在外部类函数中创建内部类对象，调用内部类函数。
package itheima.com;
/**
* 第7题： 定义一个包含私有成员变量和函数的类，再定义一个内部类，
* 在内部类函数中访问外部成员变量，并调用外部函数。
* 在外部类函数中创建内部类对象，调用内部类函数。
*
* 内部的访问特点：
* A:内部类可以直接访问外部类的成员，包括私有。
* B:外部类要访问内部类的成员，必须创建对象。
*
* @author AllenIverson
*/
public class Test7 {// 外部类
private static int a = 2015;// 私有成员变量
private static void outFunction() {// 私有成员函数
System.out.println("调用outFunction()");
// 外部类要访问内部类的成员，必须创建对象
Inner Inner = new Test7().new Inner();
System.out.println("创建Inner对象");
Inner.innerFunction();// 调用内部类函数
return;
}
private static void outFunction1() {// 私有成员函数
System.out.println("outFunction1");
return;
}
public class Inner {// 内部类
public void innerFunction() {
// 访问外部成员变量
System.out.println("innerFunction访问外部成员变量");
System.out.println("外部类a的值:" + Test7.a);
// 调用外部函数
System.out.println("Inner调用外部函数");
Test7.outFunction1();
}
}
public static void main(String[] args) {
outFunction();
}
} 12、声明类Person，包含2个成员变量：name、age。定义函数sayHello()，调用时输出：我叫，今年岁了。声明类Chinese继承Person。
package itheima.com;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Test8 {
/**
* 第8题：
* 声明类Person，包含2个成员变量：name、age。定义函数sayHello()，
* 调用时输出：我叫***，今年***岁了。声明类Chinese继承Person。
*
* @author AllenIverson
*/
public static void main(String[] args) throws Exception {
Person p = new Person("陈冠杰", 25);
p.sayHello();
Chinese c = new Chinese("毕向东", 30);
c.sayHello();
}
}
class Person {// Person类
// 成员变量
private String name;
private int age;
// 构造方法
Person(String name, int age) {
this.name = name;
this.age = age;
}
public void sayHello() {
System.out.println("我的名字叫：" + name + ",今年" + age + "岁了");
}
// set、get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
class Chinese extends Person {// Chinese类
Chinese(String name, int age) {
super(name, age);// 调用父类的构造方法
}
public void sayHello() {// 重写sayHello()方法
super.sayHello();
System.out.println("我是中国人");
}
} 13、编程实现：猫和狗都会叫，但猫是喵喵的叫，狗是汪汪的叫？定义一个动物类，在动物类(animal)中有一个叫的抽象方法。写两个子类，一个猫一个狗，继承自动物类，并实现相应的抽象方法。
package itheima.com;
public class Test9 {
/**
* 第9题： 编程实现：猫和狗都会叫，但猫是喵喵的叫，狗是汪汪的叫？
* 定义一个动物类，在动物类(animal)中有一个叫的抽象方法。
* 写两个子类，一个猫一个狗，继承自动物类，并实现相应的抽象方法。
*
* @author AllenIverson
*/
public static void main(String[] args) {
Animal cat = new Cat();
cat.call();
Animal dog = new Dog();
dog.call();
}
}
abstract class Animal {// 抽象动物类，父类
public abstract void call();// 抽象的方法
}
class Cat extends Animal {// 猫继承了动物类
public Cat() {
}
public void call() {// 重写call()方法
System.out.println("喵喵");
}
}
class Dog extends Animal { // 狗继承了 动物类
public Dog() {
}
public void call() { // 重写call()方法
System.out.println("汪汪");
}
} 14、编写函数，从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表），例如：从“HM程序员”中截取2个字节是“HM”，截取4个则是“HM程”，截取3个字节也要是”HM”而不要出现半个中文
package itheima.com;
import java.io.UnsupportedEncodingException;
/**
* 第10题：
* 编写函数，从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表），
* 例如：从“HM程序员”中截取2个字节是“HM”，截取4个则是“HM程”，截取3个字节也要是"HM"而不要出现半个中文
*
* @author AllenIverson
*/
public class Test10 {
public static void main(String[] args) throws UnsupportedEncodingException {
String str="HM程序员isVery好";
//将字符串按gbk编码 转换为字节数组 然后获取其长度
int len=str.getBytes("gbk").length;
//按字节截取
for(int x=0;x//cutStringByByte(str,x+1) 传入字符串及需要截取的字节长度
System.out.println("截取"+(x+1)+"个字节结果是 "+cutStringByByte(str,x+1));
}
}
/**
* @param str 传入一个字符串
* @param len 传入字符串的长度
* @return 返回一个截取后的字符串
* @throws UnsupportedEncodingException
*/
private static String cutStringByByte(String str, int len) throws UnsupportedEncodingException {
//将字符串转换为字符数组
byte[] buf=str.getBytes("gbk");
int count=0;
//len-1为最后一个角标
for(int x=len-1;x>0;x--)
{
//如果字节负数，说明是汉字
if(buf[x]<0)
{
//记录负数个数
count++;
}
else
{
break;
}
}
//如果截取的数,能整除2，说明是汉字的后半部分，不需要截取
if(count%2==0)
{
return new String(buf,0,len,"gbk");
}
else
{
//如果截取的数,不能整除2，说明是汉字的前半部分，需要截取
return new String(buf,0,len-1,"gbk");
}
}
}