java容器和6个常见的接口

 

 

 

容器API属于 java.util.* 内

 

重点：1图 1类 3 知识点 6 接口

 

1图：常见的一些接口

 

• Set:没有顺序且不可以重复。

• List:有顺序而且可以重复

 

1类：Collections     

 

3知识点：

1. foreach;
2. Generic(泛型)；
3. Auto_Boxing/unboxing;

6接口:

1. collection
2. Set
3. List
4. Map
5. iterator(遍历容器，有三个方法)

6. comparable

   ---

Collection常用方法：

• int size()
• boolean isEmpty()
• void clear()
• boolean contains(Object element)
• boolean add(Object element)
• boolean remove(Object element)
• Iterator iterator();
• boolean containsAll(Collection c)
• boolean addAll(Collection c)
• boolean removeAll(Collection c);
• boolean retainAll(Collection c);
• Object[] toArray()

 

注意：语法（... instanceof ...）判断一个类是否是另一个类

if(Obj instanceof Name){

    Name a =(Name)obj;

}

Collection c = new ArrayList<***>();

//父类引用指向子类对象，访问不了子类的方法（设计模式相关） //方便以后换

顺带一提：面向对象着重类与类之间的各种关系，而面向对象的三大特点：封装，多态，继承。

 

 

---

Iterator 接口 

有多态的存在（多态存在的三大条件：有继承、有重写、有父类引用指向子类的对象）

Iterator 存在于每个实现了Collection接口的容器中，他们可以返回一个实现了Iterator接口的对象。

 作用：迭代器，遍历容器内的元素。

Iterator常用方法：

• boolean hasNext();  判断游标右边是否有元素
• Object next()           返回右边右边的元素并且下移一个游标
• void     remove()     删除游标左边的元素，执行完next之后该操作只执行一次（迭代过程中删除元素唯一的安全方法）
• 

Iterator 方法的运用

import java.util.*;

class Test{

    public static void main(String[] args){

        HashSet<Name>c = new HashSet<Name>();

        c.add(new Name("f1","l1"));c.add(new Name("f2","l2"));

        for(Iterator<Name> i =c.iterator();i.hasNext();){

            Name n = i.next();

            System.out.println(n.firstname+" "+n.lastname);

        }

    }

}

class Name{

    String firstname,lastname;

    Name(String firstname,String lastname){

        this.firstname = firstname;

        this.lastname  = lastname;

     }

}

 

Collection<Name> c = new HashSet<Name>();

c.add(new Name("fff1","lll1"));

c.add(new Name("f2","l2"));

c.add(new Name("fff3","lll3"));

for(Iterator<Name> i =c.iterator();i.hasNext();）{

    Name n = i.next();

    if(n.getFirstName().length()<3){

    i.remove();

    }

}

System.out.println(c);

 

 

---

增强的for循环

只能简单遍历并且读出其中的内容。

int[] arr = {3,4，5,6,7}；

for(int i :arr){

    System.out.println(i);

}

import java.util.*;

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

c.add("aaa");c.add("bbb");c.add("ccc");

for(String s: c){

    System.out.println(s);

}

 

 

---

Set(HashSet) 

（没有顺序且不可以重复）

 

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

s.add("aaa");

s.add("aaa")://!!!这句话不会被执行

 

若 S1：[a,b,c]  s2:[b,c,d]

s1.addAll(s2);   s1:[a,b,c,d]  /(就像集合里面的求交集)

Set<String> Sn  =new HashSet(s1); Sn.retainAll(s2);   sn:[b,c]

 

 

---

Map接口

 (HashMap,TreeMap(二叉树，红黑树))

存储  键-值（key-value）

注意：键值不能重复：所以修改了equal,就必须修改HashCode;

常用的方法：

• 放入数据：Object put(Object key,Object value);   //如：m1.put("One",1);如果再执行下一条语句m1.put("One",2);会返回原来的值，也就是1；
• 取出数据：Object get(Object key); //泛型:int i =m1.get("Two");
• Object remove(Object key);
• boolean containsKey(Object key);
• boolean containsValue(Object value);
• int size();
• boolean isEmpty();
• void putAll(Map t);
• void clear();

import java.util.*;

 

...

 

Map<String.Integer> m1 = new HashMap<String,Integer>();

m1.put("One",1);m1.put("Two",2);m1.put("Three",3);

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

System.out.println(m1.containsKey("One"));

if(m1.containsValue(1)){

    int i = (Integer)m1.get("Two");

        System.out.println(i);

}

 

 

---

List(LinkedList,ArrayList):

List<String> l1 = new LinkedList<String>();

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

    l1.add("a"+i);

}                        //l1:[a0,a1,a2,a3,a4,a5]

l1.add(3,"a100");        //在第四个位置插入a100 l1:[a0,a1,a2,a100,a3,a4,a5]

l1.set(6,"a200");        //把第七个位置的替换为a200  l1:[a0,a1,a2,a100,a3,a4,a200];

String a = l1.get(3);               // 得到第四个元素

int i = l1.indexOf("a3");         // 返回元素a3的位置 下标从0开始

l1.remove(1);

 

 

---

List容器常用的算法！！！  都在java.util.Collections

 

• void sort(List)   //升序，如果需要降序，就先升序再逆序
• void shuffle(List)  //随机排序
• void reverse(List) //逆序排序
• void fill(List,Object) //用一个特定的对象重写整个List容器
• void copy(List dext,List src) //将后者拷贝给前者
• int    binarySearch(List, Object) 如：int a=binarySearch(l1, "a5");  //(！！必须先排序，才可以用此方法查找！！）

 

特别注意：

   要用到以上的方法，应该这样写： Collections.sort(l1);    Collections.reverse(l1);.......

 

---

Comparable 接口   

 属于 java.lang.Comparable (所有可以“排序”的类都实现了java.lang.Comparable接口)

要想使一个类实现implements这个Comparable<E>接口，必须在类里面重写 compareTo(Object obj） 这个方法

利用comparable，实现类对象的排序方式

public int compareTo(Object obj){

    this = = obj ;返回0

    this>obj;返回大于0

    this<obj;返回小于0

}

举个例子： 使多个姓名按照英文字母排序

class Name implements Comparable<Name>{

   String firstname,lastname;

      Name(String firstname,String lastname){

      this.firstname = firstname;

      this.lastname  = lastname;

     }

 

    public int compareTo(Name n){

        //(有了泛型可以省略)Name n = (Name)o

        int lstcmp = lastname.compareTo(n.lastname);

        return (lastcmp!=0?lastcmp:firstname.compareTo(n.firstname));

    }

}