黑马程序员_新特性

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------

/*

高级for循环。

for(数据类型变量名 :被遍历的集合(Collection)或者数组)

{

}

对集合进行遍历。

只能获取集合遍历，但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。

如果是ListIterator,还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

 

高级for有一个局限性，必须有遍历的目标。

建议在遍历数组的时候，还是希望使用传统for。因为传统for可以定义角标。

*/

import java.util.*;

class ForEachDemo

{

       public static void main(String[] args)

       {

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

              al.add("abc1");

              al.add("abc2");

              al.add("abc3");

              for(String s : al)

              {

                     //s = "kk";

                     //sop(s);

              }

              //sop(al);

              /*

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

              while(it.hasNext())

              {

                     sop(it.next());

              }

              */

       /*

              int[] arr = {3,5,1};

 

              for (int x=0;x<arr.length ;x++ )

              {

                     sop(arr[x]);

              }

              for(int i : arr)

              {

                     sop("i:"+i);

              }

              */

             

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

 

              hm.put(1,"a");

              hm.put(2,"b");

              hm.put(3,"c");

 

              //Set<Integer> keySet = hm.keySet();

              for(Integer i : hm.keySet())

              {

                     sop(i+"::"+hm.get(i));

              }

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

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

              {

                     sop(me.getKey()+"----"+me.getValue());

              }

 

       }

       public static void sop(Object obj)

       {

              System.out.println(obj);

       }

}

 

方法的可变参数

使用时注意:可变参数一定要定义在参数列表的最后面。 

class ParamMethodDemo

{

       public static void main(String[] args)

       {

       /*

              可变参数。

              其实就是上一种数组参数的简写形式。

              不用每一次都手动的建立数组对象。

              只要将要操作的元素作为参数传递即可。

              隐式将这些参数封装成数组。

              */

              show(2,3,4,5,7);

              show(2,3,4,5,6,7,8,9);

       }

       public static void show(int... arr)

       {

              System.out.println(arr.length);

       }

}

 

StaticImport：静态导入。

 

当类名重名时，需要指定具体的包名。

当方法重名时，指定具体所属的对象或者类。

*/

import java.util.*;

import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员

 

import static java.lang.System.*;//导入了System类中的所有静态方法

class StaticImport

{

       public static void main(String[] args)

       {

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

 

              out.println("kkkk");

              sort(arr);

 

              int index = binarySearch(arr,1);

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

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

       }

}

 

泛型：用于解决安全问题，是一个类型安全机制。

 

好处

1，将运行时期出现问题ClassCastException，转移到了编译时期。

       方便于程序员解决问题。让运行时问题减少，安全。

2，避免了强制转换的麻烦。

 

泛型格式：通过<>来定义要操作的引用数据类型。

 

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，

只要见到<>就要定义泛型。

 

其实<>就是用来接收类型的。

 

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

 

泛型类定义的泛型，在整个类中有效。如果被方法使用，

那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

 

为了让不同方法可以操作不同类型，而且类型还不确定。

那么可以将泛型定义在方法上。

 

特殊之处：静态方法不可以访问类上定义的泛型。

如果静态方法操作的应用数据类型不确定时，可以将泛型定义在方法上。

*/

import java.util.*;

class GenericDemo

{

       public static void main(String[] args)

       {

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

 

              al.add("abc01");

              al.add("abc0991");

              al.add("abc012");

              //al.add(3);//al.add(new Integer(3));

 

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

              while (it.hasNext())

              {

                     String s =it.next();

 

                     System.out.println(s+":"+s.length());

              }

       }

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------