Java进阶笔记04

集合

UML图

List Set

Map

单链表

双向链表

哈希表

arraylist

import java.util.*;


public class test1 {

	/**
	 * @param args
	 * arraylist
	 * 底层是数组存储
	 * 有序（存进去什么顺序取出来什么顺序）
	 * 可重复
	 * 适合查询
	 * 不适合频繁的增删改
	 * 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Collection c=new ArrayList();//多态  创建集合
		
//		c.add(1);//添加集合
//		c.add(new Integer(100));
//		c.add(new Object());
//		c.add(new a());
//		
//		System.out.println(c.size()); //查看数组中几个元素
//		c.clear();//清空
		
//		c.isEmpty();//是否为空
		
//		Object obj=c.toArray();//转换成数组
		
//		Iterator it=c.iterator(); //创建迭代器 遍历
//		while(it.hasNext()){//开始遍历 开始迭代  it.hasNext()判断下一个是否有元素 如果有返回true
//			Object o=it.next(); //向下一位 取出元素 将下一个传给o 
//			System.out.println(o);
//		}
		
		
//		for(Iterator it1=c.iterator();it.hasNext();){ //for循环遍历
//			Object o=it.next(); 
//			System.out.println(o);
//		}
		
		Integer i1=new Integer(10);
		c.add(i1); //10传进去
		Integer i2=new Integer(10);
		System.out.println(c.contains(i2));//contains底层调用的是equals 比较的是内容 所以返回true
		
		a a1=new a(1);
		c.add(a1);
		a a2=new a(1);
		System.out.println(c.contains(a2));//比较的是内存地址 所以返回false 需要重写equals方法
		
	}

}
class a{
	int i;
	a(int i){
		this.i=i;
	}
}

list

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


public class test2 {

	/**
	 * @param args
	 * 
	 * list
	 * 特点：
	 * 有序
	 * 可重复
	 * 初始化容量为10 扩容后是原来的1.5倍
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

//		Collection c=new ArrayList();
//		List c=new ArrayList(); //查询效率高
		List c=new LinkedList();//增删效率高
		c.add(10);
		c.add(100);
		c.add(1000);

		Iterator i =c.iterator();
		while(i.hasNext()){
			System.out.println(i.next());
		}
	}

}

HashSet

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


public class test3 {

	/**
	 * @param args
	 * 
	 * HashSet集合
	 * 取出来的数据不一定按照顺序取
	 * 无序 不可重复
	 * 1.底层是一个HashMap采用哈希数据结构
	 * 2.哈希表底层是数组 数组里面存储单向链表	每个链表都有一个相同的hash值 代表数组的下标 调用hashcode算出来的值
	 * 3.hashset是hashmap中的key部分
	 * 4.hashmap和hashset初始容量为16 默认加载因子0.75
	 * 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Set s=new HashSet();
//		Set s=new TreeSet();//无序 不可重复 	会自动从小到大排序
		s.add(100);
		s.add(1);
		s.add(111);
		s.add(7);
		s.add(7);//无序   不 可重复
		s.add(88);
		s.add(2);
		s.add(3);
		
		Iterator i =s.iterator();
		while(i.hasNext()){
			System.out.println(i.next());
		}
		
	}

}

重写hashcode+equals

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


public class test4 {

	/**
	 * @param args
	 * 存储在hashcode集合或者hashmap集合key部分元素，需要同时重写hashcode+equals方法
	 * 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Set es=new HashSet();//创建集合
		
		//实例化Emp
		Emp e1= new Emp("111","J");
		Emp e2= new Emp("111","J");
		Emp e3= new Emp("112","r");
		Emp e4= new Emp("113","d");
		
//		添加元素
		es.add(e1);
		es.add(e2);
		es.add(e3);
		es.add(e4);

//		查看集合中元素个数
		System.out.println(es.size());
//		本来传进去内存地址 equals比较内存地址 认为没有重复  实际上员工编号和名字已经重复 
//		没有重写hashcode+equals方法前 元素个数4	重写后3
	
	}

}


class Emp{
	String  no;// 编号
	String name; //姓名
	
//	有参构造方法
	Emp(String no,String name){
			this.no=no;
			this.name=name;
	}
	
//	重写equals方法
	public boolean equals(Object o){
		if(this==o){
			return true;
		}
		if(o instanceof Emp){
			Emp e=(Emp)o;
			if(e.no.equals(this.no) && e.name.equals(this.name)){
				return true;
			}
			
		}
		return false;
	}
	
//	重写hashcode方法
	public int hashCode(){
		return no.hashCode();
	}
	
}

Map

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


public class test5 {

	/**
		Map
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Map m=new HashMap();
		m.put(1, "a");
		m.put(2, "b");
		m.put(3, "d");
		m.put(4, "e");
		m.put(5, "f");
		
//		遍历map
		Set keys=m.keySet();
		Iterator it=keys.iterator();
		while(it.hasNext()){
			Object _key=it.next();
			Object _value=m.get(_key);
			System.out.println(_key+"->"+_value);
		}
		
	}
}

sortedmap

import java.util.Iterator;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;


public class test6 {

	/**
	 * @param args
	 * 
	 * sortedmap key的特点 ： 无序不可重复 但是会自动按照大小排序 
	 * 想自动排序需要 1.实现comparable接口  2.单独写一个比较器
	 * 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		SortedMap ps=new TreeMap();
		
		Product p1=new Product("西瓜",1.0);
		Product p2=new Product("苹果",4.0);
		Product p3=new Product("香蕉",2.0);
		Product p4=new Product("桃子",5.0);
		
		ps.put(p1, 8.0);
		ps.put(p2, 8.1);
		ps.put(p3, 8.2);
		ps.put(p4, 8.3);
		
		Set keys =ps.keySet();
		Iterator it =keys.iterator();
		while(it.hasNext()){
			Object k =it.next();
			Object v =ps.get(k);
			System.out.println(k+"-->>"+v+"kg");
		}
	}

}


class Product implements Comparable{
	String name;
	double price;
	
	

	public Product(String name, double price) {
		super();
		this.name = name;
		this.price = price;
	}



	@Override
	public String toString() {
		return "Product [name=" + name + ", price=" + price + "]";
	}



//	按照商品价格排序
	@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		double p1=this.price;
		double p2=((Product)o).price;
		if(p1<p2){
			return -1;
		}else if(p1>p2){
			return 	1;
		}else{
			return 0;
		}
		

	}
	
}