java学习之集合框架与泛型

java集合框架与泛型

5.1 java集合框架与泛型

5.1.1 java集合框架的主要接口

tips:

• 接口map与接口collection是相互独立的
• 所有集合类均直接或间接地实现了迭代接口interable

5.1.2 迭代接口Iterable与迭代器Iterator

Iterator用于遍历集合中元素，定义了三种方法：

• hasNext():判断是否还有下一个元素。有元素可以迭代则返回true。
• next() 返回下一个元素
• remove() 删除当前元素

5.1.3 泛型

java通过object的引用来实现参数类型的任意化，特点则是需要进行显示的强制类型转化，但编译器有时发现不了强制类型转化引起的异常，给系统带来隐患。由此引入了泛型。

泛型的本质：参数化类型，操作的数据类型被指定为一个参数。可以有泛型类，泛型接口，泛型方法。

5.2 Collection集合及其遍历

5.2.1 List接口及其常用类

List的特征：

• 元素有序排列
• 可以有重复元素
• 可以随机访问，及通过索引快速访问元素

List的实现类ArrayList

package 容器;
/**
 * 手工实现Arraylist
 * @author CR553
 */

public class TestArrayList01<E> {
	private Object[] elementDate;
	private int size;
	
	private static final int MAX=10;
	
	public TestArrayList01()//构造函数
	{
		elementDate =new Object[MAX];
	}
	
	public TestArrayList01(int index)//构造函数
	{
		elementDate =new Object[index];
		if(index<0)
		{
			throw new RuntimeException("容器大小不能为负数!");
			
		}
		else if(index==0)
		{
			elementDate= new Object[MAX];
		}
		else
		{
			elementDate =new Object[index];
		}
	}
	
	public void add(E element)
	{
		if(size== elementDate.length)//扩容操作
		{
			Object[] newArray = new Object[elementDate.length+(elementDate.length>>1)];
			System.arraycopy(elementDate, 0, newArray, 0, elementDate.length);
			elementDate = newArray;
		}
		elementDate[size++]=element;
	}
	
	public void checkRange(int index)//越界判断
	{
		if(index<0||index>=size)
		{
			throw new RuntimeException("索引不合法!:"+index);
			
		}
		
	}
	public void set(E element ,int index)//修改操作
	{
		checkRange(index);
		elementDate[index]=element;
		
	}
	public E get(int index)
	{
		checkRange(index);
		return (E)elementDate[index];
		
	}
	public void remove(int index)//移除操作
	{
		int numMoved=elementDate.length-index-1;
		System.arraycopy(elementDate, index+1, elementDate, index, numMoved);//自己复制自己实现删除
	}
	public void remove(E element)
	{
		for(int i=0;i<size;i++)
		{
			if(element.equals(get(i)))
			{
				remove(i);
			}
		}
		elementDate[--size]=null;
	}
	
	public String toString() {//重写toString方法
		StringBuilder sb =new StringBuilder();
		sb.append("[");
		for(int i=0;i<size;i++)
		{
			sb.append(elementDate[i]+",");
			
		}
		sb.setCharAt(sb.length()-1,']');
		return sb.toString();
	}
	public static void main(String[] args) {
		TestArrayList01<String> t1 =new TestArrayList01<String>(20);
		t1.add("*");
		t1.add("/");
		for(int i=0;i<50;i++)
		{
			t1.add("mm"+i);
		}
		t1.set("bb", 5);
		System.out.println(t1.get(5));
		t1.remove(4);
		t1.remove("bb");
		System.out.println(t1);
	}

}

List实现类：LinkLisst

package 容器;
/**
 * 自定义链表
 * @author asus
 *
 */
public class TestLinklist<E> {

	private Node first;
	private Node last;
	private int size;

	//a,b,c
	public void add(E element)//添加元素

	{
		Node node =new Node(element);
		if(first==null)
		{
			first=node;
			last=node;
			
		}
		else 
		{
			node.previous=last;
			node.next=null;
			
			last.next= node;
			last=node;

		}
		size++;
	}
	public void checkRange(int index)//判断索引是否越界
	{
		if(index<0||index>size-1)
		{
			throw new RuntimeException("索引数字不合法:"+index);
		}
	}
	public Node getNode(int index)
	{
		checkRange(index);
		Node temp=null;
		if(index<(size>>1))//二分
		{
			temp=first;
			for(int i=0;i<index;i++)
			{
				temp=temp.next;
			}
		}
		else
		{
			temp=last;
			for(int i=size-1;i>index;i--)
			{
				temp=temp.previous;
			}
		}
		return temp;
	}
	public void remove(int index)//删除
	{
		checkRange(index);
		Node temp=getNode(index);
		Node up=temp.previous;
		Node down = temp.next;
		
		if(up!=null)
		{
			down.previous=up;
		}
		if(down!=null)
		{
			up.next=down;
		}
		if(index==0)
		{
			first=down;
			
		}
		if(index==size-1)
		{
			last=up;
		}
		size--;
	}
	public Object get(int index)//获得值
	{
		checkRange(index);
		Node temp = getNode(index);
		return temp==null?null:temp.element;
		
	}
	
	public String toString()//重写

	{
		StringBuilder sb =new StringBuilder("[");
		Node temp =first;
		while(temp!=null)
		{
			sb.append(temp.element+",");
			temp=temp.next;
		}
		sb.setCharAt(sb.length()-1, ']');
		return sb.toString();
		
	}
	public void add(int index,E element)
	{
		checkRange(index);
		Node newnode =new Node(element);
		Node temp=getNode(index);
		
		if(temp!=null)
		{
			Node up=temp.previous;
			
			up.next=newnode;
			newnode.previous=up;
			
			temp.previous=up;
			newnode.next=temp;
		}
		size++;
		
		
	}
	
	public static void main(String[] args) {
		TestLinklist<String> t2 =new TestLinklist<>();
		t2.add("aa");
		t2.add("ab");
		t2.add("as");
		t2.add("asaa");
		System.out.println(t2);
		System.out.println(t2.get(2));
		t2.remove(1);
		System.out.println(t2);
		t2.add(2,"梅海迪");
		System.out.println(t2);  
		
		
		
		
		
	}
}

HashSet

package 容器;

import java.util.HashMap;

public class TestHashSet {
	HashMap map;
	private static final Object PRESENT =new Object();
	
	public TestHashSet()
	{
		map=new HashMap();
	}
	public void add(Object o)
	{
		map.put(o, PRESENT);
	}
	public int size()
	{
		return map.size();
	}
	@Override
	public String toString() {
		StringBuilder sb =new StringBuilder("[");
		for(Object key:map.keySet())
		{
			sb.append(key+",");
		}
		sb.setCharAt(sb.length()-1, ']');
		return sb.toString();
	}
	public static void main(String[] args) {
		TestHashSet m1= new TestHashSet();
		m1.add("aa");
		m1.add("bb");
		m1.add("aa");
		m1.add("cc");
		System.out.println(m1);
		
	}
	
}

Map集合及其遍历

Map中存储键值对，键名不能重复，键值可以重复。

map中常见函数

• size()
• isEmpty()
• get(object)
• put(k,v)
• clear()
• keySet()
• entrySet()
• remove(object)

手写hashmap

package 容器;

public class TestHashMap<K,V> {
	Node2[] table;
	int size;
	
	public TestHashMap()
	{
		table =new Node2[16];
		
	}
	public String toString() {
		StringBuilder sb =new StringBuilder("{");
		
		for(int i=0;i<table.length;i++)
		{
			Node2 temp=table[i];
			while(temp!=null)
			{
				sb.append(temp.key+":"+temp.value+",");
				temp=temp.next;
			}
		}
		sb.setCharAt(table.length-1, '}');
		return sb.toString();
		
		
	}
	public V get(K key)
	{
		int hash=myhash(key.hashCode(), table.length);
		V value=null;
		
		if(table[hash]!=null)
		{
			Node2 temp=table[hash];
			while(temp!=null)
			{
				if(key.equals(temp.key))
				{
					value=(V)temp.value;
					break;
				}
				else
				{
					temp=temp.next;
				}
			}
		}
		return value;
		
		
	}
	public void put(K key,V value)
	{
		Node2 newNode =new Node2<>();
		newNode.hash=myhash(key.hashCode(), table.length);
		newNode.key=key;
		newNode.value=value;
		newNode.next=null;
		
		Node2  temp=table[newNode.hash];
		Node2  iterLast= null;
		boolean keyRepeat=false;
		
		if(temp==null)
		{
			table[newNode.hash]=newNode;
			size++;
		}
		else
		{
			while(temp!=null)
			{
				if(key.equals(temp.key))
				{
					keyRepeat=true;
					temp.value=value;
					
					break;
					
				}
				else
				{
					iterLast=temp;
					temp=temp.next;
					
				}
				
			}
			if(keyRepeat==false)
			{
				newNode=iterLast.next;
				size++;
			}
		}
		
	}
	public int myhash(int v,int length)
	{
		return v&(length-1);
	}
	
	public static void main(String[] args) {
		TestHashMap<Integer,String> m1=new TestHashMap<>();
		m1.put(10, "梅");
		m1.put(20,"海");
		m1.put(30,"迪");
		
		System.out.println(m1);
		System.out.println(m1.get(10));
		
	}
	
}