Java基础——集合框架（二）

最新推荐文章于 2024-07-04 22:30:00 发布
最新推荐文章于 2024-07-04 22:30:00 发布
阅读量538 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： 程序员 集合 TreeSet 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_29174099/article/details/46925787
版权

Set：

无序，不可重复元素

  • HashSet：数据结构是哈希表，线程是非同步的。
    • 保证元素唯一性的原理：判断元素的hashCode值是否相同
    • 如果相同，还会继续判断元素的equals方法，是否为true
  • TreeSet：
    • 可以对Set集合中的元素进行排序
    • 底层数据结构式二叉树，
    • 保证元素唯一的依据是：
    • compareTo方法return 0 。
      • TreeSet排序的第一种方式：
        • 让元素自身具备比较性
        • 元素需要实现Comparable接口，覆盖compareTo方法
        • 这种方式也称为元素的自然顺序，或者叫做默认顺序
      • TreeSet的第二种排序方式。
        • 当元素自身不具备比较性时，或者具备的比较性不是所需要的。
        • 这时就需要让集合自身具备比较性。
        • 在集合初始化时，就有了比较方式。

//TreeSet集合简单的存储以及取出演示
import java.util.*;
public class TreeSetDemo {
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();
		ts.add("aaa");
		ts.add("cbc");
		ts.add("aac");
		ts.add("bde");

		for (Iterator it = ts.iterator();it.hasNext() ; )
		{
			sop(it.next());
		}
	}
}

运行结果为：

TreeSet集合的简单演示

发现TreeSet集合中打印出来的数据不仅无序，而且他会按照自己的规则（ASCII码表顺序）给集合中的元素进行排序。

那么接下来，老规矩，给集合中添加自定义对象呢？

//在TreeSet集合中添加自定义对象
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 class TreeSetDemo1 {
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();//创建TreeSet集合对象

		ts.add(new Person("zhangsan",12));
		ts.add(new Person("lisi",28));
		ts.add(new Person("wangwu",17));
		ts.add(new Person("zhaoliu",40));

		for (Iterator it = ts.iterator(); it.hasNext(); )//用迭代器取出集合中的元素
		{
			Object obj = it.next();
			Person p = (Person)obj;
			sop("姓名= "+p.getName()+"...年龄为..."+p.getAge());
		}
	}
}

编译通过，，运行，，

对象进行比较蹦出来的异常

在运行的时候，出现了异常，ClassCastException 原因是，Person can not be cast to Comparable

找到Comparable的详细信息

Comparable接口信息

发现接口中只有一个方法

compareTo方法摘要

上边说了那么一大堆，其实简单来说就是：
TreeSet集合会给传进来的对象进行排序，但是传进来的Person类的对象并不具备比较性。TreeSet集合不知道用什么方式来给对象进行排序。

那怎么就有了比较性了呢？
实现Comparable接口。

那怎么定义比较方法呢？
在实现Comparable接口的类中，重写compareTo方法。
将比较规则写在该方法中，调用方的对象比较大于参数方，则返回正整数，否则返回负整数，相同返回0.

代码实现是这样的。

//在TreeSet集合中添加自定义对象
import java.util.*;
class Person implements Comparable//此接口强制让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 compareTo(Object obj)
	{
		if (!(obj instanceof Person))
			throw new RuntimeException("参数格式不正确");
		Person p = (Person)obj;
		//想按照年龄排序,从小到大的顺序
		//如果调用方的属性值大于参数对象的属性值，返回一个正整数。
		if (this.age>p.age)
			return 1;
		if(this.age==p.age)
			return 0;
		return -1;
	}
}
public class TreeSetDemo1 {
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();//创建TreeSet集合对象

		ts.add(new Person("zhangsan",12));
		ts.add(new Person("lisi",28));
		ts.add(new Person("wangwu",17));
		ts.add(new Person("zhaoliu",40));

		for (Iterator it = ts.iterator(); it.hasNext(); )//用迭代器取出集合中的元素
		{
			Object obj = it.next();
			Person p = (Person)obj;
			sop("姓名= "+p.getName()+"...年龄为..."+p.getAge());
		}
	}
}

运行结果为：

TreeSet集合对自定义对象进行排序

那么想到当两个人的年龄一样的话，会不会将对象存进来呢？

//在TreeSet集合中添加自定义对象
import java.util.*;
class Person implements Comparable//此接口强制让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 compareTo(Object obj)
	{
		if (!(obj instanceof Person))
			throw new RuntimeException("参数格式不正确");
		Person p = (Person)obj;
		
		if (this.age>p.age)
			return 1;
		if(this.age==p.age)
			return 0;
		return -1;
	}
}
public class TreeSetDemo1 {
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();

		ts.add(new Person("zhangsan",12));
		ts.add(new Person("lisi",28));
		ts.add(new Person("wangwu",17));
		ts.add(new Person("zhaoliu",40));
		ts.add(new Person("zhouqi",40));//两个人年龄一样，但是姓名不一样

		for (Iterator it = ts.iterator(); it.hasNext(); )
		{
			Object obj = it.next();
			Person p = (Person)obj;
			sop("姓名= "+p.getName()+"...年龄为..."+p.getAge());
		}
	}
}

运行结果：

相同年龄的人存不进去

运行结果显示，那个年龄形同的人没有存进来

解释：每一个被添加进来的对象都会运行compareTo方法和已经在集合中的元素比较一次，如果返回为0，会认为这个对象和集合中的元素是同一个，不进行存储。

解决方法：设置完主要条件要设置次要条件。
假如年龄相同要在判断一次姓名是否相同，

//在TreeSet集合中添加自定义对象
import java.util.*;
class Person implements Comparable//此接口强制让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 compareTo(Object obj)
	{
		if (!(obj instanceof Person))
			throw new RuntimeException("参数格式不正确");
		Person p = (Person)obj;
		
		if (this.age>p.age)
			return 1;
		if(this.age==p.age)
		{
			return this.name.compareTo(p.name);
			//这里的this.name是String类型的，String类型有自己的比较方法（自然顺序）
			//因为Sting类实现了Comparable接口，所以字符串具有比较性。
			//最后将String类比较完compareTo方法返回的值再返回去。
		}
		return -1;
	}
}
public class TreeSetDemo1 {
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();

		ts.add(new Person("zhangsan",12));
		ts.add(new Person("lisi",28));
		ts.add(new Person("wangwu",17));
		ts.add(new Person("wangwu",17));
		ts.add(new Person("zhaoliu",40));
		ts.add(new Person("zhouqi",40));//两个人年龄一样，但是姓名不一样

		for (Iterator it = ts.iterator(); it.hasNext(); )
		{
			Object obj = it.next();
			Person p = (Person)obj;
			sop("姓名= "+p.getName()+"...年龄为..."+p.getAge());
		}
	}
}

运行结果：

实现方式的比较器

实验结果，年龄相同，姓名不同的两个人，可以存储进来。
年龄相同，姓名相同的人（视为同一个人）存储不进来。

TreeSet中的数据存储方式图：二叉树

二叉树示意图

根据二叉树的示意图，就了解了TreeSet集合中数据的存储方式，

那么如果我想要将TreeSet集合中的对象按照存进去时候的顺序取出来呢？

只要将复写compareTo方法的内容中只写一句：return 1，
进来一个元素，元素判断时调用compareTo方法，一看返回值为1 ，放在右边
以此类推…
最后存进去的顺序就和元素存进去的先后顺序一样的了。

那么如果我想要将TreeSet集合中的对象反向的取出来呢？

只要将复写compareTo方法的内容中只写一句：return -1，
进来一个元素，元素判断时调用compareTo方法，一看返回值为-1 ，放在左边
以此类推…
最后存进去的顺序就是倒着的，取出来的顺序就和存进去的顺序相反了。

自定义比较器

像以上自定义对象存入TreeSet集合中，使用的是给对象强制加了比较性。
但是在实际开发中，已经定义好的Person类的排序方式（先判断年龄，再判断姓名）不是我们想要的。
我们想要的是：先按照姓名排序（主要条件），然后按照年龄排序（次要条件）
但是之前已经给了的Person类的代码不能动（因为我们知道，修改代码是灾难啊）
解决办法就是在集合自身上定义一个比较器：不管你自己的排序方式是什么样的，要进我的集合中，按照我的排序方式来。

如何自定义比较器呢？

自定义类实现Comparator接口，
覆盖里边的int compare(Object o1,Object o2)方法
同样是以return 0 来判断元素是否相同。

示例代码如下：

/*
当对象所具备的比较性不是我们想要的时候
我们需要给集合定义自己的比较器
只要将定义好的比较器作为参数传给TreeSet的构造函数就好了
*/

//需求：自定义集合的比较器，让对象按照集合的比较器进行比较并存储
//而不按照对象的比较方式
import java.util.*;
//这里定义Person类实现了接口，让Person对象具备比较性
class Person implements Comparable
{
	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 compareTo(Object obj)
	{
		if (!(obj instanceof Person))
			throw new RuntimeException("对象不正确");
		Person p = (Person)obj;
		if (this.age>p.age)
			return 1;
		if (this.age==p.age)
		{
			return this.name.compareTo(p.name);
		}
		return -1;
	}
}
//定义比较器
class MyCompare implements Comparator
{
	public int compare(Object o1,Object o2)//形参必须是Obj的，如果不是就不算复写接口中的方法。
	{
		if ((!(o1 instanceof Person)) || (!(o1 instanceof Person)))//如果传入的参数不是Person类的，抛出运行时异常
		{
			throw new RuntimeException("传入的对象不正确");
		}
		//通过if条件了，就执行强转
		Person p1 = (Person)o1;
		Person p2 = (Person)o2;
		//如果姓名相同，，再比较年龄
		if ((p1.getName().compareTo(p2.getName()))==0)
		{
			//Integer类中有自己重写过的compareTo方法，这里直接借过来使用
			return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
		}
		//如果姓名不相同，直接返回字符串之间的自然顺序比较的结果值
		return p1.getName().compareTo(p2.getName());
	}
}
public class TreeSetDemo2 {
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new MyCompare());

		ts.add(new Person("java08",34));
		ts.add(new Person("java04",24));
		ts.add(new Person("java09",43));
		ts.add(new Person("java43",12));
		ts.add(new Person("java43",25));
		ts.add(new Person("java01",39));
		ts.add(new Person("java05",39));
		//ts.add("java05");//这里抛出运行时异常

		for (Iterator it = ts.iterator();it.hasNext() ; )
		{
			Person p = (Person)it.next();
			sop(p.getName()+"......"+p.getAge());
		}
	}
}

运行结果：正常

自定义比较器

运行结果显示：对象按照姓名顺序排序，姓名相同的话，按照年龄排序。
而且，当第一种比较方式（对象类实现Comparable接口）和第二种比较方式（自定义比较器实现Compatator接口）共存的时候，使用的是第二种比较方式。

一个TreeSet集合的小练习：

//需求：TreeSet 中存放字符串对象，要求按照字符长度排序
import java.util.*;
class MyCompare implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		//对象进来先进行判断
		if ((!(o1 instanceof String)) || (!(o1 instanceof String)))
			throw new RuntimeException("对象不是字符串的对象");
		//再进行强转
		String s1 = (String)o1;
		String s2 = (String)o2;
		//再进行判断（长度）
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		//如果长队相等，再进行自然排序
		if (num==0)
		{
			return s1.compareTo(s2);
		}
		//如果长度不相等，直接返回判断长度返回的值
		return num;
	}
}
public class TreeSetTest {
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new MyCompare());
		
		ts.add("abfdfdc");
		ts.add("abcd");
		ts.add("abcdf");
		ts.add("aaaaa");
		ts.add("c");
		ts.add("cfd");

		for (Iterator it = ts.iterator();it.hasNext() ; )
		{
			System.out.println((String)it.next());
		}
	}
}

运行结果为：

按照字符串长度进行排序

运行结果，如果字符串的长度不相等，按照字符串的长度排序
如果字符串的长度相等，按照字符串的自然顺序排序。

记住，compare方法和compareTo方法，返回的都是大于0，小于0，等于0的整数，不是简单的1,0，-1。

泛型

jdk1.5版本以后出现的新特征，用于解决安全问题，是一个类型安全机制。

看一个小程序来了解泛型:

//需求：想打印一下存在集合中的字符串对象的长度。
import java.util.*;
public class GenericDemo {
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();

		al.add("dsfd");
		al.add("cvv");
		al.add("eref");
		al.add("dfdsd");

		for (Iterator it =al.iterator();it.hasNext() ; )
		{
			String s = (String)it.next();
			System.out.println(s.length());
		}
	}
}

运行结果：

泛型的引出

如果我在这个集合中一不小心存储了一个Integer类型的值呢？

//需求：想打印一下存在集合中的字符串对象的长度。
import java.util.*;
public class GenericDemo {
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();

		al.add("dsfd");
		al.add("cvv");
		al.add("eref");
		al.add("dfdsd");
		al.add(new Integer(4));//添加一个Integer类型的对象

		for (Iterator it =al.iterator();it.hasNext() ; )
		{
			String s = (String)it.next();
			System.out.println(s.length());
		}
	}
}

运行结果显示:

存储错误的值造成的实验结果

由运行结果可以看到：编译可以通过，但是运行时出了问题，抛出了ClassCastException
Integer类型的对象不能被转换成String类型的。

这种编译时不出现问题，运行时出现问题的程序很危险，
为了让该程序在编译的时候，有什么问题都会显示 出来，也就是为了提高安全性，
在定义集合的时候给他加上一个标识，明确只有什么类型的对象才可以存入到集合中来，
只要是添加了不符合规则的类型对象进来，编译时期就报错

怎么添加标识呢？

这就用到了泛型，给TreeSet集合明确要存的对象类型

代码示例：

//需求：想打印一下存在集合中的字符串对象的长度。
import java.util.*;
public class GenericDemo {
	public static void main(String[] args) 
	{
		//泛型标识，用<>将集合中要存的对象类型写进来，集合中只可以存这种类型的对象
		//如果存进来其他类型的对象，就会报错
		ArrayList<String> al = new ArrayList<String>();

		al.add("dsfd");
		al.add("cvv");
		al.add("eref");
		al.add("dfdsd");
		al.add(new Integer(4));//添加一个Integer类型的对象


		//既然存的时候要限定类型，取得时候也要限定类型
		//因为Iterator接口接收到的是Object对象，
		for (Iterator<String> it =al.iterator();it.hasNext() ; )
		{
			//既然在迭代器上已经限定了要存进来的对象，所以取对象的时候就不用进行对象的向下强转了。
			String s = it.next();
			System.out.println(s.length());
		}
	}
}

编译结果：

泛型类的标识

发现，加上泛型之后，往集合中添加其他类型的对象的时候，在编译时期就出现了错误，可以让程序员发现并进行修改。提高了安全性。

我们重新将代码修改（将添加Integer对象的那一行代码注释），使代码编译能够通过，并且运行。

运行结果：

泛型类实现

发现，编译正常通过，而且不再会提示：使用了未经检查的不安全操作了。

泛型的好处：

1，将运行时出现问题ClassCastException转移到了编译时期。
方便程序员解决问题，让运行时期问题减少，安全。
2，避免了强制转换的麻烦。

**泛型格式：**通过<>来定义要操作的引用数据类型。

在使用java中提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，
只要见到<>就要定义泛型
其实<>就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

一个泛型在集合中比较器里边的应用：

/*
泛型在集合比较器中的应用
*/

//需求：在集合中存入字符串对象，要求按照长度从长到短排序，用泛型类加强安全措施
import java.util.*;

class MyCompare implements Comparator<String>//Comparator接口也要定义泛型类
{
	public int compare(String s1,String s2)//接口标识了泛型类，这里就不用再进行强转，进来的元素都是String类型的
	{
		//按照长度从长到短的顺序，只要将先后传进来的对象的比较顺序进行调换就可以了。

		int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));
		if (num==0)
			return s2.compareTo(s1);
		return num;
	}
}
public class GenericDemo2 {
	public static void main(String[] args) 
	{
		TreeSet<String> ts = new TreeSet<String>(new MyCompare());

		ts.add("gfdgd");
		ts.add("aaa");
		ts.add("dcf");
		ts.add("fdsfewwef");
		ts.add("cv");

		for (Iterator<String> it  = ts.iterator();it.hasNext() ; )
		{
			String s = it.next();
			System.out.println(s);
		}
	}
}

运行结果为：

泛型在集合中比较器的应用

运行结果显示，按照字符串从长到短的顺序进行排列的。

练习二：自定义具有泛型限制的工具类
前后作为对比：
没有泛型的时候是这样的：

/*
定义一个工具类，能够调用被创建出来的对象，
*/
import java.util.*;

class Person
{

}
class UtilClass//创建一个工具类
{
	private Person p;
	public void set(Person p)//set方法创建一个Person对象
	{
		this.p = p;
	}
	public Person get()//get方法返回一个Person对象
	{
		return p;
	}
}
public class GenericDemo3 {
	public static void main(String[] args) 
	{
		UtilClass u = new UtilClass();
		u.set(new Person());
		Person p = (Person)u.get();

	}
}

这样的代码，可以执行也可以运行，
但是不止一个类需要有这样的工具，当其他类调用这样的工具的时候，
还要重新创建该工具类，设置参数类，这样的话不能提高代码的复用性，也降低了该工具程序的扩展性。
于是，我们将代码变成了这样：

/*
定义一个工具类，能够调用被创建出来的对象，使用泛型，让该方法可以被多个类调用
*/
import java.util.*;

class Person
{

}
class Student
{
}
class UtilClass
{
	private Object obj;
	public void setObject(Object obj)
	{
		this.obj = obj;
	}
	public Object getObject()
	{
		return obj;
	}
}
public class GenericDemo3 {
	public static void main(String[] args) 
	{
		UtilClass u = new UtilClass();
		u.setObject(new Person());//在这里Person类会被提升为Object类

		//这里要将提升到Object类型的对象进行强制向下转型
		Person p = (Person)u.getObject();

	}
}

这样也可以，但是，当我在主函数中的setObject方法中new了一个Student对象，

u.setObject(new Student());

编译也能通过（因为setObject方法接收的参数是Object类型的）
但是运行时出了问题，

编译失败

运行结果如图所示，编译能通过，但是运行时抛出来类型转换异常，因为到强制向下转型的时候不能将原本Student类型的对象转换成Person对象。
这种编译可以通过，但是运行出问题的方式是不可取的。

这种办法行不通，但是怎么样才可以提高代码的复用性，而且还能提高程序的扩展性呢？

这就用到了自定义泛型工具类

/*
定义一个工具类，能够调用被创建出来的对象，使用泛型，让该方法可以被多个类调用
*/
import java.util.*;

class Person
{

}
class Student
{
}
class UtilClass<T>//这里标识一个类型形式参数
{
	private T t;//里边的类型，变量全是参数值
	public void setObject(T t)
	{
		this.t = t;
	}
	public T getObject()
	{
		return t;
	}
}
public class GenericDemo3 {
	public static void main(String[] args) 
	{
		//在定义工具类的时候就要加泛型以约束
		UtilClass<Person> u = new UtilClass<Person>();

		//这里new对象作为参数
		u.setObject(new Person());

		//在这里就不用进行强转了。
		Person p = u.getObject();

	}
}

运行结果正常，

如果我们在倒数第二行new错了对象

u.setObject(new Student());

在编译时期就会报错，提醒程序员修改代码，这样提高了安全性。

将泛型定义在方法上

在以上的示例中，我们将泛型定义在类上，泛型在全类中有效。

看以下代码：

/*演示将泛型添加在方法上*/

class Demo<T>
{
	public void show(T t)
	{
		System.out.println("show.."+t);
	}
	public void print(T t)
	{
		System.out.println("print.."+t);
	}
}
public class GenericDemo4 {
	public static void main(String[] args) 
	{
		Demo<String> d = new Demo<String>();
		d.show("hahah");
		d.print("hehe");


		Demo<Integer> d1 = new Demo<Integer>();
		d1.show(new Integer(7));
		d1.print(4);//这里会自动装箱操作
	}
}

运行结果：

泛型添加在方法上1

但是想要只new一个对象，然后用着一个对象打印多个类型的数据呢？
这就用到了泛型方法：

/*演示将泛型添加在方法上*/

class Demo
{
	public<T> void show(T t)//在返回值类型前边添加类型参数
	{
		System.out.println("show.."+t);
	}
	public<T> void print(T t)
	{
		System.out.println("print.."+t);
	}
}
public class GenericDemo4 {
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		d.show("haha");
		d.show(new Integer(7));
		d.show(9);
	}
}

运行结果：

泛型添加在方法上

  • 泛型类定义的泛型，在整个类中有效，如果被方法调用
  • 那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
  • 为了让不同的方法可以操作不同类型，而且类型还不确定
  • 那么可以将泛型定义在方法上
  • 特殊之处：
    • 静态方法不可以访问类上定义的泛型
    • 如果静态 方法操作的应用数据类型不确定，可以将泛型定义在方法上。

为什么静态方法不可以访问类上定义的泛型呢？

看下面的代码：

/*演示将泛型添加在静态方法上*/

class Demo<T>
{
	public<T> void show(T t)//该方法直接用的是类中的泛型，只能操作类上的泛型定义的数据
	{
		System.out.println("show.."+t);
	}
	public<Q> void print(Q q)//该方法用的是自己方法上的泛型，可以存在，可以操作多种类型的数据
	{
		System.out.println("print.."+q);
	}
	/*
	这个编译会失败，因为静态方法优先于对象存在，而方法中的泛型参数T，要等到new了对象才可以确定。
	public static void method(T t)
	{
		System.out.println("method.."+t);
	
	}
	*/

	//那么静态方法上的泛型应该怎么定义呢？
	//泛型写在修饰符后边，返回值类型前边

	public static<W> void method(W w)
	{
		System.out.println("method.."+w);
	}
}
public class GenericDemo4 {
	public static void main(String[] args) 
	{
		Demo.method("hahahahahah");
		Demo.method(new Integer(7));
	}
}

运行结果：

泛型定义在静态方法上

泛型定义在接口上

//泛型定义在接口上

/*

这是第一种方法，当类实现了接口之后，明确自己要对什么样的数据进行操作
interface Inter<T>
{
	public void show(T t);
}
class IntImpl implements Inter<String>//在实现的接口上写上类参数
{
	public void show(String t)
	{
		System.out.println(t);
	}
}
public class GrnericDemo5 {
	public static void main(String[] args) 
	{
		IntImpl i = new IntImpl();//new对象的时候就不用写泛型了，因为接口已经确定了泛性

		i.show("nihao");
	}
}
*/

//第二种方法，类实现了接口，但是要用什么泛型还不确定
interface Inter<T>
{
	public void show(T t);
}
class IntImpl<T> implements Inter<T>//类也和接口用一样的泛型
{
	public void show(T t)
	{
		System.out.println(t);
	}
}
public class GrnericDemo5 {
	public static void main(String[] args) 
	{
		
		IntImpl<String> i = new IntImpl<String>();//new对象的时候需要写泛型了，因为接口还没有确定泛性

		i.show("nihao");

		IntImpl<Integer> j = new IntImpl<Integer>();

		j.show(4);
	}
}

运行结果：

泛型类定义在接口上

泛型限定

//泛型限定

//要用一个迭代器取出同一种集合中（ArrayList），两个集合（al,al1）的元素，两个集合的对象类型不一样(Ingeter,String)。
import java.util.*;
public class GenericDemo6 {
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc1");
		al.add("abc2");
		al.add("abc3");


		ArrayList<Integer> al1 = new ArrayList<Integer>();

		al1.add(3);
		al1.add(5);
		al1.add(6);
		
		printColl(al);
		printColl(al1);
	}
	public static <T>void printColl(ArrayList<T> al)//静态泛型限定，记得在返回值前边加泛型限定
	{
		for (Iterator<T> it = al.iterator();it.hasNext() ; )
		{
			T t = it.next();
			System.out.println(t);
		}
	}
	/*
	printColl方法也可以这样写

	public static void printColl(ArrayList<?> al)//不确定什么类型的限定，所以用一个?（占位符）
	{
		for (Iterator<?> it = al.iterator();it.hasNext() ; )
		{
			System.out.println(it.next());
		}
	}
	*/
}

运行结果为：

用一个方法取出两个集合中的元素

？通配符：也可以理解为占位符
泛型的限定：
？extends E ：可以接收E类型或者E的子类型。上限
？ super E ：可以接收E类型或者E的父类型，下限

通过代码巩固一下：

//泛型限定

//需求：有Person类和Student类
//Student类继承了Person类
//将两个对象分别装进两个集合中，
//用一个方法将两个集合中的元素全取出来。
import java.util.*;
class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}
class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
	
}
public class GenericDemo6{
	public static void main(String[] args)
	{
		ArrayList<Student> al = new ArrayList<Student>();
		al.add(new Student("lisi01"));
		al.add(new Student("lisi02"));
		al.add(new Student("lisi03"));


		ArrayList<Person> al1 = new ArrayList<Person>();//原则，必须前后一致
		al1.add(new Person("lisi--01"));
		al1.add(new Person("lisi--02"));
		al1.add(new Person("lisi--03"));
		

		printColl(al);
		printColl(al1);
	}
	public static void printColl(ArrayList<? extends Person> al)//泛型限定为Person类他的子类。
	//也就是说，在这个打印集合元素的方法中，该方法只接收Person和他的子类对象
	{
		for (Iterator<? extends Person> it = al.iterator(); it.hasNext(); )//泛型限定必须上下一致
		{
			System.out.println(it.next().getName());
		}
	}
}

运行结果为：

泛型限定

在开发中，还是上限用的比较多一些，
下限使用起来的话，父类会一直延伸到Object类中，而Object类中的方法不是很多，所以总会报出来没有哪个哪个方法。建议使用上限（个人看法）

不管是上限还是下限，都要保证需要进来的元素是泛型类的子类，出于多态的原因，父类可以将子类接收进来。

下山打老虎◆
关注
专栏目录
Java 基础 —— 集合框架概述
IT__learning的博客
11-15 1627
集合框架图 Java 集合框架主要包括两种类型的容器：一种是集合（Collection），存储一个元素集合；另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型：List、Set 和 Queue。再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。 集合框架内容： 集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容： 1、
Java 基础 —— 集合框架
Genius only means hard-working all one's life.
04-23 307
Java 基础 —— 集合
Java基础——集合框架
千里之行，始于足下
03-08 1463
集合是用来存放数据的，大部分集合底层都是使用数组来进行实现的。但是数组有一个缺点，就是数组一旦初始化后，就无法改变数组的长度，那么我们在存放未知个数的数据的时候，数组就已经无法满足我们的需求了。 于是就有了集合，它的底层虽然是数组实现，但是却对底层数组进行了动态维护，使得集合可以动态进行扩容操作，而且提供公有的操作数组的方法，免去了使用索引下标在操作数组时而引起的各种问题。 集合主要有Collection和Map两种体系。
JAVA基础——集合框架
任长江
11-14 1232
一、概述：     集合框架从总体上可以认为它是一个容器，不同的集合框架可以利用相应的数据结构存放相应的数据。底层的数据结构大致分为如下几种：数组、链表、二叉树和哈希表等。根据各集合类间相应的所属关系，我画了如下的思维导图，下面依据思维导图对其中的相关类和接口做说明。 二、思维导图： 三、数据结构特点：     1、ArrayList底层的数据结构为数组结构，LinkedList底层的
Java基础——集合
最新发布
joker_0641的博客
07-04 429
在Java中，集合（Collection）是一种用于存储、检索和操作一组对象的数据结构。Java集合框架提供了一系列的接口和实现类，使得我们可以更高效地处理数据。Java集合框架提供了丰富的数据结构，能够满足各种场景下的需求。理解并熟练使用这些集合，对于提高我们的编程效率和代码质量有着重要的作用。二、Java集合框架概述。
JavaSE基础——集合框架
冰羽
07-31 196
JavaSE基础——集合框架 JavaSE基础——集合框架1 一、集合简介 二、集合框架简介 集合框架体系 集合框架的逻辑 三、Collection接口 Collection接口中的方法 Interator接口（迭代器） 2.1 迭代器简介 2.2 迭代器的方法 for-each循环遍历集合 JavaSE基础——集合框架2 四、List接口 List接口概述 ArrayList、LinkedList、Vector的异同
java——集合框架
Why_does_it_work的博客
06-24 3744
集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象下面是 Java 集合框架中所有的集合接口及其对应的特点，以表格形式展示：以上是 Java 集合框架中所有的集合接口及其对应的特点。在实际开发中，可以根据需求选择适合的集合类型来存储和处理数据。是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、
Java岗大厂面试百日冲刺 - 日积月累，每日三题【Day19】—— 集合框架3
热门推荐
陈哈哈的菜园子
07-05 1万+
百日闭关修炼，每日三道高频面试题。一起冲进大厂！看什么看？快上车！
JAVA——集合框架
爱学习的鱼的博客
07-21 198
【Java集合框架】01 ——集合框架（Collections Framework）
weixin_44735928的博客
07-30 1108
Java集合框架介绍
java集合——Java中的equals和hashCode方法详解
09-01
在Java编程语言中，`equals()` 和 `...总的来说，`equals()` 和 `hashCode()` 方法在Java集合框架中扮演着核心角色，它们共同确保了对象的比较和查找效率。理解和正确使用这两个方法是编写高效、健壮的Java代码的关键。
详解Java基础知识——JDBC
08-26
Java基础知识——JDBC Java DataBase Connectivity（JDBC）是一种用于执行SQL语句的Java API。JDBC提供了很多接口，然后不同数据库厂商去实现这个接口，以便降低操作数据的难度。 知识点一：JDBC的基本概念 *...
Java并发编程之——Amino框架
08-10
Amino框架是Java并发编程领域的一个工具，它旨在简化并发编程，提高程序的性能和可维护性。这篇博客文章可能详细探讨了Amino框架的设计理念、核心功能以及如何在实际项目中应用。 Amino框架可能提供了以下一些关键...
Java(JDK1.9)集合框架归纳总结——集合框架图与两个顶级接口
zhoucheng05_13的博客
04-06 1896
注：该系列文章总结自JDK1.9源码的文档注释和源码，我对源码的部分中文注释已经同步到Github：https://github.com/Dodozhou/JDK Java Collections Framework概述 Java集合框架继承图： Java集合框架由两个顶层接口衍生而出。这两个接口区别如下： Collection：保存一维列表，有数组和链表两种形式。 Map：保存二...
【狂神说笔记—— Java基础08-集合框架】
weixin_46055348的博客
07-10 707
【狂神说笔记—— Java基础08-集合框架】
Java基础——异常及处理方法
12345~
06-20 987
什么是异常？让我们先运行一段代码来理解 class Demo { int chuFa(int x,int y)//这是一个除法运算 { return x/y; } } public class ExceptionDemo { public static v
Java基础——IO流（四）
12345~
08-07 814
序列化对象将堆内存中的东西（对象）写到硬盘中ObjectOutputStream(OutputStream)中的writeObject方法可以将对象写入到硬盘中来 ObjectInputStream(InputStream)中的readObject方法可以将硬盘中的对象读取出来。先上手写程序： 先定义一个Per
Java基础——GUI概述
12345~
08-08 765
GUI图形用户界面GUI用户图形接口：用图形的方式，来显示计算机操作的界面，这样更方便更直观CLI命令行用户接口：就是常见的dos命令行操作，需要记忆一些常用的命令，操作不直观java为GUI提供的对象都存在java.Awt和javax.Swing两个包中Awt和Swing java.Awt抽象窗口工具包，需要调用
Java基础——其他类对象，IO流
12345~
07-30 762
System类System：类中的方法和属性都是静态的。 out：标准输出，默认是控制台 in ：标准输入，默认键盘描述系统的一些信息。获取系统属性信息：Propertise getPropertises();//获取系统信息的方法演示 import java.util.*; public class Syst
Java集合框架：List接口与ArrayList详解
Java的集合框架是Java平台提供的一种强大的数据管理工具，它主要由一组操作对象的接口组成，这些接口包括Collection、List、Map等，分别对应不同类型的数据结构。在这个框架中，List接口是一个关键的部分，其中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值