1. 泛型
伪泛型(类型擦除)
java中的泛型是伪泛型,编译后转变为与泛型类同名的(非泛型)原始类。
将运行时器的classCaseException转移到编译时期的编译失败;避免了类型转化的麻烦。
泛型声明
泛型类
修饰符 class 类名<代表泛型的变量>{}
泛型方法
修饰符<代表泛型的变量> 返回值类型 方法名(参数){}
泛型接口
public interface List<E>{
abstract boolean add(E e){}
}
//实现类
//1. 先实现接口,不理会泛型
public calss ArrayList<E> implements List<E>{}
//调用者后期创建对象时,指定数据类型
new ArrayList<String>()
//2. 实现接口的同时,指定数据类型
public class ArrayList<E> implements List<String>{}
类型限界
<? extends A>:上限限定,可传递类A及其子类对象
<? super A>:下限限定,可传递类A及其父类对象
对泛型的限制
- 基本类型不能用作类型参数。
- instanceof检测和类型转换只对原始类型进行。
- static方法和static域均不可引用类的类型变量,因为类型擦除后类型变量就不存在了。另外,由于实际只存在一个原始类,,故是static域在该类的诸泛型实例之间是共享的。
- 不能创建一个泛型类型的实例。
- 不能创建一个泛型类型的数组。
- 参数化类型的数组的实例化是非法的。
2. 增强for循环
for(数据类型 变量名:数组或集合){
sop(变量);
}
- jdk1.5之后,出现java.lang.Iterable,Collection开始继承Iterable,实现增强for循环,能遍历Set,不能遍历Map
- 对对象数组遍历,可以调用对象方法
- 优:代码少,方便遍历容器
- 缺:无索引,不能操作容器内的元素
3. 集合常用接口类
3.1. 接口 Iterator< E >
boolean hasNext()
E next()
void remove()
3.2. 接口Collection< E >
boolean add(E e)
boolean addAll(Collection<? extends E> c)
void clear()
boolean contains(Object o)
boolean containsAll(Collection<?> c)
boolean equals(Object o)
int hashCode()
boolean isEmpty()
Iterator<E> iterator()
boolean remove(Object o)
boolean removeAll(Collection<?> c)
boolean retainAll(Collection<?> c)
int size()
Object[] toArray()
<T> T[] toArray(T[] a)
3.2.1 接口 Set< E >
3.2.1.1 类 HashSet< E >
//构造方法
HashSet()
HashSet(Collection<? extends E> c)
HashSet(int initialCapacity)
HashSet(int initialCapacity, float loadFactor)
//方法
Object clone()
- 由哈希表支持,不能保证迭代次序与存储次序一致
- 保证元素唯一性的方法:hashCode() equals()
- 在给哈希表存放对象时,调用hashcode方法,算出对象的有效位置,若两个对象的hashCode结果一致,则为哈希冲突。此时调用对象的equals办法,比较两个对象是否为同一个对象,若true,不把对象存在哈希表中;若false,存!
- 若往集合中存放自定义对象,为保证其唯一性,许重写hashCode和equals,建立属于当前对象的比较方法;若不重写,每次运行得到的hash值不一样。
- hashCode相等->equals不一定相等;
- equals相等->hashCode一定相等.
3.2.2 接口 Queue< E >
boolean offer(E e)
E peek()
E poll()
3.2.2.1 类 PriorityQueue
//构造方法
PriorityQueue()
PriorityQueue(Collection<? extends E> c)
PriorityQueue(int initialCapacity)
PriorityQueue(int initialCapacity, Comparator<? super E> comparator)
PriorityQueue(PriorityQueue<? extends E> c)
PriorityQueue(SortedSet<? extends E> c)
//方法
Comparator<? super E> comparator()
3.2.2.2 接口 Deque< E >
void addFirst(E e)
void addLast(E e)
Iterator<E> descendingIterator()//返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
E getFirst()
E getLast()
boolean offerFirst(E e)
boolean offerLast(E e)
E peekFirst()
E peekLast()
E pollFirst()
E pollLast()
E pop() //从此双端队列所表示的堆栈中弹出一个元素
void push(E e)// 将一个元素推入此双端队列所表示的堆栈(换句话说,此双端队列的头部)
E removeFirst()
boolean removeFirstOccurrence(Object o)
E removeLast()
boolean removeLastOccurrence(Object o)
3.2.2.2.1 类 LinkedList< E >
//构造方法
LinkedList()
LinkedList(Collection<? extends E> c)
//方法
Object clone()
3.2.3 接口List< E >
void add(int index, E element)
boolean addAll(int index, Collection<? extends E> c)
E get(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
ListIterator<E> listIterator(int index)
E remove(int index)
E set(int index, E element)
List<E> subList(int fromIndex, int toIndex)
Iterator并发修改异常:
在Iterator迭代器中,不能使用集合的方法对元素进行增删操作(List.remove()等),这会导致迭代器并不知道集合中的变化,引发数据的不确定性。可以用Iterator本身的remove()方法。
3.2.3.1 类 ArrayList< E >
//构造方法
ArrayList()
ArrayList(Collection<? extends E> c)
ArrayList(int initialCapacity)
// 方法
Object clone()
protected void removeRange(int fromIndex, int toIndex)
void trimToSize()
//将此 ArrayList 实例的容量调整为列表的当前大小。
ArrayList | Vector |
---|---|
迭代器 | 枚举 |
add | addElement |
Iterator | Enumeration |
hasNext | hasMoreElements |
next | nextElements |
3.2.3.2 类 LinkedList< E >
3.2.3.3 类 Stack< E >
//构造方法
Stack()
//方法
boolean empty()
E peek()
E pop()
E push(E item)
int search(Object o)
3.3 接口Map<K, V>
//嵌套类
static interface Map.Entry<K,V>
//方法摘要
void clear()
boolean containsKey(Object key)
boolean containsValue(Object value)
Set<Map.Entry<K,V>> entrySet()
boolean equals(Object o)
V get(Object key)
int hashCode()
boolean isEmpty()
Set<K> keySet()
V put(K key, V value)
void putAll(Map<? extends K,? extends V> m)
V remove(Object key)
int size()
Collection<V> values()
3.3.1 接口 Map.Entry<K,V>
//方法摘要
boolean equals(Object o)
K getKey()
V getValue()
int hashCode()
V setValue(V value)
3.3.2 类HashMap<K,V>
//构造方法
HashMap()
HashMap(int initialCapacity)
HashMap(int initialCapacity, float loadFactor)
HashMap(Map<? extends K,? extends V> m)
//方法
Object clone()
3.3.3 类LinkedHashMap<K,V>
//构造方法
LinkedHashMap()
LinkedHashMap(int initialCapacity)
LinkedHashMap(int initialCapacity, float loadFactor)
LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
LinkedHashMap(Map<? extends K,? extends V> m)
//方法
protected boolean removeEldestEntry(Map.Entry<K,V> eldest)
- HashMap存取不一致;LinkedHashMap存取一致
- 若键为自定义对象,需保证唯一性->重写hashCode() equals()
- Map集合遍历键招值的方式
法1:
- Set keySet()
- 遍历键的集合,得到每一个键
- 根据键找对应的值:V get(Object key)
法2:
- Set<Map.Entry<K,V>> entrySet()
- 遍历键值对对象的Set集合,得到每一个键值对对象
- K getKey() V getValue()
3.4 类 Collections
//静态成员
static List EMPTY_LIST//空的列表(不可变的)。
static Map EMPTY_MAP//空的映射(不可变的)。
static Set EMPTY_SET//空的 set(不可变的)。
//方法
static <T> boolean addAll(Collection<? super T> c, T... elements)
//将所有指定元素添加到指定 collection 中。
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
//使用二分搜索法搜索指定列表,以获得指定对象。
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
//使用二分搜索法搜索指定列表,以获得指定对象。
static <T> void copy(List<? super T> dest, List<? extends T> src)
static boolean disjoint(Collection<?> c1, Collection<?> c2)
//如果两个指定 collection 中没有相同的元素,则返回 true。
static <T> List<T> emptyList() //返回空的列表(不可变的)。
static <K,V> Map<K,V> emptyMap()
static <T> Set<T> emptySet()
static <T> void fill(List<? super T> list, T obj)
//使用指定元素替换指定列表中的所有元素。
static int frequency(Collection<?> c, Object o)
//返回指定 collection 中等于指定对象的元素数。
static int indexOfSubList(List<?> source, List<?> target)
//返回指定源列表中第一次出现指定目标列表的起始位置;如果没有出现这样的列表,则返回 -1。
static int lastIndexOfSubList(List<?> source, List<?> target)
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
static <T> List<T> nCopies(int n, T o)
//返回由指定对象的 n 个副本组成的不可变列表。
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
static void reverse(List<?> list)
static <T> Comparator<T> reverseOrder()
//返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
//返回一个比较器,它强行逆转指定比较器的顺序。
static void rotate(List<?> list, int distance)
//根据指定的距离轮换指定列表中的元素。
static void shuffle(List<?> list)
//使用默认随机源对指定列表进行置换。
static void shuffle(List<?> list, Random rnd)
//使用指定的随机源对指定列表进行置换。
static <T> Set<T> singleton(T o)
//返回一个只包含指定对象的不可变 set。
static <T> List<T> singletonList(T o)
static <K,V> Map<K,V> singletonMap(K key, V value)
static <T extends Comparable<? super T>> void sort(List<T> list)
//根据元素的自然顺序对指定列表按升序进行排序。
static <T> void sort(List<T> list, Comparator<? super T> c)
//根据指定比较器产生的顺序对指定列表进行排序。
static void swap(List<?> list, int i, int j)
//在指定列表的指定位置处交换元素。
3.5 类Arrays
static int binarySearch(byte[] a, byte key)
static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)
static <T> int binarySearch(T[] a, T key, Comparator<? super T> c)
//byte : char double float int long Object short
使用二分搜索法来搜索指定的 byte 型数组的范围,以获得指定的值。
static boolean[] copyOf(boolean[] original, int newLength)
static <T> T[] copyOf(T[] original, int newLength)
static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)
static boolean[] copyOfRange(boolean[] original, int from, int to)
static <T> T[] copyOfRange(T[] original, int from, int to)
static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)
//boolean : byte char double float int long Object short
static boolean equals(boolean[] a, boolean[] a2)
//boolean : byte char double float int long Object short
static void fill(boolean[] a, boolean val)
static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)
//boolean : byte char double float int long Object short
static int hashCode(boolean[] a)
//boolean : byte char double float int long Object short
static void sort(byte[] a)
static void sort(byte[] a, int fromIndex, int toIndex)
static <T> void sort(T[] a, Comparator<? super T> c)
static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
//byte : char double float int long Object short
static String toString(boolean[] a)
//boolean : byte char double float int long Object short