[三.J2EE]

1.UML
	统一建模语言，例如：类图、用例图等等

2.Collection接口
	集合框架的顶级接口
	是List和Set的父接口
	不是Map集合的父接口

3.List
	特点
		有序
			元素添加的顺序与输出的顺序一致
		不唯一
			允许添加重复元素
	遍历方式
		for下标
		foreach
		iterator（迭代器）
			hasNext
				判断集合中的下一个元素是否存在，不移动下标
			next
				移动下标并取出当前元素
	删除方式
		for正向删除
			问题点：for(int i=0;i lst=new ArrayList<>(20)
	泛型
		以类型作为参数的类
		作用：提高程序的健壮性、简化代码
		默认类型是Object
		>jdk1.5
	装拆箱
		装箱
			值类型到引用类型
		拆箱
			引用类型到值类型
		>jdk1.5
	ArrayList/LinkedList/Vector区别
		ArrayList
			以连续的数组结构存储数据，查询快，增删改慢
		LinkedList
			以链表结构存储数据，查询慢，增删改快
		Vector
			增删改查都慢，已过时，线程安全

public static void main(String[] args) {
		// Student stu=new Student();
		// 唯一：是被过滤还是重复替换？(被过滤)
		// Set set=new HashSet();
		// set.add("a");
		// set.add("b");
		// set.add("c");
		// set.add("e");
		// set.add("f");
		//
		// set.forEach(System.out::println);

		// 答案：(被过滤)

		Set set = new HashSet<>();
		set.add(new Student(1, "1", 132f));
		set.add(new Student(2, "1", 132f));
		set.add(new Student(3, "1", 132f));
		set.add(new Student(1, "1", 1322f));
		// set.forEach(System.out::println);

		// 1）默认使用equals比较
		// Object类型是引用类型
		// 默认比较是 内存地址 重点（去实体类比较）
		// 2)重写hashcode和equals方法，先比较hashcode值是否相同，再比较equals
		// 2.1)hashcode值相同，则比较equals
		// 2.2)hashcode值不同，则不比

		
	
}

package com.zking.entity;

import java.io.Serializable;


public class Student implements Comparable,Serializable {
	private int sid;
	private String name;
	private float score;
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public float getScore() {
		return score;
	}
	public void setScore(float score) {
		this.score = score;
	}
	public Student(int sid, String name, float score) {
		super();
		this.sid = sid;
		this.name = name;
		this.score = score;
	}
	public Student(String name, float score) {
		super();
		this.name = name;
		this.score = score;
	}
	public Student() {
		super();
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		//result = prime * result + Float.floatToIntBits(score);
		result = prime * result + sid;
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		//true代表已存在，false:代表允许添加
		//当前对象是否与obj对象是相同
		if (this == obj)
			return true;
		//obj对象是否为空
		if (obj == null)
			return false;
		//当前类对象与obj对象不相同
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if(this.getSid()!=other.getSid()) 
			return false;
			return true;
		}
	
	
	@Override
	public int compareTo(Student o) {
		// TODO Auto-generated method stub
		return this.getSid()-o.getSid();
	}
	@Override
	public String toString() {
		return "Student [sid=" + sid + ", name=" + name + ", score=" + score + "]";
	}
		
	
	
	
	
}

       1.2.1 foreach
       1.2.2 迭代器  

  // 第一种：            

for (Student student : set) {
            System.out.println(student);
        }
    //第二种

set.forEach(System.out::println);
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {

            System.out.println(iterator.next());
        }

       HashSet
      TreeSet：根据某种(规则)对里面的元素进行排序
        自然比较接口: java.lang.Comparable 
        比较器: java.util.Comparator
        String以AscII码进行比较，返回差值

简单排序：IdCom类

public class IdCom implements Comparator {

    @Override
    public int compare(Student o1, Student o2) {
        // TODO Auto-generated method stub
        return o1.getSid()-o2.getSid();
    }

}
 

        

public static void main(String[] args) {
        // TreeSet:以某种特定的规则对集合中的袁旭进行排序。(升降序)
        // java.lang.Comparable:自然比较接口
        // java.util.Comparator:比较器
        // 按字母排序

        Set set=new TreeSet<>();
         set.add("a1");
         set.add("xs2");
        set.add("a3");
         set.forEach(System.out::println);

        Set set = new TreeSet<>(new IdCom());

        set.add(new Student(1, "d1", 12));
        set.add(new Student(7, "a1", 13));
        set.add(new Student(3, "f1", 13f));
        set.forEach(System.out::println);

    }
 

  队列 Queue：表示一个先入先出的数据结构

  (堆栈 Stack：表示一个先进后出的数据结构
  压：push
  弹：pop   已拓展)