Java面试

Object o1 = new Object();
Object o2 = new Object();
o1 = o2; // 这时2个对象的引用地址是一样的，但是o1申请的内存就没有被使用

public interface IService {
    void service();
}
public class MyService implements IService {
    @Override
    public void service() {
        System.out.println("service...");
    }
}
public class MyProxy implements InvocationHandler {

    private IService service;

    public MyProxy(IService service) {
        this.service = service;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before service");
        Object invoke = method.invoke(service, args);
        System.out.println("after service ");
        return invoke;
    }
}
public class Main {

    public static void main(String[] args) {
        MyService myService = new MyService();
        MyProxy myProxy = new MyProxy(myService);

        // 动态生成代理对象
        IService instance = (IService) Proxy.newProxyInstance(MyService.class.getClassLoader(), MyService.class.getInterfaces(), myProxy);
        instance.service();// 利用代理对象调用service方法

    }
}

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class Test {

    /**
     * 根据map的value进行排序
     * @param map
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(map.entrySet());
        // 先将map转换成List便于使用sort排序
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                return (o2.getValue()).compareTo(o1.getValue());
            }
        });

        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        String fileName = "ngen.log";
        TreeMap<String, Integer> map = new TreeMap<>();
//      SortedMap<String, Integer> map = new
        try {
            fileInputStream = new FileInputStream(fileName);
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(fileInputStream));
            String line = null;
            // 按行读取文件分解单词
            while ((line = bufferedReader.readLine()) != null) {
                String[] ss = line.split(" ");
                for (int i = 0; i < ss.length; i++) {
                    String s = ss[i];
                    if (s != null && s.matches("\\w+")) {
                        // 如果map中有此单词就将次数+1
                        // 否则此单词第一次出现
                        if (map.containsKey(s)) {
                            map.put(s, map.get(s) + 1);
                        } else {
                            map.put(s, 1);
                        }
                    }
                }
            }

            Map<String, Integer> sortedMap = sortByValue(map);
            for (Map.Entry<String, Integer> entry : sortedMap.entrySet()) {
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(key + ":" + value);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

    /**
     * 根据map的value进行排序
     * @param map
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
        return map.entrySet()
                .stream()
                .sorted(Map.Entry.comparingByValue(Collections.reverseOrder())) // 逆序
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue,
                        (e1, e2) -> e1,
                        LinkedHashMap::new
                ));
    }

    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        String fileName = "D:/app.log";
        TreeMap<String, Integer> map = new TreeMap<>();
        try {
            fileInputStream = new FileInputStream(fileName);
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(fileInputStream));
            bufferedReader.lines()
                    .flatMap(line -> Stream.of(line.split(" ")))
                    .filter(word -> word.matches("\\w+"))
                    .forEach(s -> { // Stream语法不太熟悉，不知道有木有更方便的方法？
                        if (map.containsKey(s)) {
                            map.put(s, map.get(s) + 1);
                        } else {
                            map.put(s, 1);
                        }
                    })
            ;

            Map<String, Integer> sortedMap = sortByValue(map);
            sortedMap.forEach((k, v) -> System.out.println(k + "," + v));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}