- 概述
泛型在java中有很重要的地位,在面向对象编程及各种设计模式中有非常广泛的应用。
什么是泛型?为什么要使用泛型?
泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。
泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。
泛型示例,顺便讲解Collections工具类
package Z.Kbzl.jihe.zuoye;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
public class Collections01 {
public static void main(String[] args) {
//Collection 集合接口基类、集合接口超类
//Collections 工具类、 提供很多集合常用的方法
List<Integer> list=new ArrayList<Integer>();
//所谓泛型就是集合后面的<>里给定一个具体参数化类型
list.add(100);
list.add(300);
list.add(200);
list.add(500);
list.add(400);
list.add(250);
Collections.sort(list);//Collections.sort是升序
for(Integer in:list) {//高级for打印
System.out.println(in);
}
System.out.println(" ");
Collections.reverse(list);//Collections.reverse是反序,反转
for(Integer in:list) {
System.out.println(in);
}
//非线程安全list------->线程安全list
list=Collections.synchronizedList(list);
//非线程安全map------->线程安全map
Collections.synchronizedMap(new HashMap());
}
}
500
400
300
250
200
100
{/collapse-item}
HashSet集合
package Z.Kbzl.jihe.zuoye;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Hashset01 {
public static void main(String[] args) {
//set是无序的,不能存放重复的数据,(通常使用它来去重)
Set<String> set=new HashSet<String>();//泛型HashSet
set.add("小冯");//存
set.add("小冯");
set.add("小冯");
set.add("小赵");
set.add("小赵");
set.add("小赵");
set.add("小张");
set.add("小张");
System.out.println(set.size());//判断长度,3个,因为把重复的数据去除了,删掉了
System.out.println(set.isEmpty());//判断是否为空
//第一种打印方式是增强for
for(String i:set){//<String>泛型方法
System.out.println(i);//循环打印结果,并且是无序的
}
System.out.println(" ");//分割线
//第二种打印方式是迭代器
//但是一般通常使用迭代器
Iterator<String> it=set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
小张
小冯
小赵
{/collapse-item}
ok,泛型和HashSet讲完了.
然后再做三道题就行.
我们做程序员的一定要多敲多练,把代码放在第一位.

要做到代码第一,代码第二,女票第三. 
package Z.Kbzl.jihe.zuoye;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;
public class QQ {
public static void main(String[] args) {
String[] strs = {"12345","67891","12347809933","98765432102","67891","12347809933"};
//第一种方法
LinkedList<String> list=new LinkedList<String>();
for (int i = 0; i < strs.length; i++) {
if(!list.contains(strs[i])) {//判断list集合里包含strs数组里有重复的就没进if
list.add(strs[i]);
}
}
for(String i:list) {//增强for打印
System.out.println(i);
}
System.out.println(" ");//分割线
Iterator<String> it = list.iterator();//Iterator 迭代器
while (it.hasNext()){//hasNext判断有没有,有就取
System.out.println(it.next());
}
//第二种方法
Set<String> set = new HashSet<String>();//Set自动去重
for (int i = 0; i < strs.length; i++) {
set.add(strs[i]);
}
LinkedList<String> linkedList = new LinkedList<>(set);//强转set
//foreach 增强for
for (String s : linkedList){
System.out.println(s);
}
System.out.println(" ");
//iterator 迭代器
Iterator<String> it = linkedList.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}
打印结果自己拿去运行.
看不懂不要紧,慢慢理解.

package Z.Kbzl.jihe.zuoye;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Random1 {
public static void main(String[] args) {
Random r=new Random();//随机数
ArrayList<int[]> ran=new ArrayList<int[]>();//泛型int数组
List list=new ArrayList();//集合
int a[]=new int[10];
for (int i = 0; i <a.length; i++) {
ran.add(a);//把数组放到集合中
a[i]= r.nextInt((99)+1);//给数组里存放1-100的随机数
}
for(int i:a) {
if(i>=10) {//把大于等于10的数字放到list集合中
list.add(i);
}
}
for(Object i:list) {//循环打印
System.out.println(i);
}
System.out.print("一共有:");
System.out.println(list.size());
}
}
打印结果自己试.
package Z.Kbzl.jihe.zuoye;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
public class Ball {
public static void main(String[] args) {
Random r=new Random();//随机数
List<Integer> list1=new ArrayList<>();//泛型 包装类 Integer
HashSet<Integer> set1=new HashSet<>();//去重集合
while(set1.size()<6) {//存放随机数
int i=r.nextInt(32)+1;
set1.add(i);
}
list1.addAll(set1);//添加所有
Collections.sort(list1);//升序
System.out.println("红球:"+list1);
int i=r.nextInt(15)+1;
System.out.println("蓝球:"+i);
}
}
学累了吧?这个是编程小姐姐
,送给你们.

泛型的好处:
编译时的严格类型检查。
消除了绝大多数的类型转换。
//例:使用 ArrayList<E>
ArrayList<String> list = new ArrayList<String>();
//只能添加String类型数据
list.add(“黎明”);
String name= list.get(0);//不需要做类型转换
最后别忘了去看看思维导图.
本文共 1125 个字数,平均阅读时长 ≈ 3分钟
评论 (0)