黑马程序员__泛型_Set集合类_Map集合类

最新推荐文章于 2021-11-14 14:29:33 发布

置顶 haojude

最新推荐文章于 2021-11-14 14:29:33 发布

阅读量438

点赞数

文章标签： java 面向对象集合

本文链接：https://blog.csdn.net/haojude/article/details/45552153

版权

------<a href=" http://www.itheima.com " target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、泛型(理解)

(1)泛型是一种把明确类型放在了创建对象或者调用方法时候才去明确的特殊的类型。

(2)格式：

<数据类型>引用数据类型

(3)好处：

A:解决了黄色警告线问题

B:把运行期间的转换异常给提前到了编译期间

C:优化了程序设计，不需要做强制类型转换了

(4)泛型的前世今生

A:泛型类

B:泛型方法

C:泛型接口

(5)泛型的使用：(掌握)

看API中的类或者接口,其后是否跟有<>,如果有，就是泛型的应用。

一般在集合中用

==符号和equals方法的区别

1,==符号是比较运算符,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值

2,equals方法只能比较引用数据类型,如果子类中没有重写Object类中的equals方法,equals方法是依赖==号比较的,比较的是

对象的地址值,但是一般我们都会重写equals方法,重写之后比较的是对象中的属性

[java]view plaincopy 
     
 class Person {  
     private String name;  
     private int age;  
     public Person() {  
         super();  
           
     }  
     public Person(String name, int age) {  
         super();  
         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;  
     }  
     @Override  
     public String toString() {  
         return "Person [name=" + name + ", age=" + age + "]";  
     }  
     @Override  
     public boolean equals(Object obj) {       
 Person p = (Person)obj;  
         return this.name.equals(p.name) && this.age == p.age;  
     }  
       
       
 }  
   
   
   
 public static void main(String[] args) {  
         //demo1();  
         ArrayList<Integer> list = new ArrayList<>();  
         list.add(123);  
           
         System.out.println(list);  
     }  
   
     private static void demo1() {  
         ArrayList<Person> list = new ArrayList<Person>();  
 //      list.add("a");  
 //      list.add(123);  
         list.add(new Person("张三", 23));  
         list.add(new Person("李四", 24));  
         Iterator<Person> it = list.iterator();  
         while(it.hasNext()) {  
             Person p = it.next();  
             System.out.println(p.getName() + "..." + p.getAge());  
         }  
     }  
   
 }  

/**

* @param args

* 泛型的通配符

* ?

* 高级泛型

* ? extends E 固定上边界

* ? super E

[java]view plaincopy 
     
 public static void main(String[] args) {  
         //ArrayList<?> list = new ArrayList<String>();  
         ArrayList<Person> list1 = new ArrayList<>();  
         list1.add(new Person("张三", 23));  
         list1.add(new Person("李四", 24));  
         list1.add(new Person("王五", 25));  
           
           
     }  
   
 }  

[java]view plaincopy 
     
 public class Tool<Q> {                //Q在创建对象的时候被赋值,创建对象传入的是什么类型Q就是什么类型  
     private Q obj;  
   
     public Q getObj() {  
         return obj;  
     }  
   
     public void setObj(Q obj) {  
         this.obj = obj;  
     }  
   
     public void show(Q q) {             //非静态方法的泛型可以和类的泛型一致  
         System.out.println(q);  
     }  
       
     public static<T> void method(T t) {//静态方法需要定义自己的泛型,因为静态方法是随着类的加载而加载的,在静态方法  
         System.out.println(t);          //加载的时候还没有创建对象,那么泛型就没有值,但是定义属于自己的泛型就没事了  
     }                                   //在调用这个静态方法的时候会给泛型赋值  
 }  

二、Set 不可重复, 没索引,无序

HashSet 使用哈希算法去重复, 效率高, 但元素无序

TreeSet TreeSet是用排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列

LinkedHashSet HashSet的子类, 原理相同, 除了去重复之外还能保留存储顺序

1)HashSet(LinkedHashSet)

1.HashSet原理

我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低

哈希算法提高了去重复的效率, 降低了使用equals()方法的次数

当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象

如果没有哈希值相同的对象就直接存入集合

如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较

比较结果为false就存入, true则不存

2.将自定义类的对象存入HashSet去重复

类中必须重写hashCode()和equals()方法

hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)

equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储

[java]view plaincopy 
     
 public class Person {  
     private String name;  
     private int age;  
     public Person() {  
         super();  
           
     }  
     public Person(String name, int age) {  
         super();  
         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;  
     }  
     @Override  
     public String toString() {  
         return "Person [name=" + name + ", age=" + age + "]";  
     }  
     /*@Override 
     public boolean equals(Object obj) { 
         System.out.println("equals方法执行了吗"); 
         Person p = (Person)obj; 
         return this.name.equals(p.name) && this.age == p.age; 
     } 
     @Override 
     public int hashCode() { 
         final int NUM = 38; 
         return NUM * name.hashCode() + age; 
          
     }*/  
     /* 
      * 1,31是一个质数 
      * 2,31这个数既不大也不小 
      * 3,31这个数好算,2的5次方-1 
      */  
     @Override  
     public int hashCode() {  
         final int prime = 31;  
         int result = 1;  
         result = prime * result + age;  
         result = prime * result + ((name == null) ? 0 : name.hashCode());  
         return result;  
     }  
     @Override  
     public boolean equals(Object obj) {           
         if (this == obj)                        //如果调用的对象和传入的对象是同一个对象  
             return true;                        //返回true  
         if (obj == null)                        //如果传入的对象为null  
             return false;                       //返回false  
         if (this.getClass() != obj.getClass())  //调用的对象的字节码文件和传入对象的字节码文件不一致  
             return false;                       //返回false  
         Person other = (Person) obj;            //强制类型转换  
         if (age != other.age)                   //如果调用对象的年龄不等于传入对象的年龄  
             return false;                       //返回false  
         if (name == null) {                     //如果调用对象的name为null  
             if (other.name != null)             //传入对象的name不为null  
                 return false;                   //返回false  
         } else if (!name.equals(other.name))    //如果调用的对象的name不等于传入对象的姓名  
             return false;                       //返回false  
         return true;                            //返回true  
     }  
       
 }  

[java]view plaincopy 
     
 class Demo1_HashSet {  
   
     /** 
      * @param args 
      * HashSet是如何保证元素的唯一性的 
      * 向HashSet集合存储的对象所属的类,必须重写hashCode和equals方法 
      */  
     public static void main(String[] args) {  
         //demo1();  
         HashSet<Person> hs = new HashSet<>();  
         hs.add(new Person("张三", 23));  
         hs.add(new Person("张三", 23));  
         hs.add(new Person("张三", 23));  
         hs.add(new Person("李四", 24));  
         hs.add(new Person("李四", 24));  
         hs.add(new Person("李四", 24));  
         hs.add(new Person("王五", 25));  
           
         System.out.println(hs);  
     }  
   
     private static void demo1() {  
         HashSet<String> hs = new HashSet<>();  
         hs.add("a");  
         hs.add("a");  
         hs.add("b");  
         hs.add("b");  
         hs.add("c");  
         hs.add("d");  
         hs.add("e");  
         System.out.println(hs);  
     }  
   
 }  

2)LinkedHashSet

[java]view plaincopy 
     
 public class Demo2_LinkedHashSet {  
   
     /** 
      * @param args 
      * LinkedHashSet 
      * 可以保证怎么存就怎么取 
      */  
     public static void main(String[] args) {  
         LinkedHashSet<String> lhs = new LinkedHashSet<>();  
         lhs.add("a");  
         lhs.add("a");  
         lhs.add("b");  
         lhs.add("c");  
         lhs.add("d");  
           
         System.out.println(lhs);  
     }  
   
 }  

3)迭代(遍历)

1.List

a.普通for循环, 使用get()逐个获取

b.调用iterator()方法得到Iterator, 使用hasNext()和next()方法

c.增强for循环, 只要可以使用Iterator的类都可以用

d.Vector集合可以使用Enumeration的hasMoreElements()和nextElement()方法

2.Set

a.调用iterator()方法得到Iterator, 使用hasNext()和next()方法

b.增强for循环, 只要可以使用Iterator的类都可以用

[java]view plaincopy 
     
 import java.util.HashSet;  
 import java.util.Iterator;  
   
 public class Demo3_Iterator {  
   
     /** 
      * @param args 
      * Set集合迭代有两种 
      * 1,迭代器 
      * 2,增强for循环,只要能用迭代器迭代的,都能用增强for循环迭代 
      */  
     public static void main(String[] args) {  
         HashSet<String> hs = new HashSet<>();  
         hs.add("a");  
         hs.add("b");  
         hs.add("c");  
         hs.add("d");  
           
         /*Iterator<String> it = hs.iterator(); 
         while(it.hasNext()) { 
             System.out.println(it.next()); 
         }*/  
         for(String str : hs) {  
             System.out.println(str);  
         }  
     }  
   
 }  

4)TreeSet

1.特点

TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列

2.使用方式

a.自然顺序(Comparable)

TreeSet类的add()方法中会把存入的对象提升为Comparable类型

调用对象的compareTo()方法和集合中的对象比较

根据compareTo()方法返回的结果进行存储

b.比较器顺序(Comparator)

创建TreeSet的时候可以制定一个Comparator

如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序

add()方法内部会自动调用Comparator接口中compare()方法排序

c.两种方式的区别

TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错ClassCastException)

TreeSet如果传入Comparator, 就优先按照Comparator

1)自然排序

[java]view plaincopy 
      
 public class Demo5_TreeSet {  
   
 public static void main(String[] args) {  
   
     TreeSet<Person> ts=new TreeSet<>();  
                 ts.add(new Person("张三",24));  
                 ts.add(new Person("李三",23));  
                 ts.add(new Person("王三",23));  
                 ts.add(new Person("刘三",25));  
                   
                 System.out.println(ts);  
 }  
 }  
   
   
 class Person implements Comparable<Person>{  
     private String name;  
     private int age;  
     public Person() {  
         super();  
           
     }  
     public Person(String name, int age) {  
         super();  
         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;  
     }  
     @Override  
     public String toString() {  
         return "Person [name=" + name + ", age=" + age + "]";  
     }  
 public int compareTo(Person o) {            //重写compareTo方法  
 int num = this.age - o.age;             //主要条件按照年龄比较  
 return num == 0 ? this.name.compareTo(o.name) : num;//如果年龄相同比较姓名  
     }*/  
     //字符串的compareTo方法其实是按照unicode码表值比较的  
     public int compareTo(Person p) {  
         int num = this.name.compareTo(p.name);  //主要条件按照姓名比较  
         return num == 0 ? this.age - p.age : num;//如果姓名相同比较年龄  
     }  
 }  

2)选择排序

[java]view plaincopy 
      
 import java.util.Comparator;  
 import java.util.TreeSet;  
   
 public class Demo5_TreeSet {  
   
     /** 
      * @param args 
      * TreeSet比较器 
      * 2,比较器排序 
      *  
      * 需求:将字符按照长度排序 
      */  
     public static void main(String[] args) {  
           
         TreeSet<String> ts = new TreeSet<>(new CompareByLen());  
         ts.add("cba");  
         ts.add("nba");  
         ts.add("wc");  
         ts.add("ccav");  
         ts.add("aaaaaaaaaaaaaaaaaaaaaaaaa");  
         ts.add("z");  
           
         System.out.println(ts);  
     }  
   
       
   
 }  
   
 class CompareByLen implements Comparator<String> {  
   
     @Override  
     public int compare(String s1, String s2) {  
         int num = s1.length() - s2.length();  
         int z = num == 0 ? s1.compareTo(s2) : num;  
         return z;  
     }  
       
 }  

三、Map集合

1.Map集合的特点

Map集合一次存储两个对象, 一个键对象, 一个值对象

键对象在集合中是唯一的, 可以通过键来查找值

2.Map常用方法

put() 存储一条记录, 一个键和一个值

get() 根据键对象获取值

containsKey() 判断是否包含指定的键

containsValue() 判断是否包含指定的值

remove(key) 根据键删除一条记录

size() Map集合中的记录数

values() 得到所有的值对象组成的一个Collection集合

[java]view plaincopy 
       
 public class Demo1_Map {  
   
     /** 
      * @param args 
      *  
      */  
     public static void main(String[] args) {  
         Map<String, Integer> map = new HashMap<>();  
         Integer i1 = map.put("张三", 97);  
         Integer i2 = map.put("李四", 80);  
         Integer i3 = map.put("王五", 59);  
         Integer i4 = map.put("赵六", 98);  
           
         Integer i5 = map.put("张三", 100);    //双列集合中键是唯一的,如果添加重复的键,后面添加的元素会 把前面元素的值替换  
                                             //并返回被替换的值  
         System.out.println(i1);  
         System.out.println(i2);  
         System.out.println(i3);  
         System.out.println(i4);  
         System.out.println(i5);  
         System.out.println(map);            //打印结果是{赵六=98, 张三=97, 李四=80, 王五=59}  
                                             //因为HashMap的父类重写了Object类中的toString方法  
     }  
 }  

3.迭代Map集合

a.keySet()

先调用keySet()方法从Map集合中获取所有Key组成的一个Set集合

迭代Set集合可以得到每一个Key

然后再调用get()方法通过Key获取每一个Value

b.entrySet()

先调用entrySet()方法从Map集合中获取所有Entry(键值对)组成的一个Set集合

迭代Set集合可以得到每一个Entry

然后再调用getKey()和getValue()方法得到每一个Key和每一个Value

[java]view plaincopy 
       
 public class Demo2_Iterator {  
   
     /** 
      * @param args 
      * foreach是不能直接遍历双列集合的 
      */  
     public static void main(String[] args) {  
         //demo1();  
         Map<Person,String> map = new HashMap<>();  
         map.put(new Person("张三", 23), "北京");  
         map.put(new Person("李四", 24), "上海");  
         map.put(new Person("王五", 25), "广州");  
         map.put(new Person("赵六", 26), "深圳");  
           
         /*Set<Map.Entry<Person, String>> entrySet = map.entrySet();                 //获取键值对对象的集合 
         Iterator<Map.Entry<Person, String>> it = entrySet.iterator();               //获取迭代器 
         while(it.hasNext()) { 
             Map.Entry<Person, String> en = it.next();                             //迭代每一个键值对象 
             System.out.println(en.getKey() + "=" + en.getValue());                  //通过键值对象获取键和值 
         }*/  
           
         for(Entry<Person, String> en : map.entrySet()) {                                                    
             System.out.println(en.getKey() + "=" + en.getValue());  
         }  
     }  
   
     private static void demo1() {  
         Map<Person,String> map = new HashMap<>();  
         map.put(new Person("张三", 23), "北京");  
         map.put(new Person("李四", 24), "上海");  
         map.put(new Person("王五", 25), "广州");  
         map.put(new Person("赵六", 26), "深圳");  
           
         /*Set<Person> keySet = map.keySet();      //获取所有的键 
         Iterator<Person> it = keySet.iterator();  //获取迭代器 
         while(it.hasNext()) {                       //判断集合中是否有元素 
             Person key = it.next();                 //获取双列集合中的每一个键 
             String value = map.get(key);            //通过键获取值 
             System.out.println(key + "=" + value);  //打印键和值 
         }*/  
           
         for(Person key : map.keySet()) {  
             System.out.println(key + "=" + map.get(key));  
         }  
     }  
   
 }  
   
 class Person implements Comparable<Person>{  
     private String name;  
     private int age;  
     public Person() {  
         super();  
           
     }  
     public Person(String name, int age) {  
         super();  
         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;  
     }  
     @Override  
     public String toString() {  
         return "Person [name=" + name + ", age=" + age + "]";  
     }  
 }  

4.HashMap

在使用HashMap存储键值对的时候, 先调用Key对象的hashCode()方法计算一个哈希值, 在Map中查找是否有相同哈希值的Key对象

如果没有哈希值相同的Key对象, 这个键值对直接存入

如果有哈希值相同的Key对象, 那么就进行equals比较

比较结果为false就存入, true则覆盖原Value

[java]view plaincopy 
       
 import java.util.HashMap;  
 public class Demo4_HashMap {  
   
     /** 
      * @param args 
      * 查看源码发现HashSet底层的add方法其实是依赖于HashMap的put方法 
      * 这就是为什么HashSet集合中所有的元素是唯一的 
      * 而HashMap集合中所有的键是唯一的 
      */  
     public static void main(String[] args) {  
         //demo1();  
         HashMap<Person, String> hm = new HashMap<>();  
         hm.put(new Person("张三", 23), "北京");  
         hm.put(new Person("张三", 23), "上海");  
           
         System.out.println(hm);  
     }  
   
     private static void demo1() {  
         HashMap<String, Integer> hm = new HashMap<>();  
         hm.put("a", 3);  
         hm.put("b", 1);  
         hm.put("c", 4);  
         hm.put("d", 2);  
         hm.put("a", 5);  
           
         System.out.println(hm.size());  
         System.out.println(hm);  
     }  
   
 }  
   
 public class Person {  
     private String name;  
     private int age;  
     public Person() {  
         super();  
           
     }  
     public Person(String name, int age) {  
         super();  
         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;  
     }  
     @Override  
     public String toString() {  
         return "Person [name=" + name + ", age=" + age + "]";  
     }  
     @Override  
     public int hashCode() {  
         final int prime = 31;  
         int result = 1;  
         result = prime * result + age;  
         result = prime * result + ((name == null) ? 0 : name.hashCode());  
         return result;  
     }  
     @Override  
     public boolean equals(Object obj) {  
         if (this == obj)  
             return true;  
         if (obj == null)  
             return false;  
         if (getClass() != obj.getClass())  
             return false;  
         Person other = (Person) obj;  
         if (age != other.age)  
             return false;  
         if (name == null) {  
             if (other.name != null)  
                 return false;  
         } else if (!name.equals(other.name))  
             return false;  
         return true;  
     }  
       
       
       
 }  

Hashtable和HashMap的区别

Hashtable

类似HashMap, 线程安全, 效率略低,不允许null键和null值

1,Hashtable是线程安全的,效率比较低

HashMap是线程不安全的,效率高

2,Hashtable不能存储null键,不能存储null值

HashMap可以存储null键和null值

[java]view plaincopy 
      
 public class Demo5_Hashtable {  
   
       
     public static void main(String[] args) {  
         /*Hashtable<String, Integer> ht = new Hashtable<>(); 
         //ht.put(null, 123); 
         ht.put("张三", null); 
         System.out.println(ht);*/  
         HashMap<String, Integer> hm = new HashMap<>();  
         //hm.put(null, 123);  
         hm.put("张三", null);  
         System.out.println(hm);  
     }  
   
 }  

5.LinkedHashMap

HashMap的子类, 算法相同, 但保留了存储的顺序

[java]view plaincopy 
      
 public class Demo6_LinkedHashMap {  
   
     /** 
      * @param args 
      */  
     public static void main(String[] args) {  
         HashMap<String, Integer> hm = new LinkedHashMap<>();        //Hashtable<String, Integer> ht = new LinkedHashMap<>();//  
         hm.put("a", 1);  
         hm.put("b", 2);  
         hm.put("c", 3);  
         hm.put("d", 4);  
           
         System.out.println(hm);  
     }  
   
 }  

6.TreeMap

在使用TreeMap存储键值对时候, 会使用Key对象和集合中已存储的Key对象进行比较, 确定二叉树上的位置

比较的方式和TreeSet指定的方式相同, Comparable和Comparator

[java]view plaincopy 
      
 public class Demo7_TreeMap {  
   
     /** 
      * @param args 
      * TreeMap是对键进行排序,有两种方式 
      * 方式1,自然排序,存储在集合中的对象所属的类,必须实现Comparable接口,并重写compareTo方法,根据compareTo方法的返回值存储 
      * 方式2,比较器排序,在TreeSet的构造函数中,传入Comparator的子类对象,并重写compare方法,根据compare的返回值存储 
      */  
     public static void main(String[] args) {  
           
           
         TreeMap<Person, String> tm = new TreeMap<>(new Comparator<Person>() {  
             @Override  
             public int compare(Person p1, Person p2) {  
                 int num = p1.getAge() - p2.getAge();  
                 return num == 0 ? p1.getName().compareTo(p2.getName()) : num;  
             }  
         });  
           
         tm.put(new Person("张三", 23), "北京");  
         tm.put(new Person("李四", 54), "上海");  
         tm.put(new Person("王五", 35), "广州");  
         tm.put(new Person("赵六", 26), "深圳");  
           
         System.out.println(tm);  
           
     }  
   
     private static void demo2() {  
         TreeMap<Person, String> tm = new TreeMap<>();  
         tm.put(new Person("张三", 23), "北京");  
         tm.put(new Person("李四", 14), "上海");  
         tm.put(new Person("王五", 35), "广州");  
         tm.put(new Person("赵六", 26), "深圳");  
           
         System.out.println(tm);  
     }  
   
       
 }  
 class Person implements Comparable<Person>{  
     private String name;  
     private int age;  
     public Person() {  
         super();  
           
     }  
     public Person(String name, int age) {  
         super();  
         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;  
     }  
     @Override  
     public String toString() {  
         return "Person [name=" + name + ", age=" + age + "]";  
     }  
       
     @Override  
     public int compareTo(Person o) {  
         int num = this.age - o.age;  
         return num == 0 ? this.name.compareTo(o.name) : num;  
     }  

四、总结

集合的迭代

1.Collection

Iteraotr: 通过iterator()方法得到迭代器, 调用hasNext()和next()方法进行迭代

ForEach: for (类型变量名 : 容器) { 循环体 }

2.Map

keySet(): 得到所有的键组成的Set,遍历Set得到每一个键, 然后再分别获取值

entrySet(): 得到所有的Entry组成的Set, 遍历Set得到每一个Entry, 再分别getKey()和getValue()

3.List

Iterator

ForEach

for: 根据索引定义for循环, 调用get()方法根据索引获取每一个元素

4.Vector

Iterator

ForEach

for

Enumeration: 类似Iterator, 通过elements()方法得到Enumeration, 调用hasMoreElements()和nextElement()方法进行迭代

haojude

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员__泛型_Set集合类_Map集合类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------一、泛型(理解)(1)泛型是一种把明确类型放在了创建对象或者调用方法时候才去明确的特殊的类型。 (2)格式：引用数据类型 (3)好处： A:解决了黄色警告线问题 B:把运行期间的转换异常给提前到了编译
复制链接

扫一扫