容器 - mathor

Java 容器的继承关系展开目录

Collection 接口展开目录

Collection 接口中所定义的方法

int size();
boolean isEmpty();
void clear();
boolean contains(Object element);//是否包含某个对象
boolean add(Object element);
Iterator iterator();
boolean containsAll(Collection c);//是否包含另一个集合中的所有元素
boolean addAll(Collection c);
boolean removeAll(Collection c);
boolean retainAll(Collection c);求当前集合类和另一个集合类的交集
Object[] toArray();

Collection 方法举例展开目录

import java.util.*;
public class Test{
    public static void main(String[] args){
        Collection c = new ArrayList();
        //可以放入不同类型的对象
        c.add("hello");
        c.add(new Integer(100));
        System.out.println(c.size());//2
        System.out.println(c);//[hello,100]
    }
}

这里提出一个我学习过程中问题：第四行代码，为什么不写成如下形式:

ArrayList c = new ArrayList();
//或者
List c = new ArrayList();

后来看了马士兵老师的视频以及网上找了一些博客解释才大概有个了解

首先，利用基类（父类）引用指向子类对象，该引用只能访问子类中父类的属性和方法，不能访问子类中新的属性和方法，当然这里不是父类，而是接口，效果也是一样的。这样做相当于给使用者固定一个模板，只能使用 Collection 中的一些方法，而且本身程序也只用到 Collection 中的方法，更加简洁

其次，使用 Collection 接口的引用更加具有扩展性，比方说下次要将 c 指向 LinkedList 对象，就可以直接改，但如果是上述两种方式，就不方便进行转换

Set 接口展开目录

Set 接口中所定义的方法

boolean add(Object o)//如果不存在指定的元素，则添加此元素
boolean contains(Object o)//如果包含指定的元素，则返回true
boolean retainAll(Collection c)//保留包含collection中的元素
boolean addAll(Collection c)//将Collection中的元素添加到Set中（不包括重复的）

Set 方法举例展开目录

public static void main(String[] args){
    Set s = new HashSet();
    s.add("hello");
    s.add("world");
    s.add(new Inetger(100));
    s.add("hello");//相同的元素不会被添加
    System.out.println(s);//
}

pulic static void main(String[] args){
    Set s1 = new HashSet();
    Set s2 = new HashSet();
    s1.add("a");s1.add("b");s1.add("c");
    s2.add("d");s2.add("a");s2.add("b");
    Set sn = new HashSet(s1);//把s1的内容copy到sn
    Set su = new HashSet(s1);
    sn.retainAll(s2);//两个集合的交集
    su.addAll(s2);
    System.out.println(sn);
    System.out.println(su);
}

List 接口展开目录

List 接口中所定义的方法

Object get(int index)//返回指定下标位置的元素
Object set(int index,Object element)//用指定的元素替换指定位置的元素，返回被替换的元素
void add(int index,Object element)//在指定位置添加元素，后面的元素依次向后移
Object remove(int index)//去除指定位置的元素
int indexOf(Object o)//返回元素第一次出现在List中的下标
int LastIndexOf(Object o)//返回元素最后一次出现在List中的下标

List 方法举例展开目录

public static void main(String[] args){
    List l1 = new LinkedList();
    for(int i = 0;i <= 5;i++)
        l1.add("a" + i);
    System.out.println(l1);//[a0,a1,a2,a3,a4,a5]
    l1.add(3,"a100");
    System.out.println(l1);//[a0,a1,a2,a100,a3,a4,a5]
    l1.set(6,"a200");
    System.out.println(l1);//[a0,a1,a2,a100,a3,a4,a200]
    System.out.print((String)l1.get(2) + " ");//a2
    System.out.println(l1.indexOf("a3"));//4
    l1.remove(1);
    System.out.println(l1);//[a0,a2,a100,a3,a4,a200]

上面程序注意一点是，get 方法返回值是 Object 类型，所以要强制转换为 String 类型

Collections 类展开目录

类 java.util.Collections 提供了一些静态方法实现了基于 List 容器的一些常用算法

void sort(List)//对List容器内的元素排序
void shuffle(List)//对List容器内的元素随机排列
void reverse(List)//将List容器内的元素逆序
void fill(List,Object)//用一个特定的对象重新填充List
void copy(List dest,List src)//将src的内容拷贝到dest
int binarySearch(List,Object)//二分查找特定对象

Collections 方法举例展开目录

public static void main(String[] args){
    List l1 = new LinkedList();
    List l2 = new LinkedList();
    for(int i = 0;i <= 9;i++)
        l1.add("a" + i);
    System.out.println("l1");
    Collections.shuffle(l1);//随机排序
    System.out.println(l1);
    Collections.reverse(l1);//逆序
    System.out.println(l1);
    Collections.sort(l1);//排序
    System.out.println(l1);
    System.out.println(Collections.binarySearch(l1,"a5"));//折半查找
}

Comparable 接口展开目录

Comparable 中只有一个方法：

public int compareTo(Object obj);
//返回  0 表示this == obj
//返回正数表示this > obj
//返回负数表示this < obj

实现 Comparable 接口的类通过实现 compareTo 方法，从而确定该类对象的排序方式

Comparable 方法举例展开目录

import java.util.*;

class Person implements Comparable{//必须实现接口
    String firstName,lastName;
    Person(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 o) {
        if(o instanceof Person) {
            Person p = (Person)o;    
                return p.firstName == this.firstName && p.lastName == this.lastName;
        }
        return
                super.equals(o);
    }
    public int hashCode() {
        return firstName.hashCode();
    }
    public int compareTo(Object o) {//实现compareTo方法
        Person p = (Person)o;
        int perCmp = this.firstName.compareTo(p.firstName);
        //调用String类的compareTo方法
        return (perCmp == 0 ? this.lastName.compareTo(p.lastName) : perCmp);
        //如果姓相同，比较名
    }
}

public class Test{
    public static void main(String[] args) {
        List l1 = new LinkedList();
        l1.add(new Person("W","M"));
        l1.add(new Person("X","Z"));
        l1.add(new Person("Z","S"));
        l1.add(new Person("W","L"));
        System.out.println(l1);
        Collections.sort(l1);
        System.out.println(l1);
    }
}

Map 接口展开目录

Map 接口的实现类用来存储键 & 值对
Map 接口的实现类有 HashMap 和 TreeMap 等
Map 类中存储的键 & 值对通过键来标识，所以键值不能重复

Object put(Object Key,OBject Value)//如果原本的key存在，
//那么就会把原本的value作为返回值返回，并且把当前的参数传进去
Object get(Object Key)
Object remove(Object Key)
boolean containsKey(Object Key)
boolean containsValue(Object Value)
int size()
boolean isEmpty()
void putAll(Map t)
void clear()

Map 方法举例展开目录

import java.util.*;
public class Test{
    public static void main(String[] args){
        Map m1 = new HashMap();
        Map m2 = new HashMap();
        m1.put("one",new Integer(1));
        m1.put("two",new Integer(2));
        m1.put("three",new Integer(3));
        m2.put("A",new Integer(1));
        m2.put("B",new Integer(2));
        System.out.println(m1.size());
        System.out.println(m1.containsKey("one"));
        System.out.println(m2.containsValue(new Integer(1)));
        if(m1.containsKey("two")){
            int i = ((Integer)m1.get("two")).intValue();
            System.out.pritnln(i);
        }
        Map m3 = new HashMap(m1);
        m3.putAll(m2);
        System.out.println(m3);
    }
}

import java.util.*;
//记录每个单词出现多少次
public class Test{
    private static final Integer ONE = new Integer(1);
    public static void main(String[] args) {
        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);
    }
}

Catalog

容器

June 22, 2018 • Read: 3192 • Java • 阅读设置