面向对象学习记录4

1.容器1136，装其他对象的对象，数组一旦长度确定，就不能添加长度，只有再造一个


数组，灵活性差。


一个图，一个类（Collections,封装了List的常用的方法如shuffle,binarySearch等）


，三个知识点（for,generic,auto-boxing/unboxing）,六个接口（Collection,Set 


,List,Map,Iterator,Comparable）
2.容器位于java.util包里。
Collection 容器里装的都是对象或引用，不能是基础数据类型
Set（对象没有顺序，且不可重复equals()方法判断）
HashSet（实现了Set接口）
List（对象有顺序，可重复）
LinkedList（实现了List接口）
ArrayList（实现了List接口）
Map
HashMap（实现了Map接口）






容器调用equals()方法，要看对象重写equals方法与否，没有重写则是默认使用的“==


”来进行判断，两个对象equals，则需具有相同的hash codes;使用map时，键值对时要


重写hashcode()方法


import java.util.*;
class  BasicContainer
{
public static void main(String[] args) 
{
// System.out.println("Hello World!");
Collection c = new HashSet();
c.add("hello");
c.add(new Name("f1","l1"));
c.add(new Integer(100));
c.remove("hello");
c.remove(new Integer(100));
System.out.println(c.remove(new Name("f1","l1")));
System.out.println(c);
}
}


class Name implements Comparable
{
private String firstName,lastName;
public Name(String firstName,String lastName)
{
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName()
{
return firstName;
}
public String getLastName()
{
return lastName;
}
public String toString()
{
return firstName+" "+lastName;
}


public boolean equals(Object obj)
{
if(obj instanceof Name)
{
Name name = (Name)obj;
return (firstName.equals(name.firstName))&&
(lastName.equals(name.lastName));
}
return super.equals(obj);
}


public int hashCode()
{
return firstName.hashCode();
}

public int compareTo(Object o){
Name n = (Name)o;
int lastCmp = lastName.compareTo(n.lastName);
return (lastCmp!=0?lastCmp:firstName.compareTo


(n.firstName));

}
}


3.ArrayList,以数组为底层实现的List；HashSet底层用Hash表实现的容器


Iterator是一个会被容器实现以对容器自身进行遍历的方法的接口。remove


();hasNext();next()返回游标右边的元素并将游标移动到下一个位置；Iterator对象


的remove()方法是在迭代过程中删除元素的唯一的安全的方法，产生Iterator对象的原


来容器对象的remove()方法也不能调用，否则会产生例外。


Iterator i = c.iterator();
while(i.hasNext()){
SomeObject so = (SomeObject)i.next();
System.out.println(so.getName());
}


4.增强的for循环对于集合遍历array或Collection的时候相当简便；缺陷是在数组中使


用时不能方便的访问下标值，在集合中使用时与Iterator相比，不能方便的删除集合中


的内容。


5.容器中对象的“大小”如何确定：可“排序”的类都实现了java.lang.Comparable接


口，Comparable接口中只有一个方法public int compareTo(Object obj)


6.如何选择容器：Array 读快改慢；Linked 改快读慢；Hash两者之间。另外


Hashtable,Vector等是以前遗留的，无论读写，其内部都是锁定的，效率较低；
Map的Object put(Object key,Object value)方法,如果原来有key，则用新value替换


原value并将原value 对象返回。


7.int i = (Integer)mapObject.get("keytwo");//自动解包不能把Integer转换去掉


import java.util.*;
class  TestArgsWords
{
private static final Integer ONE = new Integer(1);


public static void main(String[] args) 
{
// System.out.println("Hello World!");
Map m = new HashMap();
for(int i=0;i<args.length;i++){
Integer freq = (Integer)m.get(args[i]);
m.put(args[i],(freq==null?ONE : new Integer


(freq.intValue()+1)));

}
System.out.println(m.size()+"distinct words detected:");
System.out.println(m);
}
}




写法2：


import java.util.*;
class  TestArgsWords
{
private static final int ONE = 1;//new Integer(1);


public static void main(String[] args) 
{
// System.out.println("Hello World!");
Map m = new HashMap();
/*for(int i=0;i<args.length;i++){
Integer freq = (Integer)m.get(args[i]);
m.put(args[i],(freq==null?ONE : freq.intValue()+1));

}*/
for(int i=0;i<args.length;i++){
int freq =(Integer)m.get(args[i])==null?0:(Integer)


m.get(args[i]);
m.put(args[i],(freq==0?ONE : freq+1));

}
System.out.println(m.size()+"distinct words detected:");
System.out.println(m);
}
}
写法3：


import java.util.*;


class  TestArgsWords3
{
private static final int ONE = 1;
public static void main(String[] args) 
{
// System.out.println("Hello World!");
Map<String ,Integer> m = new HashMap<String,Integer>();
for(int i=0;i<args.length;i++){
if(!m.containsKey(args[i]))
m.put(args[i],ONE);
else{
int freq = m.get(args[i]);
m.put(args[i],freq+1);
}
}
System.out.println(m.size()+" distinct words detected: ");
System.out.println(m);
}
}




8.泛型：jdk1.4以前装入集合时都当作Object对待，从而失去自己的实际类型；从集合


中取出时往往需要转型，效率低，容易产生错误。解决方案：在定义集合的时候同时定


义集合中对象的类型。


class BasicGeneric 
{
public static void main(String[] args) 
{
List<String> c = new ArrayList<String>();
c.add("aaa");
c.add("bbb");
c.add("ccc");
for(int i=0;i<c.size();i++){
String s = c.get(i);
System.out.println(s);
}


Collection<String> c2 = new HashSet<String>();
c2.add("aaa");
c2.add("bbb");
c2.add("ccc");
for(Iterator<String> it = c2.iterator();it.hasNext();){
String s = it.next();
System.out.println(s);
}
System.out.println("Hello World!");
}
}




class MyName implements Comparable<MyName>
{
int age;
public int compareTo(MyName mn){
if(this.age>mn.age) return 1;
else if(this.age<mn.age)
{
return -1;
}else
return 0;
}
}