黑马程序员----6集合

------- android培训、java培训、期待与您交流！ ----------

>> map集合

|--map集合：接口Map<K,V>//将键（key）映射到值（value）的对象，一个映射不能包含重复的键（键是唯一的），每个键最多只能映射到一个值。

                            map是双列集合，对应的collection是单列集合。

            该集合存储键值对，一对一对往里面存，而且要保证键的唯一性。

|--HashTable:底层是哈希表数据结构，不可以存入null键和null值。该集合是线程同步的。jdk1.0效率低

  |--properties: 用于配置文件的定义和操作，使用频率非常高，同时键和值都是字符串。

                                 是集合中可以和IO技术相结合的对象。 到了IO在学习它的特有和io相关的功能。

|--HashMap：底层是哈希表数据结构，允许存入null键和null值。该集合是不同步的。jdk1.2，效率高。是无序的。

     |--LinkedHashMap

|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

 

实际上，Set底层就是使用了Map集合。

 

>>功能

1、添加

         V put(K key,V value)//将指定的值与此映射中的指定键关联（可选操作）。

         void putAll(Map<? extends K,?extends V> m)//从指定映射中将所有映射关系复制到此映射中

 

补充：为什么put返回V而putAll为void呢？因为put方法将k和v作为元素存储如map集合，当存入了相同的k时，新的值会覆盖原来的值，并返回原来的值。

 

2、删除

         void clear()//从此映射中移除所有映射关系（可选操作）。

         V remove(Object key)//如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

 

3、判断

         boolean containsValue(Object value)//如果此映射将一个或多个键映射到指定值，则返回 true。

         boolean containsKey(Object key)//如果此映射包含指定键的映射关系，则返回 true。

         boolean isEmpty()//如果此映射未包含键-值映射关系，则返回 true。

 

补充：凡是“is”打头的方法，返回值几乎是boolean型的。

 

4、获取

       V get(Object key)//返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null。

         int size()//返回此映射中的键-值映射关系数。

       Collection<V> values()//返回此映射中包含的值的Collection 视图。

       重点

         Set<Map.Entry<K,V>> entrySet()//返回此映射中包含的映射关系的 Set 视图。

         Set<K> keySet()//返回此映射中包含的键的Set 视图。

 

5、Map没有迭代器

         迭代器是collection集合有的，Map集合的取出元素的原理：就是将Map集合先转成Set集合，再进行迭代。

 

>>eg：基本演示

importjava.util.*

classMapDemo

{

         public static void main(String[] args)

         {

                   Map<String,String> map= new HashMap<String,String>();//泛型

                   //添加元素

                   map.put(“01”,”zhangsan1”);

                   map.put(“02”,”zhangsan2”);

                   System.out.println(map.put(“03”,”zhangsan3”));//返回null

                   System.out.println(map.put(“01”,zhangsan88));//返回zhangsan1

                  

                   Systme.out.println(“containsKey:”+map.containsKey(“022”));

                   Systme.out.println(“remove:”+map.remove(“02”));

                  

                   Systme.out.println(map);//打印，结果02消失

                  

                   Systme.out.println(“get:”+map.get(“023”));//结果null

                  

//特殊情况

                   map.put(null,”kong”);//HashMap可以存入空键

                   //map.put(“04”,null);

                   Systme.out.println(“get:”+map.get(null));//结果输出kong

                   //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。

                  

                   //获取Map集合中所有的值

                   Collection<String> coll= map.values()

                   Systme.out.println(coll);//输出值，无序

                   Systme.out.println(map);//输出键值对，无序

                  

                   /*特殊：put方法*/

                   Systme.out.println(“put:”+map.put(“01”,zhangsanBbb));//返回zhangsan1

                   Systme.out.println(“put:”+map.put(“01”,wangwu));//返回zhangsanBbb

                   /*添加相同的键，原有值被覆盖了，返回被替换的值*/

                  

                  

                  

         }

}

 

>>map集合的两种取出方式：

1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键，再根据get方法。获取每一个键对应的值。

 

         Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

eg: import java.util.*;

class MapDemo2

{

         publicstatic void main(String[] args)

         {

                   Map<String,String>map = new HashMap<String,String>();

 

                   map.put("02","zhangsan2");

                   map.put("03","zhangsan3");

                   map.put("01","zhangsan1");

                   map.put("04","zhangsan4");

 

                   //先获取map集合的所有键的Set集合,keySet();

                   Set<String>keySet = map.keySet();

 

                   //有了Set集合。就可以获取其迭代器。

                   Iterator<String>it = keySet.iterator();

 

                   while(it.hasNext())

                   {

                            Stringkey = it.next();//取键

                            //有了键可以通过map集合的get方法获取其对应的值。

                            Stringvalue = map.get(key);//取值

                            System.out.println("key:"+key+",value:"+value);

                   }

         }

}

 

2，Set<Map.Entry<k,v>>entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry

 

         上面的意思其实是：将map集合中的键值关系取出，并封装成一个键值关系对象。再存储到一个set集合中。键值映射关系封装对象后的数据类型是：Map.Entry。如果是键是丈夫，值是妻子，那么键值映射关系封装对象就是结婚证。

 

entry其实就是Map中的一个static内部接口。为什么要定义在内部呢？因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。

 

eg: import java.util.*;

 

class MapDemo2

{

         publicstatic void main(String[] args)

         {

                   Map<String,String>map = new HashMap<String,String>();

 

                   map.put("02","zhangsan2");

                   map.put("03","zhangsan3");

                   map.put("01","zhangsan1");

                   map.put("04","zhangsan4");

 

                   //将Map集合中的映射关系取出。存入到Set集合中。

                   Set<Map.Entry<String,String>>entrySet = map.entrySet();

//泛型嵌套形式，Map是一个接口，Entry是它的内部接口

 

                   Iterator<Map.Entry<String,String>>it = entrySet.iterator();

 

                   while(it.hasNext())

                   {

                            Map.Entry<String,String>me = it.next();

                            Stringkey = me.getKey();

                            Stringvalue = me.getValue();

 

                            System.out.println(key+":"+value);

 

                   }

 

                   /*

                   //先获取map集合的所有键的Set集合,keySet();

                   Set<String>keySet = map.keySet();

 

                   //有了Set集合。就可以获取其迭代器。

                   Iterator<String>it = keySet.iterator();

 

                   while(it.hasNext())

                   {

                            Stringkey = it.next();

                            //有了键可以通过map集合的get方法获取其对应的值。

                            Stringvalue  = map.get(key);

                            System.out.println("key:"+key+",value:"+value);

                   }

 

                   */

         }

}

 

Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。

interface Map

{

         publicstatic interface Entry//作为子接口，而且被静态修饰的一定是内部接口

         {

                   publicabstract Object getKey();

                   publicabstract Object getValue();

         }

}

 

class HashMap implements Map

{

         classHahs implements Map.Entry

         {

                   public  Object getKey(){}

                   public  Object getValue(){}

         }

        

}

 

>>Map例子

每一个学生都有对应的归属地。

学生Student，地址String。

学生属性：姓名，年龄。

注意：姓名和年龄相同的视为同一个学生。

保证学生的唯一性。

 

1，描述学生。

2，定义map容器。将学生作为键，地址作为值。存入。

3，获取map集合中的元素。

 

import java.util.*;

class Student implementsComparable<Student>//实现接口，注意泛型

{

         privateString name;

         privateint age;

         Student(Stringname,int age)

         {

                   this.name= name;

                   this.age= age;

         }

        

         publicint compareTo(Student s)//覆盖方法

         {

                   intnum = new Integer(this.age).compareTo(new Integer(s.age));

 

                   if(num==0)

                            returnthis.name.compareTo(s.name);

                   returnnum;

                   //整合if语句

                   //returnnum==0? this.name.compareTo(s.name):num;

         }

 

         publicint hashCode()//覆盖方法

         {

                   returnname.hashCode()+age*34;

         }

         publicboolean equals(Object obj)//覆盖方法

         {

                   if(!(objinstanceof Student))

                            thrownew ClassCastException("类型不匹配");//返回false改成抛出异常

 

                   Students = (Student)obj;

 

                   returnthis.name.equals(s.name) && this.age==s.age;

                  

 

         }

         publicString getName()

         {

                   returnname;

         }

         publicint getAge()

         {

                   returnage;

         }

         publicString toString()

         {

                   returnname+":"+age;

         }

}

 

class MapTest

{

         publicstatic void main(String[] args)

         {

                   HashMap<Student,String>hm = new HashMap<Student,String>();

 

                   hm.put(newStudent("lisi1",21),"beijing");

                   hm.put(newStudent("lisi1",21),"tianjin");

                   hm.put(newStudent("lisi2",22),"shanghai");

                   hm.put(newStudent("lisi3",23),"nanjing");

                   hm.put(newStudent("lisi4",24),"wuhan");

 

                   //第一种取出方式keySet

 

                   Set<Student>keySet = hm.keySet();

 

                   Iterator<Student>it = keySet.iterator();

 

                   while(it.hasNext())

                   {

                            Studentstu = it.next();

                            Stringaddr = hm.get(stu);

                            System.out.println(stu+".."+addr);

                   }

 

 

                   //第二种取出方式entrySet

                   Set<Map.Entry<Student,String>>entrySet = hm.entrySet();

 

                   Iterator<Map.Entry<Student,String>>iter = entrySet.iterator();

                  

                   while(iter.hasNext())

                   {

                            Map.Entry<Student,String>me = iter.next();

                            Studentstu = me.getKey();

                            Stringaddr = me.getValue();

                            System.out.println(stu+"........."+addr);

                   }

         }

}

 

eg：排序还可以引入比较器

/*

需求：对学生对象的姓名进行升序排序。

 

因为数据是以键值对形式存在的。

所以要使用可以排序的Map集合。TreeMap。

*/

import java.util.*;

 

class StuNameComparator implementsComparator<Student>//比较器类

{

         publicint compare(Student s1,Student s2)

         {

                   intnum = s1.getName().compareTo(s2.getName());

                   if(num==0)

                            returnnew Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

 

                   returnnum;

         }

}

 

class MapTest2

{

         publicstatic void main(String[] args)

         {

                   TreeMap<Student,String>tm =

new TreeMap<Student,String>(new StuNameComparator());//载入比较器

 

                   tm.put(newStudent("blisi3",23),"nanjing");

                   tm.put(newStudent("lisi1",21),"beijing");

                   tm.put(newStudent("alisi4",24),"wuhan");

                   tm.put(newStudent("lisi1",21),"tianjin");

                   tm.put(newStudent("lisi2",22),"shanghai");

 

                  

                   Set<Map.Entry<Student,String>>entrySet = tm.entrySet();

 

                   Iterator<Map.Entry<Student,String>>it = entrySet.iterator();

 

                   while(it.hasNext())

                   {

                            Map.Entry<Student,String>me = it.next();

 

                            Studentstu = me.getKey();

                            Stringaddr = me.getValue();

                            System.out.println(stu+":::"+addr);

                   }

         }

}

 

>>例子

eg：

需求："sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。

希望打印结果：a(1)c(2).....

 

分析：通过结果发现，每一个字母都有对应的次数。

说明字母和次数之间都有映射关系。

注意了，当发现有映射关系时，可以选择map集合。

因为map集合中存放就是映射关系。

 

思路：第一次用“s”字母作为键去找集和。那么集合没有“s”这个键，座椅也没有对应的次数。返回null。如果为null，就将“s”字母和1（次数）存入集合。如果指定的键（比如“s”）已经存在，就将对应的次数取出，自增，重新存入集合。

 

1，将字符串转换成字符数组。因为要对每一个字母进行操作。

2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。

3，遍历字符数组。

         将每一个字母作为键去查map集合。

         如果返回null，将该字母和1存入到map集合中。

         如果返回不是null，说明该字母在map集合已经存在并有对应次数。

         那么就获取该次数并进行自增。，然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。

4，将map集合中的数据变成指定的字符串形式返回。

 

import java.util.*;

class MapTest3

{

         publicstatic void main(String[] args)

         {

                   Strings= charCount("ak+abAf1c,dCkaAbc-defa");

                   System.out.println(s);

         }

        

         publicstatic String charCount(String str)

         {

                   char[]chs = str.toCharArray();

 

                   TreeMap<Character,Integer>tm = new TreeMap<Character,Integer>();

 

                  

                   intcount = 0;

                   for(intx=0; x<chs.length; x++)

                   {

                           

                            if(!(chs[x]>='a'&& chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))

                                     continue;

 

                            Integervalue = tm.get(chs[x]);

 

                            if(value!=null)

                                     count= value;//取出次数

                            count++;

                            tm.put(chs[x],count);

//直接往集合中存储字符和数字，为什么可以，因为自动装箱。

 

                            count= 0;//为下一次使用准备

                            /*

                            if(value==null)

                            {

                                     tm.put(chs[x],1);

                            }

                            else

                            {

                                     value= value + 1;

                                     tm.put(chs[x],value);

                            }

                            */

                   }

 

                   //System.out.println(tm);

 

                   StringBuildersb = new StringBuilder();

 

                   Set<Map.Entry<Character,Integer>>entrySet = tm.entrySet();

                   Iterator<Map.Entry<Character,Integer>>  it = entrySet.iterator();

 

                   while(it.hasNext())

                   {

                            Map.Entry<Character,Integer>me = it.next();

                            Characterch = me.getKey();

                            Integervalue = me.getValue();

                            sb.append(ch+"("+value+")");

                   }

                   returnsb.toString();

         }

 

}

 

>>map集合拓展知识

 

map集合使用是因为具备映射关系

 

eg：1班，1号，aaa

         1班，2号，bbb

         2班，1号，aa

         2班，2号，bb

这样有两组对应关系，大集合（班与学号、名字的映射）里嵌套小集合（学号和名字的映射）。

class QianTao

{

         public static void main(String[] args)

         {

                   //学号、姓名映射

                   HashMap<String,String>oneBan = new HashMap<String,String>();

                   oneBan.put(“1号”,”aaa”);

                   oneBan.put(“2号”,”bbb”);

                  

                   HashMap<String,String> twoBan= new HashMap<String,String>();

                   oneBan.put(“1号”,”aa”);

                   oneBan.put(“2号”,”bb”);

                  

                   //班级与学号、姓名映射

                   HashMap<String,HashMap<String,String>>banJi

= newHashMap<String,HashMap<String,String>>()；//注意此映射的值

 

banJi.put(“oneBan”,oneBan);

banJi.put(“twoBan”,twoBan);

//我想取出某班级所有学生信息

getStudentInfo(oneBan);

 

//我想取出全部学生的信息

//遍历所有banJim集合，获取所有班级

Iterator<String>it = banJi.keySet().iterator();

 

while(it.hasNext())

{

         String roomName = it.next();

         HashMap<String,String> room =banJi.get(roomName);

 

         //Systme.out.println(roomName);

         //使用班级获取学生

         getStudentInfo(roomName)；

}

public staticvoid getStudentInfo(HashMap<String,String> roomMap)

{

         Iterator<String> it =roomMap.keySet().iterator();

        

         while(it.hasNext())

         {

                   String id = it.next;

                   String name =roomMap.get(id);

                   System.out.println(id+”:”+name);

         }

}

                   }

 

如果将学号和姓名封装成一个学生类（Student）对象呢？还可以用集合么？

eg：import java.util.*;

class Student

{

         privateString id;

         privateString name;

         Student(Stringid,String name)

         {

                   this.id= id;

                   this.name= name;

         }

         publicString toString()

         {

                   returnid+":::"+name;

         }

}

class MapDemo

{

         publicstatic void demo()

         {

                   HashMap<String,List<Student>>czbk = new HashMap<String,List<Student>>();

 

                   List<Student>reyu = new ArrayList<Student>();

                   List<Student>jiuye = new ArrayList<Student>();

 

                   czbk.put("yureban",reyu);

                   czbk.put("jiuyeban",jiuye);

 

                   reyu.add(newStudent("01","zhagnsa"));

                   reyu.add(newStudent("04","wangwu"));

                   jiuye.add(newStudent("01","zhouqi"));

                   jiuye.add(newStudent("02","zhaoli"));

 

                   Iterator<String>it = czbk.keySet().iterator();

 

                   while(it.hasNext())

                   {

                            StringroomName = it.next();

                            List<Student>room = czbk.get(roomName);

                           

                            System.out.println(roomName);

                            getInfos(room);

                   }

         }

         publicstatic void getInfos(List<Student> list)

         {

                   Iterator<Student>it = list.iterator();

                   while(it.hasNext())

                   {

                            Students = it.next();

                            System.out.println(s);

                   }

         }

 

 

>>工具类utilities

|--Collections，其中方法皆为静态，因为没有特有数据，所以直接调用，不用创建对象

|--Arrays，其中方法皆为静态，所以直接调用，不用创建对象

 

>> Collection与Collections有什么区别？比如现在有一些元素，不需要保证唯一，所以用List，但是我又想排序，不能用tree了,tree属于set集合。Collections提供了集合的操作工具。其中

static<T extends Comparable<? super T>> void sort(List<T> list)

          //根据元素的自然顺序 对指定列表按升序进行排序。

 

static<T> void sort(List<T> list, Comparator<? super T> c)

//根据指定比较器产生的顺序对指定列表进行排序。

解决这个问题

eg：import java.util.*

class CollectionsDemo

{

         publicstatic void main(String[] args)

         {

                   sortDemo();

         }

 

         publicstatic void sortDemo()

         {

                   List<String>list = new ArrayList<String>();//数组结构

 

                   list.add(“a”);

                   list.add(“c”);

                   list.add(“b”);

                   list.add(“z”);

                   list.add(“g”);

                   list.add(“z”);//重复？可以排序，有索引！

 

                   sop(list);

 

                   Collections.sort(list);//注意，不能给set排序，只能用于List

sop(list);

                   Collections.sort(list,newStrLenComparator());

                   sop(list);

         }

 

public staticvoid sop(Object obj)

         {

                   System.out.println(obj);

         }

}

 

//依据字符串长度排序，使用比较器

class StrLenComparator implementsComparator<String>

{

         publicint compare(String s1,String s2)

         {

                   if(s1.length()>s2.length())

                            return1;

                   if(s1.length()<s2.length())

                            return-1;

                   returns1.compareTo(s2);

         }

}

 

>>使用sort方法排序，但是希望从z输出，于是，在collections中有一个方法：

static<T> Comparator<T> reverseOrder()

//返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

 

eg：………………

Collections.sort(arrayList,Collections.reverseOrder());

………………

还有其他的形式：

Collections.sort(list,Collections.reverseOrder(newStrLenComparator()));

//也可以逆转自定义的比较器

 

如果是SetTree容器,本身就有排序功能，也可以逆转

eg：………………

         TreeSet<String>ts = new TreeSet<String>(Collections.reverseOrder());

………………

 

>>static <T extends Object &Comparable<? super T>> T max(Collection<? extends T> coll)

         //根据元素的自然顺序，返回给定 collection 的最大元素。

public staticvoid maxDemo()

         {

                   List<String>list = new ArrayList<String>();

 

                   list.add("abcd");

                   list.add("aaa");

                   list.add("zz");

                   list.add("kkkkk");

                   list.add("qq");

                   list.add("z");

                   //Stringmax = Collections.max(list,new StrLenComparator());//返回最大长度

                   Stringmax = Collections.max(list);

                   sop("max="+max);

         }

 

>> static <T> intbinarySearch(List<? extends Comparable<? super T>> list, T key)

         //使用二分搜索法搜索指定列表，以获得指定对象。

注意，其中，只能对List进行支持，因为二分查找需要角标

 

eg: public static void binarySearchDemo()

         {

                   List<String>list = new ArrayList<String>();

 

                   list.add("abcd");

                   list.add("aaa");

                   list.add("zz");

                   list.add("kkkkk");

                   list.add("qq");

                   list.add("z");

 

                   //二分法针对的是有序的集合，故而先排序

                   Collections.sort(list,newStrLenComparator());

 

                   sop(list);

 

                   //intindex = Collections.binarySearch(list,"aaaa");

                   /*

结果为负数，意思是没有查到，并指示插入位置

注意，这里指示的插入位置是：插入点-1！

为什么减一呢？是防止插入点为0，而方法想定义负数是没有找到！

所以如果指示-3，其实插入点为2。

 

当然，也可以传自定义的比较器

*/

 

                   intindex = halfSearch2(list,"aaaa",new StrLenComparator());

                   sop("index="+index);

         }

 

原理：

 

public staticint halfSearch(List<String> list,String key)

         {

                   intmax,min,mid;

                   max= list.size()-1;

                   min= 0;

 

                   while(min<=max)

                   {

                            mid= (max+min)>>1;// 右移，除以2

 

                            Stringstr = list.get(mid);

 

                            intnum = str.compareTo(key);

                            if(num>0)

                                     max= mid -1;

                            elseif(num<0)

                                     min= mid + 1;

                            else

                                     returnmid;

                   }

                   return-min-1;//返回插入点

         }

 

原理，带比较器

 

public staticint halfSearch2(List<String> list,String key,Comparator<String>cmp)

         {

                   intmax,min,mid;

                   max= list.size()-1;

                   min= 0;

 

                   while(min<=max)

                   {

                            mid= (max+min)>>1;//  /2;

 

                            Stringstr = list.get(mid);

 

                            intnum = cmp.compare(str,key);

                            if(num>0)

                                     max = mid -1;

                            elseif(num<0)

                                     min= mid + 1;

                            else

                                     returnmid;

                   }

                   return-min-1;

         }

 

>>一些其它方法

staticvoid reverse(List<?> list) //反转指定列表中元素的顺序。

 

staticvoid swap(List<?> list, int i, int j) //在指定列表的指定位置处交换元素。

 

staticvoid shuffle(List<?> list, Random rnd) //使用指定的随机源对指定列表进行置换。好玩

 

static<T> boolean replaceAll(List<T> list, T oldVal, T newVal) //使用另一个值替换列表中出现的所有某一指定值。

 

重点：将不同步的集合转换成同步的

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。

 

static<K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) //返回指定有序映射支持的同步（线程安全的）有序映射。

 

static<T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) //返回指定有序 set 支持的同步（线程安全的）有序 set。

 

>>Arrays中的方法，有大面积重载

binarySeach、fill、sort（还可以分段排序）、copyOf、

 

static boolean deepEquals(Object[] a1, Object[] a2) //如果两个指定数组彼此是深层相等 的，则返回 true。具体就是比较两个数组是否有相同对象且对象中的元素是否相同

 

static <T> List<T> asList(T... a) //返回一个受指定数组支持的固定大小的列表。

//即将数组变成集合

eg：………………

                 public staticvoid main(String[] args)

                 {

                            //Arrays中有一个重要的方法，将数组变成集合。

                            String[] arr = {"haha","hehe","heihei"};

                           

                            List<String>list = Arrays.asList(arr);//数组转成集合。

                            /*

                            当数组变成集合后，就可以使用集合的方法来操作数组。

                            而不用自己在定义指针进行数组的操作。（或者for）

                            但是有些方法不可以用，只要改变集合长度的方法

                                     都不能用，因为数组是固定长度的。

                            */

                           

                            boolean b =list.contains("hehe");

                            //list.add(“xixi”);//编译错误

                 ………………

                 ………………

                 int[] arr ={3,4,6};

//当数组中元素是引用数据类型时，变成集合后，就将数组中的元素作为集合中的元素存在。

//但是集合中不能存储基本数据类型！

//当数组中的元素是基本数据类型时，变成集合后，会将“这个数组”变成集合中的元素。

                 List<int[]>list = Arrays.asList(arr);//注意这里的泛型

                 ………………

 

toString方法，将数组变成字符串

eg：………………

                 System.out.println(Arrays.toString(arr));//将数组直接变成字符串。

                 ………………

 

>>Collection中的方法，集合转数组

<T> T[] toArray(T[] a)//返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

 

方便在于传入什么类型，返回什么类型！

eg：

import java.util.*;

class  CollectionToArray

{

                 public staticvoid main(String[] args)

                 {

 

                   ArrayList<String>al = new ArrayList<String>();

 

                   al.add("haha");

                   al.add("hehe");

                   al.add("heihei");

                

                   String[] arr= al.toArray(new String[al.size()]);//将集合变成数组。

                

                   /*

                   给toArray方法传递指定类型的数组。

                   长度该怎么定义呢？

                   当指定的长度小于集合的长度，String[] arr = al.toArray(0);

                 该方法内部会自动创建一个该类型的新数组长度和集合长度一致 。用于存储集合中的元素。

                

                   如果指定的数组长度大于集合的长度，String[] arr = al.toArray(5);

                   那么该方法就不会创建新数组。而是使用传递进来的数组，

                   存储完集合的元素后，其他的未存储的位置为null。

                

           所以在定义数组是，最好定义长度和集合长度相同的数组。这样就不用创建新数组了。

                   而且也不会出现空位为null。

                

                

                   将集合变成数组有什么用呢？

                   其实是限定了对元素的增删操作。

                

                   */

                   System.out.println(Arrays.toString(arr));

                 }

}

 

>>一些JDK1.5以后的新特性

 

>>Collection 继承了Iterable接口，Iterable对Iterator方法进行了抽取，主要是为了以后的扩展。

                 同时，实现Iterable接口可以使用“foreach”，即增强for循环。

 

格式：for( 元素类型 变量 : 数组或者Collection集合)

{

 

}

 

增强for循环和传统for循环有什么不同呢？

                 增强for循环，使用时，必须要有被遍历的目标。而且只能遍历数组和Collection集合。简化了迭代。传统for循环，它的应用更为普遍。注意：建议遍历数组还是使用传统for循环，可以通过指针对数组元素进行操作。这个升级是注重简化书写。

 

eg：……………………

                 public staticvoid main(String[] args)

                 {

                   ArrayList<String>al = new ArrayList<String>();

 

                   al.add("haha");

                   al.add("hehe");

                   al.add("heihei");

 

                   for(String s: al)//高级for循环一般只用于遍历。不对元素进行操作。

                   {

                            System.out.println(s);

                   }

                 ………………

 

eg：………………

int[] arrayx = {3,4,5,6};

                  

                   for(intabb:arrayx)

                   {

                            //System.out.println(abb);

                            abb= 10；

                 }

                 System.out.println(Arrays.toString(arrayx));//将数组变成字符串输出

                 ………………

//结果输出：[3,4,5,6]

                 abb是局部变量，数组不变

 

要对map集合进行遍历，可以使用foreach循环吗？

                 不可以直接使用。但是可以间接使用。可以将map集合转成set结合，在使用foreach循环。

eg：

import java.util.*;

class ForeachDemo

{

                 public staticvoid main(String[] args)

                 {

                   ArrayList<String>al = new ArrayList<String>();

                  

                   al.add("aaa1");

                   al.add("aaa2");

                   al.add("aaa3");

                   al.add("aaa4");

                   al.add("aaa5");

                  

                   for(Strings:al)

                   {

                            System.out.println(s);

                   }

                  

                   //遍历数组

                  

                   int[] arr=new int[3];

                   int[] arrayx= {3,4,5,6};

                  

                   for(intabb:arrayx)

                   {

                            System.out.println(abb);

                   }

                  

                   //对map集合进行操作

                   HashMap<String,String>hm = new /*Linked*/HashMap<String,String>();

                   //要按照输入顺序输出？把HashMap加上Linked

                  

                   hm.put("1","aa");

                   hm.put("2","bb");

                   hm.put("3","cc");

                   hm.put("4","dd");

                   hm.put("5","ee");

                  

                   Set<String>keySet = hm.keySet();//转成Set集合

                  

                   //第一种遍历方法

                   for(Strings:keySet)

                   {

                            System.out.println("key:"+s+"-value:"+hm.get(s));

                   }

                  

                   //第二种遍历方法

                   for(Map.Entry<String,String>me:hm.entrySet())

                   {

                            //System.out.println(me);

                            Stringkey = me.getKey();

                            Stringvalue = me.getValue();

                            System.out.println(key+"--"+value);

                   }

               }

}

 

>>可变类型参数

通常，一个方法这样定义

                 public intvoid show(int x,int y){return 1;}

如果参数较多

                 public intvoid show(int[] arr){return 1;}

但是上面这个需要传入数组，意味着要new一个数组传入，麻烦

所以还可以这样定义，在指定数据类型的后面加上三个点 ，其实就是一个数组类型的参数。

                 public staticvoid show(int... arr)//可变参数。其实arr就是一个数组类型的参数。

{

                            for(inti : arr)

                            {

                            System.out.println(i);

                            }

                 }

那么，在main中可以这样调用：

show(3);

或

show(3,5,1,6,8,9);

 

但是，简化的操作一定有局限性，比如，如果这样书写

                 public staticvoid show(int... arr, int temp){}

结果编译错误，因为有可能参数都被存入arr数组，temp就什么都没有接收到了，所以

注意：如果函数上有多个参数，可变参数一定要定义在参数列表最后面。

                 public staticvoid show(int temp ,int... arr){}

否则编译失败。

 

另外，如果我多此一举，传入一个数组呢？

eg：import java.util.*;

class ParamterDemo

{

                 public staticvoid main(String[] args)

                 {

                            int[] arr = {1,2,3,4};//建立一个数组

                            show(arr);//传入

                            show(1,2,3,4);

                 }

                

                 public staticvoid show(int... arr)//定义的可变参数

                 {

                            System.out.println(Arrays.toString(arr));

                   /*

                   for(intout:arr)

                   {

                            System.out.println(out);

                   }

                   */

                 }

}

这样也是可以的，正常的编译和运行输出。

 

>>静态导入

eg：import java.util.*;//简化类名的书写。

import static java.util.Collections.*;//导入了一个类中的所有静态成员.

import static java.util.Arrays.*;

import static java.lang.System.*;//System.out.println()

 

class StaticImportDemo

{

                 public staticvoid main(String[] args)

                 {

                   /*java.util.*/ArrayList<Integer>al = new ArrayList<Integer>();

 

                   al.add(1);

                   al.add(4);

                   al.add(6);

                   al.add(2);

 

                   sort(al);

                   System.out.println(al);

 

                   int index =binarySearch(al,4);

                   System.out.println("index="+index);

 

                   int[] arr ={4,1,6};

                   sort(arr);//和Collections的sort传的参数不一样，不冲突

                   System.out.println(Arrays.toString(arr));

                 //这里的“toString”和Object中的冲突,需加上Arrays

 

                   out.println("haha");//导入了System

                 }

}