比较器、set、map、范型

一 set 

1.1 set特点

 set特点 : 无序 不可重复,添加顺序和取出顺序不一定一致
 TreeSet : 存进去的元素,会按照某个规则进行排序,

        HashSet底层由HashMap实现,TreeSet底层由TreeMap实现

1.2 排序规则

        数字 : 从小到大
         字符串 : 每一位的ASCII
         日期 : 自然日期

例子:

public class Collection_01_Set_01 {

	public static void main(String[] args) {
		// 数字 升序排序
				Set set = new TreeSet();
				set.add(10);
				set.add(1);
				set.add(2);
				// 重复的添加不进去
				set.add(2);
				// 报错, 因为不是相同类型比较的时候回出现问题
				// set.add("xxx");
				// [1, 2, 10]
				System.out.println(set);
				for (Object object : set) {
					
				}
				
				// 字符串 比较ASCII
				Set strs = new TreeSet();
				strs.add("123");
				strs.add("12");
				strs.add("1");
				strs.add("2");
				strs.add("21");
				strs.add("3");
				// [1, 12, 123, 2, 21, 3]
				System.out.println(strs);
	}

}

二 比较器

2.1比较器用途

          对象排序，就是比较大小，要实现Comparable或Comparator比较器之一，才有资格做比较      排序。

2.2  比较器两种方式 : 

1 要添加的元素实现Comparable接口并覆写compareTo方法
2 集合比较器 : Comparator比较器,元素自身不需要实现该接口
   如果添加的元素不是我们自定义的类
          1 假如该类有排序,但是不是我们想要的结果,比如Integer,默认升序
              但是我们想要降序 可以使用 Comparator
          2 假如该类没有排序,没有实现Comparable,那么我们想要排序还是要使用Comparator
                  因为类不是我们写的,所以我们无法更改人家的源码
  如果添加的元素是我们写的,那么想要排序 使用 Comparable ,这样如果不能满足其他用户的排序规则, 别人也可以使用 Comparator 进行更改
当comparable和comparator同时存在,那么 comparator的优先级大于 comparable

2.3 TreeSet为什么可以排序?

          因为添加的元素都实现了Comparable接口,在向TreeSet中添加数据的时候,会自动调用该对象的compareTo()方法所以 存储自定义类型的时候,如果要使用TreeSet 那么 必须实现Comparable接口

2.4 Comparable

2.4.1 概念

Comparable：与对象紧相关的比较器，可以称“第一方比较器”。

例子:

public class Collection_02_Comparable {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建对象
		User u1 = new User(18);
		User u2 = new User(19);
		User u3 = new User(13);
		User u4 = new User(15);
		//把对象添加进set里面
		TreeSet set = new TreeSet();
		set.add(u1);
		set.add(u2);
		set.add(u3);
		set.add(u4);
		System.out.println(set);//[User [age=19], User [age=18], User [age=15], User [age=13]]
	}

}
class User implements Comparable{
private int age;
	@Override
	public int compareTo(Object o) {
		// this是要添加的元素
		// o是集合中的元素
		if (o instanceof User) {
			User user = (User) o;
			// 如果该方法返回 0 说明相等.不添加
			// 如果该方法返回 小于0  说明要添加的元素比集合中的元素小,就放前面
			// 如果该方法返回 大于0 说明要添加的元素比集合中的元素大,就放后面
			return  user.age-this.age ;
		}
		return 0;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public User(int age) {
		super();
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [age=" + age + "]";
	}
		
}

2.5 compartor

compartor一般以匿名内部类的形式出现

例子:

public class Collection_03_Comparator {
public static void main(String[] args) {
												//匿名内部类
	TreeSet set =new TreeSet(new Comparator() {

		@Override
		public int compare(Object o1, Object o2) {
			Integer i1=(Integer)o1;
			Integer i2=(Integer)o2;
			// 0 说明重复,不添加
			// 大于0 往后放
			// 小于0 往前放
			return i1-i2;
		}
	});
	set.add(1);
	set.add(6);
	set.add(3);
	set.add(4);
	System.out.println(set);//[1, 3, 4, 6]
}
}

2.5 list排序

 List想要排序,元素必须实现Comparable接口, 如果没有实现 需要用 Comparator

2.5.1 数值型比较

例子:

public class Collection_04_Collections {
public static void main(String[] args) {
	List list = new ArrayList();
	list.add(1);
	list.add(11);
	list.add(2);
	list.add(3);
	list.add(14);
	// 因为Integer 实现了Comparable接口,所以可以进行排序,默认升序
	Collections.sort(list);//默认升序
	System.out.println(list);//[1, 2, 3, 11, 14]
	// 假如 Integer没有实现Comparable 或者我们想要降序排序,那么Integer就无法满足我们的要求
	// 需要使用Comparator解决
	Collections.sort(list,new Comparator() {

		@Override
		public int compare(Object o1, Object o2) {
			// TODO Auto-generated method stub
			Integer i1=(Integer)o1;//将Object类型转化为Integer类型进行比较
			Integer i2=(Integer)o2;
			return -1;
		}
	});
	System.out.println(list);//[14, 11, 3, 2, 1]
}
}

2.5.2 字符串比较

规则: 按照字符串中的数值大小进行排序,而不是按照ASCII

例子:

public class Collection_05 {
public static void main(String[] args) {
	// 字符串 比较ASCII
			Set strs = new TreeSet(new Comparator() {

				@Override
				public int compare(Object o1, Object o2) {
					// 1 Object 转换为String
					String s1 = (String) o1;
					String s2 = (String) o2;
					// 2 把String转换为 int
					int i1 = Integer.parseInt(s1);
					int i2 = Integer.parseInt(s2);
					// 3 比较
					return i1 - i2;
				}
			} );
			strs.add("123");
			strs.add("12");
			strs.add("1");
			strs.add("2");
			strs.add("21");
			strs.add("3");
			System.out.println(strs);
			
}
}

三 范型

3.1 概念

 范型 : 类型检查,在编译时检查类型是否匹配 

3.2 为什么要是用范型        

    集合中 什么元素都能保存,太杂,优点就是可以保存任意类型的数据,缺点 就是操作起来必须先强制类型转换才行,否则因为多态,无法访问特有属性
          引入范型之后,那么该集合中就只能保存指定类型,优点 : 操作起来方便,缺点 : 只能保存指定的类型,而结合实际操作,我们绝大部分都是用来保存统一类型的数据的范型 只能写引用类型,不能写基本类型

        使用大写字母表示 : A,B,C,D,E,F,......X,Y,Z 都是可以的,只不过是一个占位符而已
但是还是要合理选择
?  表示不确定的类型
T(Type) : 表示是一个具体的java类型
 E(Element) : 表示是元素的类型 (集合中保存的是元素)
K , V : 键值对,map中的key和vaule
如果说规定了泛型,但是没有传入泛型类型,那么 默认是Object

例子:

public class Collection_06_Generic_01 {
public static void main(String[] args) {
	List list = new ArrayList();
	list.add(1);
	list.add(123);
	list.add("xxx");
	list.add(true);
	for (Object object : list) {
		//判断是不是字符串类型,如果是就输出
		if (object instanceof String) {
			String s = (String) object;
			System.out.println(s.toLowerCase());//xxx
			//s.toLowerCase():把字符串转化为小写字母
		}
	}
	//<Integer>指定了该list中只能保存Integer类型
	List<Integer> list1 = new ArrayList<Integer>();
	list1.add(123);
	// 不能保存字符串
	// list1.add("22");
	for (Integer integer : list1) {
		System.out.println(integer);//123
	}
}