java基础学习笔记之集合.doc

List(ArrayList、Vector、LinkedList)、Map(HashMap、TreeMap、Hashtable)、Set(HashSet、TreeSet)、equals、hashcode

java基础学习笔记之集合

集合（集合中的数据默认都是object类型，最好使用泛型来指定数据类型）

List：常见的有：ArrayList、vecdtor(旧的类，JDK1.2之后又升级的)、LinkedList Map：常见的有：HashMap、Hashtable、TreeMap

Set：常见的有：HashSet、TreeSet

List：List 中允许有内容重复的元素，因为在list中的数据是按照下标来排序的，下标不可能相同 ArrayList，实现了list接口，性能高，采用异步处理，但是线程不安全：

public static void main(String[] args) {

// TODO Auto-generated method stub

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

list.add("a");

list.add("b");

list.add("c");

list.add("a");

for(String s:list){

System.out.println(s);

}

}

Linkedlist链表集合，可以模拟链表、堆栈

public static void main(String[] args) {

// TODO Auto-generated method stub

LinkedList<String> link=new LinkedList<String>();

link.add("aa");

link.add("bb");

link.add("cc");

link.add("dd");

link.add("ee");

int len=link.size();//先将link的长度取出来

for(int i=0;i<len;i++){

System.out.println(link.poll());

}

}

Vector是旧的类，性能低，采用同步处理，线程安全，

List<String> vet=new Vector<String>();

vet.add("a");

vet.add("b");

vet.add(1, "bb");//将bb加到下标为1的元素前面，即加到b前

vet.add("c");

vet.add("hello");

vet.add("world");

vet.remove(0);//删除制定下标的元素

List(ArrayList、Vector、LinkedList)、Map(HashMap、TreeMap、Hashtable)、Set(HashSet、TreeSet)、equals、hashcode

vet.remove("c");//删除制定的元素

for(int i=0;i<vet.size();i++){

System.out.println(vet.get(i));

}

Map也可以使用泛型，map是根据key来获取value的，其中key不可以相同，如果相同，后一个value值将覆盖前一个value值，如下：

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

map.put("name", "wei");

map.put("age", "21");

map.put("sex", "female");

System.out.println(map.get("name"));//根据key来取value的值

//如果要遍历，通过keySet()这个方法获取所有key的集合

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

for(String k:keys){

System.out.println(k+" "+map.get(k));//用key来取value值

}

注意：map里有自己的一套算法，所以在输出遍历的结果时，不一定是按照我们添加元素的顺序排列出来的

Hashtable和HashMap 的区别：hashtable是同步处理，性能较低；hashmap是异步处理，性能较高；hashmap可以设置null值，hashtable不能设置null值

，否则会出现空指向异常

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

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

hm.put("age", null);

System.out.println(hm);

输出的结果为：{age=null, name=aa}

Map<String,String> htm=new Hashtable<String,String>();

htm.put("name", "aa");

htm.put("age", null);

System.out.println(htm);

输出结果报错：Exception in thread "main" http://ng.NullPointerException 空指针异常

属性操作类：Properties是专门操作属性文件的类

对属性的操作：

public static void main(String[] args) {

Properties ppt=new Properties();

ppt.setProperty("title", "Java");

List(ArrayList、Vector、LinkedList)、Map(HashMap、TreeMap、Hashtable)、Set(HashSet、TreeSet)、equals、hashcode

ppt.setProperty("author", "xiaoyan");

ppt.setProperty("publisher", "qinghua");

ppt.setProperty("time", "1991-01-01");

System.out.println("可以查到的属性："+ppt.getProperty("title"));

System.out.println("查不到的属性："+ppt.getProperty("name"));//查不到的属性，返回默认值

System.out.println("查不到的属性："+ppt.getProperty("age","没有此属性的记录")); }

//将属性写入普通文件中，并从文件中将内容读取出来，

//将内容向普通文件中保存

Properties pro=new Properties();

pro.setProperty("title", "Java");

pro.setProperty("author", "xiaoyan");

pro.setProperty("publisher", "qinghua");

File file=new File("e:"+File.separator+"e.txt");

OutputStream out=new FileOutputStream(file);

//pro.store(new FileOutputStream(new File("e:"+File.separator+"e.txt")), "Area Info"); pro.store(out, "Area Info");

//从文件中将内容读出

Properties pro1=new Properties();

InputStream input=new FileInputStream(file);

pro1.load(input);

System.out.println(pro1.getProperty("title"));

System.out.println(pro1.getProperty("author"));

System.out.println(pro1.getProperty("publisher"));

//先保存到xml文件中，在将其读出来

//将内容保存到XML中

Properties ppt1=new Properties();

File file=new File("e:"+File.separator+"e.txt");

OutputStream out=new FileOutputStream(file);

ppt1.setProperty("title", "Java");

ppt1.setProperty("author", "xiaoyan");

ppt1.setProperty("publisher", "qinghua");

ppt1.storeToXML(out, "Area XML");

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

//将内容从XML文件中读取出来

Properties ppt2=new Properties();

File file=new File("e:"+File.separator+"e.txt");

InputStream input=new FileInputStream(file);

List(ArrayList、Vector、LinkedList)、Map(HashMap、TreeMap、Hashtable)、Set(HashSet、TreeSet)、equals、hashcode

ppt2.loadFromXML(input);

System.out.println(ppt2.getProperty("title"));

System.out.println(ppt2.getProperty("author"));

System.out.println(ppt2.getProperty("publisher"));

Set也可以使用泛型，set中没有下标，也没有key，所以set中的数据不能重复，如果重复，就会被覆盖，但是放进去的数据肯定会被读出来，

HashSet如下：

Set<String> set=new HashSet<String>();

set.add("111");

set.add("123");

set.add("123");

set.add("234");

for(String str:set){

System.out.println(str);

}

结果如下： 123

111

234

注意：Set和map一样，内部有自己的算法，输出的结果顺序会有所不同

排序的子类：TreeSet

Set<String> ts=new TreeSet<String>();

ts.add("W");

ts.add("R");

ts.add("D");

ts.add("A");

for(String t:ts){

System.out.println(t);

}

用TreeSet对对象进行排序

public class Person implements Comparable<Person>{

private String name;

private int age;

public Person(String name,int age){

http:// =name;

this.age=age;

}

public String getName() {

return name;

}

public void setName(String name) {

http:// = name;

}

List(ArrayList、Vector、LinkedList)、Map(HashMap、TreeMap、Hashtable)、Set(HashSet、TreeSet)、equals、hashcode

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String toString(){

return "姓名："+http:// +" 年龄："+this.age;

}

public int compareTo(Person per) {

if(this.age>per.age ){

return 1;

}

else if(this.age<per.age )

{

return -1;

}else{

return http://pareTo(http:// );

}

}

}

public class Person2 {

public static void main(String[] args) {

Set<Person> set=new TreeSet<Person>();

set.add(new Person("王灵",22));

set.add(new Person("王真",23));

set.add(new Person("箫剑",22));

set.add(new Person("小红帽",21));

for(Person p:set){

System.out.println(p);

}

}

}

注意：TreeSet的排序实现，如果是集合中对象是自定义的或者说其他系统定义的类没有实现Comparable接口，则不能实现TreeSet的排序，会报类型转

换（转向Comparable接口）错误。换句话说要添加到TreeSet集合中的对象的类型必须实现了Comparable接口。不过TreeSet的集合因为借用了

List(ArrayList、Vector、LinkedList)、Map(HashMap、TreeMap、Hashtable)、Set(HashSet、TreeSet)、equals、hashcode

Comparable接口，同时可以去除重复值，而HashSet虽然是Set接口子类，但是对于没有复写Object的equals和hashCode方法的对象，加入了HashSet集合

中也是不能去掉重复值的。

集合输出使用迭代Iterator

记住：只要碰到了集合，就想都不想的使用iterator 来进行输出，其操纵原理是：判断有没有下一个元素，如果有，就直接输出

Collection<String> all=new ArrayList<String>();

all.add("E");

all.add("D");

all.add("S");

all.add("F");

all.add("A");

Iterator<String> ite=all.iterator();

while(ite.hasNext()){

String str=ite.next();

System.out.println(str);

}

这是iterator最常用的输出方式，也是一种标准书写方式

分析equals、hashCode与内存泄露

Equals的作用：比较两个对象的地址值是否相等

向Set集合中放入数据不能出现重复，如果重复，只保留一个，如何判断是否重复

A. 比较hashcode，如果hashcode不同，则对象肯定不同

B. 如果hashcode相同，比较equals方法，看内容是否相同，如果equals相同，则对象相同

C. 如果这个set是treeset，内部排序，这时候，实现comparable接口，则比较对象是否相同，使用的不再是hashcode、equals方法，而是

compareto方法

D. Equals相同，hashcode一定相同，hashcode相同，equals不一定相同，但是hashcode比较省时间