java 容器继承关系_java容器总结

容器：顾名思义，它是用来装载东西的，以下我整理出来的容器笔记

容器的概念

容器 API

Collection 接口

Iterator 接口

Set 接口

Comparable 接口

List 接口

Map 接口

(数据结构就是存储数据的方式)

Collection 接口

//接口的引用指向一个实现类的对象 //[1][1][1][][][] Collection cln = new ArrayList(); //添加元素 容器会自动将所要添加的元素放在第一个为空的位置 cln.add("one"); cln.add("two"); cln.add("three"); Collection cln2 = new ArrayList();

//将原容器中的每一个元素都拷贝一份到新的容器中 cln2.addAll(cln);

cln2.add("four");

//将参数的容器作为一个元素 存入当前容器中

// cln2.add(cln);

// 判断容器中是否包含某个元素

boolean b = cln.contains("one");

// 判断容器是否包含某一批元素

b = cln.containsAll(cln2);

// 判断两个容器是否相等 容器的类型相同 元素个数相同 和元素内容意义对 应相等 才判断两个容器相等

b = cln.equals(cln2);

// 删除容器中某个元素

// cln2.remove("one");

// 批量删除容器中的元素 在cln2中删除和cln的交集

// cln2.removeAll(cln);

// 在cln2中保留和cln的交集

cln2.retainAll(cln);

System.out.println(cln2);

Collection 接口存储一组不唯一，无序的对象

List 接口存储一组不唯一，有序(插入顺序)的对象

Set 接口存储一组唯一，无序的对象

Map接口存储一组键值对象，提供key到value的映射

List接口

两个实现类：

ArrayList：实现了长度可变的数组，在内存中分配连续的空间。

优点：遍历元素和随机访问元素的效率比较高

缺点：添加和删除需要大量移动元素效率低，按照内容查询效率低

LinkedList：采用双向链表存储方式

优点：插入、删除元素时效率比较高

缺点：遍历和随机访问元素效率低下

Iterator接口

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

Iterator接口的对象。

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

Iterator方法：

boolean hasNext():判断是的下否存在另一个可访问的元素

Object next():返回要访问一个元素

void remove():删除上次访问返回的对象

泛型：

为什么需要泛型

因为集合中可以存放任意引用数据类型,所以在使用的时候可能需要向下类型 转型在转型的时候如果不确定元素的类型,很容易出错

所以有时候我们会规定在集合中只能存放一种类型的数据 这就是泛型

泛型的分类

1.泛型类

2.泛型方法

3.泛型接口

* 在声明一个类的时候 声明了一种未知的类型

public class Cat {

// 可以用该未知的类型作为成员变量的类型

private E e;

// 也可以用未知的该类型作为方法返回值的类型

public E getE() {

return e;

}

// 也可以用该未知的类型作为方法参数的类型

public void setE(E e) {

this.e = e;

}

// 在定义一个方法的时候也可以单独定义出来一个未知的类型

// 该未知的类型在调用方法的时候确定

// 这种情况 可以替换参数个数相同 参数类型不同的方法的重载问题

public void test(G g) {

System.out.println(g);

}

// 用泛型实现一个可变参数，可以替换所有情况的方法重载的问题

// ws 是一个数组 调用的时候所传的第一个参数 就是数组中下标为0的元素

public void test02(W...ws) {

System.out.println(ws[1]);

}

public static void main(String[] args) {

Cat cat = new Cat();

cat.setE("小黑");

cat.getE();

cat.test("123");

cat.test(123);

cat.test02("f","b","c");

Set 接口(无下标) Set接口不存在get()方法

三个实现类：

1、HashSet：(最常用)

采用Hashtable哈希表存储结构

优点：添加速度快，按照内容查询速度快，删除速度快

缺点：无序

2、LinkedHashSet (继承了HashSet)：采用哈希表存储结构，同时使用链表维护次序

有序(添加顺序)

3、TreeSet：采用二叉树(红黑树)的存储结构优点：有序(升序排序)查询速度比List快

(按照内容查询)

缺点：查询速度比HashSet慢

Map接口

两个实现类：

HashMap：(是一个最常用的Map)

Key无序 唯一(Set)

Value无序 不唯一(Collection)

例子：

获取map中的映射关系

System.out.println(map.entrySet());

// 通过键来获取value

System.out.println(map.get("01"));

// 获取map中的所有的键

System.out.println(map.keySet());

// 获取map中所有的value

System.out.println(map.values());

//遍历map

Set set = map.keySet();

Iterator it = set.iterator();

while (it.hasNext()) {

System.out.println(map.get(it.next()));

LinkedHashMap:

有序的HashMap

TreeMap：

有序 速度比Hash慢

collections工具类

Collections和Collection不同，前者是集合的操作类，后者是集合接口Collections提供的静态方法。

addAll():批量添加

sort():排序

fill()：替换

reverse():逆序

binarySearch()：二分查找

例子：

ArrayList list = new ArrayList();

Collections.addAll(list, new Worker("001", "旺财", 2),

new Worker("002", "旺财", 2),

new Worker("003", "旺财", 2),

new Worker("004", "旺财", 2));

//第一种二分查找 使用内部比较器来比较元素大小，当前类实现Comparable的接

口，实现compareTo 的方法来实现比较大小的能力称之为内部比较器。

int n = Collections.binarySearch(list, new Worker("002", "旺财", 2));

ArrayList list2 = new ArrayList();

list2.add(new Dog("wangcai01", 1));

list2.add(new Dog("wangcai02", 2));

list2.add(new Dog("wangcai03", 3));

n = Collections.binarySearch(list2, new Dog("wangcai02",2), new Compare());

System.out.println(n);

System.out.println(list.size());

整章总结：

集合：只能存储对象，对象类型可以不一样，长度可变。

常用的接口和类：

1、List接口(有序、可重复)：ArrayList类、LinkedList类、Vector类(不学)

2、Set接口(无序、不能重复):HashSet类、 TreeSet类

3、Map接口(键值对、键唯一、值不唯一)：HashMap类、Hashtable类、TreeMap类

集合类的循环遍历

1、普通for循环：如 for(int i = 0;i< arr.size();i++){…}

2、foreach(增强型for循环)：如 for(Object　i：arr){…}

3、Iterator(迭代器)：

例如 Iterator it = arr.iterator();

while(it.hasNext()){

Object o =it.next(); …}

注意：无法在遍历的过程中对数组或者集合进行修改，而for循环可以在遍历的过程中对原数组或者集合进行修改

ArrayList、LinkedList和Vector的区别：

ArrayList：效率高，多用于查询

LinkedList：多用于插入和删除

Vector：线程安全，多用于查询