07 - JavaSE之容器

本章宗旨:1136 -- 1个图 1个类 3个知识点 6个接口

容器

  • J2SDK 所提供的容器 API 位于 java.util 包内。
  • 容器 API 的类图如下:

Collection 接口的子接口分为:Set接口(包含 HashSet类) + List接口(包含LinkedList 类和 ArrayLis t类) Map接口:包含HashMap类

Set接口和List接口定义了不同的数据存储方式:

  1. Set 中的数据对象没有顺序并且不可以重复。
  2. List 中的数据对象有顺序并且可以重复。
  • Map接口定义了存储“键(key)——值(value)映射”的方法。

Collection接口

  • 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()

举例1:

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

举例2:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Collection c = new HashSet();
        c.add("Hello");
        c.add(new String("World"));
        c.add(new Integer(100));
        // 可以删除因为HashSet重写了equals方法。
        c.remove("Hello"); 
        c.remove(new Integer(100));
        System.out.println(c.size());
        System.out.println(c);
    }
}
// 1
// [100]
  • 容器类对象在调用 remove,contains 等方法时需要比较对象是否相等,这会涉及到对象类型的 equals 方法和 hashcode 方法;对于自定义的类型,需要重写 equals 和 hashCode 方法以实现自定义的对象相等规则。
  • 相等的对象应该具有相同的 hash codes,但是 hashCode 只在这个对象作为索引、键值的时候使用此方法,其他时候虽然不用,但是还是要重写此方法,至于重写此方法的具体实现可以随便写(比如我直接返回0也是可以的)。

Iterator 接口

  • 所有实现了 Collection 接口的容器类都有一个 iterator 方法,这个方法返回一个实现了 Iterator 接口的对象。
  • 这个 Iterator 对象称为迭代器,用以方便的实现对容器内的元素的遍历操作。
  • Iterator 接口定义了如下方法:
boolean hasNext(); // 判断游标右边是否有元素
Object next(); // 返回游标右边的元素并移动游标到下一个位置
void remove(); // 删除游标左边的元素,在执行完next之后,该操作只能执行一次

举例1:

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("Hello");
        c.add(new String("World"));
        c.add(new Integer(100));
        
        Iterator i = c.iterator();

        while(i.hasNext()) {
            System.out.println(i.next());
        }
    }
}
  • Iterator 对象的 remove 方法是在迭代过程中删除元素的唯一的安全方法。(不能使用 Collection 对象的 remove 方法,因为管家Iterator 对象在迭代过程中会将元素上锁,外人无法访问。)
import java.util.*;
public class Test {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("Hello");
        c.add(new String("World"));
        c.add(new Integer(100));
        
        Iterator i = c.iterator();

        for(Iterator i = c.iterator(); i.hasNext(); ) {
            if(i.next().equals(100)) {
                i.remove();
            }
        }
        System.out.println(c); // [Hello, World]
    }
}

补充:JDK1.5 增强的 for 循环

  • 增强的 for 循环对于遍历 array 或者 Collection 的时候相当简便。
import java.util.*;

public class EnhancedFor {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for(int i : arr) {
            System.out.println(i);
        }
        
        Collection c = new ArrayList();
        c.add(new String("aaa"));
        c.add(new String("bbb"));
        c.add(new String("ccc"));
        for(Object o : c) {
            System.out.println(o);
        }
    }
}
  • 增强型 for 循环的缺陷:(除了简单遍历外,不建议使用增强 for 循环)
  1. 对于数组:不能方便的访问下标值。
  2. 对于 Iterator ,不能方便的删除集合中特定的元素。

Set 接口

  • Set接口是 Collection 的子接口,Set 接口没有提供额外的方法,实现Set接口的容器类中的元素是没有顺序的,而且不可以重复
  • Set容器可以与数学中的“集合”概念相对应。
  • JDK API中所提供的Set容器类有HashSet,TreeSet等。

举例1:

public static void main(String[] args) {
  Set s = new HashSet();
  s.add("hello");
  s.add("world");
  s.add("world"); // 相同的元素不会被加入,类似数学的集合概念
  System.out.println(s); // [hello, world]
}

举例2:

public 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);
  Set su = new HashSet(s1);
  sn.retainAll(s2);
  su.addAll(s2);
  System.out.println(sn); // [a, b]
  System.out.println(su); // [d, a, c, b]
}

List 接口

  • List接口是 Collection的 子接口,实现List接口的容器类中的元素是有顺序的,而且可以重复。
  • List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
  • JAVA SDK提供的List容器类有 ArrayList,LinkedList等。
Object get(int index) // 返回index位置的元素
// 返回值为Object,表示set替换掉的元素,返回出来
Object set(int index, Object element) 
void add(int index, Object element)
Object remove(Object o)
int indexOf(Object o)
int lastIndexOf(Object o)

举例:

List l1 = new LinkedList();
for(int i=0; i<6; i++) {
  li.add("a" + i);
} // [a0, a1, a2, a3, a4, a5, a6]
System.out.print((String)l1.get(2) + " "); // a2
System.out.println(li.indexOf("a3")); // 3
li.remove(1);
System.out.println(l1); // [a0, a2, a3, a4, a5, a6]

List 常用算法(Collections类)

  • Collections类提供了一些静态方法实现了基于List容器的常用算法。
void sort(List) // 对List容器内的元素排序
void shuffle(List) // 对List容器内的元素进行随机排列
void reverse(List) // 对List容器内的元素进行逆序排列
void fill(List, Object) // 用特定的List元素列表填充整个List容器
void copy(List dest, List src) 
void binarySearch(List, Object) // 对于顺序的List容器,采用二分法查找指定对象

Comparable 接口

问题:上面的算法根据什么确定容器中对象的“大小”顺序?

其实,所有可以排序的类都实现了 java.lang.Comparable 接口,Comparable河口中只有一个方法:

public int compareTo(Object obj);

该方法:

返回0表示: this == obj

返回正数表示:this > obj

返回负数表示:this < obj

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

PS:我们可以看到 compareTo 方法的参数类型是 Object 类型的,意味着如果我只想比较两只猫的话,我扔一只狗也是可以的,这就没意义了,所以在之后的 JDK 里面,将 Object 类型统一改为 泛型,这样在传入的时候就统一了比较的对象。

改写 Name 类,让其实现 Comparable 接口:

class Name implements comparable {
  //...
  public int compareTo(Object o) {
    Name n = new (Name)o;
    int lastCmp = lastName.compareTo(n.lastName); // 先比较姓氏大小
    return (lastCmp != 0 ? lastCmp : firstName.compareTo(n.firstName)); // 再比较名字大小
  }
}

改写了 compareTo 方法,相当于改写了Collections类的排序算法,至于如何排序,由你决定!


如何选择数据结构?

  • 衡量标准:读的效率和写的效率(如字符串逆序操作)
  1. Array 读快写慢(写的慢,需要另开辟数组)
  2. Linked 写快读慢(写的快,还需要改变指针指向)
  3. Hash 介于两者之间

Map接口

  • 实现Map接口的类用来存储 “键值对”
  • Map接口的实现类有 HashMap 和 TreeMap
  • Map类中存储的键值对通过键来标识,所以键的值不能重复
Object put(Object key, Object value) // 返回值为 Object,是替换掉的 value
Object get(Object key)
Object remove(Object key)
boolean containsKey(Object key)
boolean containsValue(Object value)
int size()
boolean isEmpty()
void putAll(Map m)
void clear()

举例1:

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(2)));

        if(m1.containsKey("two")) {
            int i = ((Integer) m1.get("two")).intValue();
            System.out.println(i);
        }

        Map m3 = new HashMap(m1);
        m3.putAll(m2);
        System.out.println(m3);

    }
}

举例2:

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);

    }
}
// java Test 77 88 99 99 99 
// {77=1, 88=1, 99=3}

Auto-boxing/unboxing

  • 在合适的时机自动打包/解包
  1. 自动将基础类型转换成对象
  2. 自动将对象转换成基础类型
import java.util.*;
public class Test {
    private static final int ONE = 1;
    public static void main(String[] args) {
        Map m = new HashMap();

        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);
    }
}

泛型

  • 起因
  1. JDK1.4之前类型不明确,装入集合的类型都被当做 Object 对待,从而失去了其本身的实际类型。
  2. 从集合中取出元素时需要转型,效率低,容易产生错误。
  • 解决办法
  1. 在定义集合的时候定义集合中对象的类型
import java.util.*;
public class Test {
    public static void main(String[] args) {
        Collection<String> c = new HashSet<String>();
        c.add("aaa"); c.add("bbb"); c.add("ccc");

        for(Iterator<String> i = c.iterator(); i.hasNext(); ) {
            System.out.println(i.next());
        }
    }
}
// aaa ccc bbb

总结

1136:一个图,一个类,三个知识点,六个接口

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Android群英传

深入Java源码解析容器类List、Set、Map

2043
来自专栏向治洪

java 之容器

在Java中,我们想要保存对象可以使用很多种手段。我们之前了解过的数组就是其中之一。但是数组具有固定的尺寸,而通常来说,程序总是在运行时根据条件来创建对象,我们...

2208
来自专栏Java技术分享圈

Java集合之map 集合使用

732
来自专栏浪淘沙

java学习day07 常用API

2018.6.11 1.object 所有类的父类 toString 打印对象的地址值 hashCode 对象的存储位置的算法 ...

1393
来自专栏章鱼的慢慢技术路

顺序表示的线性表——顺序表

2224
来自专栏Java爬坑系列

【Java入门提高篇】Day20 Java集合类详解(三)List接口

  今天要说的是Collection族长下的三名大将之一,List,Set,Queue中的List,它们都继承自Collection接口,所以Collectio...

2347
来自专栏LinkedBear的个人空间

唠唠SE的集合-01——Collection接口

当集合中存储的对象类型不同时,那么会导致程序在运行的时候的转型异常,所以jdk1.5加入了泛型机制。

682
来自专栏用户2442861的专栏

Java中如何遍历Map对象的4种方法

既然java中的所有map都实现了Map接口,以下方法适用于任何map实现(HashMap, TreeMap, LinkedHashMap, Hashtabl...

981
来自专栏算法修养

2016天梯模拟赛 进阶题解

L2-005 集合相似度 题目链接: https://www.patest.cn/contests/gplt/L2-005 题目的意思是要求两个集合的交集中...

4279
来自专栏武培轩的专栏

剑指Offer-和为S的两个数字

题目描述 输入一个递增排序的数组和一个数字S,在数组中查找两个数,是的他们的和正好是S,如果有多对数字的和等于S,输出两个数的乘积最小的。 输出描述: 对应每...

3214

扫码关注云+社区

领取腾讯云代金券