zoukankan      html  css  js  c++  java

  • 07

    本章宗旨：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：一个图，一个类，三个知识点，六个接口
  • 相关阅读:
    停机文件[Warning] Unsafe statement written to the binary log using statement format since 错误
    生成class关于使用javah生成头文件时无法访问class文件的问题
    NTLM
    openssl多线程实例
    GetProcessIDByName
    wmi事件
    web service远程测试（.net）
    NTpassword(MD4)
    [转载]win下实现切换帐号的方法
    fstoyou.com改了域名
  • 原文地址：https://www.cnblogs.com/lvonve/p/8228451.html
Copyright © 2011-2022 走看看