黑马程序员之——Map、泛型、集合框架工具类：Collections，Arrays
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
第一讲，第二讲：黑马程序员_毕向东_Java基础视频教程第15天-06-集合框架(泛型概述)，(泛型使用)
一，泛型了解：
- 泛型的由来：泛型是JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。
- 好处：将运行时期出现的问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时期问题减少、安全。
- 好处：避免了强制转换的麻烦。
二，泛型的格式：通过<>来定义要操作的引用数据类型。 如：ArrayList<String> //定义要存入集合中的元素指定为String类型
三，泛型使用时机：在集合框架中使用的较多，只要见到<> 就要使用泛型。
四，代码练习。
1 import java.util.*; 2 public class GenericDemo { 3 public static void main(String[] args) { 4 //使用泛型 5 ArrayList<String> list = new ArrayList<String>(); 6 7 list.add("lisi"); 8 list.add("wangwu"); 9 list.add("zhaoliu"); 10 11 //list.add(4); //编译不通过 12 13 for(Iterator<String> iterator = list.iterator();iterator.hasNext();){ 14 //泛型机制，不用强制转换 15 String str = iterator.next(); 16 System.out.println(str+str.length()); 17 } 18 } 19 }
第三讲：黑马程序员_毕向东_Java基础视频教程第15天-08-集合框架(泛型类)
一，泛型类的定义：在类的定义名称后加上泛型 如 ： class Tool<String>;
二，泛型类的使用时机：当类中要操作的类型（只能是引用类型）不确定的时候。使用泛型。====注：早期定义Object完成扩展。
三，代码练习：
1 class Worker{ 2 3 } 4 5 class Tools<E>{ 6 private E element; 7 8 public void setE(E e){ 9 this.element = e; 10 } 11 12 public E getE(){ 13 return this.element; 14 } 15 } 16 public class GenericTestDemo { 17 public static void main(String[] args) { 18 19 Tools<Worker> tool = new Tools<Worker>(); 20 21 tool.setE(new Worker()); 22 23 //tool.setE(new String()); //编译报错 24 Worker worker = tool.getE(); 25 26 //String str = tool.getE(); //编译报错 27 } 28 }
第四讲，第五讲：黑马程序员_毕向东_Java基础视频教程第15天-09-集合框架(泛型方法)，(静态方法泛型)
一，泛型方法：
-
- 为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
- 方法中的泛型可以不和类泛型相同。
- 泛型定义在方法上应该放到返回值类型的前面，修饰符的后面。
- 只有引用类型才能作为泛型方法的实际参数。
二，静态泛型方法：
-
- 静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
三。代码练习：
1 //定义泛型类 2 class Demo <T>{ 3 4 //类的泛型方法 5 public void myprint(T t){ 6 System.out.println(t); 7 } 8 9 //泛型方法 10 public <Q> void myprint2(Q q){ 11 System.out.println(q); 12 } 13 14 //泛型静态方法 15 public static <Q> void myprint3(Q q){ 16 System.out.println(q); 17 } 18 } 19 public class Generic_Method { 20 public static void main(String[] args) { 21 Demo<String> d = new Demo<String>(); 22 23 d.myprint("haha"); 24 25 //d.myprint(2); //编译报错 26 27 d.myprint2(4); //编译运行都不报错 28 29 d.myprint3(5); 30 } 31 }
第六讲：黑马程序员_毕向东_Java基础视频教程第15天-11-集合框架(泛型接口)
一，泛型接口的两种使用方式：
-
- 在实现类中继续使用泛型。 ==构成了泛型类==
- 在实现类中确定泛型类型。
二，代码练习：
1 //定义泛型接口 2 interface inter <T>{ 3 public void myprint(T t); 4 } 5 6 //泛型接口第一种使用方式，确定泛型 7 class InterImpl implements inter<String>{ 8 9 //实现泛型方法 10 public void myprint(String s){ 11 System.out.println(s); 12 } 13 } 14 15 //泛型接口第二种使用方式 16 class InterImpl2 <T> implements inter <T>{ 17 18 //实现泛型方法 19 public void myprint(T t){ 20 System.out.println(t); 21 } 22 } 23 public class Generic_Interface { 24 public static void main(String[] args) { 25 26 InterImpl inter1 = new InterImpl(); 27 28 inter1.myprint("lisi"); 29 30 //inter1.myprint(2); //编译报错 31 32 InterImpl2 <String> inter2 = new InterImpl2 <String>(); 33 34 inter2.myprint("inter2"); 35 } 36 }
第七讲，第八讲：黑马程序员_毕向东_Java基础视频教程第15天-12-集合框架(泛型限定)
一，泛型限定
- 占位符 ？ 表示泛型可以接受任意对象。 ==优点：可以扩展接受的类型，确定：不能使用具体类型的方法==
- 也可以定义泛型方法表示接受任意泛型。 ====好处：可以操作具体对象，的绝体方法====
- 上限限定： ？ extends E 表示能够接收的对象是E 以及其子类对象。
- 下限限定： ? super T 表示能够接受的对象是 T 以及T的父类对象。
Map部分：
第一讲，第二讲,第三讲：黑马程序员_毕向东_Java基础视频教程第16天-01-集合(Map概述)，(Map子类对象特点)，(Map共性方法)
一，Map 接口的简单了解：
- 接口的定义：public interface Map<K,V> 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
- 添加：V put(K key, V value) 将指定的值与此映射中的指定键关联。如果此映射以前包含一个该键的映射关系，则用指定值替换旧值。
- 添加：void putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中。
- 删除：void clear() 从此映射中移除所有映射关系。此调用返回后，该映射将为空
- 删除：V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除。
- 判断：boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
- 判断：boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
- 判断：boolean isEmpty() 如果此映射未包含键-值映射关系，则返回 true。
- 获取：V get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回
null。 - 获取：int size() 返回此映射中的键-值映射关系数。如果该映射包含的元素大于 Integer.MAX_VALUE，则返回 Integer.MAX_VALUE。
- 获取：Collection<V> values() 返回此映射中包含的值的
Collection视图。 - 获取：Set<K> keySet() 返回此映射中包含的键的
Set视图。 - 获取：Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的
Set视图。
二，Map 接口的子类：
-
- Hashtable :此类实现一个哈希表，该哈希表将键映射到相应的值。任何非
null对象都可以用作键或值。 jdk1.0出现，线程同步，效率较差。 - HashMap ：基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。 jdk1.2出现，非线程同步，效率高。
- TreeMap : 底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
- Hashtable :此类实现一个哈希表，该哈希表将键映射到相应的值。任何非
三，代码练习：
1 import java.util.*; 2 3 4 public class MapDemo { 5 public static void main(String[] args) { 6 //创建一个Map对象底层使用Hash表结构 7 Map<String,String> map = new HashMap<String,String>(); 8 9 //添加元素 10 map.put("001", "lisi"); 11 12 //put方法返回被替代的值 13 System.out.println("put:"+map.put("001", "lisi2")); 14 map.put("002", "wangwu"); 15 16 map.put("003", "zhaoliu"); 17 18 //判断是否包含指定的键 19 System.out.println(map.containsKey("001")); 20 21 System.out.println(map.containsKey("01")); 22 23 //判断是否包含指定的值 24 System.out.println(map.containsValue("lisi")); 25 26 //删除指定的键值对 27 System.out.println(map.remove("002")); 28 29 //打印集合 30 System.out.println(map); 31 32 //获取 33 System.out.println(map.get("001")); 34 35 System.out.println(map.get("004")); 36 37 //获取集合中的所有值： 38 Collection<String> coll = map.values(); 39 40 System.out.println(coll); 41 } 42 }
第四讲，第五讲：黑马程序员_毕向东_Java基础视频教程第16天-04-集合(Map-keySet)，(Map-entrySet)
一，Map集合的两种取出方式：
-
- 通过，Set<K> keySet()方法。原理：将Map集合转成Set集合。再通过迭代器取出。
- 通过Set<Map.Entry<K,V>> entrySet() 方法：
二，Map.Entry 接口了解：
-
- 接口的定义 ：public static interface Map.Entry<K,V> 映射项（键-值对）。Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类。
- 方法：K getKey() 返回与此项对应的键。
- 方法：V getValue() 返回与此项对应的值。
- 方法：V setValue(V value) 用指定的值替换与此项对应的值。返回被替换的值。
三，图示：
Set<K> keySet()方法 图：
Set<Map.Entry<K,V>> entrySet() 方法 图：
四，代码练习：
Set<K> keySet()方法：
1 import java.util.*; 2 3 public class Map_Set { 4 public static void main(String[] args) { 5 6 //创建一个Map对象底层使用Hash表结构 7 Map<String,String> map = new HashMap<String,String>(); 8 9 //添加元素 10 map.put("001", "lisi"); 11 map.put("002", "wangwu"); 12 map.put("003", "zhaoliu"); 13 map.put("004", "zhangsan"); 14 15 //获取Map集合的所有键的Set集合 16 17 Set<String> set = map.keySet(); 18 19 //通过Set的迭代器区出所有的值 20 for(Iterator<String> iterator = set.iterator();iterator.hasNext();){ 21 System.out.println(map.get(iterator.next())); 22 } 23 } 24 }
Set<Map.Entry<K,V>> entrySet() 方法
1 import java.util.*; 2 3 public class Map_Entry { 4 public static void main(String[] args) { 5 6 Map<String,String> map = new HashMap<String,String>(); 7 8 map.put("001", "lisi"); 9 map.put("002","wangwu"); 10 map.put("003","zhaoliu"); 11 map.put("004", "zhangsan"); 12 13 //将Map集合中的映射关系取出。存入Set集合中 14 Set<Map.Entry<String,String>> set = map.entrySet(); 15 16 //迭代获取所有的Entry 17 for(Iterator<Map.Entry<String,String>> iterator = set.iterator();iterator.hasNext();){ 18 Map.Entry<String,String> entry = iterator.next(); 19 System.out.println("key"+entry.getKey()+" "+"value"+entry.getValue()); 20 } 21 } 22 }
第六讲：黑马程序员_毕向东_Java基础视频教程第16天-06-集合(Map练习)
一，练习要求：将学生对象和所对应的归属地作为键值对存储到Map集合中。
二，思路：
-
- 描述学生。
- 定义Map容器将学生视为键，地址作为值。存入。
- 获取Map集合中的元素。
三，代码练习：
1 import java.util.*; 2 3 public class Map_Student { 4 public static void main(String[] args) { 5 6 Map<Student,String> map = new HashMap<Student,String>(); 7 8 map.put(new Student("lisi",23), "上海"); 9 map.put(new Student("wangwu",22),"北京"); 10 map.put(new Student("zhaoliu",24),"天津"); 11 map.put(new Student("zhaoliu",22), "广东"); 12 13 //第一中取出方式：keySet() 14 Set<Student> set = map.keySet(); 15 16 for(Iterator<Student> iterator = set.iterator();iterator.hasNext();){ 17 Student s = iterator.next(); 18 System.out.println("学生："+s+" "+"地区："+map.get(s)); 19 } 20 21 //第二种取出方式：entrySet(); 22 23 Set<Map.Entry<Student,String>> set2 = map.entrySet(); 24 25 for(Iterator<Map.Entry<Student,String>> iterator = set2.iterator();iterator.hasNext();){ 26 Map.Entry<Student,String> entry = iterator.next(); 27 System.out.println("学生："+entry.getKey()+" "+"地址："+entry.getValue()); 28 } 29 } 30 } 31 32 class Student implements Comparable<Student>{ 33 private String name; 34 private int age; 35 36 public Student(String name,int age){ 37 this.name = name; 38 this.age = age; 39 } 40 41 public String getName(){ 42 return this.name; 43 } 44 45 public void setName(String name){ 46 this.name = name; 47 } 48 49 public int getAge(){ 50 return this.age; 51 } 52 53 public void setAge(int age){ 54 this.age = age; 55 } 56 57 @Override 58 public int hashCode() { 59 final int prime = 31; 60 int result = 1; 61 result = prime * result + age; 62 result = prime * result + ((name == null) ? 0 : name.hashCode()); 63 return result; 64 } 65 66 @Override 67 public boolean equals(Object obj) { 68 if (this == obj) 69 return true; 70 if (obj == null) 71 return false; 72 if (getClass() != obj.getClass()) 73 return false; 74 Student other = (Student) obj; 75 if (age != other.age) 76 return false; 77 if (name == null) { 78 if (other.name != null) 79 return false; 80 } else if (!name.equals(other.name)) 81 return false; 82 return true; 83 } 84 85 @Override 86 public int compareTo(Student s) { 87 int num = 0; 88 num = this.getName().compareTo(s.getName()); 89 90 if(num == 0){ 91 return this.age-s.age; 92 } 93 return num; 94 } 95 96 @Override 97 public String toString(){ 98 return "姓名:"+this.name+" "+"年龄："+this.age; 99 } 100 }
第七讲，第八讲：黑马程序员_毕向东_Java基础视频教程第16天-07-集合(TreeMap练习)，(TreeMap练习-字母出现的次数)
一，TreeMap 的了解：
- 类的声明：public class TreeMap<K,V>extends AbstractMap<K,V>implements NavigableMap<K,V>, Cloneable, Serializable 该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的
Comparator进行排序，具体取决于使用的构造方法。 - 构造方法：public TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序。
- 方法：public K ceilingKey(K key) 返回大于等于给定键的最小键；如果不存在这样的键，则返回
null。 - 方法：public Comparator<? super K> comparator() 返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。
- 方法：public K firstKey() 返回此映射中当前第一个（最低）键。
二，TreeMap 排序原理：对键集合按照TreeSet 规则进行排序。
三，练习： 获取一个字符串中每一个字母出现的次数。思路，字母和次数之间有映射关系。
思路：
-
- 将字符串转换为字符数组。
- 定义一个Map集合。存入字母以及出现的次数
- 遍历字符数组。
- 将Map集合中的数据变为指定的字符串并返回。
四，代码：
1 import java.util.*; 2 3 public class Map_Count { 4 public static void main(String[] args) { 5 System.out.println(charCount("abc总过abcd334678fgc")); 6 } 7 8 //创建方法实现功能 9 public static String charCount(String s){ 10 11 //将字符串变为字符数组，用于遍历 12 char[] ch = s.toCharArray(); 13 14 //存入字母，次数键值对 15 Map<Character,Integer> map = new HashMap<Character,Integer>(); 16 17 //出现的次数 18 Integer count = 0; 19 20 //将map转换为String返回 21 StringBuilder sb = new StringBuilder(); 22 23 //遍历数组 24 for(int i=0 ;i<ch.length;i++){ 25 //如果不是字母忽略 26 if(!(ch[i]>='a'&&ch[i]<='z'||ch[i]>='A'&&ch[i]<='Z')) 27 continue; 28 29 //统计次数 30 count = map.get(ch[i]); 31 //次数为空 32 if(count == null) 33 count = 0; 34 35 //设置键值对 36 map.put(ch[i], ++count); 37 } 38 39 //遍历集合，将内容转换为String返回 40 Set<Map.Entry<Character,Integer>> set = map.entrySet(); 41 for(Iterator<Map.Entry<Character,Integer>> iterator = set.iterator() ; iterator.hasNext();){ 42 Map.Entry<Character,Integer> entry = iterator.next(); 43 sb.append(entry.getKey()+"<"+entry.getValue()+">"); 44 } 45 46 return sb.toString(); 47 } 48 }
第九讲：黑马程序员_毕向东_Java基础视频教程第16天-09-集合(Map扩展)
集合的嵌套：
1 import java.util.*; 2 3 4 public class Maps { 5 public static void main(String[] args) { 6 7 //创建学校集合，保存班级名——班级实体键值对 8 Map<String,List<Student>> map = new HashMap<String,List<Student>>(); 9 10 //创建班级集合，保存学生对象 11 List<Student> class1 =new ArrayList<Student> (); 12 List<Student> class2 = new ArrayList<Student> (); 13 14 //加入集合中 15 map.put("class1", class1); 16 map.put("class2", class2); 17 18 //班级一中加入学生对象 19 class1.add(new Student("lisi",23)); 20 class1.add(new Student("wangwu",34)); 21 class1.add(new Student("zhaoliu",14)); 22 class1.add(new Student("zhansan",43)); 23 24 //班级二中加入学生对象 25 class2.add(new Student("lisi",23)); 26 class2.add(new Student("wangwu",34)); 27 class2.add(new Student("zhaoliu",14)); 28 class2.add(new Student("zhansan",43)); 29 30 //遍历输出 31 Set<String> set = map.keySet(); 32 33 for(Iterator<String> iterator = set.iterator();iterator.hasNext();){ 34 printInfo(map.get(iterator.next())); 35 } 36 } 37 38 //创建方法输出班级中所有学生的信息 39 public static void printInfo(List<Student> list){ 40 for(Iterator<Student> iterator = list.iterator();iterator.hasNext();){ 41 System.out.println(iterator.next()); 42 } 43 } 44 }
Collections学习
一，Collections类的了解：
- public class Collectionsextends Object 此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
- 此类没有构造方法，期类中定义的方法都是静态方法。
- 大部分方法是用于对List集合进行操作的，如比较，二分查找，随机排序等。
- 方法——排序：public static <T extends Comparable<? super T>> void sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。
- 方法——排序：public static <T> void sort(List<T> list,Comparator<? super T> c) 根据指定比较器产生的顺序对指定列表进行排序。
- 方法——排序：public static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。
- 方法——查找：public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 根据元素的自然顺序，返回给定 collection 的最大元素。
- 方法——查找：public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) 根据指定比较器产生的顺序，返回给定 collection 的最大元素。
- 方法——查找：public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 根据元素的自然顺序 返回给定 collection 的最小元素。
- 方法——查找：public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) 使用二分搜索法搜索指定列表，以获得指定对象。
- 方法——替换：public static <T> void fill(List<? super T> list,T obj) 使用指定元素替换指定列表中的所有元素。
- 方法——替换：public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 使用另一个值替换列表中出现的所有某一指定值。
- 方法——替换：public static void swap(List<?> list, int i, int j) 在指定列表的指定位置处交换元素。
- 方法——反转：public static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 返回一个比较器，它强行逆转指定比较器的顺序。
- 方法——反转：public static void reverse(List<?> list) 反转指定列表中元素的顺序。
二，代码练习：
1 import java.util.*; 2 3 4 public class CollectionsDemo { 5 public static void main(String[] args) { 6 7 //定义List集合 8 List<String> list = new ArrayList<String>(); 9 10 11 //向list集合添加内容 12 list.add("abc"); 13 list.add("cdfr"); 14 list.add("abc"); 15 list.add("utyuy"); 16 list.add("auiy"); 17 list.add("abcdef"); 18 19 //打印输出list集合 20 System.out.println(list); 21 22 //对list集合中的内容自然排序 23 Collections.sort(list); 24 25 //打印排序后的list集合 26 System.out.println(list); 27 28 //自定义排序规则，对list内容进行排序 29 Collections.sort(list,new StrLenComp()); 30 31 //打印排序后的list集合 32 System.out.println(list); 33 34 //查找最大元素 35 String max = Collections.max(list); 36 //最小元素 37 String min = Collections.min(list); 38 //输出最大最小元素 39 System.out.println("max:"+max+" "+"min:"+min); 40 41 //二分查找 42 int index = Collections.binarySearch(list, "abc"); 43 //二分查找，若找不到则返回 （-插入点-1） 44 int index2 = Collections.binarySearch(list, "z"); 45 46 System.out.println("abc:"+index+" "+"z:"+index2); 47 48 //替换元素 49 Collections.replaceAll(list, "abc", "cba"); 50 51 System.out.println(list); 52 53 //调换位置 54 Collections.swap(list, 1, 2); 55 System.out.println(list); 56 57 //随机排序 58 Collections.shuffle(list); 59 System.out.println("shuffle:"+list); 60 } 61 } 62 63 //自定义排序类 64 class StrLenComp implements Comparator<String>{ 65 public int compare(String s,String s2){ 66 return s.length()-s2.length(); 67 } 68 }
Arrays学习：
一，Arrays 类的了解：
-
- public class Arraysextends Object 此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
- 方法：public static <T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表。==注：数组转变为列表的意义：可以使用列表的思想和方法操作数组。将数组转变为集合后不可以使用集合的增删方法。（原因数组的长度不能改变）==
二，两点注意：
-
- 如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
- 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
1 import java.util.*; 2 3 public class ArraysDemo { 4 public static void main(String[] args) { 5 6 //声明数组 7 String[] strs = {"lisi","zhangsan","wangwu"}; 8 9 //数组遍集合 10 List<String> list = Arrays.asList(strs); 11 System.out.println(list); 12 13 //基本类型的数组 14 int[] arr = {1,2,3}; 15 16 //基本类型数组变为集合 17 List<int[]> list2 = Arrays.asList(arr); 18 System.out.println(list2); 19 20 //引用类型数组 21 Integer[] arrs = {1,2,3,4}; 22 23 List<Integer> list3 = Arrays.asList(arrs); 24 System.out.println(list3); 25 } 26 }
三，集合变数组：
-
- 使用到的方法：Object[] toArray() 返回包含此 collection 中所有元素的数组。
- 使用到的方法：<T> T[] toArray(T[] a) 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
- 集合转变为数组的意义：为了限定对元素的操作。不需要进行增删了。
- 指定类型的数组到底要定义多长呢：
- 当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
- 当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
五，代码练习：
1 import java.util.*; 2 3 public class ToArraysDemo { 4 public static void main(String[] args) { 5 6 //创建集合 7 List<String> list = new ArrayList<String>(); 8 //添加元素 9 list.add("lisi"); 10 list.add("wangwu"); 11 list.add("zhaoliu"); 12 13 //将集合转变为数组，数组长度小于集合长于 14 String[] arr = list.toArray(new String[1]); 15 16 System.out.println(Arrays.toString(arr)); 17 18 //数组长度大于集合长度 19 String[] arr2 = list.toArray(new String[5]); 20 21 System.out.println(Arrays.toString(arr2)); 22 } 23 }
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------