java day_Java_Day8

Java learning_Day8

内容

容器

泛型

容器

Java API 所提供的一系列类的实例，用于在程序中存放对象。

容器 API

JDK 所提供的容器 API 位于 java.util 包内。

容器 API 的类图结构如下图所示：

Collection 接口：定义了存取一组对象的方法，其子接口 Set 和 List 分别定义了存储方式。

Set 中的数据对象没有顺序且不可以重复。

List 中的数据对象有顺序且可以重复。

Map 接口定义了存储“键(key)—— 值(value)映射对”的方法。

Collection

Collection接口所定义的方法：

Collection 方法举例

容器类对象在调用 remove、contains 等方法时需要比较对象是否相等，这回涉及到对象类型的 equals 方法和 hashCode 方法；对于自定义的类型，需要重写 equals 和 hashCode 方法以实现自定义的对象相等规则。

注意：相等的对象应该具有相等的 hashCodes。

Iterator 接口

所有实现了 Collection 接口的容器类都有一个 iterator 方法用以返回一个实现了 Iterator 接口的对象。

iterator 对象称作迭代器，用以方便地实现对容器内元素的遍历操作。

Iterator 接口定义了如下方法：

方法举例一

import java.util.*;

public class IteratorTest {

public static void main(String[] args) {

Collection c = new HashSet();

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

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

c.add(new Name("f3", "l3"));

Iterator i = c.iterator();

while (i.hasNext()) {

//next()的返回值为object类型，需要转换为相应类型

Name n = (Name)i.next();

System.out.println(n.getFirstName());

}

}

}

class Name {

String firstName, lastName;

public Name(String firstName, String lastName) {

this.firstName = firstName;

this.lastName = lastName;

}

public String getFirstName() {

return firstName;

}

public String getLastName() {

return lastName;

}

}

输出

f3

f1

f2

注意：由于哈希值没有固定的顺序，因此输出内容的顺序可能有所不同

方法举例二

... ... ...

Collection c = new HashSet();

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

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

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

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

Name name = (Name)i.Next();

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

i.remove();

//如果换成 c.remove(name)；会产生例外(线程锁定)

}

}

增强 for 循环

增强的 for 循环对于遍历 array 或 Collection 的时候相当简便

缺陷：

数组：不能方便地访问下标值

集合：

与使用 Iterator 相比，不能方便地删除集合中的内容

在内部也是调用 Iterator

总结：除了简单遍历并读出其中的内容外(只读)，不建议使用增强 for

举例

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

}

}

}

Set 接口

Set 接口是 Collection 的子接口，Set 接口没有提供额外的方法，但实现 Set 接口的容器类中的元素是没有顺序的，而且不可以重复。

Set 容器可以与数学中“集合”的概念相对应。

JDK API 中所提供的的 Set 容器类有 HashSet，TreeSet 等。

List 接口

List 接口是 Collection 的子接口，实现 List 接口的容器类的元素是有顺序的，而且可以重复。

List 容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

JDK 所提供的 List 容器类有 ArrayList，LinkList 等。

List 常用算法

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

Comparable 接口

所有可以“排序”的类都实现了 java.lang.Comparable 接口，Comparable 接口中只有一个方法：

public int compareTo(Object obj);

该方法：

返回0表示 this == obj

返回正数表示 this > obj

返回负数表示 this < obj

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

如何选择数据结构*

衡量标准：读的效率和改的效率

Array 读快改慢

Linked 改快读慢

Hash 两者之间

Map 接口

实现 Map 接口的类用来存储键——值对。

Map 接口的实现类有 HashMap 和 TreeMap 等。

Map 类中存储的键——值对通过键来标识，所以键值不能重复。

示例

import java.util.*;

public class TestMap {

public static void main(String[] args) {

Map m1 = new HashMap();

Map m2 = new TreeMap();

m1.put("one", new Integer(1));

m1.put("two", new Integer(2));

m1.put("three", new Integer(3));

m2.put("A", new Character('A'));

m2.put("B", new Character('B'));

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

System.out.println(m1.containsKey("one")); //true

System.out.println(m2.containsValue(new Character('A'))); //true

if (m2.containsKey("A")) {

char i = ((Character)m2.get("A")).charValue();

System.out.println(i); //A

}

Map m3 = new HashMap(m1);

m3.putAll(m2);

System.out.println(m3);

}

}

输出

3

true

true

A

{A=A, B=B, two=2, three=3, one=1}

Auto-boxing/unboxing

在合适的时机自动打包、解包

自动将基础类型转换为对象

自动将对象转换为基础类型

对上一处的程序进行改进

import java.util.*;

public class TestMap {

public static void main(String[] args) {

Map m1 = new HashMap();

Map m2 = new TreeMap();

m1.put("one", 1); //Autoboxing

//m1.put("one", new Integer(1));

m1.put("two", 2); //Autoboxing

//m1.put("two", new Integer(2));

m1.put("three", 3); //Autoboxing

//m1.put("three", new Integer(3));

m2.put("A", 'A'); //Autoboxing

//m2.put("A", new Character('A'));

m2.put("B", 'B'); //Autoboxing

//m2.put("B", new Character('B'));

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

System.out.println(m1.containsKey("one")); //true

System.out.println(m2.containsValue('A')); //Autoboxing

//System.out.println(m2.containsValue(new Character('A'))); //true

if (m2.containsKey("A")) {

char i = (Character)m2.get("A"); //Autoboxing

//char i = ((Character)m2.get("A")).charValue();

System.out.println(i); //A

}

Map m3 = new HashMap(m1);

m3.putAll(m2);

System.out.println(m3);

}

}

编译通过，可见编译器会自动执行打包和解包工作。

泛型(generic)

起因：

JDK1.4 以前类型不明确；

装入集合的类型都被当做 Object 对待，从而失去自己的实际类型。

从集合中取出时往往需要转型，效率低，容易产生错误。

解决办法：在定义集合的时候同时定义集合中对象的类型

好处：增强程序的可读性和稳定性

对上一个程序应用泛型

import java.util.*;

public class TestMap {

public static void main(String[] args) {

//Map m1 = new HashMap();

Map m1 = new HashMap(); //generic

//Map m2 = new TreeMap();

Map m2 = new TreeMap(); //generic

m1.put("one", 1); //Autoboxing

//m1.put("one", new Integer(1));

m1.put("two", 2); //Autoboxing

//m1.put("two", new Integer(2));

m1.put("three", 3); //Autoboxing

//m1.put("three", new Integer(3));

m2.put("A", 'A'); //Autoboxing

//m2.put("A", new Character('A'));

m2.put("B", 'B'); //Autoboxing

//m2.put("B", new Character('B'));

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

System.out.println(m1.containsKey("one")); //true

System.out.println(m2.containsValue('A')); //Autoboxing

//System.out.println(m2.containsValue(new Character('A'))); //true

if (m2.containsKey("A")) {

char i = m2.get("A"); //generic

//*char i = (Character)m2.get("A"); //Autoboxing

//char i = ((Character)m2.get("A")).charValue();

System.out.println(i); //A

}

Map m3 = new HashMap(m1);

m3.putAll(m2);

System.out.println(m3);

}

}