(每日一转)黑马程序员----跟着老毕学Java-集合框架篇之Collection

最新推荐文章于 2020-09-16 22:22:23 发布
最新推荐文章于 2020-09-16 22:22:23 发布
阅读量815 收藏
点赞数
分类专栏： java学习

集合框架

概述

为什么要用集合？

对象是对数据的封装，而集合是对对象的封装。编程中除了对单个象的操作外，常常还需要对多个对象进行统一操作，这时就需用一个容器将这些对象存储起来，这样的容器就是集合。其实，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接口的子类，ArrayList
		ArrayList 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方法，那么传入引用没有问题，
				//但如果传入的是匿名对象，那么就会出现重复元素，该函数的实现就出现了bug
				newAl.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().compareTo(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()).compareTo(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+"...compareTo..."+s.name);
  62. if(this.age>s.age)
  63. return 1;
  64. if(this.age==s.age)
  65. {
  66. return this.name.compareTo(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().compareTo(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()).compareTo(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+"...compareTo..."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}		
		return -1;	

	}
	/*
	public int compareTo(Object obj){
		
		return 1;//这样做会导致按存入顺序取出元素；改为-1，则逆序；改为0，则永远只能存一个元素。		
	}*/
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	
}


莱茵阿尔法
关注
专栏目录
java项目部署看这一篇,老毕了
qq_42403929的博客
11-22 892
1.虚拟机安装 1.1.IP设置 查看本地与虚拟机端的各自IP---ipconfig 检查windows与linux之间网络是否通畅 1.2.在虚拟机上安装JDK 1.2.1上传jdK 1.2.2.解压jdk tar -xvf jdk-8u51-linux-x64.tar.gz 1.2.3.删除安装文件 1.2.4.修改JDK文件名称 1.2.5.检查JDK是否有效 1.2.6.JDK配置 命令: vim /etc/profile #设定jdk环境 export
老毕个人总结java+安卓
10-28
老毕个人总结,java android总结,对基础部分很有帮助!
老毕java基础总结
05-19
老毕的java基础总结，对于刚学习java的人是一个很好的教材，简单易懂的代码由简入深。
Java老毕
HaC 的博客
10-15 488
Java基础，视频Markdownday1： 1. 命令符 进入C盘：cd\ 进入D盘：d: 显示该盘所有的文件： dir 创建文件夹：md [文件夹名称] 删除文件夹：rd [文件夹名称] 返回上一层目录：cd.. 返回根目录：cd\ 删除文件：del [文件名.后缀] (del [文件夹名称] 表示删除该文件夹下所有的文件，但是文件夹还在，可以用rd命令删除)；del *.txt 表示删除
（每日一转） 黑马程序员----跟着老毕学Java之基础篇（一）
mugen
03-11 885
第一章 Java概述 引入：基础常识 软件开发：软件是一系列按照特定顺序组织的计算机数据和指令的结合，一般分为系统软件和应用软件。软件开发就是制作软件。 人机交互方式：其中介就是软件，软件实现了人与计算机之间的更好的交互。交互方式一般分为：图形化界面和命令行方式。 常用的DOS命令：    dir : 列出当前目录下的文件以及文件夹   md : 创建目录   rd : 删除目录
老毕java视频源代码.zip
10-20
老毕java视频源代码.zip。
基础知识之IO流(装饰设计模式)
CYM_LMY的专栏
10-19 702
readLine方法是增强read方法。 装饰设计模式 /* 装饰设计模式： 当想要对已有的对象进行功能增强时， 可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。 那么自定义的该类称为装饰类。 装饰类会通过构造方法接受被装饰的对象。 并基于被装饰的对象的功能，提供更强的功能。 * * */ class Person {  public void chifan()
WirelessQA-Provider源码
02-27
在Android开发中，ContentProvider是四大组件之一，它充当了数据共享的桥梁，使得不同的应用程序之间可以安全地访问和操作数据。"WirelessQA-Provider源码" 是一个专门用于无线质量评估（Wireless Quality Assurance...
黑马程序员--老毕的“模版方法设计模式”
foreverhuylee的专栏
03-15 749
老毕在讲完抽象类之后，讲了“模版方法设计模式”，内容是这样的： 在项目开发过程中，已经明确的业务（定义属性为final）去调用不明确的业务，设计模版时，要把不明确的业务设计成抽象方法，交给其子类去复写。     老毕举了个计算程序运行时间的例子，以下是代码：   abstract class TimeTemplate {    public final void getTime()//
黑马程序员--- 送大家一份毕老师的笔记
jasjsdajsdjf的专栏
08-16 615
文章来源：黑马程序员，黑马论坛。     送大家一份毕老师的笔记，自己一边看，一遍弄的，有很多截图，大家没事看两眼，当复习资料应该不错   http://pan.baidu.com/s/1pJPqglH
黑马程序员--老毕的“单例设计模式”
foreverhuylee的专栏
03-15 693
黑马程序员--老毕的“单例设计模式”   老毕在讲完abstract关键字之后，简单提了下“单例设计模式”，在讲到线程的时候,又加入了许多精彩的内容. 在项目开发过程中，要确保对象在内存中的唯一性(一个类在内存只存在一个对象),就要用到“单例设计模式”。 “单例设计模式”的必备的三大步: 1.为了避免其他程序过多建立该对象，先禁止其他程序建立该对象       2.为了让其他程序可以
java精简学习笔记（黑马毕老师授）
敢拼就能赢_LQ
05-25 997
1.在dos下删除文件夹（rd命令）须保证文件夹是空的。而del命令(删除文件)不同。 建立jar包双击可执行：                  将java文件打包    javac -d 存放目录 源文件.java 进入存放目录 jar -cvf 文件名.jar 包名 建立一个清单文件指定Main-Class: 包名.主函数所在类名 jar -cvfm 文件名.jar 清单文
黑马程序员—java毕老师视频个人总结01
u013383259的专栏
01-06 1452
------- android培训、java培训、期待与您交流！ ---------- 因为之前看有一遍，但没有同步书写blog，如果现在硬着头皮回想每一天的所学所得，无疑是既浪费时间又不可能牢固知识点，所以就再次看一遍，在牢固知识点的基础上书写blog。毕老师的视频着实是从零开始，但是我写blog不仅是为了完成任务，更是根据自己知识点的掌握，方便以后复习所写，所以可能概括的知识点只是出于
黑马程序员-有关IO的总结
u014300492的专栏
04-04 555
------------------- android开发、java培训、期待与您交流！ ---------------------- 黑马程序员-有关IO的总结 在变量、数组和对象中存储的数据是暂时存在的，程序结束以后他们就会丢失，为了能够永久的保存程序创建的数据，需要将其保存在磁盘中，这样就可以在其他程序中使用。Java的IO技术可以将数据存储在文本文件、二进制文件甚至是ZIP压缩文
跟随小破站学习java SE第六天
Mars_LJ的博客
09-16 219
/* * 方法的重写(override / overwrite) * * 1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作 * * 2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。 * * 3. 重写的规定： * 方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{ * //方法体 * } * 约定...
基于SpringBoot仿天猫购物系统.zip(毕设&课设&实训&大作业&竞赛&项目)
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
Python网络爬虫与推荐算法新闻推荐平台(毕设&课设&实训&大作业&竞赛&项目)
最新发布
09-20
Python网络爬虫与推荐算法新闻推荐平台：网络爬虫：通过Python实现新浪新闻的爬取，可爬取新闻页面上的标题、文本、图片、视频链接（保留排版） 推荐算法：权重衰减+标签推荐+区域推荐+热点推荐.zip项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
THUCNews数据集
09-20
THUCNews数据集
精通Web开发：HTML-CSS-JavaScript基础教程
JavaScript是一种强大的脚本语言，常用于网页的动态效果和用户交互。课程将教授如何使用JavaScript来改变HTML内容，响应用户操作，比如创建动画效果，验证表单数据，或者与服务器进行异步通信。 课程的其他部分将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值