`

黑马程序员18-3：各种集合泛型的方法接收传递参数类型的，以及通配符的使用

java集合泛型 
阅读更多

------- android培训 、java培训、期待与您交流！------- 



package cn.itcast.p5.generic.advance.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class GenericAdvanceDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ArrayList<String> al = new ArrayList<String>();
		
		al.add("abc");
		al.add("hehe");
		
		ArrayList<Integer> al2 = new ArrayList<Integer>();
		
		al2.add(5);
		al2.add(67);
		
		printCollection(al);
		printCollection(al2);
	}

	/**
	 * 迭代并打印集合中元素。
	 * @param al
	 */
	//!!!接受任意类型参数的集合方法写法，通配符，printCollection(Collection<?> al)
	public static void printCollection(Collection<?> al) {	
	
		Iterator<?> it = al.iterator();
		
		while(it.hasNext()){
//			T str = it.next();
//			System.out.println(str);
			System.out.println(it.next().toString());
		}
		
	}

}



package cn.itcast.p5.generic.advance.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import cn.itcast.p2.bean.Person;
import cn.itcast.p2.bean.Student;
import cn.itcast.p2.bean.Worker;

public class GenericAdvanceDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ArrayList<Person> al = new ArrayList<Person>();
		
		al.add(new Person("abc",30));
		al.add(new Person("abc4",34));
		
		ArrayList<Student> al2 = new ArrayList<Student>();
		
		al2.add(new Student("stu1",11));
		al2.add(new Student("stu2",22));
		ArrayList<String> al3 = new ArrayList<String>();
		
		al3.add("stu3331");
		al3.add("stu33332");
		
		printCollection(al2);
		printCollection(al);
	}

	/**
	 * 迭代并打印集合中元素。
	 * 
	 * 可以对类型进行限定：
	 * ? extends E:接收E类型或者E的子类型对象。上限（上面封顶，从封顶处无限往下）！，用的多
	 * 
	 * ? super E ：接收E类型或者E的父类型。下限（下面封顶，从封顶处无限往上）！
	 * @param al
	 */
	//！！！！！！！只接受继承某父类的子类，其他的都不接受，这样做的好处可以对接受类型进行限定
	//如果写extends Object就可以接受所有的类型
	/*public static void printCollection(Collection<? extends Person> al) {//Collection<Dog> al = new ArrayList<Dog>()
		Iterator<? extends Person> it = al.iterator();
		
		while(it.hasNext()){
//			T str = it.next();
//			System.out.println(str);
//			System.out.println(it.next().toString());
			Person p = it.next();
			
			System.out.println(p.getName()+":"+p.getAge());
		}
	}*/
	//！！！！只能接受自己类型和父类
	public static void printCollection(Collection<? super Student> al){
		Iterator<? super Student> it = al.iterator();
		
		while(it.hasNext()){
			
			System.out.println(it.next());
		}
	}
}



package cn.itcast.p5.generic.advance.demo;

import java.util.ArrayList;

import cn.itcast.p2.bean.Person;
import cn.itcast.p2.bean.Student;
import cn.itcast.p2.bean.Worker;

public class GenericAdvanceDemo3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ArrayList<Person> al1 = new ArrayList<Person>();	
		al1.add(new Person("abc",30));
		al1.add(new Person("abc4",34));
		
		ArrayList<Student> al2 = new ArrayList<Student>();
		
		al2.add(new Student("stu1",11));
		al2.add(new Student("stu2",22));
	
		ArrayList<Worker> al3 = new ArrayList<Worker>();
		
		al3.add(new Worker("stu1",11));
		al3.add(new Worker("stu2",22));
		
		ArrayList<String> al4 = new ArrayList<String>();
		al4.add("abcdeef");
//		al1.addAll(al4);//错误，类型不匹配。	
		al1.addAll(al2);
		al1.addAll(al3);	
		System.out.println(al1.size());
	
//		printCollection(al2);
//		printCollection(al);
	}
}

/*
 * 一般在存储元素的时候都是用上限，因为这样取出都是按照上限类型来运算的。不会出现类型安全隐患。 
 * 
 */

class MyCollection<E>{
	public void add(E e){
	
	}
	//！！！能够接受E及其子类
	public void addAll(MyCollection<? extends E> e){
		
	}
}



package cn.itcast.p5.generic.advance.demo;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

import cn.itcast.p2.bean.Person;
import cn.itcast.p2.bean.Student;
import cn.itcast.p2.bean.Worker;

public class GenericAdvanceDemo4 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		TreeSet<Person> al1 = new TreeSet<Person>(new CompByName());
		
		al1.add(new Person("abc4",34));
		al1.add(new Person("abc1",30));
		al1.add(new Person("abc2",38));
		//！！！！！默认构造方法中，Tree(Comparator<? super Student> comp);因此，可以用与Person一致的方法接受
		TreeSet<Student> al2 = new TreeSet<Student>(new CompByName());
		
		al2.add(new Student("stu1",11));
		al2.add(new Student("stu7",20));
		al2.add(new Student("stu2",22));

		TreeSet<Worker> al3 = new TreeSet<Worker>();
		
		al3.add(new Worker("stu1",11));
		al3.add(new Worker("stu2",22));
		
		TreeSet<String> al4 = new TreeSet<String>();
		al4.add("abcdeef");
//		al1.addAll(al4);//错误，类型不匹配。
		
//		al1.addAll(al2);
//		al1.addAll(al3);
		
//		System.out.println(al1.size());

		Iterator<Student> it = al2.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		
	}
}


/*
 * class TreeSet<Worker>
 * {
 * 		Tree(Comparator<? super Worker> comp);
 * }
 * ！！！重点看这个TreeSet中有这个构造函数用来比较，因此具备了Comparator直接使用父类接受一切子类的情况
 * 什么时候用下限呢？通常对集合中的元素进行取出操作时，可以是用下限。
 * 
 */

class CompByName implements Comparator<Person>{

	@Override
	public int compare(Person o1, Person o2) {
		
		int temp = o1.getName().compareTo(o2.getName());
		
		return temp==0? o1.getAge()-o2.getAge():temp;
	}
	
}

class CompByStuName implements Comparator<Student>{

	@Override
	public int compare(Student o1, Student o2) {
		
		int temp = o1.getName().compareTo(o2.getName());
		
		return temp==0? o1.getAge()-o2.getAge():temp;
	}
	
}

class CompByWorkerName implements Comparator<Worker>{

	@Override
	public int compare(Worker o1, Worker o2) {
		
		int temp = o1.getName().compareTo(o2.getName());
		
		return temp==0? o1.getAge()-o2.getAge():temp;
	}
	
}



package cn.itcast.p5.generic.advance.demo;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

import cn.itcast.p2.bean.Person;
import cn.itcast.p2.bean.Student;
import cn.itcast.p2.bean.Worker;

public class GenericAdvanceDemo4 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		TreeSet<Person> al1 = new TreeSet<Person>(new CompByName());
		
		al1.add(new Person("abc4",34));
		al1.add(new Person("abc1",30));
		al1.add(new Person("abc2",38));
		//！！！！！默认构造方法中，Tree(Comparator<? super Student> comp);因此，可以用与Person一致的方法接受
		TreeSet<Student> al2 = new TreeSet<Student>(new CompByName());
		
		al2.add(new Student("stu1",11));
		al2.add(new Student("stu7",20));
		al2.add(new Student("stu2",22));

		TreeSet<Worker> al3 = new TreeSet<Worker>();
		
		al3.add(new Worker("stu1",11));
		al3.add(new Worker("stu2",22));
		
		TreeSet<String> al4 = new TreeSet<String>();
		al4.add("abcdeef");
//		al1.addAll(al4);//错误，类型不匹配。
		
//		al1.addAll(al2);
//		al1.addAll(al3);
		
//		System.out.println(al1.size());

		Iterator<Student> it = al2.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		
	}
}


/*
 * class TreeSet<Worker>
 * {
 * 		Tree(Comparator<? super Worker> comp);
 * }
 * ！！！重点看这个TreeSet中有这个构造函数用来比较，因此具备了Comparator直接使用父类接受一切子类的情况
 * 什么时候用下限呢？通常对集合中的元素进行取出操作时，可以是用下限。
 * 
 */

class CompByName implements Comparator<Person>{

	@Override
	public int compare(Person o1, Person o2) {
		
		int temp = o1.getName().compareTo(o2.getName());
		
		return temp==0? o1.getAge()-o2.getAge():temp;
	}
	
}

class CompByStuName implements Comparator<Student>{

	@Override
	public int compare(Student o1, Student o2) {
		
		int temp = o1.getName().compareTo(o2.getName());
		
		return temp==0? o1.getAge()-o2.getAge():temp;
	}
	
}

class CompByWorkerName implements Comparator<Worker>{

	@Override
	public int compare(Worker o1, Worker o2) {
		
		int temp = o1.getName().compareTo(o2.getName());
		
		return temp==0? o1.getAge()-o2.getAge():temp;
	}
	
}

------- android培训 、java培训、期待与您交流！-------


详细请查看：http://edu.csdn.net/heima -------

分享到：
| 黑马程序员18-2：自定义泛型类、方法
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    黑马程序员----泛型学习注意点

    黑马程序员提供的这篇关于泛型的学习注意点，结合了源码分析和工具应用，旨在帮助开发者深入理解并有效运用泛型。下面将详细阐述泛型的主要知识点： 1. 泛型的基本概念： 泛型是Java SE 5.0引入的新特性，主要用于...

    Java试题-3：反射和泛型的综合应用

    Java试题-3：反射和泛型的综合应用 Java反射 泛型都是比较高级的应用技术

    黑马程序员----泛型与反射的小运用

    泛型的基本语法是在类、接口或方法声明前加上尖括号`&lt;&gt;`，并在其中指定一个或多个类型参数。例如，一个简单的泛型列表类可以定义为`List&lt;T&gt;`，其中`T`就是类型参数，代表任意类型。使用泛型，我们可以创建一个能够...

    泛型讲解 类型通配符

    3. 限制：不能向类型通配符集合中添加元素，因为不知道集合里的元素类型。 泛型方法： 1. 定义：使用类型形参定义的方法，例如 `public static void test(List&lt;T&gt; c){...}` 2. 优点：可以使得方法更加通用和可重用...

    29-API-集合框架-泛型-使用_java_

    它允许程序员在定义类、接口和方法时指定参数类型，从而在编译阶段就能进行类型检查，提高代码的可读性和可维护性。 在Java集合框架中，泛型的应用尤其广泛。集合框架是Java中用于存储和操作对象的核心组件，包括...

    java-generic.rar_泛型

    3. **泛型接口**：类似于泛型类，泛型接口也可以包含类型参数，使接口的方法可以操作参数化的类型。例如，`Comparator&lt;T&gt;` 接口用于比较两个对象，`T` 是要比较的对象类型。 4. **泛型方法**：泛型方法是定义在类或...

    Generic_2(泛型类-泛型方法-泛型接口-泛型限定(上限)

    这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”...

    Java语言 泛型讲解案例代码 （泛型类、泛型接口、泛型方法、无界及上下限通配符、泛型对协变和逆变的支持、类型擦除 ...）

    类型通配符：展示如何使用类型通配符来增加灵活性，以及如何进行类型边界约束。 泛型接口：演示如何定义和实现泛型接口，并通过示例代码展示泛型接口的应用。 希望这个代码资源能够帮助你更好地理解和应用Java中的...

    集合与泛型

    - **类型参数使用**：类型参数可以在类或接口的任何地方使用，例如方法签名、字段类型等。这使得开发者能够在运行时确定实际的类型。 #### 类型参数 - **命名习惯**：类型参数的命名一般采用单个大写字母，如`T`...

    Java泛型_Java中的泛型结构_

    Java泛型是Java编程语言中一个强大的特性，它允许在定义类、接口和方法时使用类型参数，从而实现参数化类型。泛型的主要目标是提高代码的类型安全性和重用性，减少类型转换的麻烦，并在编译时捕获可能的类型错误。...

    .NETC#汇总 -集合、异常、泛型.rar

    .NET框架中的C#语言在开发过程中提供了丰富的特性，如集合、异常处理以及泛型，这些都是构建高效、可维护代码的关键工具。在这个`.NETC#汇总 -集合、异常、泛型.rar`压缩包中，主要讨论了这三个核心概念，特别是泛型...

    jdk1.5的泛型实现

    泛型允许我们在定义类、接口和方法时声明参数化类型，这样在编译时期就能捕获类型错误，而不是等到运行时。这种特性在面向对象编程中扮演着关键角色，尤其是在集合框架的使用上。 1. 泛型的基本概念： - 类型参数...

    Java-Generics-and-Collections-Example:Java泛型和集合的示例

    在"Java-Generics-and-Collections-Example-master"这个压缩包中，可能包含了各种关于Java泛型和集合的实例代码，如创建和操作泛型集合、遍历和搜索元素、使用泛型方法等。通过研究这些示例，开发者可以深入理解这两...

    关于java基础的泛型的练习

    - 静态方法如果需要处理泛型，可以使用类型参数或者通配符。 10. 泛型和数组： - 由于历史原因，Java不支持泛型数组的直接创建，如`new MyList[5]`是非法的。 - 可以通过类型安全的工厂方法或运行时转型解决这个...

    java 泛型方法使用示例

    泛型方法是一种具有类型参数的方法，这些类型参数可以在方法声明时指定，并在方法体内部使用。与类的泛型类似，它们提供了编译时类型检查，防止了不兼容类型的对象被传递，同时消除了强制类型转换的需要。 **二、...

    黑马程序员面试宝典(java)2018版

    - 泛型的基本概念：了解类型参数、边界、通配符等泛型特性。 - 泛型方法和泛型类：编写和使用泛型方法及泛型类的技巧。 6. **IO流** - 文件操作：File类的使用，以及FileReader/Writer、FileInputStream/...

    C#泛型集合使用实例

    泛型集合提供了一种高效且灵活的方式来处理各种类型的数据，同时保持了编译时的类型检查。下面将详细探讨C#泛型集合的使用及其相关知识点。 1. **泛型接口与类** C#中的泛型接口如`IEnumerable&lt;T&gt;`和泛型类如`List...

    JAVA-泛型课件-泛型课件

    泛型，即参数化类型（Parameterized Types），是允许在定义类、接口和方法时使用类型参数的特性。在创建类、接口或方法的时候，可以用一个或多个类型作为参数。泛型的关键在于类型参数化，这意味着可以将操作的数据...

Magicbox
Global site tag (gtag.js) - Google Analytics