集合和数组

一:集合

1.多态的概念

多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法
多态的作用：消除类型之间的耦合关系
多态存在的三个必要条件：
(1) 要有继承；
(2)要有重写；
(3)父类引用指向子类对象。

动物类 public class Animal
狗类（动物类的实现）Public class Dog extends Animal
有一个吃动物的方法public void eat(Animal animal)
就可以传入一个Dog了
eat(new Dog());

2.集合中的接口:

Collection 所有集合接口的顶级接口,包含下列方法:

Int size();
boolean remove(Object element); //optional
Iterator iterator();
boolean  isEmpty();
Boolean add(Element o);
Boolean contains(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c); //optional
boolean removeAll(Collection<?> c); //optional
boolean retainAll(Collection<?> c); //optional

集合的接口：

1. List 列表
2. Set 集合
3. 3Map 映射
4. Iterator 迭代器

3.List定义及常用方法

List是一个顺序的Collection（通常被称作序列）。List可以包含重复元素。List接口基本功能如下：
按位置访问 — 通过元素在list中的位置索引访问元素。
查询 — 获取某元素在list中的位置
迭代 — 扩展了Iterator的接口能实现更多功能
List子集合 — 获取List某个位置范围的子集合
List接口如下：

public interface List<E> extends Collection<E> {
// Positional access
E get(int index);
E set(int index, E element); //optional
boolean add(E element); //optional
void add(int index, E element); //optional
E remove(int index); //optional
boolean addAll(int index,
Collection<? extends E> c); //optional
// Search
int indexOf(Object o);
int lastIndexOf(Object o);
// Iteration
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
// Range-view
List<E> subList(int from, int to);
}

4.Set接口:

Set 是一个不包含重复元素的集合（Collection）。Set接口中的函数都是从Collection继承而来。 但限制了add 的使用，需要其不能添加重复元素。
Set接口声明如下：

public interface Set<E> extends Collection<E> {
// Basic operations
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(E element); //optional
boolean remove(Object element); //optional
Iterator<E> iterator();
// Bulk operations
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c); //optional
boolean removeAll(Collection<?> c); //optional
boolean retainAll(Collection<?> c); //optional
void clear(); //optional
// Array Operations
Object[] toArray();
<T> T[] toArray(T[] a);
}

5.Map接口:

Map 是一种包含键值对的元素的集合。Map不能包含重复的键，并可通过键实现对值的快速访问。Map接口如下所示：

public interface Map<K,V> {
// Basic operations
V put(K key, V value);
V get(Object key);
V remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
// Bulk operations
void putAll(Map<? extends K, ? extends V> m);
void clear();
// Collection Views
public Set<K> keySet();
public Collection<V> values();
public Set<Map.Entry<K,V>> entrySet();
}// Interface for entrySet elements
public interface Entry {
K getKey();
V getValue();
V setValue(V value);
}

6.List的实现类:

List的常用实现类有ArrayList（数组）和LinkedList（链表）。

7.LinkedList类:

LinkedList是链表形式的集合类，有特殊的addFirst(),addLast(),removeFirst(),removeLast()方法。
以链表形式存储数据，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，接口中没有定义的方法get，remove，insertList，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用

8.ArrayList同LinkedList区别:

1. ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要将已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除，允许空元素
2. Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
3. LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，接口中没有定义的方法get，remove，insertList，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

9.Set的子类:

(1). 散列的存放：HashSet
HashSet是Set接口的一个子类，主要的特点是：里面不能存放重复元素，而且采用散列的存储方式，所以没有顺序。
(2).有序的存放：TreeSet
如果想对输入的数据进行有序排列，则要使用TreeSet子类。

10. Map的子类:

(1).HashMap：无序存放的，是新的操作类，key不允许重复。
(2).Hashtable：无序存放的，是旧的操作类，key不允许重复。
(3).TreeMap：可以排序的Map集合，按集合中的key排序，key不允许重复。
(4).WeakHashMap：弱引用的Map集合，当集合中的某些内容不再使用时清除掉无用的数据，使用System.gc()进行回收。
(5).IdentityHashMap：key可以重复的Map集合。

11.容器的集合类:

Collection 
├List 
│├LinkedList 
│├ArrayList 
│└Vector 
│　└Stack 
└Set 
Map 
├Hashtable 
├HashMap 
└WeakHashMap

二:数组

1.数组概念:

数组（Array）：相同类型数据的集合。

2.数组同其他容器的区别:

Java中的每个数组都有一个名为length的属性，表示数组的长度。
length属性是public final int的，即length是只读的。数组长度一旦确定，就不能改变大小。

3.一维数组的声明、初始化及引用:

(1).一维数组的声明：

TYPE name[];
Ex:int s[];
TYPE[] name;
Ex:int s[];

(2).一维数组的初始化：

TYPE name[] = new TYPE[]{member1,member2,…};
Ex:int s[] = new int[]{1,2,3};
TYPE[] name = new TYPE[]{member1,member2,…};
Ex:int[] s = new int[]{1,2,3};
TYPE[] name = new TYPE[length];
Ex:int[] s = new int[6];
TYPE name[]  = new TYPE[length];

(3).一位数组的赋值：

Array_name[index] = value;
Ex: s[2] = 1;
一维数组的引用：
Ex: int y = s[2];

4.二维数组的声明、初始化及引用:

(1).二维数组的声明：

TYPE name[][];
Ex:int s[][];
TYPE[][] name;
Ex:int s[][];

(2).二维数组的初始化：

TYPE name[][] = new TYPE[][]{member1,member2,…};
Ex:int s[][] = new int[][]{{1,2},{1,2}};
TYPE[][] name = new TYPE[][]{member1,member2,…};
Ex:int[][] s = new int[][]{{1,2},{1,2}};
TYPE[][] name = new TYPE[xlength][ylength];
Ex:int[][] s = new int[6][6];
TYPE name[][]  = new TYPE[xlength][ylength];
Ex:int s[][] = new int[6][6];

(3).二维数组的赋值：

Array_name[index][index] = value;
Ex: s[2] [2]= 1;
s[2] = new int[]{2,3}
s[2] = {1,2}

(4).二维数组的引用:

Ex: int i=s[1][2];
Ex:int[] ss = s[1];

(5).二维变长数组:

 int[][] a = new int[3][];
        a[0] = new int[2];
        a[1] = new int[3];
        a[2] = new int[1];