黑马程序员之java学习笔记10

 

1.       ArrayList,HashSet,HashMap底层都是用数组来实现的。

2.       Properties类：是hashTable的一个子类，hashMap的用法一样，其中主要方法是getProperty(); Public String getProperty(String key)

实例代码：

Properties p = System.getProperties();//获得系统环境变量

Set set  = p.keySet();

For(Iterator it = set.interator(); it.hasNext();){

String key= (String)It.next();

String value = p.getProperty(key)

 

System.out.println(value);

}

 

3.       泛型：用<T>表示，其中T表示的类型的类别。泛型不一定使用T，也可以使用K，N等字母。在new对象时，要将T具体化，如将T具体化为String,int.

4.       泛型的实质就是类型的参数化。T可以是任何类型，相当与Object。使用泛型，类中每个对象的引用可以改变为不同类型。而且使用泛型，编译没问题，运行就基本不会有问题。

Public class GenericTest<T>{

Private T number;

Public T getNumber(){

Return number

}

Public void setNumber(T  number){

this.number = number;

}

Public static void main(String[] args){

GenericTest<integer>  n = new GenericTest<integer>();

GenericTest<String>  m = new GenericTest<String>();

n.setNumber(new integer(3));

m.setNumber(“123”);

integer k = n.getNumber();

String b= m.getNumber();

System.out.println(k);

System.out.println(b);            

 

}

}

 

小结：GenericTest<String>整体被看成了一个类型，m就是GenericTest<String>类型。使用泛型就避免了强转(在ArrayList中get元素后必须的进行强转)。

 

5.       泛型不能以new方式来创建数组，new T[10]是错误的。要这样(T[])new Object[10];

6.       一般情况下，一个集合内放置同一类型的对象。（集合内是可以放置不同类型数据的）。

7.       多个泛型的使用：

8.       Public class GenericTest<T1，T2>{

9.       Private T1 number;

10.   Private T2 name;

11.   Public T1 getNumber(){

12.   Return number

13.   }

14.   Public void setNumber(T1  number){

15.   this.number = number;

16.   }

17.   Public T2 getName(){

18.   Return name;

19.   }

20.   Public void setName(T2  name){

21.   this.name = name;

22.   }

23.    

24.   Public static void main(String[] args){

25.   GenericTest<integer,String>  n = new GenericTest<integer,String>();

26.   n.setNumber(new integer(3));

27.   n.setName(“123”);

28.    

29.   integer k = n.getNumber();

30.   String b= m.getName();

31.   System.out.println(k);

32.                                                                                    System.out.println(b);        

33.    

34.   }

35.   }

 

36.   Public class GenericArray<T>{

Private T[] arraylist;

Public void setArraylist(T[] arraylist){

    This.arraylist=arraylist;

}

Public T[] getArraylist(){

    Return arraylist;

}

Public static void main(String[] args){

GenericArray<ArrayList>  ga = new GenericArray<ArrayList>();

ArrayList[] al = new ArrayList[10];

ga.set(al);

 

 

 

37.   限制泛型的使用：使用extends，如<T extends E>.那么T类型只能是E的子类或是实现E接口的类。在泛型中，不管是继承还是实现接口，都使用关键字extends。

38.   泛型的泛型：如<T extends List<K>>.

39.   当没有指定泛型T继承的类型或实现的接口，默认情况该类型或接口是Object。所以任何类型都可以作为参数传入，<T>=<T extends Object>.

40.   类型通配符使用?,如 <? Extends list>,其中的?代表list子类中的任意一种。当<? Extends Object>时可以简写成<?>.

41.   <T extends Object>与<? Extends Object>比较：

1)       位置不同，<T extends Object>放在类名后面；<? Extends Object>在实例化对象时使用。

2)       T只能表示一种类型，而？能表示多种类型。

 

42.   Collections.sort(List list, new MyComparator())方法，必须的实现Comparator接口中的compare方法。

Class MyComparator implements Comparator{

Public int compare(Object obj1, Object obj2){

 Return obj1-obj2;

}

String类中的比较方法是对象1.compareTo(对象2)。