本文包含:

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]