泛型、MAP集合
/** * */ package com.qfedu.Day18.HomeWork; public abstract class Animal { private int tui; public int getTui() { return tui; } public void setTui(int tui) { this.tui = tui; } public Animal(int tui) { super(); this.tui = tui; } public Animal() { super(); // TODO Auto-generated constructor stub } } /** * */ package com.qfedu.Day18.HomeWork; public class Cat extends Animal { /** * @param tui */ public Cat(int tui) { super(tui); // TODO Auto-generated constructor stub } /** * */ public Cat() { // TODO Auto-generated constructor stub } } /** * */ package com.qfedu.Day18.HomeWork; public class Fish extends Animal{ //子类是无法继承父类的构造方法的 //子类必须提供自己的构造方法 public Fish() { //调用父类的无参构造方法 super(); } public Fish(int tui) { super(tui); // 调用类父类的有参构造方法 } } /** * */ package com.qfedu.Day18.HomeWork; public class QQ extends Animal { /** * @param tui */ public QQ(int tui) { super(tui); // TODO Auto-generated constructor stub } /** * */ public QQ() { // TODO Auto-generated constructor stub } } /** * */ package com.qfedu.Day18.HomeWork; /** * Description： 创建自定义异常<br/> * Copyright (c) , 2018, JK <br/> * This program is protected by copyright laws. <br/> * Program Name:TUIException.java <br/> * * @author 千锋智哥 * @version : 1.0 * 继承Exception --> 编译时异常 --> 在书写代码调用方法或其他的属性时就会出现异常信息,必须处理 * try...catch...finally throws * 继承RuntimeException -->运行时异常 在程序运行以后,才会出现的异常 出现异常之后,可以捕捉也继续抛出 */ public class TUIException extends Exception{ /** * 区分JdK版本号使用 --> 对象流 */ private static final long serialVersionUID = -2974291582387079751L; public TUIException() { super(); // TODO Auto-generated constructor stub } public TUIException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { super(message, cause, enableSuppression, writableStackTrace); // TODO Auto-generated constructor stub } public TUIException(String message, Throwable cause) { super(message, cause); // TODO Auto-generated constructor stub } public TUIException(String message) { super(message); // TODO Auto-generated constructor stub } public TUIException(Throwable cause) { super(cause); // TODO Auto-generated constructor stub } } /** * */ package com.qfedu.Day18.HomeWork; public class AnimalFactory { private AnimalFactory() {} public static Animal getAnimal(int tui,String AnimalName) { switch (AnimalName) { case "猫": return new Cat(tui); case "鱼": return new Fish(tui); case "企鹅": return new QQ(tui); default: throw new RuntimeException("没有这种动物"); } } } /** * */ package com.qfedu.Day18.HomeWork; import java.util.HashSet; import java.util.Scanner; import java.util.Set; public class AnimalManagerSystem { public static void main(String[] args) { Scanner input = new Scanner(System.in); Set set = new HashSet(); while(true) { System.out.println("请输入您要添加的动物:"); String name = input.next(); System.out.println("请输入退的个数:"); int tui = input.nextInt(); //通过工厂就能的到对象 try { Animal animal = AnimalFactory.getAnimal(tui, name); addAnimal(animal); set.add(animal); System.out.println("谢谢添加"); break; }catch(TUIException | RuntimeException e) { System.out.println(e.getMessage()); } } } /** * 就是一个检查动物退是否正确的一个方法 * @param a 父类Animal * @throws TUIException 个数不对 */ public static void addAnimal(Animal a)throws TUIException { if(a instanceof Cat) { Cat c = (Cat)a; if(c.getTui() != 4) { throw new TUIException("这个退不对"); } }else if(a instanceof Fish) { Fish f = (Fish)a; if(f.getTui() != 0) { throw new TUIException("这个鱼是不可能有退的,若有拿来看!!!!"); } }else { QQ qq = (QQ)a; if(qq.getTui() != 2) { throw new TUIException("这个退不对"); } } System.out.println("添加成功"); } }
回顾:
学习了Set集合
Set集合的特点就是:无序(无序不等于随机),排重
ps:打印是打印 存储是存储
打印只是展示存储的数值数据
存储是底层存放的方式
实现类:
HashSet:使用Hash表的形式来存数据, 无序 ,排重
当前类的子类:
LinkedHashSet:链表和Hash表的双重实现,即可以排重也可以记录存储信息本身没有特殊方法,使用可以参考Set集合中的方法
TreeSet:二叉树形式存储-->使用红黑二叉树
排重 排序(默认是升序) 使用TreeSet需要注意:存储的数据必须具备可比性(相同数据类型才行)
自定义类进行排序如何使用:
实现两个接口
Comparator 自定义比较器
Comparable 系统比较器
两者接口返回的 使用 正数,负数,零来判断这些升序,降序,不变
两个接口实现的方法时不同的
TreeSet排序建议使用哪个Comparable接口 对应TreeSet默认无参构造方法
Comparator可以使用在一些自己定义排序的方式
例如: Collections.sort Arrays.sort 也能对应TreeSet的有参构造方法
/** * */ package com.qfedu.Day18.HomeWork; public class Worker implements Comparable{ private int age; private int workAge; private int money; public Worker(int age, int workAge, int money) { super(); this.age = age; this.workAge = workAge; this.money = money; } public Worker() { super(); // TODO Auto-generated constructor stub } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public int getWorkAge() { return workAge; } public void setWorkAge(int workAge) { this.workAge = workAge; } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } /* (non-Javadoc) * @see java.lang.Comparable#compareTo(java.lang.Object) */ @Override public int compareTo(Object o) { //没有泛型之前 Worker other = (Worker)o; int Sage = this.age - other.age; int SworkAge = other.workAge - this.workAge; int Smoney = other.money - this.money; int sum = Sage == 0 ? SworkAge == 0 ? Smoney : SworkAge : Sage; //return sum; return this.age - other.age == 0 ?other.workAge - this.workAge == 0 ? other.money - this.money : other.workAge-this.workAge : this.age-other.age; } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { return "年龄:"+age+","+"工龄:"+workAge+","+"薪水:"+money; } } /** * */ package com.qfedu.Day18.HomeWork; import java.util.TreeSet; public class Test { public static void main(String[] args) { TreeSet set = new TreeSet(); set.add(new Worker(18, 2, 3000)); set.add(new Worker(18, 5, 3100)); set.add(new Worker(18, 2, 3700)); set.add(new Worker(19, 2, 3200)); set.add(new Worker(30, 10,1500)); System.out.println(set); } }
泛型(genericity):
为什么要使用泛型?
/** * */ package com.qfedu.Day18.Genericity.Tong; import java.util.ArrayList; import java.util.List; public class Demo { public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(123); //list.add("123"); //手动擦除 -->严禁使用 List list1 = list; list1.add("1111"); System.out.println(list); } } /** * */ package com.qfedu.Day18.Genericity.Tong; import java.util.ArrayList; import java.util.List; public class Test { public static void main(String[] args) { //千万不能这样使用 ? 是通配符 错误 // List<?> list = new ArrayList<>(); // list.add("1"); //盖住变量名 去除等号右边 ,剩下的就是数据类型 List<Integer> list1 = new ArrayList<>(); doWork(list1); List<String> list2 =new ArrayList<>(); doWork(list2); } //若集合使用了泛型,此时在方法中作为参数是,也要指定泛型是什么 // public static void doWork(List<Integer> array) { // // } //1.通配符的第一个作用就是作为方法的参数的数据类型而存在 //此时,此方法可以接受任何泛型的集合,传入到方法中 public static void doWork(List<?> list) { //list.add(1); System.out.println(list); } }
案例1:
集合可以存储任何数据类型,必然集合中需要使用Object类型接受
1.若需要使用计算或是当前对象的特有属性和方法强制类型转换(向下转型)
2.向集合中存储元素,无法限制存储元素的数据类型
我们可以使用泛型来约束集合中存储的数据类型,并且使用了泛型后就不需要强制类型转换了(向下转型)
但是这样一来会出现一个问题,不能再存储任何数据类型,只能存储限制的数据类型对应的值
案例2:
设计一个点(Ponit),来封装坐标,要求坐标的数据类型可以支持String,int,double,float,
class Point{
private String x;
private String y;
}
class Point{
private int x;
private int y;
}
....
原则DRY 不要重复自己
可以通过创建对象时在决定Point的数据是什么,这样一来是不是就可以不用创建多个Point而只要建立一个类即可
class Point{
privare T x;
private T y;
}
new Point();
就可以使用泛型
什么是泛型:
1.泛型的含义就是代表任何数据类型,但是本身没有任何含义,就是一个站位符
2.在不能明确数据类型式,我们即可以使用这种占位符的形式来替代数据类型
特点:
通过<数据类型>接收一种引用数据类型,在编译程序时该类型会对[集合、类、接口、方法]中传入的数据进行类型匹配
如果不是当前类型,编译就不会通过,从运行时的问题提升到了编译时
泛型是用在编译时期的,编译完成之后产生.class文件后泛型就不会存在了-->泛型擦除
泛型在定义阶段没有任何意义,只是占位符问题
实际使用中参数的传递或类型的定义,此时当前泛型才会有真正的意义
泛型的分类
泛型应用在类上
泛型中定义的字本身没任何意义,就是占位
看Class包
/**
*
*/
package com.qfedu.Day18.Genericity.Class;
/**
* Point类可以接受String,double,float,int,long 作为参数的数据类型
*/
public class Point<T> {//泛型类 -->类中定义的泛型可以在类体中使用 -->通用性
//在没有给ArrayList指定泛型时,可以接受任何数据类型
//此时定义在ArrayList上的<E> 相当于什么 --> Object
//可以作为属性的数据类型而存在 ,当前数据类型是不能确定了 只是使用了一个字母T作为占位使用
private T x;
private T y;
public Point() {
}
public Point(T x, T y) {//类中方法可以作为数据类型
this.x = x;
this.y = y;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
public void show(T z) {
System.out.println(z);
}
}
/**
*
*/
package com.qfedu.Day18.Genericity.Class;
public class Test {
//如何使用泛型类
public static void main(String[] args) {
//不推荐
// Point p1 = new Point();
// //默认是泛型类,在创建对象时不指定泛型类型也可以使用但是,不指定就是Object
// p1.show(10);
//如何创建对象
Point<String> p1 = new Point<>();
p1.setX("1");
//T 相当于 Object
Point<Integer> p2 = new Point<>();
p2.setX(1);
Point<Boolean> p3 = new Point<>();
p3.setX(true);
}
}
/** * */ package com.qfedu.Day18.Genericity.Method; public class MethodClass<T> { //当前方法使用泛型类型就和类是一致的了 public void show(T t) { } //类所定义的泛型不能再静态方法中使用,提供自己的泛型方法 // public static void display(T t) { // System.out.println(t); // } //泛型方法的定义 //什么时候能确定这个泛型的数据类型-->调用方法时传递参数,就会决定方法的泛型的数据数据类型 public<E> void dispaly(E e) { System.out.println(e); } public static<K> void showInfos(K k) { } }
泛型应用在方法上
1.泛型类中的泛型只能适用于非静态方法,如果需要给静态方法添加泛型,此时就需要定义泛型方法了
2.方法想使用自己的泛型类型,并不想使用其他方式提供的泛型,此时就需要使用泛型方法了
看Method包
泛型应用在接口上
看Inteface包
/** * */ package com.qfedu.Day18.Genericity.Inteface; //和类是类似的使用方式 public interface InterFaceDemo<T> { //1.8之前 String NAME = "1"; //public static final //抽象方法 全局静态常量 void show(T t); // public abstract //1.8之后 //定义实现方法 //default 修饰 static 修饰 --> 都是公有public //default可以重写 static 不行 //default可以通过接口对象调用 static接口名调用 } /** * */ package com.qfedu.Day18.Genericity.Inteface; //1.确定泛型接口中泛型的数据类型,使用类实现接口并制定泛型类型 public class Person implements InterFaceDemo<String>{ /* (non-Javadoc) * @see com.qfedu.Day18.Genericity.Inteface.InterFaceDemo#show(java.lang.Object) */ @Override public void show(String t) { // TODO Auto-generated method stub } } /** * */ package com.qfedu.Day18.Genericity.Inteface; //2.泛型类实现泛型接口,此时可以通过泛型类型中的泛型来占位泛型接口中的泛型 // 创建当前泛型类对象的时,此时就可以制定泛型的数据类型 public class Student<M> implements InterFaceDemo<M>{ /* (non-Javadoc) * @see com.qfedu.Day18.Genericity.Inteface.InterFaceDemo#show(java.lang.Object) */ @Override public void show(M t) { // TODO Auto-generated method stub } } /** * */ package com.qfedu.Day18.Genericity.Inteface; public class Test { public static void main(String[] args) { //3.以匿名内部类的形式来完成泛型接口的创建,同时指定泛型类型 new InterFaceDemo<String>() { @Override public void show(String t) { // TODO Auto-generated method stub } }; } }
泛型通配符 ?
通配符不能单独使用,仅限于在使用参数定义数据类型时使用
? 在不知道是什么数据类型时,也可以使用? 来代替
泛型的限定:
<? extends 类>
此时只能传入当前类的子类或当前类
<? super 类>
此时只能传入当前类或父类类型
ps:
泛型擦除:
1.泛型在编译过后会被自动消除
2.当把带有泛型的集合赋值给不带有泛型的集合时,此时泛型被擦除(手动擦除)
Map集合:(非常重要)
Map集合是一种映射集合,map集合集合中存在着一种对应关系 key- value 键值对 -->(JSON数据格式)
要求:
1.key的值必须是唯一的,不能重复
2.value的可以重复必备唯一
key必须唯一,但是Value可以不唯一 一个key只能对应一个value 同一个value可以对应多个key
key这边想成是一个Set集合
value这边想成是一个List集合
HashMap集合常用方法
API
看HashMap包
/** * */ package com.qfedu.Day18.HashMap; public class Card { //cardNo：银行卡号，startDate：开户日期， money private String cardNo; private String startDate; private String money; public Card() { super(); // TODO Auto-generated constructor stub } public Card(String cardNo, String startDate, String money) { super(); this.cardNo = cardNo; this.startDate = startDate; this.money = money; } public String getCardNo() { return cardNo; } public void setCardNo(String cardNo) { this.cardNo = cardNo; } public String getStartDate() { return startDate; } public void setStartDate(String startDate) { this.startDate = startDate; } public String getMoney() { return money; } public void setMoney(String money) { this.money = money; } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { return "卡号:"+cardNo+"开户日期:"+startDate+"金额:"+money; } } /** * */ package com.qfedu.Day18.HashMap; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Scanner; import java.util.Set; public class HashMapDemo { public static void main(String[] args) { //1.创建Map集合对象 Map<String,String> map = new HashMap<>(); //2.向map集合对象中存储map集合中的元素 Map<String,String> map1 = new HashMap<>(map); //常用方法: //1.向集合中添加元素 /* * 这个方法是有返回值的,返回的是 value的数据类型 */ map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); map.put("key4", "value4"); map.put("key5", "value5"); map.put("key6", "value6"); System.out.println(map); //2.向集合中添加集合(添加集合中的元素) map1.putAll(map); System.out.println(map1); //3.清空集合,集合还在 map1.clear(); System.out.println(map1); //4.判断集合中是否存在指定的key值 //true证明存在 false 不存在 boolean res = map.containsKey("key7"); System.out.println(res); //5.判断集合中是否存在指定的value值 //true证明存在 false 不存在 boolean result = map.containsValue("value7"); System.out.println(result); //6通过key获取value值 ,若key不存在返回null String value = map.get("key4"); System.out.println(value); //7.判断集合是否是空,说明集合存在,没有元素 System.out.println(map1.isEmpty()); //8.key相当于存储到了set集合中 排重 保持唯一 //获取所有的key值并存储到set集合中 Set<String> set = map.keySet(); //此时所有的key是不是都在set集合集合中了 //是不是通过操作set集合就能获取或改变map集合对应的键值对 for(String keys : set) { if(keys.equals("key6")) { //不仅是向集合中添加元素,修改对应的键值对 map.put(keys, "vlaue10"); } } System.out.println(map); //9.获取Map集合中所有Value的值,存储到Collection集合中 Collection<String> c = map.values(); for(String value1 : c) { System.out.println(value1); } //10.获取所有键值对的总和(个数) System.out.println(map.size()); //11.通过key删除对应的键值对 ,返回值是对应的value //删除成功会获取对应的value 失败则返回null String value2 = map.remove("key9"); System.out.println(value2); //12. /* * Set<Map.Entry<K,V>> entrySet() 返回此映射所包含的映射关系的 Set 视图。 通过此方法可以的到一个set集合 需要给set集合添加泛型 这个方法的类型是一个Map.Entry Map.Entry自己也有泛型 这个泛型类型需要和map集合中存储的 key和value的数据类型一致 * */ Set<Map.Entry<String,String>> mapSet = map.entrySet(); System.out.println(mapSet); for(Map.Entry<String, String> entry :mapSet) { //取出key 和 value System.out.println(entry.getKey()+" ---> "+ entry.getValue()); } //若存在两个相同的key值最后一次添加的键值对会替代第一次添加键值对 map1.put("key1", "value1"); map1.put("key1", "value2"); System.out.println(map1); map1.put("key1", "value1"); map1.put("key2", "value1"); System.out.println(map1); /* * 需求: 一个人对应多张银行卡 Card： cardNo：银行卡号，startDate：开户日期， money：余额 请设计一个程序，输入一个人的名称，得到这个人的所有银行卡信息。 键值对 一个对多 value是什么? 分析如下: 1.通过第一句话已知得到一个信息就是需要一个描述Card的方式 在java中描述只能有类来完成所以 应该创建一个Card类 2.Card的后面提供了一些信息 包括卡号 开户日期 余额 这些明显的属于是对类的信息描述,那信息描述应该是类的属性 3.第二句话中隐藏着一些信息,首先既然是输入一个人名 那么必然要用到Scanner 人名是String类型所以是字符串 再者人名是属于对人的一种描述属性 所以应该推断而出 可以创建一个人类 属性是人名 综上所述这个参数即可以用String也可以使用自己创建的类来完成 4.第二句话还有一个信息就是一个人有多张卡的问题 这里应该很明确卡不能是单纯的一张?那么如何来表示多张卡呢?--> 集合 选用那个集合呢? 一个人可以在同一个银行办多张卡 所以在不考虑其他特殊情况下应该使用 List 5.最后将这些信息汇总,即可以通过人名获取对应的卡,那么就需要一个稳定的获取模式 键值对 key-value形式 即 key 是人名 value 是list集合 集合中存在多张卡 */ System.out.println("请输入一个人名:"); Scanner input = new Scanner(System.in); String name = input.next(); List<Card> list = new ArrayList<>(); list.add(new Card("88888888", "1900-01-01", "1")); list.add(new Card("77777777", "1292-02-02", "10000")); list.add(new Card("66666666", "2018-08-22", "1000000000000000000000000")); //非常常见的集合中存储了另外一个集合 Map<String,List<Card>> hmap = new HashMap<>(); hmap.put("王健林", list); System.out.println("稍等正在查询......."); if(hmap.containsKey(name)) { // List<Card> listmap = hmap.get(name); // for(Card c1 : listmap) { // System.out.println(c1); // } System.out.println(hmap.get(name)); }else { System.out.println("不好意思没有这个人"); } } }
LinkedHashMap是HashMap的子类没有特殊方法使用方式参考HashMap即可
TreeMap二叉数 --> 自带排序 这个排序时key排序 ,需要进行排序的数据存储到Key
key是什么集合 Set --> TreeSet
Hashtable和HashMap都是Map的实现类
Hashtable是线程安全的,效率低 - properties 资源文件 --> 加载
HashMap是线程不安全,效率高
总结:
Collection:
List:有序存储,允许存重复值并且有下标 提供了迭代器,for循环等方式遍历集合
主要应用 ArrayList
Set:无序存储,不允许重复,没有下标,提供了迭代器和for循环等遍历方式遍历集合
主要应用 HashSet
TreeSet --> 自带排序功能的集合
必须实现Comparable接口
若自定义类需要进行排序,建议实现Comparable接口
实现Comparator接口也可以
Map:无序 是一种映射关系,键值对 key-value ,key必须唯一,value可以不唯一
并没有提供Iterator,但是提供了另外一种方式 Map.Entry --> entrySet
主要应用 HashMap
Collections工具类:
为集合提供方法可以方便操作
/** * */ package com.qfedu.Day18.Collections; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Vector; public class CollectionsDemo { public static void main(String[] args) { List<Integer> list = new ArrayList<>(); //向集中一次性添加多个元素 /* * 第一个参数需要是一个Collection这边的集合 * 第二个参数是一个可变参数(可以什么都没有,也可以有一堆) */ Collections.addAll(list, 1,2,3,4,5,56,6,4,3,5,2); System.out.println(list); //不是只有TreeSet才可以进行排序操作 //List这边的集合以可以 //Collections.sort(list);//升序 //System.out.println(list); //重载方法 // Collections.sort(list, new Comparator<Integer>() { // // @Override // public int compare(Integer o1, Integer o2) { // // return o2-o1; // } // });//降序 //降序快捷方式,这个方式不适合自定义类的排序 Collections.sort(list, Collections.reverseOrder()); System.out.println(list); //static void shuffle(List<?> list) // 使用默认随机源对指定列表进行置换 //3个51 - 17 1次一个呢只能有1张 Collections.shuffle(list); System.out.println(list); //集合中查找某个元素--> 二分查找 /* * 第一个参数是要查找的集合 * 第二个参数要查找的值 *找到就是下标 找不到-1的值 *一定要先排序 */ Collections.binarySearch(list, 1); // static void reverse(List<?> list) // 反转指定列表中元素的顺序。 //若需要线程安全时,只需要通过Collections中的方法即可 完成转换 /* * static <T> Collection<T> synchronizedCollection(Collection<T> c) 返回指定 collection 支持的同步（线程安全的）collection。 static <T> List<T> synchronizedList(List<T> list) 返回指定列表支持的同步（线程安全的）列表。 static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 返回由指定映射支持的同步（线程安全的）映射。 static <T> Set<T> synchronizedSet(Set<T> s) 返回指定 set 支持的同步（线程安全的）set。 * * */ List<Integer> safeList = Collections.synchronizedList(list); System.out.println("当前线程安全的集合是:"+(safeList instanceof Vector)); } }
