Java learning_Day8
本人学习视频用的是马士兵的，也在这里献上
<链接：https://pan.baidu.com/s/1qKNGJNh0GgvlJnitTJGqgA>
提取码：fobs
内容
- 容器
- 泛型
容器
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 对待，从而失去自己的实际类型。
- 从集合中取出时往往需要转型，效率低，容易产生错误。
- JDK1.4 以前类型不明确；
- 解决办法：在定义集合的时候同时定义集合中对象的类型
- 好处：增强程序的可读性和稳定性
对上一个程序应用泛型
import java.util.*;
public class TestMap {
public static void main(String[] args) {
//Map m1 = new HashMap();
Map<String, Integer> m1 = new HashMap<String, Integer>(); //generic
//Map m2 = new TreeMap();
Map<String, Character> m2 = new TreeMap<String, Character>(); //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<String, Object> m3 = new HashMap<String, Object>(m1);
m3.putAll(m2);
System.out.println(m3);
}
}