javase集合

集合框架简介

1.集合框架是一个用来代表和操纵集合的统一架构。
2.组成
	1）.接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
	2）.实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。		
	3）.算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

collection

1.list：允许集合内存在重复值,有序、可以添加多个null值 （所以只要添加元素即为true）
	1) arrayList：相当于一个自增的数组，查询快、增删改慢
		a) 常用方法

		b) 案例：模仿数据库（用户登陆、注册、修改 ）

public class User {

	private int uid;
	private String username;
	private String password;
	private String tel;

	public User() {
	}

	public User(int uid, String username, String password, String tel) {
		super();
		this.uid = uid;
		this.username = username;
		this.password = password;
		this.tel = tel;
	}

	@Override
	public String toString() {
		return "User [uid=" + uid + ", username=" + username + ", password=" + password + ", tel=" + tel + "]";
	}

	public int getUid() {
		return uid;
	}

	public void setUid(int uid) {
		this.uid = uid;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getTel() {
		return tel;
	}

	public void setTel(String tel) {
		this.tel = tel;
	}
}


public class UserDao {

	//	用集合List模拟整个数据源
	private static List<User> datas = new ArrayList<>() ;
	
	static {
		datas.add(new User(1, "zhangsan", "888888", "13333333"));
		datas.add(new User(2, "lisi", "888888", "13333333"));
		datas.add(new User(3, "wangwu", "888888", "13333333"));
	}
	
	/**
	 * 模拟一个用户注册功能，将给定的用户对象存入datas数据源
	 * @param u
	 * @return
	 */
	public boolean registry(User u) {
		
		if(datas.add(u)) {
			return true;
		}
		
		return false;
	}
	
	/**
	 * 查询目前数据源中的所有用户的信息
	 * @return
	 */
	public List<User> getAllUsers(){
		return datas;
	}

	
	/**
	 * 判断用户是否登录成功
	 * @param username:用户的用户名
	 * @param password:用户的密码
	 * @return true代表登录成功，否则false
	 */
	public boolean login(String username, String password) {
		
		for (User u : datas) {
			if(username.equals(u.getUsername()) && password.equals(u.getPassword())) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 测试
	 * @param args
	 */
	public static void main(String[] args) {
		new UserDao().remove();
	}

	/**
	 * 删除的两种方法
	 */
	public void remove() {
		System.out.println(datas);
		datas.remove(0);
		System.out.println(datas);
		System.out.println("=========");
		System.out.println(datas);
		datas.remove(0);
		System.out.println(datas);
		System.out.println("=========");
		System.out.println(datas);
		datas.remove(datas.get(0));
		System.out.println(datas);
	}

	/**
	 * 修改
	 * @param pass
	 */
	public void update(String pass) {
		for (User data : datas) {
			if (!pass.equals(data.getPassword())){
				data.setPassword(pass);
			}
		}
	}
}

public class TestUserDao {

	//	创建UserDao对象
	private static UserDao userDao = new UserDao();
	
	private static Scanner input = new Scanner(System.in);

	public static void main(String[] args) {
		
		while(true) {
			System.out.println("//****************************//");
			System.out.println("//********1. 查询所有用户********//");
			System.out.println("//********2. 注册用户***********//");
			System.out.println("//********3. 用户登录***********//");
			System.out.println("//****************************//");
			
			System.out.println("请输入您要做的操作的编号：");
			int op = input.nextInt();
			
			switch (op) {
				case 1:
					getAllUser();
					break;
				case 2:
					register();
					break;
				case 3:
					login();
					break;
				default:
					break;
			}
		}
		
		//input.close();
	}

	/**
	 * 登陆
	 */
	public static void login() {
		
		System.out.println("请输入用户名：");
		String username = input.next();
		
		System.out.println("请输入密码：");
		String password = input.next();
		
		if(userDao.login(username, password)) {
			System.out.println("您好：欢迎" + username + "进入系统");
			update();
		}else {
			System.out.println("登录失败");
		}
	}

	/**
	 * 查询所有用户
	 */
	public static void getAllUser() {
		List<User> list = userDao.getAllUsers();
		
		if(list == null || list.isEmpty()) {
			System.out.println("\r\n----------------------------");
			System.out.println("------目前还没有用户存在！--------");
			System.out.println("----------------------------\r\n");
			return;
		}
		
		System.out.println("----------------------------");
		for (User u : list) {
			System.out.println(u);
		}
		System.out.println("----------------------------");
	}

	/**
	 * 注册
	 */
	public static void register() {
		
		System.out.println("请输入用户的id");
		int uid = input.nextInt();
		System.out.println("您输入的id是："+ uid);
		
		System.out.println("请输入用户的用户名");
		String username = input.next();
		System.out.println("您输入的用户名是："+ username);
		
		System.out.println("请输入用户的密码");
		String password = input.next();
		System.out.println("您输入的密码是："+ password);
		
		System.out.println("请输入用户的电话");
		String tel = input.next();
		System.out.println("您输入的电话是："+ tel);
		
		User u = new User(uid, username, password, tel);
		
		//	判断用户的注册结果
		if(userDao.registry(u)) {
			System.out.println("用户注册成功!");
		}else {
			System.out.println("用户注册失败!");
		}
		
		System.out.println(userDao.getAllUsers());
	}

	/**
	 * 修改密码
	 */
	public static void update() {
		System.out.println("是否需要修改信息请输入：yes/no");
		String trg = input.next();
		if ("yes".equals(trg)){
			System.out.println("输入新密码：");
			String pass = input.next();
			userDao.update(pass);
		}else{
			return;
		}
	}
}

	2) linkedList：一个双向链表，增删改快、查询慢
		a) 常用方法

		b) 案例
			i.模拟一个队列

public class Stack {
    //定义一个队列
    private LinkedList<String> link ;
    /**定义获取队列中元素方法*/
    public LinkedList<String> getLink(){
        return link;
    }

    public Stack() {
        link = new LinkedList<String>();
    }

    /**
     * 插入元素
     * @param element
     */
    public void insertElement(String element){
        link.add(element);
    }

    /**
     * 删除最后一个元素,FILO
     */
    public void delete(){
        link.removeLast();
    }

    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isEmpty(){
        return link.isEmpty();
    }
}

public class TestStack {
    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.insertElement("k");
        stack.insertElement("i");
        stack.insertElement("l");
        stack.insertElement("l");
        stack.insertElement("e");
        stack.insertElement("r");
        System.out.println(stack.getLink());

        //模拟堆栈 FILO
        while (!stack.isEmpty()){
            stack.delete();
            System.out.println(stack.getLink());
        }
    }
}

			ii.模拟一个堆栈

	3) vactor：线程安全（和arraylist的区别）		
2.set：不允许存在重复值、只能添加一个null值、数据顺序不由程序员控制
	i. 自定义规则：
		1) 利用hashSet方法时考虑重写equals方法在其中再重写hashcode方法（元素去重）
		2) treeSet：实现排序，实现接口Comparable，根据要求重写comparaTo方法
		3)实现以上两种

public class Dept implements Comparable<Dept>{

	private String did;
	private String dname;
	private String loc;

	public Dept() {
	}

	public Dept(String did, String dname, String loc) {
		super();
		this.did = did;
		this.dname = dname;
		this.loc = loc;
	}
	
	/**
	 * 重写该方法，目的是即使是不同的部门对象，调用hashCode()方法后得到的哈希码值一样，
	 * 则被认为是相同的部门对象
	 * 	相同的部门对象不能被重复插入set集合中
	 */
	@Override
	public boolean equals(Object obj) {
		
		Dept dept = (Dept) obj;
		
		return this.hashCode() == dept.hashCode();
	}
	
	/**
	 * 自定义规则，只要不同的两个部门对象的部门编号和部门名称分别相同，
	 * 即使是不同的部门对象，也能保证hashCode（）方法的返回值相同
	 * 	只要hashCode的返回值相同，则被认为是相同的对象，不能被重复插入
	 */
	@Override
	public int hashCode() {
		return did.hashCode() + dname.hashCode();
	}

	@Override
	public String toString() {
		return "Dept [did=" + did + ", dname=" + dname + ", loc=" + loc + "]";
	}

	public String getDid() {
		return did;
	}

	public void setDid(String did) {
		this.did = did;
	}

	public String getDname() {
		return dname;
	}

	public void setDname(String dname) {
		this.dname = dname;
	}

	public String getLoc() {
		return loc;
	}

	public void setLoc(String loc) {
		this.loc = loc;
	}

	@Override
	public int compareTo(Dept o) {
		return did.compareTo(o.did);
	}
}


public class TestSet {

	public static void main(String[] args) {
		//去重
		Set<Dept> sets = new HashSet<>();
		
		Dept d1 = new Dept("1", "java", "xian");
		Dept d2 = new Dept("2", "java02", "xian");
		Dept d3 = new Dept("3", "aaa", "xian02");
		Dept d4 = new Dept("4", "zzz", "xian02");
		Dept d5 = new Dept("5", "fff", "xian02");
		Dept d6 = new Dept("6", "bbb", "xian02");
		Dept d7 = new Dept("6", "bbb", "xian02");
		
		System.out.println(d1.equals(d2));
		
		System.out.println(sets.add(d1));
		System.out.println(sets.add(d2));
		System.out.println(sets.add(d3));
		System.out.println(sets.add(d4));
		System.out.println(sets.add(d5));
		System.out.println(sets.add(d6));
		System.out.println(sets.add(d7));
		
		System.out.println(sets);
		
		System.out.println("=============");

		//排序
		Set<Dept> sets2 = new TreeSet<Dept>();
		
		System.out.println(sets2.add(d1));
		System.out.println(sets2.add(d2));
		System.out.println(sets2.add(d3));
		System.out.println(sets2.add(d4));
		System.out.println(sets2.add(d5));
		System.out.println(sets2.add(d6));
		
		System.out.println(sets2);
	}

}

3.list、set联系案例

/**
 *生成0~9的随机数
 */
public class Random02 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Set<Integer> set = new HashSet<>();

        while (set.size() < 10){
            int num =(int) (Math.random() * 10);
            if (set.add(num)){
                list.add(num);
            }
        }
        System.out.println(list);
    }
}

map

1.简介：
	1）.双列集合，键和值，键不能重复，值可以重复，键、值和键值对均可以为null
	2）.map的put（）方法完成数据的插入，返回值为上次该key对应的value值
		对于返回为null的情况有两种，
			一种是第一次添加该key
			一种是该key上次本身的值就是null
2.常用方法

hashMap和treeMap的比较
public static void main(String[] args) {
		Map<Integer, Object> m = new TreeMap<>();
		
		m.put(1, 1);
		m.put(9527, "zhouxingxing");
		m.put(2, new Object());
		m.put(3, new User(1, "tangsanzang", "999999"));
		
		System.out.println(m);
		
		System.out.println("===========");

		Map<Integer, Object> m2 = new HashMap<>();
		
		m2.put(1, 1);
		m2.put(9527, "zhouxingxing");
		m2.put(2, new Object());
		m2.put(3, new User(1, "tangsanzang", "999999"));
		
		System.out.println(m2);
		System.out.println(m.equals(m2));
		System.out.println("===========");

		//获取指定键的值
		System.out.println(m2.get(1));
		System.out.println(m2.get(3));

		//移除
		System.out.println(m2);
		m2.remove(3);
		System.out.println(m2);
	}
}

3.应用：comparable去实现treemap的自定义排序

public class Emp implements Comparable<Emp> {

	private int eid;
	private String name;
	private double salary;

	public Emp() {
		super();
	}

	public Emp(int eid, String name, double salary) {
		super();
		this.eid = eid;
		this.name = name;
		this.salary = salary;
	}

	@Override
	public String toString() {
		return "Emp [eid=" + eid + ", name=" + name + ", salary=" + salary + "]";
	}

	public int getEid() {
		return eid;
	}

	public void setEid(int eid) {
		this.eid = eid;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	/**
	 * 重写接口Comparable的方法compareTo，实现自定义功能排序
	 * @param o
	 * @return
	 */
	@Override
	public int compareTo(Emp o) {
		return new Integer(o.getEid()).compareTo(new Integer(eid));
		//return o.getName().compareTo(name) ;
		//return new Double(o.getSalary()).compareTo(new Double(salary));

	}
}

public class TestTreemap {

	public static void main(String[] args) {
		Map<String, Emp> map = new TreeMap<>();
		
		Emp e1 = new Emp(1, "sunkongkong", 888888);
		Emp e2 = new Emp(2, "zhubajie", 666666);
		Emp e3 = new Emp(3, "shanseng", 333333);
		Emp e4 = new Emp(4, "tangseng", 100000000);
		
		map.put("齐天大圣", e1);
		map.put("净坛使者", e2);
		map.put("卷帘大将", e3);
		map.put("金蝉子", e4);
		
		System.out.println(map);
		
		System.out.println("----------------");
		
		Map<Emp, String> map2 = new TreeMap<Emp, String>();
		
		map2.put(e1, "齐天大圣");
		map2.put(e2, "净坛使者");
		map2.put(e3, "卷帘大将");
		map2.put(e4, "金蝉子");
		
		System.out.println(map2);
	}

}