队列
import java.util.LinkedList;
import java.util.Queue;
/**
* 数据结构：队列
* Queue接口：java.util.Queue
* offer：将元素放入队列
* poll：从队列中取元素，取得的是最早offer的元素
* 从队列中取出元素后，改元素会从队列中删除
* peek：获取队首元素。（不删除该元素！）
*
* LinkedList就是队列的子类
*/
public class QueueTest {
public static void main(String[] args) {
/**
* 创建一个LinkedList实例，把它当做队列去看待！
* 同样的，队列中我们应该只存放一种数据类型，
* 所以同样可以用泛型去约束
*/
Queue<String> queue = new LinkedList<>();
queue.offer("A");
queue.offer("B");
queue.offer("C");
System.out.println(queue);//[A, B, C]
//获取队首元素，但不令其出队
System.out.println("队首："+queue.peek());//队首：A
String element = null;
/*
* 从队列中获取元素使用poll()方法，若该方法返回null
* 说明队列中没有元素了
* */
while ((element=queue.poll())!=null){
System.out.println(element);
}
/**
* 队列本着先进先出原则存放数据（FIFO）
* 队列不支持插队，插队是不道德的。
*/
}
}
栈数据结构
import java.util.Deque;
import java.util.LinkedList;
/**
* 栈数据结构
* Deque：
* pust：压入，向栈中存入数据
* pop：弹出，从栈中取出数据
* peek：获取栈顶位置的元素，但不取出
* 栈结构本着先进后出原则（FILO）
* 子弹夹就是一种栈结构
*
* LinkedList也是实现了Deque接口。
*/
public class DequeTest {
public static void main(String[] args) {
/**
* 创建一个栈结构保存字符
*/
Deque<Character> deque = new LinkedList<Character>();
for (int i = 0; i < 5; i++) {
deque.push((char) ('A'+i));
}
System.out.println(deque);//[E, D, C, B, A]
/*
* 注意：
* 我们在使用pop获取栈顶元素之前，应先使用peek方法
* 获取该元素，确定该元素不为null的情况下才应该将该
* 元素从栈中”弹出“。否则若栈中没有元素后，我们调用
* pop会抛出异常“NoSuchElementException”
*/
//注意使用peek判断栈顶是否有元素
while (deque.peek()!=null){
System.out.println(deque.pop()+"");
}
}
}
比较算法
/**
* 比较算法
* 若我们定义的类想在数组或集合中实现可以排序，我们需要将当前类
* 实现Comparable接口，并定义比较规则
*/
public class ComparableTest implements Comparable<ComparableTest> {
/*属性定义*/
private int x;
private int y;
public ComparableTest(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
/**
* 比较方法，该方法由Comparable接口定义
* 所有子类均需要实现该方法来定义比较规则
* @param point 比较时传入的参数，类型在实现接口的泛型中指定
* @return 返回值
* 大于0：自身比参数大
* 小于0：自身比参数小
* 等于0：自身和参数相等
* 比较规则：
* 比较点到原点的距离，谁的距离长谁大
*/
@Override
public int compareTo(ComparableTest point) {
//自身点到原点的距离的平方
int r = x*x+y*y;
//参数点到原点的距离的平方
int other = point.x*point.x+point.y*point.y;
/*
* 需要注意：
* equals方法返回true的时候，
* compareTo的返回值应该为0，
* 反过来也一样。
*/
return r-other;
}
@Override
public String toString() {
return "ComparableTest{" +
"x=" + x +
", y=" + y +
'}';
}
}
Collections
- Collection与Collections的区别？
Collection是集合的父接口，而Collections是集合的工具类。
- Collections类
集合的工具类，提供了集合操作的若干方法。
sort():该方法可以对集合中元素做自然排序。
Comparator比较器
- 它是一个接口，实现该接口的类需要实现一个抽象方法int compareTo(E o1,E o2)。
- 该方法返回值大于0：o1比o2大；
- 该方法返回值小于0：o1比o2小；
- 该方法返回值等于0：o1比o2相等；
- 比较器用于比较集合中的元素。Collections提供了sort的重载方法，支持传入一个比较器对集合进行比较。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 测试集合工具对集合元素进行的自然排序
* 要确保集合中的元素是Comparable的子类！
*/
public class CollectionsTest {
public static void main(String[] args) {
List<ComparableTest> list = new ArrayList<ComparableTest>();
//向集合中存放3个对象
list.add(new ComparableTest(1,5));
list.add(new ComparableTest(3,4));
list.add(new ComparableTest(2,2));
System.out.println(list);//[ComparableTest{x=1, y=5}, ComparableTest{x=3, y=4}, ComparableTest{x=2, y=2}]
/**
* 使用集合工具类对集合进行自然排序
* 该方法会一次调用集合中每个元素的compareTo方法
* 进行比较
*/
Collections.sort(list);
System.out.println(list);//[ComparableTest{x=2, y=2}, ComparableTest{x=3, y=4}, ComparableTest{x=1, y=5}]
/**
* 在排序集合元素时，我们不想根据元素的比较规则
* 排序：按照x的值自小到大的顺序排序集合元素。
*
* 自定义的比较规则实现需要以下步骤：
* 1、定义一个类并实现Comparator接口
* 2、实现接口中的抽象方法compareTo(E o1,E o2)
* 3、实例化这个比较器
* 4、调用Collections的重载方法
* sort(Collection c,Comparator comparator)
* 进行排序
*/
//使用匿名类方式创建一个实例来定义比较器
Collections.sort(list, new Comparator<ComparableTest>() {
/**
* 自定义的比较规则:两个点的x值大的大
* @param o1
* @param o2
* @return 大于0：o1>o2,小于0：o1<o2,等于0：o1==o2
*/
@Override
public int compare(ComparableTest o1, ComparableTest o2) {
return o1.getX()-o2.getX();
}
});
System.out.println(list);//[ComparableTest{x=1, y=5}, ComparableTest{x=2, y=2}, ComparableTest{x=3, y=4}]
}
}
自定义比较器练习
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 自定义比较器
*/
public class ComparatorTest {
public static void main(String[] args) {
/**
* 定义一个字符串集合
* 集合中存放：“Tom”，“Jerry”，“Boss”，“Killer”，“ATom”，“Clark”
* 使用自然排序查看结果
* 自定义排序规则：字母长的在后面
*/
List<String> list = new ArrayList<String>();
list.add("Tom");
list.add("Jerry");
list.add("Boss");
list.add("Killer");
list.add("ATom");
list.add("Clark");
System.out.println(list);//[Tom, Jerry, Boss, Killer, ATom, Clark]
/**
* 使用String自带的排序规则做自然排序
*/
Collections.sort(list);
System.out.println(list);//[ATom, Boss, Clark, Jerry, Killer, Tom]
Collections.sort(list, new Comparator<String>() {
/**
* 字符串字符多的在后面
* @param o1
* @param o2
* @return
*/
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
});
System.out.println(list);//[Tom, ATom, Boss, Clark, Jerry, Killer]
}
}
