java泛型
01-泛型的引入
定义:是用泛型可以指代任意对象类型
引用泛型的作用:简化向上转型和向下转型
//泛型类要+<>,<>内的字母可以随意,但是一般都是用T(type)
public class test<T>
{
private T ob;
public T getob()
{
return ob;
}
public void setob(T ob)
{
this.ob=ob;
}
public static void main(String[] args)
{
//定义一个整形类型
CC<Integer> cc=new CC<Integer>();
CC<String> cc=new CC<String>();
}
}
02-限制泛型
有限制的,必须是继承自某个类的子类,不允许其他类型传进去,类似于一种安全机制
//父类Animal
public class Animal
{
public void print()
{
System.out.println("动物");
}
}
//子类Cat
public class Cat extends Animal
{
//改写父类的构造方法
public void print()
{
System.out.println("猫");
}
}
//限制泛型类,继承自Animal
public class Demo <T extends Animal>
{
private T ob;
//get set方法
public void setob(T ob)
{
this.ob=ob;
}
public T getob()
{
return ob;
}
//构造方法
public Demo(T ob)
{
super();
this.ob=ob;
}
}
//测试类
public class test()
{
public static void main(String[] args)
{
//这里只能是Animal类以及Animal的子类
Demo<Cat> demo=new Demo<Cat> (new Cat());
Cat cat=demo.getob();
cat.print();
//结果:猫
/*这样就会报错
Demo<Integer> demo=new Demo<Integer> (2);
*/
}
}
03-通配符泛型
特殊的场景下用到,具体看例子
import Cat;
import Demo;
import Animal;
public class Test
{
//传入的参数不确定,可以用通配符泛型“?”
private static void take(Demo<?> a)
{
a.print();
}
public static void main(String[] args)
{
Demo<Cat> demo=new Demo<Cat> (new Cat());
take(cat);
}
}
03-泛型方法
public class test
{
//泛型方法
public static <T> void function(T t)
{
System.out.println("T的类型是"+t.getClass().getName());
}
public static void main(String[] args)
{
function(1);
function("str");
}
}
java集合
01-集合的引入
用数组实现集合
public class Student
{
private Sting name;
public void setName(String name)
{
this.name=name;
}
public String getName()
{
return this.name;
}
public void Student(String name)
{
this.name=name;
}
public static void main(String[] args)
{
//可以用数组定义多个元素
//定义三个长度的数组对象
Student student[]=new Student[3];
Student s1=new Student("张三");
Student s2=new Student("李四");
Student s3=new Student("王五");
//缺点:长度固定死了,不方便
}
}
链表来实现集合
//用链表来实现集合
public static void main(String[] args)
{
Student s1=new Student("张三");
Student s2=new Student("李四");
Student s3=new Student("王五");
LinkedList<Student> list=new LinkedList<Student> ();
list.add(s1);
list.add(s2);
list.add(s3);
//遍历链表
for(int i=0;i<list.size();i++)
{
Student s=list.get(i);
System.out.pritln(s.getName());
}
}
02-List集合
List集合是Collection接口的子接口,也是最常用的接口。此接口对Collection接口进行了大量的扩展,List集合里的元素是允许重复的
ArrayList实现类(实现了List接口)
public class test
{
public static void main(String[] args)
{
//ArraryList有很多方法,具体看文档
ArraryList<String> al=new ArrayList<String>();
al.add("张三");
al.add("李四");
for(int i=0;i<ArrayList.size();i++)
{
Student s=list.get(i);
System.out.pritln(s.getName());
}
}
}
linkedList实现类
public class test
{
public static void main(String[] args)
{
linkedList<String> ll=new linkedList<String>();
ll.add("张三");
ll.add("李四");
printLinkedList(linkList);
}
}
03-集合的遍历
Iterator方法遍历集合
import Student;
public class test
{
public static void main(String[] args)
{
LinkedList<Student> list=new LinkedList<Student>();
//添加匿名Student类
list.add(new Student("张三"));
list.add(new Student("王五"));
Iterator<Student> it=list.iterator(); //返回的是一个迭代器、
while(it.hasNext()) //当迭代器类有元素
{
Student s=it.next(); //返回迭代的下一个元素
System.out.println(s.getName());
}
}
}
foreach方法遍历集合
import Student;
public class test
{
public static void main(String[] args)
{
LinkedList<Student> list=new LinkedList<Student>();
//添加匿名Student类
list.add(new Student("张三"));
list.add(new Student("王五"));
//list:集合元素
//Student s:每次循环的时候都指向这个变量
for(Student s:list)
{
System.out.println(s.getName());
}
}
}
04-set集合
set集合是Collection接口的子接口,没有对Collection接口进行扩展,里面不允许存在重复内容
HashSet类
public static void main(String[] args)
{
//HashSet是无序的(现在是有序的了)
//不循环重的值
HashSet<String> hs=new HashSet<String>();
hs.add("1");
hs.add("2");
hs.add("3");
hs.add("1");
hs.add("4");
Iterator<String> it=hs.iterator();
while(it.hasNext)
{
String next=it.next();
System.out.println(next);
//打印出来的结果是无序的!
//3124...
}
}
05-Map集合
是存放一对值的最大接口,即接口中的每一个元素都是一对,以key->value键值对的形式保存
HashMap类
import Student;
public class test
{
HashMap<String,Student> hh=new HashMap<String,Student>();
hh.put("1号",new Student("张三"));
hh.put("2号",new Student("李四"));
//通过key获取value
Student s=hh.get("1号");
//获取key集合,再获取迭代器
Interator<String> it=hh.keySet().interator();
while(it.hasNext())
{
String key=it.next();
Student s=hh.get(key);
}
}