泛型
泛型的定义
import java.util.ArrayList;
import java.util.Collection;
//泛型
/*
泛型:是JDK5中引入的特性,它提供了编译时类型安全检测机制,该机制允许在编译时检测到非法的类型,它的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
一提到参数,最熟悉的就是定义方法时有形参,调用方法时传递实参,那么参数化类型怎么解释呢?顾名思义,就是将类型由原来的具体的类型参数化,然后在使用/调用时传入具体的类型,这种参数类型可以在类、方法和接口中,分别被成为泛型类、泛型接口、泛型方法
泛型定义格式
- <类型>:指定一直类型的格式,这里的类可以看作的形参
- <类型1,类型2....>:指定多种类型的格式,多种类型之间用逗号隔开
- 将来具体调用时候给的类型可以看出是实参,并且实参的类型只能是引用数据类型。
*/
public class Demo01 {
public static void main(String[] args) {
//创建一个对象
Collection c=new ArrayList();
c.add(12);
c.add("yang");
for (Object o:c){
System.out.println(o);
}
}
}
泛型类
//泛型类
/*
定义格式:修饰符 class 类名<类型>{}
范例:
public class Generic<T>{}
*/
public class GenericClass {
public static void main(String[] args) {
Generic<String> g=new Generic();
Generic<Integer> g1=new Generic();
g.setT("String,");
g1.setT(11);
System.out.println(g.getT()+g1.getT());
}
}
class Generic <T>{//定义一个泛型类
private T t;
public Generic() {
}
public Generic(T t) {
this.t = t;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
泛型方法
//泛型方法
/*
定义格式
-格式:修饰符<类型> 返回值类型 方法名(类型 变量名){}
-范例:public<T> void show(T t){}
*/
public class GenericMethod {
public static void main(String[] args) {
Generic2 g=new Generic2();
g.show("one");
g.show(1);
g.show(11.1);
}
}
class Generic2{
public<T> void show(T t){
System.out.println(t);
}
}
泛型接口
自定义泛型接口
//泛型类实现泛型接口
public class GenericClass<T> implements Generic<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
接口实现类
//泛型类实现泛型接口
public class GenericClass<T> implements Generic<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
main方法
//泛型接口
/*
定义格式:修饰符 interface 接口名<类型>{}
范例: public interface Generic<T>{}
*/
public class Test {
public static void main(String[] args) {
//创建对象
Generic<String> g1=new GenericClass<>();
Generic<Integer> g2=new GenericClass<>();
//调用方法
g1.show("one");
g2.show(111);
}
}
类型通配符
import java.util.ArrayList;
import java.util.List;
//类型通配符
/*
类型通配符:<?>
List<?>:表示元素位置类型的List。它的元素可以匹配任意类型
这种带通配符 List仅表示它是各种泛型List的父类,并不能把元素添加到其中
类型通配符上限:<? extends 类型>
List<? extends Number>:表示的是类型是Number或者其子类型
类型通配符下线:<? super 类型>
List<? super Number>:它表示的类型是Number或者其父类
*/
public class Demo01 {
public static void main(String[] args) {
//类型通配符
List<?> list1=new ArrayList<Number>();
List<?> list2=new ArrayList<String>();
List<?> list3=new ArrayList<Integer>();
List<?> list4=new ArrayList<Object>();
// 类型通配符上限:<? extends 类型>
List<? extends Number> list5=new ArrayList<Number>();
//List<? extends Number> list6=new ArrayList<Object>();超过了上限
List<? extends Number> list7=new ArrayList<Number>();
//类型通配符下线:<? super 类型>
List<? super Number> list8=new ArrayList<Number>();
List<? super Number> list9=new ArrayList<Object>();
// List<? super Number> list10=new ArrayList<Integer>();//超过了下限
}
}
Map类
Map集合概述
import java.util.HashMap;
import java.util.Map;
/*
Map集合概述
Interface Map<K,V> K:键的类型 V:值的类型
将键映射到值的对象;不能包含重复的键,每个键可以映射到最多一个值
举例:学生的学号和姓名
2020001 one
2020002 two
2020003 three
创建Map集合的对象
多态的方式
具体的实现类HashMap
*/
public class Demo01 {
public static void main(String[] args) {
//创建集合对象
Map<Integer,String> map=new HashMap<>();
//添加元素
map.put(2020001,"one");
map.put(2020002,"two");
map.put(2020003,"three");
map.put(2020003,"threeII");
//输出
System.out.println(map);
}
}
Map集合的基本功能
import java.util.HashMap;
import java.util.Map;
//Map集合的基本功能
/*
1.V put(K key,V value) 添加元素
2.V remove(Object Key) 根据键删除键值对应元素
3.void clear() 移除所有的键对应值
4.boolean containsKey(Object Key) 判断集合是否包含指定的键
5.boolean isEmpty() 判断集合是否为空
6.int size() 集合的长度,也就是集合中键值对的个数
*/
public class Demo02 {
public static void main(String[] args) {
//创建集合对象
Map<Integer,String> map=new HashMap<>();
//添加元素
map.put(001,"yang");
map.put(002,"sheng");
map.put(003,"jie");
// map.remove(001);
// map.clear();
// System.out.println(map.containsKey(001));
// System.out.println(map.containsValue("sheng"));
System.out.println("集合的长度:"+map.size());
//输出集合
System.out.println(map);
}
}
Map集合的获取功能
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//Map集合的获取功能
/*
1.V get (Object key) 根据键获取值
2.Set<K> keySet() 获取所有键的集合
3.Collection<V> values() 获取所有值的集合
4.Set<Map.Entry<K,V> entrySet() 获取所有键值对对象的集合(以后学习)
*/
public class Demo03 {
public static void main(String[] args) {
//创建一个集合对象
Map<Integer,String> map=new HashMap<>();
//给集合添加元素
map.put(1,"one");
map.put(2,"two");
map.put(3,"three");
//V get (Object key) 根据键获取值
System.out.println(map.get(1));
System.out.println(map.get(2));
System.out.println(map.get(3));
//Set<K> keySet() 获取所有键的集合
Set<Integer> integers = map.keySet();
System.out.println(integers);
//Collection<V> values() 获取所有值的集合
Collection<String> values = map.values();
System.out.println(values);
}
}
Map集合的遍历方式(一)
import java.util.HashMap;
import java.util.Map;
//Map集合遍历的方式(一)
/*
1.得到所有主键的集合,用keySet()方法
2.用增强for遍历
3.用主键找对应的值,用get(Object key)
*/
public class Demo04 {
public static void main(String[] args) {
//创建一个map集合
Map<String,String> map=new HashMap<>();
//给map集合添加元素
map.put("one","ONE");
map.put("two","TWO");
map.put("three","THREE");
//遍历所有元素
for (String s:map.keySet()){
System.out.println(s+map.get(s));
}
}
}
Map集合 遍历方式(二)
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import static javafx.scene.input.KeyCode.M;
//Map集合的遍历方式二
/*转换为Map集合中的操作
1.获取所有键值对象的集合
Set<Map.Entry<K,V>> entrySet();获取所有键值对象的集合
2.遍历键值对对象的集合,得到每一个键值对的对象
用增强for实现,得到每一个Map.Entry
3.根据键值对对象获取键和值
用getKey()得到键
用getValue()得到值
*/
public class Demo05 {
public static void main(String[] args) {
//创建一个Map集合
Map<String,String> map=new HashMap<>();
//添加元素
map.put("one","ONE");
map.put("two","TWO");
map.put("three","THREE");
//获取键值对对象的集合
Set<Map.Entry<String, String>> entries = map.entrySet();
//用增强for遍历
for (Map.Entry<String, String> me:entries){
System.out.println(me.getKey()+","+me.getValue());
}
}
}
案例1
main方法
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//案例:HashMap集合存储学生对象并遍历
/*
需求:创建一个HashMap集合,键是学生(String),值是学生对象(Student)存储三个键值对元素
*/
public class Test {
public static void main(String[] args) {
//创建一个HashMap集合
HashMap<String,Student> hashMap=new HashMap<>();
//创建学生对象
Student s1 = new Student("one.name", 1);
Student s2 = new Student("two.name", 2);
Student s3 = new Student("three.name", 3);
//把学生对象添加进元素
hashMap.put("001",s1);
hashMap.put("002",s2);
hashMap.put("003",s3);
//用entrySet方法遍历
Set<Map.Entry<String, Student>> entries = hashMap.entrySet();
for (Map.Entry<String,Student> me:entries){
System.out.println(me.getKey()+","+me.getValue().getName()+","+me.getValue().getAge());
}
//用keySet()方法遍历
Set<String> keySet = hashMap.keySet();
for (String s:keySet){
System.out.println(s+","+hashMap.get(s).getName()+","+hashMap.get(s).getAge());
}
}
}
学生类
//自定义学生类
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
案例2
main方法
//案例:HashMap集合才能出学生对象并遍历
/*
需求:创建一个HashMap集合,键(Student)是学生对象,值(String)是居住地,存储多个键值对元素并遍历。
要求保证键的唯一性:如果学生对象的成员变量值相同,我们就认为是同一个对象。
*/
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test {
public static void main(String[] args) {
//创建一个HashMap集合
HashMap<Student,String> hm=new HashMap<>();
//创建学生对象
Student s1=new Student("one.name",11);
Student s2=new Student("two.name",22);
Student s3=new Student("three.name",33);
Student s4=new Student("three.name",33);
//添加学生对象到元素中去
//以为要判断主键是否相同,所以在学术类中重写hashCode()和equals()方法
hm.put(s1,"one.address");
hm.put(s2,"two.address");
hm.put(s3,"three.address");
hm.put(s4,"four.address");
//用keySet()遍历
Set<Student> ks = hm.keySet();
for (Student s:ks){
System.out.println(s.getName()+","+s.getAge()+","+hm.get(s));
}
System.out.println("==============");
//用entrySet()存储键值对对象进行遍历
Set<Map.Entry<Student, String>> entries = hm.entrySet();
for (Map.Entry<Student, String> me:entries){
Student s=me.getKey();
String s5=me.getValue();
System.out.println(s.getName()+","+s.getAge()+","+s5);
}
}
}
学生类
//自定义学生类
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
案例3
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*案例:ArrayList集合存储HashMap元素并遍历
需求:创建一个ArrayList集合,存储三个元素,每一个都是HashMap,每一个HashMap的键和值都是String,并遍历
*/
public class Test {
public static void main(String[] args) {
//创建一个ArrayList集合
ArrayList<HashMap<String,String>> array=new ArrayList();
array.size();
//创建三个HashMap元素
HashMap<String,String> hm1=new HashMap<>();
HashMap<String,String> hm2=new HashMap<>();
HashMap<String,String> hm3=new HashMap<>();
hm1.put("111","111");
hm1.put("222","111");
hm1.put("333","111");
hm2.put("111","111");
hm2.put("222","111");
hm2.put("333","111");
hm3.put("111","111");
hm3.put("222","111");
hm3.put("33aaa3","111");
//放入集合中
array.add(hm1);
array.add(hm2);
array.add(hm3);
//遍历需要两层
for (HashMap<String,String> hm:array){
Set<Map.Entry<String, String>> entries = hm.entrySet();
for (Map.Entry<String, String> me:entries){
String key = me.getKey();
String value = me.getValue();
System.out.println(key+value);
}
System.out.println("==========");
}
}
}
案例4
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//案例4:HashMap集合存储ArrayList元素并遍历
//需求:创建一个HashMap集合,存储三个键值对元素,每一个键值对元素的键是String,值是ArrayList
public class Test {
public static void main(String[] args) {
//创建一个HashMap集合对象
HashMap<String, ArrayList<String>> hm=new HashMap<>();
//创建ArrayList对象作为元素
ArrayList<String> a1=new ArrayList();
ArrayList<String> a2=new ArrayList();
ArrayList<String> a3=new ArrayList();
a1.add("aaaa");
a1.add("bbbb");
a1.add("cccc");
a2.add("dddd");
a2.add("eeee");
a2.add("ffff");
a3.add("ggg");
a3.add("hhhh");
a3.add("iiii");
//把ArrayList添加到HashMap
hm.put("111111",a1);
hm.put("222222",a2);
hm.put("333333",a3);
//遍历
//创建键值对对象集合
Set<Map.Entry<String, ArrayList<String>>> entries = hm.entrySet();
for (Map.Entry<String, ArrayList<String>> me:entries){
ArrayList<String> value = me.getValue();
String key = me.getKey();
System.out.println();
System.out.print(key+" ");
for (String s:value){
System.out.print(s+" ");
}
System.out.println();
}
}
}