集合的基本使用方法总结
一、 ArrayList 集合的使用方法
讲讲对象数组的排序
这里我就主要记录排序的使用，我个人比较建议用Comparetor的比较器去做排序，范例代码如下：
import java.util.*;
/**
* @author jiangzl
*/
public class MyArrayList {
public static void main(String[] args){
ArrayList myListOfTask = new ArrayList<Arraytask>();
Scanner sc = new Scanner(System.in);
for(int i = 0;i < 5;++i){
String name = sc.next();
int prio = sc.nextInt();
myListOfTask.add(new Arraytask(name, prio));
}
sc.close();
System.out.println("---------排序前---------");
for(int i = 0;i < 5;++i){
System.out.println(myListOfTask.get(i));
}
System.out.println("---------排序后---------");
Collections.sort(myListOfTask, new Comparator<Arraytask>() {
@Override
public int compare(Arraytask tk1, Arraytask tk2) {
if(tk1.getTaskPriority() != tk2.getTaskPriority()){
return tk2.getTaskPriority() - tk1.getTaskPriority();
}
else{
return tk1.getTaskName().compareTo(tk2.getTaskName());
}
}
});
for(int i = 0;i < 5;++i){
System.out.println(myListOfTask.get(i));
}
}
}
/**
* @author jiangzl
*/
class Arraytask{
private String taskName;
private int taskPriority;
public Arraytask(String name, int prio){
this.taskName = name;
this.taskPriority = prio;
}
public String getTaskName(){
return taskName;
}
public int getTaskPriority(){
return taskPriority;
}
@Override
public String toString(){
return new String("任务名：" + taskName + " , 任务优先级：" + taskPriority);
}
}
Comparetor比较器的使用方法说明：
写好一个类之后，需要对这个类的对象数组进行排序，我们可以使用集合的方法：
Collection.sort(对象数组名（ArrayList 的对象名）, new Comparetor<类名（泛型）>(){
@Override
public int compare(类名 obj1, 类名 obj2) {
/……/
}
})
需要注意的点：
① 这里的compare函数的返回值是int类型的，如果返回正数表示前面的对象obj1大于obj2，负数是小于，0当然就是相等了。
② 如果要表现某种优先级，这里和c++完全相反的一点就是，默认情况下是obj2（后面的）优先级高于obj1（前面的）。比方说我的示例代码里：
@Override
public int compare(Arraytask tk1, Arraytask tk2) {
if(tk1.getTaskPriority() != tk2.getTaskPriority()){
return tk2.getTaskPriority() - tk1.getTaskPriority();
}
else{
return tk1.getTaskName().compareTo(tk2.getTaskName());
}
}
代表的含义就是：
（1）如果两个任务优先级不相同，则让优先级高的排在前面。因为默认是后面的排在前面，于是乎，我们就返回：当符合我们设计的优先级时，返回一个大于0的数。于是如果是优先级高的在前面，那么Comparetor的比较机制是后面的在前，于是我们设计后面的值大于前面，也就是相减大于1的时候调用。（ 备注 ：这里可能不好理解……是我文笔不好，写不清楚）
（2）总的来说归结为一点：如果你想要按照某个参考值升序排序，就让前面的对象obj1大于后面的，也就是obj1.val - obj2.val。比方说我们想要优先级相同的时候，name按照字典序升序排序，于是让第一个对象的name减去第二个对象的name，按照大于0（也就是升序）排序！反之，就让后面的减去前面的。
简单讲讲对象数组（ArrayList ）的增删改查
（1）遍历读取元素
这个还是很简单的，如果只是“读”操作，最好的方法（效率最高的）就是：
int len = (ArrayList对象) arrayObj.size();
for(int i = 0;i < len;++i){
/……/
类名 obj = arrayObj.get(i);
/……/
}
这种 “读” 操作下的效率是最高的，比foreach效率要高（实验测试的结果）。
（2）修改元素
int len = (ArrayList对象) arrayObj.size();
for(int i = 0;i < len;++i){
/……/
类名 update = new 类名(……) // 你的新改的对象
类名 obj = arrayObj.set(i, update);
/……/
}
（3）删除元素
int len = (ArrayList对象) arrayObj.size();
for(int i = 0;i < len;++i){
/……/
类名 remv = arrayObj.remove(i); // remv 就是你要删除的对象
/……/
}
增删改查的一些说明&总结：
读取用 get(index)， 修改用 set(index, newObj)， 删除用 remove(index)
但是他们三个的返回值都是对象！！！这个是需要注意的！
而且ArrayList是基于向量的数据结构，是可以随机访问的！所以从这个底层来看，肯定是读写效率高，删除、增加效率低。所以有了后面的LinkedList集合
二、 LinkedList 集合的使用方法
讲讲Iterator接口与LinkedList的遍历
先来看一个示例程序：
import java.util.*;
/**
* @author jiangzl
*/
public class MyLinkedList {
public static void main(String[] args){
LinkedList myList = new LinkedList<Student>();
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 0;i < n;++i){
String name = sc.next();
int age = sc.nextInt();
myList.add(new Student(name, age));
}
String delName = sc.next();
Iterator<Student> it = myList.iterator();
while(it.hasNext()){
if(it.next().getName().equals(delName)){
it.remove();
break;
}
}
while (it.hasNext()){
System.out.println(it.next());
}
}
}
/**
* @author jiangzl
*/
class Student{
private String name;
private int age;
public Student(String name, int age){
this.name = name;
this.age = age;
}
@Override
public String toString(){
return new String("姓名：" + name + " , 年龄：" + age);
}
public String getName(){
return name;
}
}
这里先讲一下LinkedList的遍历
我们采用迭代器Iterator类进行遍历，用hasNext()方法判断是否有下一个值，然后用next()来获取当前遍历到的对象！然后该干啥操作就干啥操作了！
Iterator<类名> it = myList.iterator();
while(it.hasNext()){
类名 obj = it.next();
/……/
}
再说说ListIterator接口，这里 最大的差距就是，ListIterator支持并发执行，而Iterator不支持！ 举个小例子看看：
import java.util.*;
import java.util.ListIterator;
public class MyListIterator {
public static void main(String[] args){
List myList = new ArrayList();
myList.add("stu1");
myList.add("stu2");
myList.add("stu3");
myList.add("stu4");
myList.add("stu5");
ListIterator it = myList.listIterator();
while(it.hasNext()){
if("stu2".equals(it.next())){
it.remove();
it.add("hello");
break;
}
}
it = myList.listIterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
再看看控制台输出的结果:
很明显我们能够看到：
① ListIterator 接口可以使用 add() 方法，可以在当前迭代器的位置进行插入操作
② ListIterator 接口比如在某次遍历完成后，如果需要再次遍历这个对象数组，就必须重新：
it = myList.listIterator();
③ Iterator 接口是只读是属性，要想修改，还是得用 ListIterator 比方说上面修改 ”stu2“ 成为 “hello”
然后讲一下增删改查
这个其实就很简单了，如果使用ListIterator，不光可以实现Iterator 的 it.remove(); 完成删除当前迭代器指向的对象。还可用 add(obj); 的方法完成在当前迭代器指向的位置后插入对象obj。
就像示例里的这段代码：
while(it.hasNext()){
if(it.next().getName().equals(delName)){
it.remove();
break;
}
}
while (it.hasNext()){
System.out.println(it.next());
}
所有的操作都靠：it.next(); 来获取当前遍历到的对象，然后操作他！
最后总结一下List接口继承自Collection后拓展出来的方法：
其他的一些方法，我就不谈了，大多数都很简单。