集合一（Collection(s),List）

一、单列集合体系结构

Collection

  List    Set

ArrayList    LinkedList           HashSet     LinkedHashSet

List ：存取有序、有索引、还可以存储重复的元素

ArrayList:底层是数组实现的，有索引，查询快、增删慢

LinkedList:底层是链表实现的，有索引，查询慢、增删快

Set ： 存取无序、没有索引、不可以存储重复的元素

HashSet:底层是哈希算法的，存取无序、没有索引、不可以存储重复的元素

LinkedHashSet:底层是链表实现的，可以保证存取顺序，没有索引、不可以存

储重复的元素

   

二、 Collection 接口中提供的常用方法

成员方法：

add(E e);    添加元素

addAll(Collection c);   将一个集合中所有的元素全部添加到另外一个集合

remove(E e);              通过元素删除指定的元素

clear();    清空集合

contains(E e);             判断集合中是否包含传入的元素

size();                         获取集合的长度

isEmpty();                   判断集合是否为空

toArray();                    将集合转成数组

三、迭代器

1.定义格式

Iterator it = 集合对象.iterator();

2.成员方法：

hashNext(); 判断映射关系中是否还有元素

next(); 获取映射关系中的元素

3.示例代码：

Collection c = new ArrayList();

//获取迭代器对象

Iterator it = c.iterator();

while(it.hasNext()) {

Object obj = it.next();

System.out.println(obj);

}

4.并发修改异常

出现原因：在通过迭代器进行遍历集合的同时，然后通过集合对象对集合进行

一些修改。此时迭代器中映射关系已经和集合不一致了， 那么就会出现

并发修改异常： ConcurrentModificationException

解决方式：使用ListIterator。通过迭代器本身对集合进行修改

示例代码：

//创建集合对象

List list = new ArrayList();

//可以通过遍历来获取集合中的每一个元素，通过迭代器对象进行

//对集合的修改

ListIterator lit = list.listIterator();

while(lit.hasNext()) {

String s = (String)lit.next();

if(s.equals("java")) {

lit .add("android");

}

}

四、泛型

1.泛型的作用

约束集合可以存储的数据的元素类型

2.泛型好处

扫黄

将运行时的错误提升到编译时期

省去了强制转换的麻烦

五、增强for循环

定义格式

for(数据类型 变量名 : 容器对象){

循环体;

}

例： Collection<String> c = new ArrayList<String>();

for (String string : c) {

System.out.println(string);

}

六、List接口

1.特点

存取有序、有索引、可以存储重复元素

2.成员方法

void add(int index, E element)  : 在指定索引位置添加指定元素

list.add(0, "hello");

E get(int index)  :根据索引返回元素

System.out.println(list.get(1));

E remove(int index)  : 删除指定元素并返回

//System.out.println(list.remove(5));

E set(int index, E element) : 将指定索引位置的元素替换为指定元素，并将原

先的元素返回

System.out.println(list.set(0, "android"));

3.LinkedList

addFirst(E e);   向集合中第一个位置添加一个元素

addLast();          向集合中最后一个位置添加一个元素

getFirst();   获取集合中第一个元素

getLast();           获取集合中最后一个元素

removeFirst();    删除集合中第一个元素

removeLast();   删除集合中最后一个元素

七、可变参数

1.定义格式

数据类型...变量名

2.示例代码

public class VaragrsDemo {

public static void main(String[] args) {

int result = sum(1,2,3,4,5,6);

System.out.println(result);

}

public static int sum(int...arr) {

int sum = 0;

for (int i = 0; i < arr.length; i++) {

sum += arr[i];

}

return sum;

}

}

八、Collections工具类

static int binarySearch(List list, Object key)：使用二分查找法查找指定的

元素在集合中出现的索引位置

static void copy(List dest, List src) :将源集合复制到目标集合中

注意：目标列表的长度至少等于源列表的长度

static void fill(List list, Object obj) :将指定的元素全部填充到集合中

static void reverse(List list)  :反转

static void shuffle(List list): 随机置换

static void sort(List<T> list) :排序

static void swap(List list, int i, int j) :将两个索引上的元素进行交换位置

九、泛型类、泛型方法

public class Test03 {

public static void main(String[] args) {

Person<String> p = new Person<String>();

p.show("abc");

Person<Integer> p2 = new Person<Integer>();

}

}

class Person<T> {

public void show(T t) {

System.out.println(t);

}

}

十、泛型接口、泛型方法

public class Test04 {

public static void main(String[] args) {

InterImpl<String> ii1 = new InterImpl<String>();

ii1.show("abc");

InterImpl<Integer> ii2 = new InterImpl<Integer>();

ii2.show(50);

}

}

interface Inter<O> {

public abstract void show(O o);

}

class InterImpl<O> implements Inter<O> {

@Override

public void show(O o) {

System.out.println(o);

}

}

十一、泛型的通配符

public class Test05 {

public static void main(String[] args) {

ArrayList<String> list1 = new ArrayList<String>();

list1.add("abc");

list1.add("def");

list1.add("ghi");

print(list1);

ArrayList<Integer> list2 = new ArrayList<Integer>();

list2.add(5);

list2.add(6);

list2.add(7);

print(list2);

}

public static void print(ArrayList<?> list) {

for (int i = 0; i < list.size(); i++) {

System.out.println(list.get(i));

}

}

/*public static void print2(ArrayList<Integer> list) {

for (int i = 0; i < list.size(); i++) {

System.out.println(list.get(i));

}

}

public static void print1(ArrayList<String> list) {

for (int i = 0; i < list.size(); i++) {

System.out.println(list.get(i));

}

}*/

}