java容器

容器

1.List类

List继承类抽象类Collection接口，是一个用于有序（有顺序）存放的集合，List主要包括ArrayList和LinkedList两个子类

1.list接口方法

方法	作用
void add(int index,Object element)	在指定位置添加元素
object get(int index)	返回指定位置的元素
object remove(int index)	删除指定位置的元素，返回被删除的元素

代码实例：

public static void main(String[] args){
	  List list=new List();
	  list.add("hello");
	  list.add("world",1);
	  System.out.println(list.getItem(1));
   }

2.ArrayList

ArrayList相对于LinkedList来讲,ArrayList查询更快一些

3.LinkedList

Linkedlist是双向链表，可以以较快的速度在任意位置插入元素

void addFirst(Object element)	将对象element添加到链表头部
void addLast(Object element)	将元素添加到尾部
object get(int index)	得到指定位置的元素
object getFirst()	返回链表头的元素值
object getLast()	返回末尾的元素值
LinkedList()	构建一个新链表
LinkedList(collection c)	构建一个链表，将集合c中的元素添加到其中
object remove(int index)	删除

代码实例：

 public static void main(String[] args){
	LinkedList  lklist=new LinkedList();
	for(int i=0;i<5;i++)
		lklist.add(i);//添加五个元素
	lklist.addFirst(888);
	lklist.addLast(888);
	for(int i=0;i<lklist.size();i++)
		System.out.println(lklist.get(i));
   }

2.Set类

set具有和collection 一样的接口，Set和List最大的不同就是，Set中不允许有重复的值，也就是说，Set中任意两个成员之间相互调用方法equals必须返回为false,保证了元素的唯一性

1.Set接口的方法

• HashSet：为快速查找而设计的Set,存入HashSet的对象必须定义HashCode的方法
• TreeSet: 为确保Set中的成员有序而设计的一个Set类
• LinkedHashSet：具有HashSet的查询速度，而底层使用链表维护元素的顺序

2.哈希集和树集

Set接口中有两个实现类，分别是HashSet和TreeSet，在需要自己动手创建类的时候，需要覆盖掉hashCode()和

equals();其中TreeSet是以有序的方式对元素进行排列，HashSet和TreeSet都有不同的构造方法。

HashSet类的构造方法

HashSet()	创建一个新的哈希集
HashSet(Collection  d)	创建一个新的哈希集，将d中的元素添加到哈希集中
HashSet(int intialcity)	创建具有一定容量的的哈希集合
HashSet(int intiticity,float loadFactor)	该方法的作用是创建一定容量和加载因子的空哈希集合

public static void main(String[] args) {
	HashSet hash=new HashSet();//the first way
	hash.add("2");
	hash.add("3");
    HashSet hash2=new HashSet(hash);
    System.out.println(hash2.size());
}

hashset是继承了collection的，总的来说属于collection

TreeSet构造方法

TreeSet()	...
TreeSet(Collection c)	...
TreeSet(Comparator c)	创建树集合，并指定特定的比较器进行排序

package praitse;

import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeSet;

public class pra01 {
public static void main(String[] args) {
	TreeSet tree=new TreeSet();
	tree.add(10);
	tree.add(3);
	tree.add(5);
	tree.add(6);
	System.out.println("首元素为:"+tree.first());
	if(tree!=null&&tree.size()>0) {
		Iterator it=tree.iterator();
		while(it.hasNext()) {
			System.out.println("元素为:"+it.next());
		}
	}else System.out.println("没有找到元素");
}
}首元素为:3
 元素为:3
 元素为:5
 元素为:6
 元素为:10

TreeSet的一个最大的特点就是有序性，将元素从里面遍历出来后从小到大排列。

3.Map映射

Map提供了一种键值对应的存储方式，Map(key,value);

boolean containsKey(Object key)	判断是否存在键值key
boolean containsValue(boject Value)	判断是否存在值Value
void clear()	清空映射中所有的元素
Object remove(Object Key)	删除对应Key的value值
void putAll(Map t)	将t(Map类的对象)中的元素传递到映射中
Object put(key,value)	将相应的键值放入映射中
int size()	返回映射的数量

1.HashMap和TreeMap

两者的构造方法和前面的Collection的类似，这里不再赘述。

get(object key)	来获取值

package praitse;
import java.util.*;
public class pra01 {
public static void main(String[] args) {
System.out.println("使用HashMap映射:");
printHashMap();    
System.out.println("使用TreeMap映射：");
printTreeMap();
}
public static void printHashMap() {
    Map map=new HashMap();
    map.put("7:00","起床" );
    map.put("8:00", "上课");
    map.put("12:00", "吃午饭");
    map.put("2:00", "睡午觉");
    Iterator it=map.keySet().iterator();
    System.out.println("小菜的时间表为");
    while(it.hasNext()) {
        Object key=it.next();
        System.out.print(key+" ");
        System.out.println(map.get(key));
    }}
    public static void printTreeMap() {
        Map map=new TreeMap();
        map.put("7:00","起床" );
        map.put("8:00", "上课");
        map.put("12:00", "吃午饭");
        map.put("2:00", "睡午觉");
        Iterator it=map.keySet().iterator();
        System.out.println("小菜的时间表为");
        while(it.hasNext()) {
            Object key=it.next();
            System.out.print(key+" ");
            System.out.println(map.get(key));
    
}
}}
使用HashMap映射:
小菜的时间表为
12:00 吃午饭
8:00 上课
7:00 起床
2:00 睡午觉
使用TreeMap映射：
小菜的时间表为
12:00 吃午饭
2:00 睡午觉
7:00 起床
8:00 上课//------------------从结果看出顺序被打乱了

4.迭代器

迭代器的主要用途就是来对容器元素进行遍历的，具体用法：

boolean hasNext()	判断是否存在可以访问的元素
Object next()	返回下一个元素
void remove()	删除上次访问的元素

java 1.5 之前的做法

如果你用的是Java 1.5之前支持的类库, 那么很可能采用的是如下的做法来遍历集合元素:

1. 使用iterator()要求容器返回一个Iterator, Iterator将准备好返回序列的第一个元素;
2. 使用next()获得序列中的下一个元素;
3. 使用hasNext()检查序列中是否还有元素;
4. 使用remove()将迭代器返回的元素删除.

以下是一个实例:

List<String> strs = Arrays.asList("a", "b", "c");

// Java 1.5之前的做法
Iterator<String> iterator = strs.iterator();
while (iterator.hasNext()) {
    String str = (String)iterator.next();
    out.println(str);
}

Java 1.5支持的做法

Iterable是Java 1.5的新特性, 主要是为了支持forEach语法, 使用容器的时候, 如果不关心容器的类型, 那么就需要使用迭代器来编写代码. 使代码能够重用.

使用方法很简单:

List<String> strs = Arrays.asList("a", "b", "c");
for (String str: strs) {
    out.println(str);
}

Java 1.8支持的做法

使用接收lambda表达式的forEach方法进行快速遍历.

List<String> strs = Arrays.asList("a", "b", "c");
// 使用Java 1.8的lambda表达式
strs.forEach(System.out::println);