corejava学习(集合)

集合

 

Collection(元素，object)

 

 

List          set

（有顺序）       无顺序

 可以重复        不可重复(内容不重复)

 

 

 

 

                              Sortedset

 

 

Collections.sort()只能对list排序  排序规则通过实现comparable接口

import java.util.*;

public class TestSort {

    public static void main(String[] args) {

           List list=new ArrayList();

           list.add(new Student("Liucy",30));

           list.add(new Student("George",40));

           list.add(new Student("Huxz",18));

           list.add(new Student("Luxw",25));

           Collections.sort(list);

           print(list);

    }

    static void print(Collection con){

           Iterator it=con.iterator();

           while(it.hasNext()){

                  Object o=it.next();

                  System.out.println(o);

           }

    }

}

 

结果：

Student name=George  age=40

Student name=Huxz  age=18

Student name=Liucy  age=30

Student name=Luxw  age=25

 

Arraylist            数组

轻量级           快                 线程不安全

查询  快         增删   慢

Vector               数组

重量级            慢                 线程安全

Linkedlist            链表

查询 慢       增删   快

 

import java.util.*;

public class TestArrayList {

    public static void main(String[] args) {

           List list=new ArrayList();

           list.add("Liucy");

           list.add("Zhuzh");

           list.add("Luxw");

           list.add(0,"Huxz");

           list.remove(2);

           /*

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

                  Object o=list.get(i);

                  String s=(String)o;

                  System.out.println(s);

           }

           */

           print(list);

          

    }

    static void print(Collection con){

           Iterator it=con.iterator();

           while(it.hasNext()){

                  Object o=it.next();

                  System.out.println(o);

           }

    }

}

 

结果：

Huxz

Liucy

Luxw

 

 

Map

(key   --------------------value)

唯一的              可重复

 

Setmap

 

 

 

 

List

                          

 

                         Arraylist         linkedlist          vector

 

 

在java怎么实现一个栈

用linkedlist实现。

Class mystack{

Private Linkedlist list=new Linkedlist();

Public void push(Object o){

List.addFirst(o);

}

Public void pop(Object o){

Return List.removeFirst();

}

}

 

Set类

Class Testset{

Public static void main(String args[])

{

Set s=new HashSet();

String s1=new String(“liucy”);

Sring s2=new String(“luxw”);

String s3=new String(“liucy”);

s.add(s1);

s.add(s2);

s.add(s3);

print1(s);

}

Static void print1(collection con){

Iterator it=con.iterator();

           while(it.hasNext()){

                  Object o=it.next();

                  System.out.println(o);

}

 

}

}

结果：

Luxw

Liucy

 

Treeset

当有重复的对象，新的重复的对象进不出

 

覆盖hashCode（）

保证相同对象，返回相同哈希码

覆盖equals（）

保证相同对象返回true

 

先比较hashcode，

如果相同放在同一空间，再用Equals比较内容是否相同，相同的对象去掉

 

 

有对象的排序就得用实现comparable接口。

如果一个类中，有equals方法和compareTo方法时，两个方法必须是逻辑是一致的。

当equals返回true时，则compareTo应返回0。

当equals返回false时，则compareTo返回非0。

 

Map      里面是键值对

Key   ―――――――――――――――――value

不重复                                   可重复

无顺序

一个映射不能包含重复的键；每个键最多只能映射一个值。

当在有重复的键时，新值会覆盖旧值。

 

遍历：有值遍历，

static void printValues(Map map){

           Collection vs=map.values();

           Iterator it=vs.iterator();

           while(it.hasNext()){

                  Object o=it.next();

                  System.out.println(o);

           }

    }

 

键值对 遍历

 

static void printKeyValues(Map map){

           Set ks=map.keySet();

           Iterator it=ks.iterator();

           while(it.hasNext()){

                  Object key=it.next();

                  Object value=map.get(key);

                  System.out.println(key+"-----"+value);

           }

    }

 

 

import java.util.*;

public class TestMap {

    public static void main(String[] args){

           Map map=new TreeMap();

           map.put("Unix", "Luxw");

           map.put("CoreJava", "Liucy");

           map.put("OOAD", "Huxz");

           map.put("EJB", "George");

           map.put("CoreJava", "Huxz");

           /*

           System.out.println(map.size());

           //System.out.println(map.containsKey("EJB"));

           System.out.println(map.containsValue("Liucy"));

           System.out.println(map.get("CoreJava"));

           */

           printValues(map);

           printKeyValues(map);

    }

    static void printValues(Map map){

           Collection vs=map.values();

           Iterator it=vs.iterator();

           while(it.hasNext()){

                  Object o=it.next();

                  System.out.println(o);

           }

    }

    static void printKeyValues(Map map){

           Set ks=map.keySet();

           Iterator it=ks.iterator();

           while(it.hasNext()){

                  Object key=it.next();

                  Object value=map.get(key);

                  System.out.println(key+"-----"+value);

           }

    }

}

结果：

Huxz

George

Huxz

Luxw

CoreJava-----Huxz

EJB-----George

OOAD-----Huxz

Unix-----Luxw

 

Map的三个实现类

HashMap   1.2版的类     快    线程不安全    允许Null作为键或值

 

Hashtable   1.0版的类     慢    线程安全     不允许Null作为键或值

 

Treemap    有序的

 

集合：用来管理，容纳多个对象的对象（容器）面向对象可重用性的体现，对数组作了功能封装。

 

Collection：元素是Object

基本操作：add，remove，size

遍历：迭代遍历

 

List：元素有顺序（下标）,可以重复

基本操作：add（int，Object），remove（int），get

遍历：for，迭代