程序博客网 > 淘宝网太极武术鞋

（每日一转）黑马程序员----跟着老毕学Java-集合框架篇之Map与工具类

来源：互联网 发布：淘宝网太极武术鞋 编辑：程序博客网 时间：2024/05/17 00:56

Map和集合工具类

Map

概述

Map集合:它存储的是键值对，其中键必须保证唯一性，值允许重复。Map集合没有自身特有的迭代器，它的元素取出是通过将键或键值对放入Set集合中，利用Set集合中的迭代器取出的。Map是双列集合，Collection是单列集合。

共性方法

Map接口中定义了该体系通用的方法。

1.添加

V put(K key, V value)

void putAll(Map<? extends K,? extends V>m)

注意put与add的不同：put时，如果key已经存在，则新存入的值覆盖原来的值，并把原来的值作为方法的返回值；add时，如果该元素已经存在，则不能存入集合，方法返回值为false，如果存在，则存入集合，方法返回值为true。

2.删除

clear()

V remove(Object key)

3.判断

boolean containsKey(Object key)

boolean containsValue(Object value)

boolean isEmpty()

4.获取

V get(Object key)

int size()

Collection<V> values()

Set<Map.Entry<K,V>>entrySet()

Set<K> keySet()

示例代码1

[java] view plaincopyprint?
  1. import java.util.Collection;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. class MapDemo
  5. {
  6. public staticvoid main(String[] args)
  7. {
  8. Map<String,String> map = new HashMap <String,String>();
  9. System.out.println("put:"+map.put("01","zhangsan01"));//结果为null
  10. System.out.println("put:"+map.put("01","wangwu"));//结果我zhangsan01
  11. /*
  12. put如果存入了已经存在的键，则新键值会覆盖旧键值，并将旧键值返回；put存入一个未存在的键时，会返回null。
  13. */
  14. map.put("02","zhangsan02");
  15. map.put("03","zhangsan02");
  16. map.put(null,null);
  18. System.out.println("containsKey:"+map.containsKey("022"));
  19. //System.out.println("remove:"+map.remove("02"));
  20. System.out.println("get:"+map.get("023"));
  21. map.put("04","null");
  22. System.out.println("get:"+map.get("04"));
  23. //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。（毕老师这点讲的是不是有问题？）
  26. //获取map集合中的值
  27. Collection <String> coll =map.values();
  29. System.out.println(coll);
  30. System.out.println(map);
  31. }
  32. }
  33. /*
  34. 既然hashMap可以存放null键null值，那么通过get方法返回null，应该不能判断该键是不是存在，因为可能出现有键值为空的情况;这时就要用containsKey()方法来判断了
  35. */


Map的体系

Map

|---Hashtable<K,V>：底层是哈希表数据结构，不可以存入null键null值，该集合是同步的。JDK1.0，效率低。，

|---HashMap<K,V>：底层是哈希表数据结构，允许存入null键null值，该集合是不同步的。JDK1.2，效率高。

|---TreeMap<K,V>：底层是二叉树结构，线程不同步，可以用于给Map集合中键进行排序。

和Set很像，其实Set底层就是使用了Map集合。

元素取出的两种方式

示例代码2

[java] view plaincopyprint?
  1. /*
  3. map集合的两种取出方式：
  4. 1.Set<K> keySet;将map中的所有的键存入到Set集合，因为set具有迭代器。
  5. 所以可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。
  6. Map集合的取出原理:将Map集合转成Set集合，再通过迭代器取出。
  7. 2.Set<Map.Entry<K,V>> entrySet:将Map集合中的映射关系存入到了Set集合中，
  8. 而这个关系的数据类型就是：Map.Entry.
  9. */
  10. import java.util.HashMap;
  11. import java.util.Iterator;
  12. import java.util.Set;
  13. import java.util.Map;
  15. class MapDemo2
  16. {
  17. public staticvoid main(String[] args)
  18. {
  19. Map <String,String> map = new HashMap<String ,String>();
  20. map.put("01","zhangsan01");
  21. map.put("02","zhangsan02");
  22. map.put("03","zhangsan03");
  23. map.put("04","zhangsan04");
  24. System.out.println(map);
  25. System.out.println("-------------");
  28. //Map元素取出的方式一（EntrySet）：将Map集合中的映射关系取出，存入到Set集合中。
  29. Set<Map.Entry<String , String>> entrySet = map.entrySet();
  30. System.out.println(entrySet);
  31. System.out.println("-------------");
  33. Iterator<Map.Entry<String , String>> it = entrySet.iterator();
  34. while(it.hasNext())
  35. {
  36. Map.Entry<String,String> me = it.next();
  37. String key = me.getKey();
  38. String value = me.getValue();
  39. System.out.println(me);
  40. System.out.println("key:"+key+",value="+value);
  42. }
  44. //元素取出的方式二（KeySet)
  45. /*
  46. //先获取map集合的所有键的Set集合。
  47. Set<String> keySet = map.keySet();
  48. //有了Set集合，就可以获取机迭代器。
  49. Iterator<String> it = keySet.iterator();
  50. while(it.hasNext())
  51. {
  52. String key = it.next();
  53. String value = map.get(key);
  54. System.out.println("key:"+key+",value="+value);
  56. }
  57. */
  58. }
  59. }
  61. /*
  62. Map.Entry 其实Entry也是一个接口，他是Map接口中的一个内部接口。如下：
  64. interface Map
  65. {
  66. public static interface Entry
  67. {
  68. public abstract Object getKey();
  69. public abstract Object getValue();
  70. }
  71. }
  72. class HashMap implements Map
  73. {
  74. class Haha implements Map.Entry
  75. {
  76. public Object getKey(){}
  77. public Object getValue(){}
  78. }
  80. }
  81. */

练习1

[java] view plaincopyprint?
  1. /*
  2. 每一个学生都有对应的归属地
  3. 学生Student，地址String
  4. 学生属性：姓名，年龄
  5. 注意：姓名和年龄相同视为同一个学生
  6. 保证学生的唯一性。
  8. 1.描述学生
  9. 2.定义Map容器，将学生作为键，地址作为值，存入。
  10. 3.获取Map集合中的元素。
  11. */
  13. import java.util.*;
  14. class MapTest
  15. {
  16. public staticvoid main(String[] args)
  17. {
  18. HashMap<Student,String> hm = new HashMap<Student,String>();
  19. hm.put(new Student("lisi1",22),"beijing");
  20. hm.put(new Student("lisi1",22),"shanghai");
  21. hm.put(new Student("lisi3",24),"wuhan");
  22. hm.put(new Student("lisi4",25),"nanjing");
  24. //第一种取出方式：keySet()
  25. Iterator<Student> it = hm.keySet().iterator();
  26. while(it.hasNext())
  27. {
  28. Student stu = it.next();
  29. String addr = hm.get(stu);
  30. System.out.println(stu+".."+addr);
  31. }
  32. System.out.println("-------------");
  34. //第二种取出方式：entrySet()
  35. Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
  36. Iterator<Map.Entry<Student,String>> ite = entrySet.iterator();
  37. while(ite.hasNext())
  38. {
  39. Map.Entry<Student,String> me = ite.next();
  40. Student s = me.getKey();
  41. String str = me.getValue();
  42. System.out.println(s+","+str);
  43. }
  45. }
  46. }
  48. /*
  49. 为什么将复写equals、hashCode方法，并实现comparable接口？
  50. 因为，Sutdent有可能存入HashMap中，也有可能存入TreeMap中。
  52. */
  53. class Student implements Comparable<Student>
  54. {
  55. private String name;
  56. private int age;
  57. Student(String name,int age)
  58. {
  59. this.name = name;
  60. this.age = age;
  61. }
  62. public String getName()
  63. {
  64. return name;
  65. }
  66. public void setName(String name)
  67. {
  68. this.name = name;
  69. }
  70. public int getAge()
  71. {
  72. return age;
  73. }
  74. public void setAge(int age)
  75. {
  76. this.age = age;
  77. }
  78. public int hashCode()
  79. {
  80. return name.hashCode()+37*age;//这点要注意
  81. }
  82. public boolean equals(Object obj)
  83. {
  84. if( !(obj instanceof Student))
  85. throw new ClassCastException("类型不匹配");
  86. Student s = (Student) obj;
  87. return this.name.equals(s.getName())&&this.age==s.getAge();
  88. }
  89. public int compareTo(Student s)
  90. {
  91. int num = new Integer(this.age).compareTo(new Integer(s.getAge()));
  92. if(num == 0)
  93. this.name.equals(s.name);
  94. return num;
  95. }
  96. public String toString()
  97. {
  98. return name+","+age;
  99. }
  100. }

练习2

[java] view plaincopyprint?
[java] view plaincopyprint?
  1. /*
  2. 需求:对学生对象的年龄进行升序排序。
  4. 因为数据是以键值对形式存在的,所以要使用可以排序的Map集合，TreeMap。
  5. */
  6. import java.util.*;
  8. class StuNameComparator implements Comparator<Student>
  9. {
  10. public int compare(Student s1,Student s2)
  11. {
  12. int num = s1.getName().compareTo(s2.getName());
  13. if(num == 0)
  14. return new Integer(s1.getAge()).compareTo(s2.getAge());
  15. return num;
  16. }
  17. }
  18. class MapTest2
  19. {
  20. public staticvoid main(String[] args)
  21. {
  22. TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());
  23. tm.put(new Student("lisi1",22),"beijing");
  24. tm.put(new Student("alisi1",23),"shanghai");
  25. tm.put(new Student("alisi1",24),"shanghai");
  26. tm.put(new Student("xlisi3",24),"wuhan");
  27. tm.put(new Student("lisi4",25),"nanjing");
  29. Iterator<Map.Entry<Student,String>> it = tm.entrySet().iterator();
  30. while(it.hasNext())
  31. {
  32. Map.Entry<Student,String> me = it.next();
  33. Student stu = me.getKey();
  34. String addr = me.getValue();
  35. System.out.println(stu+","+addr);
  36. }
  38. }
  39. }


练习3

[java] view plaincopyprint?
  1. /*
  2. 练习：
  3. ”stdafasdffadf“获取该字符串中的字母出现的次数。
  4. 希望打印结果:a(1)c(2)。。。。
  6. 通过结果发现，每个字母都有对应的次数
  7. 说明字母和次数之间都有映射关系。
  9. 注意了，当发现有映射关系时，可以选择Map集合
  10. 因为Map集合中存放的就是映射关系。
  12. 什么时候使用Map集合呢？
  13. 当数据之间存在这个映射关系时，就要先想到Map集合。
  14. 我的思路：
  15. 1.建立字母为键，类型为char，次数为值，类型为int，的Map，因为字母按顺序打印，所以选用TreeMap
  16. 2.将字符串遍历，重复的字符，值++；
  17. 3.使用迭代器打印TreeMap集合。
  19. 毕老师思路：
  20. 1.将字符串转换成字符数组，因为要对每一个字母进行操作。
  22. 2.定义一个map集合，因为打印结果的字母有顺序，所以使用TreeMap集合。
  24. 3.遍历字符数组。
  25. 将每一个字符作为键去查map集合。
  26. 如果返回null，将该字母和1存入到map集合。
  27. 如果返回不是null，说明该字母在map集合已经存在，并有对应的次数。
  28. 那么就获取该次数进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖调用原键所对应的值。
  29. 4.将map集合中的数据变成指定的字符串形式返回。
  32. */
  33. import java.util.*;
  34. class MapTest3
  35. {
  36. public staticvoid main(String[] args)
  37. {
  38. //String str = myCharCount("adfasdf!!!!!sssasdfas");
  39. String str =charCount("dsadfadfasdf");
  40. System.out.println(str);
  41. }
  42. //毕老师的方法
  43. public static String charCount(String str)
  44. {
  45. char [] chs = str.toCharArray();
  46. TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
  47. for(int x =0;x<chs.length;x++)
  48. {
  49. int count =0;
  50. char ch = str.charAt(x);
  51. if(!(ch>='a'&&ch<='z'|| ch>='A'&&ch<='Z'))
  52. continue ;
  54. Integer value = tm.get(chs[x]);
  56. /*
  57. if(value == null)
  58. tm.put(chs[x],1);
  59. else
  60. {
  61. value = value+1;
  62. tm.put(chs[x],value);
  63. }
  64. */
  65. if(value!=null)
  66. count = value;
  67. count++;
  68. tm.put(chs[x],count);
  69. }
  71. StringBuilder sb = new StringBuilder();
  72. Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
  73. Iterator<Map.Entry<Character,Integer>>it = entrySet.iterator();
  74. while(it.hasNext())
  75. {
  76. Map.Entry<Character,Integer> me = it.next();
  77. Character ch = me.getKey();
  78. Integer value = me.getValue();
  79. sb.append(ch+"("+value+")");
  80. }
  81. return sb.toString();
  83. }
  84. //我的方法
  85. public static String myCharCount(String str)
  86. {
  88. String resault="";
  89. TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
  91. int count = 0;
  92. for(int x =0;x<str.length();x++)
  93. {
  94. char ch = str.charAt(x);
  95. if(!(ch>='a'&&ch<='z'|| ch>='A'&&ch<='Z'))
  96. continue ;
  97. if(!tm.containsKey(ch))
  98. tm.put(ch,1);
  99. else
  100. {
  101. int num =tm.get(ch)+1;
  102. tm.put(ch,num);
  103. }
  104. }
  107. Iterator<Map.Entry<Character,Integer>> it = tm.entrySet().iterator();
  108. while(it.hasNext())
  109. {
  110. Map.Entry<Character,Integer> me = it.next();
  111. char letter = me.getKey();
  112. int num = me.getValue();
  113. resault += letter+"("+num+")";
  114. }
  116. return resault;
  118. }
  119. }

Map扩展

Map集合中的值还可以是Map集合，这是Map集合嵌套使用的情况。

示例代码3

[java] view plaincopyprint?
  1. /*
  2. map扩展知识
  4. map集合使用是因为具备映射关系。
  6. “yureban” “01” “zhangsan”
  7. “yureban” “02” "lisi"
  8. "jiuyeban" "01" "zhousi"
  9. "jiuyeban" "02" "liuwu"
  11. 一个学校有多个教室，每个教室都有自己的名字，而一个教室对应多个学生。
  13. */
  14. import java.util.*;
  15. class Student1
  16. {
  17. private static String id;
  18. private String name;
  19. Student1(String id,String name)
  20. {
  21. this.id = id;
  22. this.name = name;
  23. }
  24. public String toString()
  25. {
  26. return id+":::"+name;
  27. }
  28. public staticvoid main(String[] args)
  29. {
  30. Student1 s1 =new Student1("id","name");
  31. id = "1212";
  32. Integer a = Integer.parseInt(id,10);
  33. System.out.println(s1.id);
  34. System.out.println(a);
  37. }
  39. }
  40. class MapDemo3
  41. {
  42. public staticvoid demo()
  43. {
  44. HashMap<String,List<Student1>> czbk = new HashMap<String,List<Student1>>();
  45. List<Student1> yure = new ArrayList<Student1>();
  46. List<Student1> jiuye = new ArrayList<Student1>();
  48. czbk.put("yuer:",yure);
  49. czbk.put("jiuye:",jiuye);
  51. yure.add(new Student1("01","zhangsan"));
  52. yure.add(new Student1("02","wagnwu"));
  54. jiuye.add(new Student1("01","liuqiang"));
  55. jiuye.add(new Student1("02","limeng"));
  57. Iterator<String> it = czbk.keySet().iterator();
  58. while(it.hasNext())
  59. {
  60. String roomName = it.next();
  61. List<Student1> room = czbk.get(roomName);
  62. System.out.println(roomName);
  63. getInfos(room);
  64. }
  65. }
  66. public staticvoid getInfos(List<Student1> room)
  67. {
  68. Iterator<Student1> it = room.iterator();
  69. while(it.hasNext())
  70. {
  71. System.out.println(it.next());
  72. }
  73. }
  75. public staticvoid main(String[] args)
  76. {
  77. demo();
  78. }
  80. public staticvoid getStudentInfo(HashMap<String,String> hm)
  81. {
  82. Iterator<Map.Entry<String,String>> it = hm.entrySet().iterator();
  83. while(it.hasNext())
  84. {
  85. Map.Entry<String,String> me = it.next();
  86. String num =me.getKey();
  87. String name = me.getValue();
  88. System.out.println(num+":"+name);
  89. }
  90. System.out.println(hm);
  91. }
  92. }

集合框架工具类

Collections

Collections是一个集合工具类，它没有构造方法，所有的成员方法都是静态的。利用它可以实现对集合的一些特殊操作，如排序、二分查找、取最值、反转等。

1、 对List集合进行排序
Collections.sort(list)，Collections.sort( list, comparator)。

2、 获取集合的最大值

Collections.sort(collection)，Collections.sort(collection，comparator)。

3、 二分查找
binarySearch(List<? extends Comparable<? super T>> list, T key)
binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

4、 填充
fill（list，obj），将集合所有元素都换成obj

5、 替换
replaceAll(List<T> list, T oldVal, T newVal)，将集合中出现的所有的某一个值，替换为另一个。

6、 反转

reverse(List<?> list)，头变尾，尾变头。

7、随机排列
shuffle(list)，应用：洗牌、掷色子。

重点掌握的下边三个方法

1、 reverseOrder：强行逆转比较器的自然顺序或元素的自然顺序。

2、 将集合由线程不安全转为线程安全的
synchronizedCollection(Collection<T>c)
synchronizedList(List<T>list)
synchronizedMap(Map<K,V>m)
synchronizedSet(Set<T>s)

其原理是：内部封装一个容器，然后定义一个锁，使用该锁同步并封装该容器的所有方法。

示例代码4：

[java] view plaincopyprint?
  1. import java.util.*;
  2. class CollectionsDemo
  3. {
  5. public staticvoid main(String[] args)
  6. {
  7. sortDemo();
  8. }
  10. public staticvoid sortDemo()
  11. {
  12. List <String> list = new ArrayList<String>();
  13. list.add("abcdd");
  14. list.add("asdfas");
  15. list.add("saa");
  16. list.add("bbb");
  17. list.add("qt");
  18. list.add("bbb");
  22. sop(list);
  23. //排序演示，要排序的元素继承comparable类或者新建一个比较器。
  24. Collections.sort(list,new StrLenComparator());
  25. sop(list);
  26. sop("----------sort");
  28. //取最大值演示：要排序的元素继承comparable类或者新建一个比较器。
  29. String max = Collections.max(list,new StrLenComparator());
  30. sop(max);
  31. sop("----------max");
  33. //二分查找：必须先是有序集合，前后排序的比较规需要相同，是自然顺序都是自然顺序，是比较器都是比较器。
  34. int index = Collections.binarySearch(list,"kkkk");
  35. //int index = halfSearch(list,"aaaa");
  36. sop(index);
  37. sop("----------binarySearch");
  38. /*
  39. 我的问题：如果前边排序是用比较器，后来查找的时候没有加比较器，返回值如何？
  40. */
  42. //reverse：将集合中的元素反转。
  43. Collections.reverse(list);
  44. sop(list);
  45. sop("----------reverse");
  47. //swap():交换集合中两个元素的位置
  48. Collections.swap(list,2,5);
  49. sop(list);
  50. sop("----------swap");
  52. //shufle:使用默认随机源对指定列表进行置换(如洗牌动作、色子)
  53. Collections.shuffle(list);
  54. sop(list);
  55. sop("----------shuffle");
  57. //fill方法：可以将list集合中的所有元素替换成指定元素，
  58. //练习：将list集合中的部分元素替换成指定元素。
  59. sop(list);
  60. Collections.fill(list,"yyyy");
  61. sop(list);
  62. sop("----------fill");
  63. //repalceAll:将集合中的所有的指定元素替换成新元素
  64. Collections.replaceAll(list,"yyyy","00");//其实封装了list.set(index,"00");
  65. sop(list);
  66. sop("----------repalceAll");
  70. }
  72. //二分法原理。
  73. public staticint halfSearch(List<String> list,String key/*,Comparator cmp*/)
  74. {
  75. int max,min,mid;
  76. max =list.size()-1;
  77. min = 0;
  79. while(min<max)
  80. {
  81. mid =(max+min)>>1;
  82. String str = list.get(mid);
  83. int num = str.compareTo(key);//int num = cmp.compare(s1,s2);
  84. if(num>0)
  85. max =mid -1;
  86. else if(num<0)
  87. min =mid + 1;
  88. else
  89. return mid;
  90. }
  92. return min;//-min-1;
  93. }
  94. public staticvoid sop(Object obj)
  95. {
  96. System.out.println(obj);
  97. }
  98. }
  99. class StrLenComparatorimplements Comparator<String>
  100. {
  101. public int compare(String s1,String s2)
  102. {
  103. if(s1.length()>s2.length())
  104. return 1;
  105. if(s1.length()<s2.length())
  106. return -1;
  107. return s1.compareTo(s2);
  108. }
  109. }


示例代码5：

[java] view plaincopyprint?
  1. *
  2. Collections.reverseOrder()命令：反转自然顺序或比较器
  3. */
  4. import java.util.*;
  5. class StrComparatorimplements Comparator<String>
  6. {
  7. public int compare(String s1,String s2)
  8. {
  9. /*int num =s1.compareTo(s2);
  10. if(num>0)
  11. return 1;
  12. if(num<0)
  13. return -1;
  14. return num;
  15. */
  17. return s2.compareTo(s1);
  18. }
  19. }
  20. class StrLenComparator implements Comparator<String>
  21. {
  22. public int compare(String s1,String s2)
  23. {
  24. if(s1.length()>s2.length())
  25. return 1;
  26. if(s1.length()<s2.length())
  27. return -1;
  28. return s1.compareTo(s2);
  29. }
  30. }
  32. class CollectionsDemo2
  33. {
  34. public staticvoid main(String[] args)
  35. {
  36. orderDemo();
  37. }
  38. public staticvoid orderDemo()
  39. {
  40. TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
  41. ts.add("adsdf");
  42. ts.add("afasdf");
  43. ts.add("efsf");
  44. ts.add("bc");
  45. ts.add("e");
  47. Iterator<String> it = ts.iterator();
  48. while(it.hasNext())
  49. {
  50. System.out.println(it.next());
  51. }
  52. }
  53. }


Arrays

数组工具类：

binarySearch：二分查找数组中的元素。
copyOf：复制数组
copyOfRange：复制数组内的某一段

equals：判断两个数组是否相等。

deeEquals：如果两个指定数组彼此是深层相等的，则返回true。

deeHashCode：基于指定数组的“深层内容”返回哈希码。

deeToString: 返回指定数组“深层内容”的字符串表示形式。

fill：将指定的值分配给指定数组的每个元素。

hashCode：基于指定数组的内容返回哈希码。

sort: 对数组元素进行排序

toString:把数组的元素转化成字符串

重点：Arrays有个asList(T… t)方法，可以把数组转换为List集合,它与Collection接口中的toArray一起，构成了数组API和集合API之间的桥梁。

CollectionToArray

示例代码6：

[java] view plaincopyprint?
  1. /*
  2. 集合变数组。
  3. Collection接口中的toArray方法。
  4. */
  5. import java.util.*;
  6. class CollectionToArray
  7. {
  8. public staticvoid main(String[] args)
  9. {
  10. ArrayList<String >al = new ArrayList<String>();
  11. al.add("abc1");
  12. al.add("abc2");
  13. al.add("abc3");
  15. /*
  16. 1.指定类型的数组到底要定义多长？
  17. 当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，数组的长度为集合的size
  18. 当指定类型的数组长度大于了集合的size，就不会新创建数组，而是用传递进来的数组。
  20. 所以创建一个刚刚好的数组最优。
  22. 2.为什么要将集合变数组？
  23. 为了限定对元素的操作。（如返回数据时，将数据变成数组）
  25. */
  27. String [] arr = al.toArray(new String[0]);
  28. System.out.println(Arrays.toString(arr));
  30. }
  31. }


ArrayToList

示例代码7：

[java] view plaincopyprint?
  1. class ArraysDemo
  2. {
  3. public staticvoid main(String[] args)
  4. {
  5. // int[] arr =new int[]{2,5,7};
  6. // System.out.println(Arrays.toString(arr));
  9. String [] arr ={"abc","cc","kkk"};
  10. //把数组编程List集合有什么好处？
  11. /*
  12. 可以使用集合的思想和方法来操作数组中的元素。（如判断是否包含：如果是数组，需要进行循环判断））。否则需要自己封装多种方法。
  14. 注意：将数组变成集合，不可以使用集合的增删方法(add,remove)，因为数组的长度是固定的。
  16. 如果增删了，那么会发生UnsupportedOperationException
  17. */
  19. List<String> list = Arrays.asList(arr);
  20. //list.add(0,"k");//UnsupportedOperationException
  21. System.out.println(list);
  26. int [] nums ={2,5,9};
  27. List<int[]> li = Arrays.asList(nums);
  30. /*
  31. 如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
  32. 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存储。
  33. */
  35. sop(li);
  36. Integer [] nums1 ={2,5,9};
  37. List<Integer> lis = Arrays.asList(nums1);
  38. sop(lis);
  39. }
  40. public staticvoid sop(Object obj)
  41. {
  42. System.out.println(obj);
  43. }
  44. }


淘宝网太极武术鞋 淘宝网太极武术鞋
原创粉丝点击
热门IT博客
实木衣柜 知乎实木衣柜 知乎
淘宝天猫返利淘宝天猫返利
python csv串行
中华软件
时差7小时 知乎
双色球组合软件
javascript用什么软件
文墨飞星排盘软件
添加json里的一个对象
淘宝特卖2016女装
网络知识产权侵权案例
办公室 闲话 知乎
小米数据分析
java for 乘法表
按键精灵网页表格数据
珠海长隆 超级激流数据
java message类
公交线路优化
淘宝iphone6s防水标志
天津淘宝礼仪公司
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 素描怎么削铅笔 削铅笔的小刀 素描用的铅笔怎么削 削铅笔的刀 梦见削铅笔 素描的铅笔怎么削 2b铅笔的削法 绘图铅笔怎么削 削铅笔的东西叫什么 削铅笔的艺术 画素描的铅笔怎么削 工程制图铅笔削法 削铅笔的拼音 削鼻头 整容 削骨 削下巴价格 下巴削骨 脸部整形削骨 削骨整形费用 整容磨腮削骨多少钱 削脸整容 颧骨削骨 颧骨内推和削颧骨有什么区别 削颧骨 什么是颧骨 下颌角 颧骨整形术 脸颧骨 颧骨凸出 颧骨是 下颌角颧骨整形费用 怎样磨颧骨 颧骨宽的男人 颧骨高磨骨 整形下颌角颧骨 磨颧骨医院 颧骨和太阳穴长斑 颧骨截骨术 磨颧骨好吗 颧骨整形方法 颧骨磨骨价格 颧骨磨骨整形价格

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里