- 简答题
- 不借助第三个变量交换值
- builder方式创建对象
- ArrayList和Vector的区别
- Java有哪些容器？
- 数组和列表（ArrayList）有什么区别？有什么时候应该使用Array而不是Array List？
- ConcurrentHashMap的原理？
- 遍历HashMap的三种方式？
- String s=new String(“abc”)分别在堆栈上新建了哪些对象？
- 什么是多线程并发安全问题？这种问题的原因是什么？如何去解决？
- Synchronized用过吗？其原理是什么？
- ThreadLocal的使用场景？
- 二十三种设计模式
- 请从100万个数字中找到最大的10个数字？
简答题
题目一
随机组成四个由0-9组成的8位不重复数字的字符串，并且这四个字符串之间也不能重复
public class Domo {
public static void main(String[] args) {
HashSet<String> nums = new HashSet<String>();//定义set集合,set集合元素不能重复
HashSet<StringBuilder> strs = new HashSet<StringBuilder>();//定义set集合,set集合元素不能重复
while(true) {
//添加8个不同的数字
while (nums.size() < 8) {
Random random = new Random();//随机生成数字,添加到nums集合
nums.add(Integer.toString(random.nextInt(10)));
}
StringBuilder stringBuilder = new StringBuilder();
for (String str : nums) {
stringBuilder.append(str);
}
strs.add(stringBuilder);
//当数组有4个数时退出方法
if(strs.size()==4){
break;
}
}
}
}
题目二
(简答题)创建一个多线程的TCP 服务器以及客户端，完成下面的功能：
已知在服务器端的目录下有一个worldcup.txt,其格式如下：
2006/意大利
2002/巴西
…
该文件采用”年份/世界杯冠军 “的方式保存每一年世界杯冠军的信息。
要求从客户端输入年份，从服务器端查询，若查询到，返回举办地；反之，返回”未查询到该年份的世界杯举办地”。
服务器
public class ServerMain {
public static void main(String[] args) throws IOException {
System.out.println("服务器已启动");
ServerSocket ss = new ServerSocket(9999);
while (true) {
Socket socket = ss.accept();
Server server = new Server(socket);
Thread t = new Thread(server);
t.start();
}
}
}
服务器逻辑
public class Server implements Runnable{
Socket socket ;
public Server(Socket socket){
this.socket=socket;
}
// 创建map对象
private Map<String, String> map = new HashMap<>();
//构造代码块的内容会在对象创建的时候执行
{
try {
// 创建字符输入流
BufferedReader br = new BufferedReader(new FileReader("D:/aa/worldcup.txt"));
// 读取服务端目录下worldcup.txt文件
String str;
while ((str = br.readLine()) != null) {
// 以/为标志将读取到的字符串分割成两个子字符串
String[] st = str.split("/");
// 将读到的内容放入到map中
map.put(st[0], st[1]);
System.out.println(st[0]+""+st[1]);
}
// 关流
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
try{
//网络输入流
DataInputStream dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
//网络输出流
DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
// 读取客户端发送过来的数据
String year = dis.readUTF();
// 判断map中是否包含year，并将结果发送给客户端
if (map.containsKey(year)) {
dos.writeUTF(map.get(year));
} else {
dos.writeUTF("未查询到该年份的世界杯举办地");
}
dos.close();
dis.close();
// 关流
socket.close();
}catch (Exception e){
e.printStackTrace();
}
}
}
客户端
public class Client {
public static void main(String[] args) throws Exception{
System.out.println("输入年份");
Scanner sc = new Scanner(System.in);
Socket socket = new Socket("localhost", 9999);
String year = sc.nextLine();
//网络输入流
DataInputStream dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
//网络输出流
DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
dos.writeUTF(year);
dos.flush();
// 读取服务端返回过来的数据
String city = dis.readUTF();
System.out.println(city);
dis.close();
dos.close();
// 关流
socket.close();
}
}
不借助第三个变量交换值
栈
借助栈的方式,先进后出,将先取出的值赋给后面的值
void exchange(int x,int y){
Stack s =new Stack();
s.push(x);
s.push(y);
x=(int) s.pop();
y=(int)s.pop();
System.out.println("x="+x+" y="+y);
}
四则运算
int a=13;
int b=23;
a=b-a;
b=b-a;
a=a+b;
位运算符
int x=10; // 1010
int y=5;// y= 0101
x=x^y; // x= 1111 =15
y=y^x;// y= 1010 =10
x=x^y;// x= 0101 =5
builder方式创建对象
public class Person {
//姓名 -required(必写)
private final String name;
//性别-required(必写)
private final String gender;
//年龄
private int age;
//省份证号
private String id;
public static class newBuilder{
//姓名 -required
private String name;
//性别-required
private String gender;
//年龄
private int age;
//省份证号
private String id;
public newBuilder setAge(int age){
this.age = age;
return this;
}
public newBuilder setId(String id){
this.id = id;
return this;
}
public newBuilder(String name,String gender){
this.name = name;
this.gender = gender;
}
public Person build(){
return new Person(this);
}
}
//外部类的私有构造函数
private Person(newBuilder builder){
this.name = builder.name;
this.gender = builder.gender;
this.age = age;
this.id = id;
}
}
创建对象时
Person p = new Person.newBuilder("miracle","male").setAge(18).build();
Person p = new Person.newBuilder("miracle","male").setAge(18).setId("1877551230").build();
思路
- 我们用builder方式创建对象时,用到了静态的内部类,内部类可以访问外部类的所有属性和方法
- 为外部类写一个私有的构造方法,就不能直接用外部类用new的方式来创建对象
- 所以用外部类打点内部类的方式先new出内部类对象,通过设置内部类的构造方法限定必须要输入的属性值;然后用内部类调用build()方法,返回一个以子类作为参数的Person类类型,内部类就通过私有的外部类构造器创建了一个新的对象
- 因为子类set方法的返回值都是子类的类类型,所以可以继续设置属性
优点
- 成员变量可以是final类型,通过设置构造函数来要求必须输入
- 对象状态连续,创建时就赋值,更加清晰
总结
- 外部类构造函数私有,且参数为静态内部类,使用静态内部类的变量为构建类逐一赋值
- 静态内部类拥有外部类相同的属性
- 为每一个属性写一个setter方法,返回的是当前Builder对象
- 最后提供一个方法build方法,new出来一个构建类的对象,参数是当前的Builder对象
ArrayList和Vector的区别
ArrayList和Vector这两个集合本质上并没有什么太大的不停，他们都实现了List接口，而且底层都是基于Java数组来存储集合元素。
Java有哪些容器？
数组和列表（ArrayList）有什么区别？有什么时候应该使用Array而不是Array List？
数组(Array)和列表(ArrayList)有什么区别？什么时候应该使用 Array 而不是ArrayList ？ 下面列出了 Array 和 ArrayList 的不同点：Array 可以包含基本类型和对象类型，ArrayList 只能包含对象类型。Array 大小是固定的，ArrayList 的大小是动态变化的。ArrayList 提供了更多的方法和特性，比如：addAll()，removeAll()，iterator()等等。对于基本类型数据，集合使用自动装箱来减少编码工作量。但是，当处理固定大小的基本数据类型的时候，这种方式相对比较慢。
ArrayList 和 LinkedList 有什么区别？ArrayList 和 LinkedList 都实现了 List 接口，他们有以下的不同点：ArrayList 是基于索引的数据接口，它的底层是数组。它可以以 O(1)时间复杂度对元素进行随机访问。与此对应，LinkedList 是以元素列表的形式存储它的数据，每一个元素都和它的前 一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是 O(n)。相对于 ArrayList ，LinkedList 的插入，添加，删除操作速度更快，因为当元素被添加到集合任 意位置的时候，不需要像数组那样重新计算大小或者是更新索引。LinkedList 比 ArrayList 更占内存，因为 LinkedList 为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。也可以参考 ArrayList vs. LinkedList 。
ConcurrentHashMap的原理？
遍历HashMap的三种方式？
1.利用键的Set集合； 2.利用值的集合遍历所有value； 3.通过entry对象存储每一次的键和值(效率最高)
String s=new String(“abc”)分别在堆栈上新建了哪些对象？
一. 在常量池找abc,如果找到,就不创建对象,如果没找到,就在常量池创建string对象 二.出现了new,在堆内存创建string对象,并存储abc,将其返回给s ,s在栈中这个对象的引用. 如果是String s=”abc”; 在常量池找abc,如果找到就不创建对象,否则,在常量池创建对象
什么是多线程并发安全问题？这种问题的原因是什么？如何去解决？
Synchronized用过吗？其原理是什么？
ThreadLocal的使用场景？
二十三种设计模式
请从100万个数字中找到最大的10个数字？
把100W平均分成100份,每份1W,挑出每份最大的十个数字,组合起来在找最大的十个数字