Collection---List 和 Set

Collection—List 和 Set

集合的接口和实现类在 java.util.*;

list有序

list集合的结构：

List接口实现者	线程安全性（是否同步）	数据存储结构	数据的增长	查询检索效率	插入、删除的效率	是否重复	是否Null
ArrayList	不安全	线性数组	默认起始10,每次增长50%	高	中	可以	可以
LinkedList	不安全	双向链表	没有起始容量，每次增长一个	中	高	可以	可以
Vector	安全	线性数组	默认起始10,每次增长1倍	低	低	可以	可以

Arraylist（Vector）线性数组的结构：开辟连续的存储空间、查询按照线下标查找迅速，删除的时候如果从中间删除就要把前面所有的数据向前挪动，从后边删除正常。

Linkedlist(双向链表):存放数据和指向下一个的地址，在空间随机存放，添加数据的时候在前面将指针更改，其他的位置不需要改动

package com.chinasoft.data;

public class Node {
	//节点的数据
	Object value;
	//下一个的位置
	Node next;
	//第几个数据
	int index;
	
	public Node(int index,Object value) {
		this.index = index;
		this.value = value;
		this.next = null;
	}
}

package com.chinasoft.data;

public class LinkedList {
	//首先定义头结点
	Node head;
	public LinkedList() {
		head = null;
	}
	//添加数据、如果头结点是空的创建新的
	public void add(Object value) {
		if(head == null) {
			head = new Node(0,value);
		}else {
			Node now = head;
			//如果下一个不是空的
			while(now.next!=null) {
				//下一个传递过来
				now = now.next;
			}
			//下一个是空的就重新创建一个
			now.next = new Node(now.index+1,value);
		}
	}
	
	//遍历到底有多少个
	public int size() {
		int count = 0;
		for(Node now=head;now!=null;now=now.next) {
			count++;
		}
		return count;
	}
	
	//找寻第几个元素
	public Object get(int index) {
		for(Node now=head;now!=null;now=now.next) {
			if(now.index == index) {
				return now.value;
			}
		}
		return null;
	}
	
}

数组集合arraylist进行查询遍历

package com.chinasoft.jh;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo {

	public static void main(String[] args) {
		
		List list = new ArrayList();
		
		list.add(1);
		list.add(null);
		list.add("abc");
		//for循环遍历
		
//		for(int i=0;i<list.size();i++) {
//			Object obj = list.get(i);
//			
//			System.out.println(obj);
//		}
//		
//		//for :
//		
//		for(Object obj : list) {
//			System.out.println(obj);
//		}
		
		//使用Iterator迭代器遍历
		
		Iterator it = list.iterator();
		//如果下一个有值为true
		while(it.hasNext()) {
            //将这个值取出来
			Object obj = it.next();
			System.out.println(obj);
		}
	}

}

arraylist常用的方法

List接口:

add(E e) 添加
add(int index, E element)添加什么值在哪里
clear() 删除
contains(Object o)有没有这个值返回布尔类型
get(int index)
remove(int index)
remove(Object o)
set(int index, E element)
size()
subList(int fromIndex, int toIndex) ，截取部分数组数据开始结束，左闭右开
toArray() 转成数组

package com.chinasoft.jh;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo2 {

	public static void main(String[] args) {
		
		List<String> list = new ArrayList<String>();
		
		list.add("123");
		list.add("abc");
		
		
		list.add(1, "xyz");
		//删除
//		list.remove(2);
//		list.remove("xyz");
		list.set(0, "234");
		//比较这个里面有没有这个值
		boolean b = list.contains("234");
		
		System.out.println(b);
		//删除全部的数据
		//list.clear();
		
		//for循环遍历
		
		for(int i=0;i<list.size();i++) {
			Object obj = list.get(i);
			
			System.out.println(obj);
		}
	}

}

转换为数组

package com.chinasoft.jh;

import java.util.ArrayList;
import java.util.List;

public class ListDemo3 {

	public static void main(String[] args) {
		
		List<Integer> list = new ArrayList<Integer>(20);
		
		list.add(3);
		list.add(7);
		list.add(2);
		list.add(1);
		
		List<Integer> subList = list.subList(1, 3);

		for(int i=0;i<subList.size();i++) {
			System.out.println(subList.get(i));
		}
		//转换为数组
		Object[] ins = subList.toArray();
		
		for(Object i : ins) {
			System.out.println(i);
		}

	}

}

set无序

无序没有下标

Set实现者	线程的安全性	值是否可以重复	是否可以为空	数据结构	排序	数据增长	效率
HashSet	不安全的	No—只有1个	可以，只能空一次	散列表(哈希表）	只对数字有效	16个 当总量75% 增长1倍	高
TreeSet	不安全的	No—只有1个	不可以为空–异常	二叉树（红黑树）	都有效	节省点空间	中低

Set接口:无序集合–没有下标的
add(E e) :
clear() 删除
contains(Object o)有没有这个值返回布尔类型
remove(Object o)
size()
toArray() 转成数组

结构：任意的向空间存储没有顺序，不过会去掉重复的，数字会排序，可以是空的，

package com.chinasoft.jh;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetDemo {

	public static void main(String[] args) {
		
		Set<Integer> set = new HashSet<Integer>();
		set.add(8);
		set.add(1);
		set.add(5);
		set.add(3);
		set.add(111);
		//set.add(null);
		
//		for(int i : set) {
//			System.out.println(i);
//		}
		
		Iterator<Integer> it = set.iterator();
//		
		while(it.hasNext()) {
			int x = it.next();
			System.out.println(x);
		}
	}
}

treeset其中插入的不可以是空的，因为数据结构是二叉树要进行比较

package com.chinasoft.jh;

import java.util.Set;
import java.util.TreeSet;

public class SetDemo2 {

	public static void main(String[] args) {

		Set set = new TreeSet();
		set.add(8);
		set.add(1);
		// set.add(null);
		set.add(5);
		set.add(3);
		set.add(1);

		// set.add(null);

		for (Object i : set) {
			System.out.println(i);
		}

//		Iterator<Integer> it = set.iterator();
//		
//		while(it.hasNext()) {
//			int x = it.next();
//			System.out.println(x);
//		}
	}
}

Map

Map—>散列表(键值对)
apple–苹果
Map这种集合里的每一个元素存储的是一对值 key-value
put
get
keySet()

Map的实现类	线程	执行效率	数据结构	数据增长	查找、删除、修改、插入
HashMap	不安全	高	链式数组	初始长度16 当达到75% 增长约为1倍	高
Hashtable	安全	低	链式数组	初始长度10	低
TreeMap	不安全	中	红黑树		中

package com.chinasoft.jh;

import java.util.Map;
import java.util.TreeMap;

public class MapDemo {

	public static void main(String[] args) {
		
		Map<String,String> map = new TreeMap<String,String>();
		
		//向map集合中追加元素
		map.put("apple","苹果");
		map.put("banana","香蕉");
		map.put("pear","大鸭梨");
		map.put("apple","苹果111");//修改
		map.put("x",null);
		map.put("y",null);
		//通过key去获取value
		String value = map.get("apple");
		
		System.out.println(value);
		
		//遍历map--->遍历所有的key 
		//Set<String> keys = map.keySet();
		for(String key : map.keySet()) {
			String val = map.get(key);
			if("香蕉".equals(val)) {
				System.out.println(key);
			}
		}
		
		System.out.println(map.size());
		
		System.out.println(map.get("x"));
	}

}