学习笔记【8月7号】

校园招聘开始了， 接下来的时间我希望自己在一下方面有比较深入的学习和思考！
1。在网上收集整理面经，并通过查资料，编程尝试自己解决问题， 查找自己的知识漏洞和不足。
2。继续熟悉Java 常用API及其API的实现原理和源代码
3。深入学习JVM，尝试编译JDK源码，进行研究和学习。
4。复习强化数据结构和算法，比如本科ACM期间学习的数据结构，贪心， 搜索， DP， 计算几何， 基础数论。
5。深入学习TCP/IP等网络知识，学习netty。
《1》类Collections是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
Java Collections框架包含了大量集合接口以及这些接口的实现类和操作它们的算法（例如：排序，查找，反转， 替换， 复制， 取最小元素， 去最大元素等等）。具体而言，主要提供了
List（列表），Queue（队列）， Set（集合）， Stack（栈）和 Map（映射）
对象在实现排序时候需要实现Comparable接口.

public interface Comparable<T> {
    public int compareTo(T o);
}

在Comparable接口中只有compareTo（）方法， 此方法返回一个int类型的数据 ，但是此int类型的数据只能是一下3种：
1 ：表示大于。
-1：表示小于。
0 ：表示等于
代码演示：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

/**
 * 年龄由小到大，如果年龄相同按照名字字母序由小到大
 * @author wwh
 *
 */
class User{
    private int age;
    private String nameString;

    public User(int age, String nameString) {
        super();
        this.age = age;
        this.nameString = nameString;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getNameString() {
        return nameString;
    }
    public void setNameString(String nameString) {
        this.nameString = nameString;
    }
    @Override
    public String toString() {
        return "User [age=" + age + ", nameString=" + nameString + "]";
    }
}
class Person implements Comparable<Person>{
    private int age;
    private String nameString;

    public Person(int age, String nameString) {
        super();
        this.age = age;
        this.nameString = nameString;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getNameString() {
        return nameString;
    }
    public void setNameString(String nameString) {
        this.nameString = nameString;
    }
    @Override
    public int compareTo(Person o) {
        if(this.age < o.age) {
            return -1;
        }else if(this.age > o.age) {
            return 1;
        } 
        int res = this.nameString.compareTo(o.nameString);
        if(res < 0) return 1;
        else if(res > 0) return -1;
        return 0;
    }
    @Override
    public String toString() {
        return "Person [age=" + age + ", nameString=" + nameString + "]";
    }
}
class UserComparator implements Comparator<User> {

    @Override
    public int compare(User o1, User o2) {
        if(o1.getAge() < o2.getAge()) return -1;
        else if(o1.getAge() > o2.getAge()) return 1;
        int res = o1.getNameString().compareTo(o2.getNameString());
        if(res < 0) return 1;
        else if(res > 0) return -1;
        return 0;
    }
}

public class CollectionsDemo01 {

    public static void testSort() {
        List<String> all = new ArrayList<>();
        Collections.addAll(all, "2.bcd", "3.cde", "1.abc");
        Iterator<String> iterator = all.iterator();
        while(iterator.hasNext()) {
            System.out.print(iterator.next() + ", ");
        }
        Collections.sort(all);
        System.out.println("\nafter sort: ");
        iterator = all.iterator();

        while(iterator.hasNext()) {
            System.out.print(iterator.next() + ", ");
        }
        System.out.println();
    }
    public static void testSort2() {
        Person person[] = {new Person(23, "albert"), new Person(24, "tom"), new Person(24, "boy"), new Person(24, "zero")};
        List<Person> personsList = Arrays.asList(person);
        Collections.sort(personsList);
        System.out.println("***************Person: List using Comparable*******************");
        for (Person obj : personsList) {
            System.out.println(obj);
        }
    }
    public static void testSort3() {
        User users[] = {new User(23, "albert"), new User(24, "tom"), new User(24, "boy"), new User(24, "zero")};
        List<User> userList = Arrays.asList(users);
        Collections.sort(userList, new UserComparator());
        System.out.println("***************User: List using Comparator*******************");
        for(User obj : userList) {
            System.out.println(obj);
        }
    }
    public static void testSort4() {
        User users[] = {new User(23, "albert"), new User(24, "tom"), new User(24, "boy"), new User(24, "zero")};
        Arrays.sort(users, new UserComparator());
        System.out.println("***************User: array using Comparator*******************");
        for(int i = 0; i < users.length; i++) {
            System.out.println(users[i]);
        }
    }

    public static void main(String[] args) {
        testSort();
        testSort2();
        testSort3();
        testSort4();
    }
}

Arrays类是数组的操作类， 定义在java.util包中， 主要功能是实现数组元素的查找， 排序， 数组内容填充等等。
代码示例：

public static void testArrays() {
        int temp[] = {3, 5, 7, 9, 1, 2, 6, 8};
        Arrays.sort(temp);
        System.out.println("After sort:");
        System.out.println(Arrays.toString(temp));//以字符串输出数组
        int index = Arrays.binarySearch(temp, 3);
        int point = Arrays.binarySearch(temp, -1);
        System.out.println("index = " + index + " point = " + point);
        Arrays.fill(temp, 3);
        System.out.println(Arrays.toString(temp));//以字符串输出数组
    }

学习Java的 fork-join
最大的增强，充分利用多核特性，将大问题分解成各个子问题，由多个cpu可以同时解决多个子问题，最后合并结果，继承RecursiveTask，实现compute方法，然后调用fork计算，最后用join合并结果。
代码示例1：斐波那契数

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class Fibonacci extends RecursiveTask<Integer> {
    final int n;
    Fibonacci(int n) {
        this.n = n;
    }
    private int compute(int small) {
        final int[] results = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
        return results[small];
    }
    public Integer compute() {
        if (n <= 10) {
            return compute(n);
        }
        Fibonacci f1 = new Fibonacci(n - 1);
        Fibonacci f2 = new Fibonacci(n - 2);
        System.out.println("fork new thread for "+(n - 1));
        f1.fork();
        System.out.println("fork new thread for " + (n - 2));
        f2.fork();
        return f1.join() + f2.join();
    }
    public static void main(String argc[]) throws InterruptedException, ExecutionException {
        Fibonacci task = new Fibonacci(20);
        ForkJoinPool pool = new ForkJoinPool();
        pool.submit(task);
        System.out.println(task.get());
    }
} 

代码示例2：求和

import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

import com.lock.test.newFairAndUnfairLockTest;
public class CountTask extends RecursiveTask<Long> {
    private static final int THRESHOLD = 10000;
    private long start;
    private long end;
    public CountTask(long start, long end) {
        this.start = start;
        this.end = end;
    }
    @Override
    protected Long compute() {
        long sum = 0;
        boolean cancompute = (end-start) < THRESHOLD;
        if(cancompute) {
            for(long i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            long step = (end-start)/100;
            ArrayList<CountTask> subTasks = new ArrayList<>();
            long pos = start;
            for(int i = 0; i < 100; i++) {
                long lastOne = pos + step;
                if(lastOne > end) lastOne = end;
                CountTask subTask = new CountTask(pos, lastOne);
                pos += step+1;
                subTasks.add(subTask);
                subTask.fork(); 
            }
            for(CountTask t:subTasks) {
                sum += t.join();
            }
        }
        return sum;
    }
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        CountTask task = new CountTask(1,  1000000000);
        ForkJoinTask<Long> result = forkJoinPool.submit(task);
        try {
            long res = result.get();
            System.out.println("sum = " + res);
        }catch(InterruptedException e  ) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        /*
        long sum = 0;
        for(long i = 1; i <= 1000000000; i++) {
            sum += i;
        }
        System.out.println("sum = " + sum);
        */
        long endTime = System.currentTimeMillis() - startTime;
        System.out.println("time: " + endTime);
    }
}

面经整理：
链接：https://www.nowcoder.com/discuss/30733?type=2&order=0&pos=30&page=1
来源：牛客网

7月31号做的在线素质测评和编程测试，8月1号晚上就打电话过来了，面试官说了解一下基本情况，并没有问太多项目的问题，这个可以作为大家面试蚂蚁金服的参考。
1Java线程有几种状态，这几种状态之间是怎么装换的
3.JDK1.8和JDK1.7新增了哪些新特性
4.七层OSI模型与TCP模型的对应关系
5.MySQL的引擎有哪些？都有神马特点？在什么场景下使用
6.Session和Cookie的原理和区别
7.HTTP状态码
8.索引的实现机制？优缺点？应用常见
9.事务的ACID特性
10 举例子说说隔离性
11 问我有技术博客没
12 自己平常会上哪些网站看互联网最新技术
13 问我知道Duddo这个技术吗
14 锁和synchronized
15 排序算法：你最熟悉的排序算法，思想原理，最坏（什么情况下）和平均时间复杂度
16 Unix在项目中用吗？有哪些常用的命令

菜鸟网络：
刚开始面试官说大概20分钟，结果全程面了59分钟，废话不多说，下面上干货
前面半个小时基本聊项目
涉及到的知识有
1.redis的消息队列
2.redis的数据类型
3.用redis做过什么
4.数据用户表是怎么设计的
5.单点登录系统是怎么实现的
6.如何实现共享session
7.登陆系统和前台系统如何拿到同一个cookie
8.http的组成结构
9.http和https的区别
10.https是如何确保数据安全的
11.数据库有哪些索引
12.(这里被坑了)主键索引是聚集索引还是非聚集索引
13.数据库水平拆分和库表散列有什么优点
14.springmvc和struts的比较一些问题
15.为什么要用spring有什么优点
16.接触过那些数据结构
17.java中那些是上述所用的？
18.启动线程的方式
19.线程池有哪几种.干什么用
20.jvm的加载过程
21.java内存模型
22.快速排序的时间复杂度，以及过程已经怎么计算时间复杂度
23.其他还有问到一些但是记不起来了，攒人品，希望一面能过

1.自我介绍
2.hashmap，put和get同时操作会发生什么，treemap实现，红黑树
3.concurrenthashmap
4.spring ioc和aop，为什么用aop
5.聚簇索引和非聚簇索引的区别
6.做过最复杂的表
7.多线程，长短连接选择，nio
8.分布式，netty
9.观察者模式，为什么不用一个总的控制

作者：YangZY
链接：https://www.nowcoder.com/discuss/29961?type=2&order=0&pos=26&page=2
来源：牛客网

1。方向是算法工程师或者是服务端研发工程师。
上午11点多投的简历，下午1点多HR就打电话过来约了第二天笔试的时间，效率惊人。
因为我不在上海，所以在线笔试，笔试是HR把pdf的题目发到邮箱里，在规定时间里答完再发回去。
2。笔试题目难度还好，一共6道题，三道简答，三道编程，有一道编程还是有难度的，笔试时间比较紧，只有1个小时20分钟。
听HR姐姐说，福利待遇还是不错的，一天管两顿饭，工资在业界算高的，刚入职的好像还有宿舍能够提供吧。
HR面结束后，开始技术面，
3。一面上来就问了一个编译原理，说一说代码从IDE中书写到运行出来的整个过程，编译和链接都有什么作用(上来有点蒙，答得不好)；
4。然后问了计算机网络，TCP，UDP有什么区别，TCP的重传机制；
5。之后问了操作系统，防止进程死锁的方法；
6。最后手写了一个代码，给一个存pair的vector，第一个数表示父亲节点，第二个数表示孩子节点，保证是一棵二叉树，得到中序遍历的结果(个人觉得建树是难度，遍历很简单，写完之后面试官基本没有找到bug)。

今天晚上7点多收到阿里二面的电话。
1、基本类型和引用类型的区别，Integer和int，有int类型了，为什么还要设计Integer对象。
2、不用Integer.ParaseInt()方法，如何将字符串转换成数字类型。
3、Map的KEY的要求，以及hashMap的原理，如果将hashcode方法都放回1，如何设计不会出现对象堆积。
4、如何设计一个算法，使得CPU呈现出余弦的形式（是编程之美的第一题可惜我不会。）
总之，问的问题一个都没有答好。感觉都是我没有看过的。

链接：https://www.nowcoder.com/discuss/27285?type=2&order=0&pos=34&page=1
来源：牛客网

先做下自我介绍：
本人本科渣二本，研究生为北京普通211，学历一般，帮导师实习了一年，年后才有机会看书刷题，总共看书大概两个月吧，我主要面的是软件研发工程师，主要面过滴滴、京东、百度、新浪等，现在有些题记不清了，希望我的经验对大家有所帮助。
滴滴：
滴滴面试是散招，就一面，挺简单的，问的问题有：
1、hashmap与hashtable的区别；
2、jvm内存模型与垃圾回收方法；
3、spring 控制反转和依赖注入关系；
4、mybatis中 %与$的区别；
5、算法：括号匹配；
6、sql语句，一个成绩表求出有不及格科目的同学
然后问我能不能尽快实习，由于不能尽快实习就放弃了。

京东:
京东是先笔试，过了笔试然后是去酒店三轮面试。
一面：
1、ArrayList与LinkedList的区别；
2、java多线程中synchronized 与lock，volatile关键字，写出线程安全的单例模式
3、Tcp与Udp
4、jvm内存分为几块，垃圾回收方法
5、spring的作用及理解
6、事务的隔离级别与ACID，mysql的存储引擎
7、redis技术与zookeeper了解多少，
8、自己做的项目
一面面试官对我印象不错，说我没问题了。

二面：

1、介绍了自己做的项目
2、redis与zookeeper的简介与功能，
然后就结束了。
Hr面：
1、为什么选择京东
2、能实习多长时间
3、自己的有点与缺点
4、以后是不是留北京
京东等了几天，后来发了offer。

百度：

百度是先笔试然后集中进行的面试，面试为三轮技术面，我是下午面试，从两点十分一直到下午五点四十，面试完身心疲惫，今天hr刚联系我可以入职了，心里终于轻松了。
（有些不会的问题没记住，问得比我写的多）
一面：
1、算法： 一个数组存着1-1000连续的整数，假如我取出其中一个数，怎么能快速找到（用类二分查找）
2、算法：一个数组存着负数与正数，将正数放在前年，负数放在后面
3、算法：快速排序+二分查找
4、java多线程、jvm垃圾回收与内存结构
5、spring的理解，注入的方式
6、linux了解多少，vim编辑器，还有一个说的一个编辑器不知道
7、sql，group by的理解
8、oracle与mysql的区别
9、redis了解多少
10、协议的划分，Tcp与Udp 网络层的ARP协议与ICMP协议，
等等等，问了一个多小时，问题太多，基本上一面会的都问了一遍

二面：

1、算法：二分查找
2、算法：旋转数组
3、算法：母鸡、公鸡和小鸡问题：公鸡五块一只，母鸡三块一只，小鸡一块三只，用100元买100只鸡的所有方法
二面就是三个算法

三面：

1、算法：将1到9这9个数放到9宫里。
2、自己项目+自己项目不足，为什么来百度
3、redis五种数据类型，当散列类型的value值非常大的时候怎么进行压缩，用redis怎么实现摇一摇与附近的人功能，redis主从复制过程，
4、zookeeper的常用功能，自己用它来做什么，有没有复杂均衡与主从协调的经验
5、自己的兴趣爱好
6、其他的nosql存储
7、记不清了，应该还有一些。。。

百度三面面完感觉好多新技术都不会，而且连续三面身心疲惫，百度很看重算法，我写了七个，还是好好刷题吧，面完说两周内给通知，10天后HR终于联系我了。

新浪：
一面：
1、算法：快速排序
2、算法：单链表的快速排序
3、算法：合并两个有序的单链表
二面：
介绍自己做的项目还有他们公司的项目，等通知（已经不想等了）

这是我主要面试的公司，三月份的时候还面过IBM，后来阿里内推，简历直接挂掉，然后笔试360，笔试编程一个不会，笔试直接挂掉，后来才开始刷题。

链接：https://www.nowcoder.com/discuss/29688?type=2&order=0&pos=56&page=3
来源：牛客网

1.自我介绍
2.问项目（实在没啥好问的，大部分都是增删改查）
3.了解冒泡排序吗，时间复杂度呢（讲了一下）
4.了解链表吗，自己动手写过吗（说了一下链表怎么写，以CLH队列为例子说了下双向链表的队列怎么实现）
5.了解AQS吗，看过源码吗（说了一下AQS的源码和ReentrantLock的源码，说了一点就被打断了，估计知道我看过没往下问）
6.了解Hashmap吗（说了下），你知道JDK1.8Hashmap有什么改动吗（引入红黑树，仔细说了一下）
7.深克隆浅克隆说一下（这个当时真没答上，没印象）
8.了解Java内存模型吗？（基于JSR133说了一下JMM，内存重排序，happens before什么的
刚要说四种内存屏障又被略过去了）

9.哦我想问的是JVM的内存划分（大哥，内存模型是JMM啊说明白啊，于是说了一下永久代那一堆，顺便提了提java也可以自己划分内存）
10.知道垃圾回收机制吗（3种，答了答）gc时各个代达到什么条件会发生迁徙（达到xx比例吧 忘了这个真忘了）
11.一般哪部分内存对应哪种回收机制（老年对标记整理，新生对复制，好像是，这个题答得不是很确定）
12.JDK1.8有什么新特性吗？（lambada表达式啊
JUC下Fuction