面经(慧科讯业)

1、map有排序的实现么？

有treeMap是实现类，实现了sortedMap的接口。

treeMap是基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的Comparator 进行排序，具体取决于使用的构造方法。 注意，此实现不是同步的。如果多个线程同时访问一个映射，并且其中至少一个线程从结构上修改了该映射，则其必须 外部同步。

注意：不会的问题不要快速瞎答，可以转移到其他的相关题目上。

2、怎么对list集合排序？

方法1：

在使用List集合时，通常情况下希望从集合中得到的对象是按照一定顺序排列的，但是List集合的默认排序方式为按照对象的插入顺序，可以通过java.util.Collections类的静态方法sort(List<T> list)、sort(List<T> list,Comparator<? super T> c)或reverse(List<?> list)对集合中的对象进行客户化排序，其中方法sort(List<T> list)和reverse(List<?> list)要求集合中的对象必须实现java.lang.Comparable接口，即实现方法compareTo()，该方法的具体定义如下： 
public int compareTo(T o); 

方法1的实现、通过实现java.lang.Comparable接口实现客户化排序 


实体类：


public class Person implements Comparable{   //实现接口Comparable
    private String name;  
    private long id_card;  
    public String getName(){  
        return name;  
    }  
    public void setName(String name){  
        this.name = name;  
    }  
    public long getId_card(){  
        return id_card;  
    }  
    public void setId_card(long id_card){  
        this.id_card = id_card;  
    }  
    public int compareTo(Object o){//实现Comparable接口的方法  
        Person p = (Person)o;  
        String s1 = CnToSpell.getFullSpell(this.name);//获得汉字的全拼  
        String s2 = CnToSpell.getFullSpell(p.getName());  
        return s1.compareTo(s2);//比较两个字符串的大小  
    }  
}  


测试类：
import java.util.*;  
public class TestList{  
    public static void main(String args[]){  
        List<Person> list = new ArrayList<Person>();  
        String names[] = {"马先生","王小姐","李先生"};  
        long id_cards[] ={22015,22020,22018};  
        for(int i=0;i<names.length;i++){//初始化List集合  
            Person person = new Person();  
            person.setName(names[i]);  
            person.setId_card(id_cards[i]);  
            list.add(person);  
        }  
        System.out.println("排序前：");  
        for(int i=0;i<list.size();i++){//遍历List集合  
            Person person = list.get(i);  
            System.out.println("-----"+person.getName()+"   "+person.getId_card());  
        }  
        //利用java.util.Collections类的sort(List list)或reverse(List list)方法对List集合排序  
        Collections.sort(list);//按升序排序  
        System.out.println("升序排列后：");  
        for(int i=0;i<list.size();i++){//遍历List集合  
            Person person = list.get(i);  
            System.out.println("-----"+person.getName()+"   "+person.getId_card());  
        }  
        Collections.reverse(list);//按降序排列  
        System.out.println("降序排列后：");  
        for(int i=0;i<list.size();i++){//遍历List集合  
            Person person = list.get(i);  
            System.out.println("-----"+person.getName()+"   "+person.getId_card());  
        }  
    }  
}  


程序的运行结果如下： 
排序前： 
-----马先生     22015 
-----王小姐     22020 
-----李先生     22018 
升序排列后： 
-----李先生     22018 
-----马先生     22015 
-----王小姐     22020 
降序排列后： 
-----王小姐     22020 
-----马先生     22015 
-----李先生     22018 
利用这种方式实现对List集合进行客户化排序，缺点是对于每个类只能采用一种排序方式，对于排序方式需求单一的对象，可采用该种方式。 

方法2：

方法sort(List<T> list)是将集合中的所有对象按正序排列，方法reverse(List<?> list)是将集合中的所有对象按倒序排列；方法sort(List<T> list,Comparator<? super T> c)不要求集合中的对象必须实现Comparable接口，但是在使用该方法时需要显式设置比较器，即该方法的第2个入口参数，比较器必须实现java.util.Comparator接口，即实现方法compare()，该方法的就具体定义如下： 
int compare(T o1,T o2); 比较器的功能是实现对集合中所有对象的排序策略。 

方法2的实现、通过实现java.util.Comparator接口实现客户化排序 


public class Person{  
    private String name;  
    private long id_card;  
    public long getId_card(){  
        return id_card;  
    }  
    public void setId_card(long id_card){  
        this.id_card = id_card;  
    }  
    public String getName(){  
        return name;  
    }  
    public void setName(String name){  
        this.name = name;  
    }  
}  


 


import java.util.Comparator;  
public class PersonComparator implements Comparator{  
    //为可能参与排序的属性定义同名的静态常量值  
    public static final int NAME = 1;  
    public static final int ID_CARD = 2;  
    private int orderByColumn = 1;//默认排序为按姓名排序  
    public int compare(Object o1,Object o2){//实现Comparator接口的方法  
        Person p1 = (Person)o1;  
        Person p2 = (Person)o2;  
        int result = 0;//默认的判断结果为两个对象相等  
        switch(orderByColumn){//判断排序条件  
            case 1://按姓名排序  
                String s1 = CnToSpell.getFullSpell(p1.getName());//获得汉字的全拼  
                String s2 = CnToSpell.getFullSpell(p2.getName());  
                result = s1.compareTo(s2);//比较两个字符串的大小  
                break;  
            case 2:  
                result = (int)(p1.getId_card()-p2.getId_card());//比较两个整数的大小  
                break;  
        }  
        return result;  
    }  
    public void orderByColumn(int orderByColumn){//用来设置排序条件  
        this.orderByColumn = orderByColumn;  
    }  
}  


public class TestList{  
    public static void main(String args[]){  
        List<Person> list = new ArrayList<Person>();  
        String names[] ={"马先生","王小姐","李先生"};  
        long id_cards[] = {22015,22020,22018};  
        for(int i= 0;i<names.length;i++){  
            Person person = new Person();  
            person.setName(names[i]);  
            person.setId_card(id_cards[i]);  
            list.add(person);  
        }  
        System.out.println("排序前：");  
        for(int i=0;i<list.size();i++){  
            Person person = list.get(i);  
            System.out.println("-----"+person.getName()+"   "+person.getId_card());  
        }  
        PersonComparator personComparator = new PersonComparator();//创建比较器对象  
        System.out.println("按姓名排序：");  
        Collections.sort(list,personComparator);//默认为按姓名排序，排序List集合  
        for(int i=0;i<list.size();i++){  
            Person person = list.get(i);  
            System.out.println("-----"+person.getName()+"   "+person.getId_card());  
        }  
        System.out.println("按编号排序：");  
        personComparator.orderByColumn(PersonComparator.ID_CARD);//设置为按编号排序  
        Collections.sort(list,personComparator);  
        for(int i=0;i<list.size();i++){  
            Person person = list.get(i);  
            System.out.println("-----"+person.getId_card()+"    "+ person.getName());  
        }  
    }  
}  
程序的运行结果如下： 
排序前： 
-----马先生     22015 
-----王小姐     22020 
-----李先生     22018 
按姓名排序： 
-----李先生     22018 
-----马先生     22015 
-----王小姐     22020 
按编号排序： 
-----22015      马先生 
-----22018      李先生 
-----22020      王小姐 


利用这种方式实现对List集合进行客户化排序，排除了每个类只能采用一种排序方式的弊端，可以根据实际需要，将List集合按照不同的方式排序。这里是按姓名的全称升序排列，如果想改为降序排列，只需将例子中的的如下代码： 


result = s1.compareTo(s2);  


修改改为：


result = s2.compareTo(s2); 

3、线程中的生产者和消费者原理

生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。