for-each循环遍历数组和集合

//for(集合中元素的类型局部变量：集合对象){}

//for(数组元素类型数组变量：数组对象){}

for(Object obj:coll){

System.out.println(obj)；

}

（一）list 接口

动态数组

三个具体实现类异同

ArrayList  ,  作为List接口的主要实现类 ，线程不安全，效率高 底层Object[]数组 elementData存储

ArrayList的源码分析;jdk7 类似单例饿汉式

ArrayList list=new ArrayList();//底层创建了长度是10的Object[]数组elementData

        list.add(123);//element Data[0]=new Integer(123)

        list.add(11);//如果此次添加导致底层elementData数组容量不构，则扩容。默认情况下，扩容 为原来容量的1.5倍

        //同时需要将原有的数组中的数据复制到新的数组中去

        //建议使用带参的构造器ArrayList list=new ArrayList(10);

Jdk8类似单例的懒汉式，延迟数组创建，节省内存

ArrayList list=new ArrayList();//底层Object[] elementData初始话为{}，并没有创建长度为10的数组

        list.add(123);//第一次调用add，底层才创建了长度10的数组，并将数据123添加到elementData[0]

后续的添加和扩容操作都一样

LinkedList ,对于频繁的插入和删除操作，使用此效率比ArrayList高   底层是使用双向链表存储

LinkedList list = new LinkedList()；内部声明了Node类型，的first和Last属性，默认值为null，其中Node定义为：体现了LinkedLsit的双向链表的说法

private static class Node<E>{

E item;

Node<E> next;

Node<E> prev;

Node (Node<E> prev,E element,Node<E> next){

this.item = element;

this.next = next;

this.prev = prev;

}

}

Vector 作为List接口的古老实现类 ，线程安全，效率低 底层Object[]数组elementData存储

同;三个类都实现了List接口，存储数据的特点相同，存储有序，可重复的数据

packagecom.example.lisr;/*
List接口中的常用方法void add(int index,Object obj):在index位置插入obj元素
boolean addAll(int index,Collection eles):在index位置插入eles中的所有元素添加
Object get(int index):获取index位置的元素
int indexOf(Object obj):返回obj在当前集合中首次出现的位置若不存在返回-1
int LastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(intindex):删除指定index位置的元素，并返回此元素
Object set(int index,Object elee):设置指定index位置的元素为elee
ListsubList(int from Index,int to Index):返回从fromIndex到toIndex位置的左闭右开子集合总结常用方法
增：add(Object obj);
删：remove(int index)/remove(Object obj)
改：set(int index,Object ele)
查：get(int index) indexOf(Object obj)
插：add(int index,Onject obj)
长度：size()
遍历：
1.Iterator迭代器方式
while(iterator.hasNext()){
Object obj=iterator.next();
System.out.println("遍历："+obj);
2.for-each循环
for(Object obj:list){
System.out.println(obj);
}
3.普通的循环*/importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.Date;
importjava.util.List;public class List Test{public static void main(String[] a){
ArrayList list=new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(newDate());
list.add(456);
System.out.println(list);
list.add(1,"BB");
System.out.println("插入"+list);
Listlist1=Arrays.asList(1,2,3);
list.addAll(list1);
System.out.println("addall"+list+list.get(2));
}
}

（二）set接口

三个实现类 无序的不可重复的

HashSet： 作为Set接口的主要实现类：线程不安全的：可以存储null值

1.无序性：不等于随机性，只是不是按照数组元素索引顺序添加

2.不可重复性：保证添加的元素按照equals()判断，不能返回true,即相同的元素只能添加一个

数组加链表的结构

3.添加数据的过程 以HashSet为例

我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法，计算出在HashSet底层数组中的存放位置（即索引位置），

判断数组此位置上是否已经有元素，

如果此位置没有其他元 素，则元素a添加成功

如果此位置上有其他元素b（或者以链表形式存在多个元素），则比较a与b的哈希值:

如果哈希值不相同，则元素添加成功，以链表的形式存储

如果哈希值相同，进而需要调用元素a所在类的equal()方法；

equals()返回true,元素a添加失败

Equals()返回false,则元素a添加成功，以链表形式存储

4.set接口中没有额外定义新的方法，使用的是collection 中声明的过的方法

5.要求：向set中添加的数据，其所在的类一定要重写hashCode()和equals()

要求：重写的hashCode()和equals()方法尽可能保持一致性：相等的对象必须具有相等的 散列码

LinkedHashSet ：作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序去遍历

TreeSet：可以按照添加对象的指定属性进行排序。

1.向TreeSet中添加，只能添加某一个类的对象，不能添加不同类的对象

2.两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator接口）

底层二叉树，中序遍历

3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals（），

（在元素对象中继承Comparable接口并重写compareTo方法，来针对性的比较）

Public int compareTo(Objecto){
if(o instanceof Empolyee){
Empolyeee=(Empolyee)o;
returnthis.name.compareTo(e.name);
}
//return0;
thrownewRuntimeException("传入数据类型不一致");
}

4.定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals（）

（新建对象Comparator对象并重写方法，形参的方式传入到TreeSet）

Comparator com=new Comparator(){
@Override
Publicint compare(Objecto1,Objecto2){
if(o1 instanceof Empolyee&&o2 instanceof Empolyee){
MyDateb1=((Empolyee)o1).getBirthday();
MyDateb2=((Empolyee)o2).getBirthday();
Return b1.getYear()-b2.getYear();}
//return0;
Throw new Runtime Exception("传入数据类型不一致");
}
};
TreeSet set=new TreeSet(com);

set接口中没有额外定义新的方法，都是使用Collection 中的方法

无序性：不等于随机性，只是不是按照数组元素索引顺序添加

不可重复性：保证添加的元素按照equals()判断，不能返回true,即相同的元素只能添加一个

<二>map 接口

Map:双列数据，存储key-value对数据我，类似函数y =f(x)

HashMap:作为map的主要实现类 ：线程不安全，效率高 存储null的key和value

LinkedHashMap:

保证在遍历map元素时，可以按照添加的顺序实现遍历。在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素

对于频繁的遍历操作，此类执行效率高于HashMap

TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑可以的自     然排序，底层是使用红黑树

想TreeMap中添加key-value,要求key必须是同一个类创建的对象

因为要按照key进行排序：自然排序，定制排序

排序方式参考treeSet；

HashTable：古老的实现类：线程安全，效率低  不能存储null的key和value

Properties：常用来处理配置文件。Key-value都是String类型

二。map结构i的理解

map中的key 无序的，不可重复的，使用set存储所有的key ，以HashMap为例其所在的类一定要重写hashCode()和equals()

Map中的value ：无序的，不可重复，使用Collection 存储所有的value  要求obj所在类要重写equals()方法

一个键值对，key-value构成了一个Entry对象

Map中的entry:无序的，不可重复的，使用set存储所有的entry

常用的方法：
Package com.example.maptest;Import java.util.HashMap;
Import java.util.Map;Public class MapTest{Public static void main(String[]args){
Map  map=new HashMap();
//添加
map.put("AA",123);
map.put("BB",456);
map.put("CC",789);
//修改
map.put("AA",124);System.out.println(map);Mapmap1=newHashMap();
map1.put("CC",123);
map1.put("DD",123);map.putAll(map1);
//Objectremove(Objectkey)移除指定key的key-value对，并返回value
Object value=map.remove("CC");
System.out.println(value);
System.out.println(map);
//voidclear()；清空当前map
//map.clear();
//System.out.println(map.size());
//Objectget(Objectkey):获取指定key对应的value
System.out.println("查询："+map.get("DD"));
//booleancontainsKey(Objectkey):是否包含指定的key
//booleancontainsValue(Objectvalue):是否包含指定的value
//intsize()返回map中key-value对的个数
//booleanisEmpty():判断当前map是否为空
//booleanequals(objectobj);判断当前map和参数对象obj是否相等}}