[TOC]

java程序员成功面试秘籍

标签（空格分隔）： java

第四章编写核心算法

Comparable和Comparator接口的区别

测试：

    @Test
    public void sortInts() {
        final int[] numbers = {-3, -5, 1, 7, 4, -2};
        final int[] expected = {-5, -3, -2, 1, 4, 7};

        Arrays.sort(numbers); //升序排列
        assertArrayEquals(expected, numbers);
        Collections.sort(numbers, new ReverseNumericalOrder());//降序排列
        assertEquals(expected, numbers);
    }

ReverseNumericalOrder.java 降序排列

import java.util.Comparator;

public class ReverseNumericalOrder implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
    // equals omitted
}

关于compare(Object o1,Object o2)

Comparator的compare

几种排序

1. 冒泡排序
2. 插入排序
3. 快速排序
4. 归并排序

快速排序.java实现方法。写法很java

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static junit.framework.Assert.assertEquals;
public class Quicksort {

public static List<Integer> quicksort(List<Integer> numbers) {
    if (numbers.size() < 2) {
        return numbers;
    }

    final Integer pivot = numbers.get(0);
    final List<Integer> lower = new ArrayList<>();
    final List<Integer> higher = new ArrayList<>();

    for (int i = 1; i < numbers.size(); i++) {
        if (numbers.get(i) < pivot) {
            lower.add(numbers.get(i));
        } else {
            higher.add(numbers.get(i));
        }
    }

    final List<Integer> sorted = quicksort(lower);

    sorted.add(pivot);
    sorted.addAll(quicksort(higher));

    return sorted;
}

第五章 数据结构

ArrayList List的数组实现（数组的特性）
LinkedList List的双向链表实现（双向链表的特性）

JVM System.arraycopy

队列

队列

散列
HashMap ：键的存储位置是由对象的hashCode决定的
TreeMap: TreeMap键的顺序不变（二叉树）
LinkedHashMap工作方式和HashMap一样，链表实现，见得遍历插入顺序相同
ConcurrentHashMap：线程安全，多线程共享数据使用

散列

几种Map的比较

Set
HashSet -->HashMap ：键的存储位置是由对象的hashCode决定的
TreeSet --> TreeMap: TreeMap键的顺序不变（二叉树）
LinkedHashSet --> LinkedHashMap工作方式和HashMap一样，链表实现，见得遍历插入顺序相同

几种Set