黑马程序员之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)。