CoreJava学习4――集合之List高级与算法

本文包含：

List高级

subList方法

Queue接口及LinkedList实现

Deque接口及LinkedList实现

栈的操作

List算法

Comparable接口

Collections.sort方法

Comparator回调

一、List高级

1、subList方法

List的subList方法用于获取子List。

注：subList获取的List与原List占有相同的存储空间，对子List的操作会影响原List。

List<E> subList(int fromIndex,int toIndex);//[....}前面包含，后面不包含。

例：

List <Integer> list = new Array<Integer>();
for(int i=0;i<10;i++){
    list.add(i);
}
System.out.println(list);//[0,1,2,3,4,5,6,7,8,9]
List<Integer> subList = list.subList(3,8);
System.out.println(subList);//[3,4,5,6,7]
for(int i=0;i<subList.size();i++){
    subList.set(i,subList.get(i)*10);//子List扩大十倍
}
//原List也扩大十倍
System.out.println(list);//[0,1,2,30,40,50,60,70,8,9]
System.out.println(subList);//[30,40,50,60,70]

2、Queue接口及LinkedList实现

队列（Queue）是常用的数据结构，可以将队列看成特殊的线性表，队列限制了对线性表的访问方式：只能从线性表的一端添加（offer）元素，从另一端取出（poll）元素。

队列遵循先进先出的原则。

JDK提供了Queue接口，同时似的LinkedList实现了该接口（选择LinkedList实现Queue的原因在于Queue经常要进行插入和删除操作，而LinkedList在这方面效率较高）。

第6个、Queue接口中主要的方法有：

boolean offer(E e)：将一个对象添加到队尾，如果添加成功则返回true.

E poll()：从队首删除并返回一个元素

E peek()：返回队首的元素（但并不删除）

例：

//create a queue

Queue<String> queue = new LinkedList<String>();

//向队尾追加元素

queue.offer("A");

queue.offer("B");

queue.offer("C");

//从队首获取元素

String str = queue.poll();//获取队首第一个元素

//遍历

while ((str=queue.poll())!=null) {

System.out.println(str);

}

//注：获取后就从队列中删除了

//由于不知道长度，当队列没有元素的标志是：poll方法返回null.

3、Deque接口及LinkedList实现

Deque是Queue的子接口，定义了所谓的“双端队列”即从队列的两端分别可以入队（offer）和出队（poll），LinkedList实现了该接口。

如果将Deque限制为之只能从一端入队和出队，则可以实现“栈”（stack）的数据结构，对于栈而言，入栈是push，出栈是pop。

栈遵循先进后出的原则。

4、栈的基本操作

方法：

push()：压入堆栈

pop()：从堆栈中取值（出栈）

//create a stack

Deque<Character> stack = new LinkedList<Character>();

String sr = "ABCDEFGHI";

for (int i = 0; i < sr.length(); i++) {

stack.push(sr.charAt(i));//入栈

}

System.out.println(stack);//[I, H, G, F, E, D, C, B, A]

/**

* 使用pop()方法回去栈的首元素，若没有元素了，pop()方法会抛出NoSuchElementException

* 栈也支持peek()方法，获取首元素。如果返回为null说明没有元素了。

*/

//遍历栈

while (stack.peek()!=null) {

char c = stack.pop();

System.out.print(c+" ");

}

二、List算法

1、Comparable接口

定义了一个抽象方法，用于定义对想之间比较规则。

所以他的子类都是可比较的，自然就可以在集合中进行排序了。

class Point1 implements Comparable<Point1>{

int x;

int y;

public Point1(int x, int y) {

super();

this.x = x;

this.y = y;

}

public int compareTo(Point1 o) {

//比较两个点哪个大

int myLen = x*x+y*y;

int otherLen = o.x*o.x+o.y*o.y;

/**

* 通过返回值的取值范围决定大小

* if return>0 => this>o

* if return<0 => this<o

* if return=0 => this=o

*/

return myLen-otherLen;

}

｝

2、Collections.sort方法

通过静态方法，提供了对集合的一些实用操作，其中运用最多的是对List进行排序的sort方法。

Collections的sort方法需要集合中的对象实现Comparable接口，从而可以调用其compareTo方法来判断对象的大小，否则sort方法无法判断哪个对象大，哪个对象小。

public class Demo3_Comparable {
    public static void main(String[] args) {
        List<Point1> list = new ArrayList<Point1>();
        list.add(new Point1(1,28));
        list.add(new Point1(1,4));
        list.add(new Point1(7,2));
        System.out.println(list);
        /**
        * 集合工具类Collections
        *
        * sort对集合中的元素进行比较，根据元素的compareTo方法的返回只进行比较。
        * 所以元素应该是Comparable的子类
        */
        Collections.sort(list);//不能使用泛型本身的属性去比较，因为对于泛型来讲类型是不确定的，比较规则就不同。
        System.out.println(list);
    }
}
//Comparable也支持泛型
class Point1 implements Comparable<Point1>{
    int x;
    int y;
    public Point1(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
    public int compareTo(Point1 o) {
        //比较两个点哪个大
        int myLen = x*x+y*y;
        int otherLen = o.x*o.x+o.y*o.y;
        /**
        * 通过返回值的取值范围决定大小
        * if return>0 => this>o
        * if return<0 => this<o
        * if return=0 => this=o
        */
        return myLen-otherLen;
    }
    public String toString() {
        return "("+this.x+","+this.y+")";
    }
}

3、Comparator回调

一旦Java类实现了Comparable，其比较逻辑就已经确定；如果希望在排序的操作中临时“指定比较规则”，可以采用Comparator接口回调方式。

Collections有一个自然排序重载方法。

sort(Collection c,Comparator com);//匿名类

Comparator是一个接口，比较器，是用来单独定义比较规则的。

例：

List<String> list = new ArrayList<String>();
list.add("Java");
list.add("PHP");
list.add("Net");
list.add("C++");
System.out.println(list);//[Java, PHP, Net, C++]
/**
* String类默认已经实现了接口Comparable的compareTo方法，
* 并且规定了是使用字母排序来比较。
*/
Collections.sort(list);
System.out.println(list);//[C++, Java, Net, PHP]
/**
* 但是，现在我们更加要求这种比较的方式不符合我们的需要，
* 这是就用到了Comparator接口回调方式。单独定义了比较规则。
*/
Collections.sort(list,new Comparator<String>(){
    @Override
    public int compare(String o1, String o2) {
        return o1.length()-o2.length();//根据字符长度来比较
    }
});
System.out.println(list);//[C++, Net, PHP, Java]