首页 > 编程入门 文章详情

(每日一转)黑马程序员

编程入门 行业动态 更新时间:2024-10-10 13:14:54

(每日<a href=https://www.elefans.com/category/jswz/34/1751113.html style=一转)黑马程序员"/>

(每日一转)黑马程序员

集合框架

概述

为什么要用集合？

对象是对数据的封装，而集合是对对象的封装。编程中除了对单个象的操作外，常常还需要对多个对象进行统一操作，这时就需用一个容器将这些对象存储起来，这样的容器就是集合。其实，String类也是一个特殊的容器，它存储的是char类型的元素。集合的共性操作就是CRUD。集合的应用比数组更广泛。

集合与数组的区别

他们都是容器，都可以存储对象，他们的区别是：数组的长度是固定的，而集合的长度的可变的；数组既能存储基本数据类型也能存储引用数据类型，而集合只能存储引用数据类型，如果给集合添加基本数据类型的元素，这些基本数据类型会自动装箱成对应的引用数据类型；数组存储的元素都是同一类型，而集合可以存储不同类型的元素。

集合的特点

集合只用于存储对象，它的长度可变，能够存储不同类型的对象。

集合框架体系

集合框架为什么有这么多的容器？

因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构。

提示：学习javaAPI时，通常查阅父类接口，了解其体系的共性方法，而使用时选择具体的子类，以利用子类的特有方法。

Collection

共性方法

Collection是一个接口，它定义了一些共性的方法，包括添加、移除、清空元素，是否为空、是否包括某一元素，获取元素个数等操作。

注意：

1.它里边有一个Iterator方法，专门用于取出元素。

2.集合的add方法的参数类型是Object，以便于接受任意类型的对象。

3.集合中存放的都是对象的引用（地址）。

示例代码1

[java] view plain copy print ?
  1. import java.util.*;
  3. class CollectionDemo
  4. {
  5. public static void main(String[] args)
  6. {
  7. method_get();
  8. //method_1();
  10. }
  11. public static void method_get()
  12. {
  13. ArrayList al = new ArrayList();
  15. //1.添加元素
  16. al.add("java01");//add的参数是Object类型的。
  17. al.add("java02");
  18. al.add("java03");
  19. al.add("java04");
  21. Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
  22. sop(it.hasNext());
  23. sop(it.next());
  24. sop(it.hasNext());
  26. while(it.hasNext())
  27. {
  28. sop(it.next());
  29. }
  30. /*
  31. for(Itera tor it = al.iterator();it.hasNext();)
  32. {
  33. sop(it.next());
  34. }
  35. */
  36. }
  38. //取交集
  39. public static void method_1()
  40. {
  41. ArrayList al1 = new ArrayList();
  42. al1.add("java01");
  43. al1.add("java02");
  44. al1.add("java03");
  45. al1.add("java04");
  47. ArrayList al2 = new ArrayList();
  48. al2.add("java02");
  49. al2.add("java05");
  50. al2.add("java07");
  51. al2.add("java08");
  53. //al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素。
  54. al1.removeAll(al2);
  56. sop("al1:"+al1);
  57. sop("al2:"+al2);
  59. }
  61. public static void base_method()
  62. {
  63. //创建一个集合容器，使用Collection接口的子类，ArrayList
  64. ArrayList al = new ArrayList();
  66. //1.添加元素
  67. al.add("java01");//add的参数是Object类型的。
  68. al.add("java02");
  69. al.add("java03");
  70. al.add("java04");
  72. //打印原集合
  73. sop(al);
  75. //3.删除元素
  76. al.remove("java02");
  78. //4.判断元素。
  79. sop("java03是否存在："+al.contains("java03"));
  80. sop("结合是否为零："+al.isEmpty());
  82. //2，获取个数，集合长度
  83. sop("size="+al.size());
  85. //打印改变后的集合
  86. sop(al);
  89. }
  90. public static void sop(Object obj)
  91. {
  92. System.out.println(obj);
  93. }
  94. } 
import java.util.*;class  CollectionDemo
{public static void main(String[] args) {method_get();//method_1();}public static void method_get(){ArrayList al = new ArrayList();//1.添加元素al.add("java01");//add的参数是Object类型的。al.add("java02");al.add("java03");al.add("java04");Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。sop(it.hasNext());sop(it.next());sop(it.hasNext());while(it.hasNext()){sop(it.next());}/*for(Itera tor it = al.iterator();it.hasNext();){sop(it.next());}*/}//取交集public static void method_1(){ArrayList al1 = new ArrayList();		al1.add("java01");		al1.add("java02");al1.add("java03");al1.add("java04");ArrayList al2 = new ArrayList();		al2.add("java02");		al2.add("java05");al2.add("java07");al2.add("java08");//al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素。al1.removeAll(al2);sop("al1:"+al1);sop("al2:"+al2);		}public static void base_method(){//创建一个集合容器，使用Collection接口的子类，ArrayListArrayList al = new ArrayList();//1.添加元素al.add("java01");//add的参数是Object类型的。al.add("java02");al.add("java03");al.add("java04");//打印原集合sop(al);//3.删除元素al.remove("java02");//4.判断元素。sop("java03是否存在："+al.contains("java03"));sop("结合是否为零："+al.isEmpty());//2，获取个数，集合长度sop("size="+al.size());//打印改变后的集合sop(al);}public static void sop(Object obj){System.out.println(obj);}
}


Iterator（迭代器）

集合中的的元素取出动作，不足以用一个函数来描述（取出前要先判断有没有），同时不同的存储结构，其取出的方式也不同，所以定义了一个接口Iterator专门用来实现其取出操作。因为要访问集合内部的元素，所以迭代器的实现放在了具体集合的内部。

Collection体系结构

Collection按元素是否允许重复，分为List和Set两类。List是允许元素重复，每个元素都有索引。Set不允许重复，元素没有索引。Collection体系结构如下：

Collection

|--List:元素是有序的，元素可以重复。因为该集合体系有索引。

|--ArrarList：底层数据使用的是数据结构。JDK1.2才出现的。特点：查询修改速度很快，但添加删除很慢。线程不同步。

|--LinkedList：底层数据用的是链表数据结构。特点：增删速度很快，查询稍慢。

|--Vector:底层是数组数据结构。JDK1.0出现的，线程同步。被ArrayList替代了，增删查询都很慢。

|--Set：元素是无序的（存入和取出的顺序不一定一致），元素不可重复，没有索引。

|---HashSet：底层数据结构是哈希表。

|---TreeSet：底层数据是二叉树结构。

Set集合的功能和Collection是一致。

List

特有方法

List中凡是可以操作角标的方法都是该体系特有的方法。

通用方法

增：

add(index,element);

addAll(index,Collection);

删：

remove(index);

改：

set(index,element);

查：

get(index);

subList(from,to);

ListIterator();

注意：

1. List判断包含、移除等操作都要调用equals方法。所以新建立一个Student类，将值存入集合时，要复写equals方法，以满足对对象相同的设定。

2. List取出元素的方式有三种：for循环，Iterator，ListIterator。

List特有的迭代器：ListIterator

ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判读，取出，删除的操作。如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

实现该接口的子类对象只能通过List集合的ListIterator方法获取。

示例代码2
[java] view plain copy print ?
  1. class ListDemo
  2. {
  3. public static void main(String[] args)
  4. {
  5. //演示列表迭代器
  6. ArrayList al = new ArrayList();
  8. //1.添加元素
  9. al.add("java01");//add的参数是Object类型的。
  10. al.add("java02");
  11. al.add("java03");
  14. //在迭代过程中，准备添加或者删除元素。
  15. ListIterator it = al.listIterator();
  17. sop("hasPrevious:"+it.hasPrevious());
  18. while(it.hasNext())
  19. {
  20. Object obj = it.next();
  21. if(obj.equals("java02"))
  22. it.set("java08");
  23. sop(obj);
  24. }
  25. while(it.hasPrevious())
  26. {
  27. sop("hasPrevious:"+it.previous());
  28. }
  29. sop("hasNext:"+it.hasNext());
  30. sop("hasPrevious:"+it.hasPrevious());
  31. sop(al);
  32. /*
  33. for(Iterator it = al.iterator();it.hasNext();)
  34. {
  35. Object obj = it.next();
  36. if(obj.equals("java02"))
  37. //al.add("java07");//迭代器和集合同时操作元素，会出现ConcurrentModificationException异常。
  38. it.remove();//将java02的引用从集合中删除了。
  39. sop("obj="+obj);
  40. }
  41. sop(al);
  42. */
  45. //method();
  49. }
  50. public static void method()
  51. {
  52. ArrayList al = new ArrayList();
  54. //1.添加元素
  55. al.add("java01");//add的参数是Object类型的。
  56. al.add("java02");
  57. al.add("java03");
  59. sop("原集合："+al);
  60. //在指定位置添加元素。
  61. al.add(1,"java09");
  62. sop(al);
  64. //删除指定位置的元素。
  65. //al.remove(2);
  67. //修改元素
  68. //al.set(2,"java07");
  70. //通过角标获取元素
  71. sop("a1.get(1):"+al.get(1));
  72. sop(al);
  73. //获取所有元素
  74. for(int x = 0;x<al.size();x++)
  75. {
  76. sop("al("+x+"):"+al.get(x));
  77. }
  79. for(Iterator it = al.iterator();it.hasNext();)
  80. {
  81. sop("next:"+it.next());
  82. }
  84. //通过indexOf获取对象的位置
  85. sop("index="+al.indexOf("java02"));
  88. List sub = al.subList(1,3);
  89. sop("sub:"+sub);
  91. }
  92. public static void sop(Object obj)
  93. {
  94. System.out.println(obj);
  95. }
  96. } 
class ListDemo 
{public static void main(String[] args) {//演示列表迭代器ArrayList al = new ArrayList();//1.添加元素al.add("java01");//add的参数是Object类型的。al.add("java02");al.add("java03");//在迭代过程中，准备添加或者删除元素。ListIterator it = al.listIterator();sop("hasPrevious:"+it.hasPrevious());while(it.hasNext()){Object obj = it.next();if(obj.equals("java02"))it.set("java08");sop(obj);}while(it.hasPrevious()){sop("hasPrevious:"+it.previous());}sop("hasNext:"+it.hasNext());sop("hasPrevious:"+it.hasPrevious());sop(al);/*for(Iterator it = al.iterator();it.hasNext();){Object obj = it.next();if(obj.equals("java02"))//al.add("java07");//迭代器和集合同时操作元素，会出现ConcurrentModificationException异常。it.remove();//将java02的引用从集合中删除了。sop("obj="+obj);}sop(al);*///method();}public static void method(){ArrayList al = new ArrayList();//1.添加元素al.add("java01");//add的参数是Object类型的。al.add("java02");al.add("java03");sop("原集合："+al);//在指定位置添加元素。al.add(1,"java09");sop(al);//删除指定位置的元素。//al.remove(2);//修改元素//al.set(2,"java07");//通过角标获取元素sop("a1.get(1):"+al.get(1));sop(al);//获取所有元素for(int x = 0;x<al.size();x++){sop("al("+x+"):"+al.get(x));}for(Iterator it = al.iterator();it.hasNext();){sop("next:"+it.next());}//通过indexOf获取对象的位置sop("index="+al.indexOf("java02"));List sub = al.subList(1,3);sop("sub:"+sub);}public static void sop(Object obj){System.out.println(obj);}
}

ArrayList

ArrayList底层是数组结构，线程不同步。

示例代码3
[java] view plain copy print ?
  1. /*
  2. 练习：将自定义对象作为元素存到ArrayList集合中，并去除重复元素，比如：存入对象，同姓名同年龄，视为同一个人，为重复元素。
  4. 思路：
  5. 1.对人描述，将数据封装进人对象。
  6. 2.定义容器，将人存入。
  7. 3.取出。
  8. List集合判断元素是否相同，依据的是元素的equals方法。
  9. */
  10. import java.util.*;
  11. class Person1
  12. {
  13. private String name;
  14. private int age;
  15. Person1(String name,int age)
  16. {
  17. this.name =name;
  18. this.age = age;
  19. }
  20. public String getName()
  21. {
  22. return name;
  23. }
  24. public int getAge()
  25. {
  26. return age;
  27. }
  28. //复写equals方法，其实是为集合做判（包含）断服务的。
  29. public boolean equals(Object obj)
  30. {
  31. if(!(obj instanceof Person1))
  32. return false;
  33. Person1 p = (Person1)(obj);
  34. return this.name.equals(p.name) && this.age==p.age;
  35. }
  36. }
  37. class ArrayListTest2
  38. {
  39. public static void main(String[] args)
  40. {
  41. ArrayList al = new ArrayList();
  42. Person1 p1=new Person1("mama",23);
  43. al.add(new Person1("lisi",20));
  44. al.add(new Person1("zhangsna",23));
  45. al.add(new Person1("wangwu",40));
  46. al.add(new Person1("wangwu",40));
  47. al.add(new Person1("loosi",20));
  48. al.add(p1);
  49. al.add(p1);
  53. al=singleList(al);
  54. // sop("remove 03:"+al.remove(new Person1("zhangsna",23)));
  56. Iterator it = al.iterator();
  57. while(it.hasNext())
  58. {
  59. Person1 p = (Person1)it.next();
  61. sop(p.getName()+"::"+p.getAge());
  62. }
  64. }
  65. //去除ArrayList中的重复的元素
  66. public static ArrayList singleList(ArrayList al)
  67. {
  68. ArrayList newAl = new ArrayList();
  70. Iterator it = al.iterator();
  71. while(it.hasNext())
  72. {
  73. Object obj = it.next();
  74. if(!(newAl.contains(obj)))
  75. //contains判断是否相同，用的是equals方法，集合中的元素如果没有重写equals方法，那么传入引用没有问题，
  76. //但如果传入的是匿名对象，那么就会出现重复元素，该函数的实现就出现了bug
  77. newAl.add(obj);
  78. }
  79. return newAl;
  81. }
  82. public static void sop(Object obj)
  83. {
  84. System.out.println(obj);
  85. }
  86. } 
/*
练习：将自定义对象作为元素存到ArrayList集合中，并去除重复元素，比如：存入对象，同姓名同年龄，视为同一个人，为重复元素。思路：
1.对人描述，将数据封装进人对象。
2.定义容器，将人存入。
3.取出。
List集合判断元素是否相同，依据的是元素的equals方法。
*/
import java.util.*;
class Person1
{private String name;private int age;Person1(String name,int age){this.name =name;this.age = age;}public String getName(){return name;}public int getAge(){return age;}//复写equals方法，其实是为集合做判（包含）断服务的。public boolean equals(Object obj){if(!(obj instanceof Person1))return false;Person1 p = (Person1)(obj);return this.name.equals(p.name) && this.age==p.age;}
}
class ArrayListTest2 
{public static void main(String[] args) {ArrayList al = new ArrayList();Person1 p1=new Person1("mama",23);al.add(new Person1("lisi",20));al.add(new Person1("zhangsna",23));al.add(new Person1("wangwu",40));al.add(new Person1("wangwu",40));al.add(new Person1("loosi",20));al.add(p1);al.add(p1);al=singleList(al);
//		sop("remove 03:"+al.remove(new Person1("zhangsna",23)));Iterator it = al.iterator();while(it.hasNext()){Person1 p = (Person1)it.next();sop(p.getName()+"::"+p.getAge());}}//去除ArrayList中的重复的元素public static ArrayList singleList(ArrayList al){ArrayList newAl = new ArrayList();Iterator it = al.iterator();while(it.hasNext()){Object obj = it.next();if(!(newAl.contains(obj)))//contains判断是否相同，用的是equals方法，集合中的元素如果没有重写equals方法，那么传入引用没有问题，//但如果传入的是匿名对象，那么就会出现重复元素，该函数的实现就出现了bugnewAl.add(obj);}return newAl;}public static void sop(Object obj){System.out.println(obj);}
}
Vector

Vector底层也是数组结构，它是线程同步的，但效率低，它有自己特有的枚举Enumeration，用来取出集合元素。后来ArrayList取代了Vector，Iterator取代了Enumeration。

示例代码4
[java] view plain copy print ?
  1. mport java.util.*;
  3. class VectorDemo
  4. {
  5. public static void main(String[] args)
  6. {
  7. Vector v = new Vector();
  8. v.add("java01");
  9. v.add("java02");
  10. v.add("java03");
  11. v.add("java04");
  13. Enumeration en =v.elements();
  14. while(en.hasMoreElements())
  15. {
  16. sop(en.nextElement());
  17. }
  18. }
  20. public static void sop(Object obj)
  21. {
  22. System.out.println(obj);
  23. }
  24. } 
mport java.util.*;class VectorDemo 
{public static void main(String[] args) {Vector v = new Vector();v.add("java01");v.add("java02");v.add("java03");v.add("java04");Enumeration en =v.elements();while(en.hasMoreElements()){sop(en.nextElement());}}public static void sop(Object obj){System.out.println(obj);}
}

LinkedList

LinkedList的特有方法：

addFirst(); addLast();

getFirst();getLast();

获取元素，但不删除元素.如果集合中没有元素，会出现NoSuchElementException

removeFirst();removeLast();

获取元素，同时删除元素。如果集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法。

offerFirst();offerLast();

peekFirst();peekLast();

获取元素，但是元素不被删除。如果集合中没有元素，会返回null

poolFirst();poolLast();

获取元素，但是元素被删除。如果集合中没有元素，会返回null。

示例代码5

[java] view plain copy print ?
  1. /*
  2. 需求：使用LinkedList模拟一个堆栈或者队列数据结构
  3. 为什么要模拟？
  4. LinkedList名称是固定的，在现实开发中，我们希望制作一个跟项目有关的容器，针对特定的数据结构提供更为简便的方法。
  5. 堆栈：先进后出。如同一个杯子。
  6. 队列：先进先出。如同一个水管。First In First Out
  7. */
  8. import java.util.*;
  9. class DuiLie
  10. {
  11. private LinkedList link ;
  12. DuiLie()
  13. {
  14. link = new LinkedList();
  15. }
  16. public void myAdd(Object obj)
  17. {
  18. link.addFirst(obj);
  19. }
  20. public Object myGet()
  21. {
  22. return link.removeLast();
  23. }
  24. public boolean isNull()
  25. {
  26. return link.isEmpty();
  27. }
  28. }
  29. class LinkedListTest
  30. {
  31. public static void main(String[] args)
  32. {
  33. DuiLie dl = new DuiLie();
  34. dl.myAdd("java01");
  35. dl.myAdd("java02");
  36. dl.myAdd("java03");
  37. dl.myAdd("java04");
  39. sop(dl.myGet());
  40. }
  41. public static void sop(Object obj)
  42. {
  43. System.out.println(obj);
  44. }
  45. } 
/*
需求：使用LinkedList模拟一个堆栈或者队列数据结构
为什么要模拟？
LinkedList名称是固定的，在现实开发中，我们希望制作一个跟项目有关的容器，针对特定的数据结构提供更为简便的方法。
堆栈：先进后出。如同一个杯子。
队列：先进先出。如同一个水管。First In First Out
*/
import java.util.*;
class DuiLie
{private LinkedList link ;DuiLie(){link = new LinkedList();}public void myAdd(Object obj){link.addFirst(obj);}	public Object myGet(){return link.removeLast();}public boolean isNull(){return link.isEmpty();}
}
class LinkedListTest 
{public static void main(String[] args) {DuiLie dl = new DuiLie();dl.myAdd("java01");dl.myAdd("java02");dl.myAdd("java03");dl.myAdd("java04");		sop(dl.myGet());}public static void sop(Object obj){System.out.println(obj);}
}

Set

与List不同，Set中的元素不允许重复，但这里的“不允许”是建立在你正确运用其实现原理的基础上，否则仍可能出现重复的情况。

Set常用的子类为HashSet和TreeSet，这两个子类实现元素唯一性的原理不同：HashSet是通过依次调用元素的hashCode和equals方法，而TreeSet是通过让元素或集合具备比较性（分别对应Comparable和Comparator两个接口）来实现的。

TreeSet还有一个特点，它是元素是有序的。这里的有序，跟其存入顺序无关，是指其自然顺序或比较器指定的顺序。

HashSet

HashSet是如何保证元素的唯一性？

是通过依次调用hashCode和equals来完成。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals方法。（开发时，往集合存对象时，一般要重写对象所属类的hashCode和equals方法）

HashSet对于判断元素是否存在，已经删除等操作，依赖的方法也是元素的hashCode和equals方法。

示例代码6

[java] view plain copy print ?
  1. package bxd.day14;
  2. /*
  3. 往HashSet集合中存入自定义对象。
  4. 姓名和年龄相同为同一个人，重复元素。
  6. */
  7. import java.util.*;
  8. class Person
  9. {
  10. private String name;
  11. private int age;
  12. Person(String name,int age)
  13. {
  14. this.name =name;
  15. this.age = age;
  16. }
  17. public String getName()
  18. {
  19. return name;
  20. }
  21. public int getAge()
  22. {
  23. return age;
  24. }
  25. public int hashCode()
  26. {
  27. System.out.println(this.name+"之前的hashCode值："+super.hashCode());
  28. return name.hashCode()+age*37;//所有的目的都是为了让HashSet判断的hashCode值只跟你要保证唯一的那些值有关，
  29. //age*37,是为了尽量保证hashCode值的唯一。比如（40+20）和（20+40）的情况。
  31. }
  32. public boolean equals(Object obj)
  33. {
  34. if(!(obj instanceof Person))
  35. return false;
  36. Person p = (Person)(obj);
  37. System.out.println(this.name+"...equals..."+p.name);//该句没有被打印说明没有调用equals()方法。
  38. return this.name.equals(p.name) && this.age==p.age;
  39. }
  40. }
  42. class HashSetTest
  43. {
  44. public static void main(String[] args)
  45. {
  46. HashSet hs = new HashSet();
  47. hs.add(new Person("a1",11));
  48. hs.add(new Person("a2",12));
  49. hs.add(new Person("a3",13));
  50. hs.add(new Person("a2",12));
  51. // hs.add(new Person("a4",14));
  53. //sop("a1存在:"+hs.contains(new Person("a1",11)));
  54. sop("a4 exists?"+hs.remove(new Person("a4",14)));
  56. Iterator it = hs.iterator();
  57. while(it.hasNext())
  58. {
  59. Person p = (Person)it.next();
  60. sop(p.getName()+"::"+p.getAge());
  61. }
  62. }
  65. public static void sop(Object obj)
  66. {
  67. System.out.println(obj);
  68. }
  69. } 
package bxd.day14;
/*
往HashSet集合中存入自定义对象。
姓名和年龄相同为同一个人，重复元素。*/
import java.util.*;
class Person
{private String name;private int age;Person(String name,int age){this.name =name;this.age = age;}public String getName(){return name;}public int getAge(){return age;}public int hashCode(){System.out.println(this.name+"之前的hashCode值："+super.hashCode());return name.hashCode()+age*37;//所有的目的都是为了让HashSet判断的hashCode值只跟你要保证唯一的那些值有关，//age*37,是为了尽量保证hashCode值的唯一。比如（40+20）和（20+40）的情况。}public boolean equals(Object obj){if(!(obj instanceof Person))return false;Person p = (Person)(obj);System.out.println(this.name+"...equals..."+p.name);//该句没有被打印说明没有调用equals()方法。return this.name.equals(p.name) && this.age==p.age;}
}class HashSetTest 
{public static void main(String[] args) {HashSet hs = new HashSet();hs.add(new Person("a1",11));hs.add(new Person("a2",12));hs.add(new Person("a3",13));hs.add(new Person("a2",12));// hs.add(new Person("a4",14));//sop("a1存在:"+hs.contains(new Person("a1",11)));sop("a4 exists?"+hs.remove(new Person("a4",14)));Iterator it = hs.iterator();while(it.hasNext()){Person p = (Person)it.next();sop(p.getName()+"::"+p.getAge());}}public static void sop(Object obj){System.out.println(obj);}
}


TreeSet

TreeSet中元素的取出顺序跟存入顺序无关，不可以有重复元素。

TreeSet实现排序的方式有两种：

一、让元素具备比较性（或自然顺序，实现Comparable接口）

TreeSet存入的元素，如果没有实现Comparable接口，往TreeSet中add第一个元素的时候，不会出问题，但add第二个元素时，会出现类型转换异常，因为TreeSet集合是通过Comparable接口的compareTo方法来完成排序的，它默认其中的元素都实现了Comparable接口。

同时，在compareTo方法中，当主要条件判断相等后，一定要再判断下次要条件。

TreeSet对于判断元素是否存在，已经删除等操作，依赖的方法也是元素的compareTo方法。

二、让集合具备比较器（集合传入Comparator）

当集合元素没有比较性或具备的比较性不是所需要的时，可以让集合自己具备比较性，即集合初始化时，把一个比较器Comparator作为参数传入集合的构造函数。

Comparator接口里边有个compare（obj，obj）方法。

示例代码7

[java] view plain copy print ?
  1. import java.util.*;
  2. class TreeSetDemo2
  3. {
  4. public static void main(String[] args)
  5. {
  6. TreeSet ts = new TreeSet(new MyCompare());
  8. ts.add(new Student2("a1",15));
  9. ts.add(new Student2("a2",12));
  10. ts.add(new Student2("a2",13));
  11. ts.add(new Student2("a4",16));
  12. ts.add(new Student2("a4",17));
  14. Iterator it = ts.iterator();
  15. while(it.hasNext())
  16. {
  17. Student2 stu = (Student2)it.next();
  18. System.out.println(stu.getName()+"::"+stu.getAge());
  19. }
  20. }
  21. }
  22. //第二种排序方式：实现比较器，现在姓名再按年龄排序。
  23. class MyCompare implements Comparator
  24. {
  25. public int compare(Object o1,Object o2)
  26. {
  27. Student2 s1 = (Student2)o1;
  28. Student2 s2 = (Student2)o2;
  31. int num = s1.getName()pareTo(s2.getName());
  32. if(num==0)
  33. {
  34. /*if(s1.getAge()>s2.getAge())
  35. return 1;
  36. if(s1.getAge()==s2.getAge())
  37. return 0;
  38. return -1;*/
  39. num=new Integer(s1.getAge())pareTo(new Integer(s2.getAge()));
  40. }
  41. return num;
  42. }
  43. }
  45. //第一种排序方式：让集合元素具备比较性，先按年龄再按姓名比较。
  46. class Student2 implements Comparable//该接口让学生具备比较性。
  47. {
  48. private String name;
  49. private int age=100;
  50. Student2(String name,int age)
  51. {
  52. this.name = name;
  53. this.age = age;
  54. }
  56. public int compareTo(Object obj)
  57. {
  58. if(!(obj instanceof Student2))
  59. throw new RuntimeException(obj.toString()+"不是学生对象");
  60. Student2 s = (Student2)obj;
  61. //System.out.println(this.name+"..pareTo..."+s.name);
  62. if(this.age>s.age)
  63. return 1;
  64. if(this.age==s.age)
  65. {
  66. return this.namepareTo(s.name);
  67. }
  68. return -1;
  70. }
  71. /*
  72. public int compareTo(Object obj){
  74. return 1;//这样做会导致按存入顺序取出元素；改为-1，则逆序；改为0，则永远只能存一个元素。
  75. }*/
  76. public String getName()
  77. {
  78. return name;
  79. }
  80. public int getAge()
  81. {
  82. return age;
  83. }
  85. } 
import java.util.*;
class TreeSetDemo2  
{public static void main(String[] args) {TreeSet ts = new TreeSet(new MyCompare());ts.add(new Student2("a1",15));ts.add(new Student2("a2",12));ts.add(new Student2("a2",13));ts.add(new Student2("a4",16));ts.add(new Student2("a4",17));Iterator it = ts.iterator();while(it.hasNext()){Student2 stu = (Student2)it.next();System.out.println(stu.getName()+"::"+stu.getAge());}}
}
//第二种排序方式：实现比较器，现在姓名再按年龄排序。
class MyCompare implements Comparator
{public int compare(Object o1,Object o2){Student2 s1 = (Student2)o1;Student2 s2 = (Student2)o2;int num = s1.getName()pareTo(s2.getName());if(num==0){/*if(s1.getAge()>s2.getAge())return 1;if(s1.getAge()==s2.getAge())return 0;return -1;*/num=new Integer(s1.getAge())pareTo(new Integer(s2.getAge()));}return num;}
}//第一种排序方式：让集合元素具备比较性，先按年龄再按姓名比较。
class Student2 implements Comparable//该接口让学生具备比较性。
{private String name;private int age=100;Student2(String name,int age){this.name = name;this.age = age;}public int compareTo(Object obj){if(!(obj instanceof Student2))throw new RuntimeException(obj.toString()+"不是学生对象");Student2 s = (Student2)obj;//System.out.println(this.name+"..pareTo..."+s.name);if(this.age>s.age)return 1;if(this.age==s.age){return this.namepareTo(s.name);}		return -1;	}/*public int compareTo(Object obj){return 1;//这样做会导致按存入顺序取出元素；改为-1，则逆序；改为0，则永远只能存一个元素。		}*/public String getName(){return name;}public int getAge(){return age;}}


更多推荐

(每日一转)黑马程序员

本文发布于:2024-02-06 19:50:31，感谢您对本站的认可！
本文链接:https://www.elefans.com/category/jswz/34/1751191.html
版权声明:本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
本文标签：一转   黑马   程序员

发布评论

评论列表 （有 0 条评论）

最近发表

草根站长

>www.elefans.com

编程频道|电子爱好者 - 技术资讯及电子产品介绍！

热门文章

标签列表