JavaSE.20190510.TreeSet.Map.反射.

一.TreeSet

     1.底层:红黑树
        优点:升序排序,查询效率较高
        引用数据类型的去重和排序:实现内部|外部比较器
        内部比较器 : Comparable 接口  实现Comparable接口重写comparaTo方法,自定义比较规则
        外部比较器 : Comparator 接口 重写compare方法,自定义比较器

import java.util.TreeSet;

public class TreeSet10 {
	public static void main(String[] args) {
		//可以指定比较规则
		TreeSet<Person> tree=new TreeSet((o1,o2)->((Person)o1).getId()-((Person)o2).getId());
		tree.add(new Person(01,"呜呜",21));
		tree.add(new Person(03,"聊聊",22));
		tree.add(new Person(03,"瞧瞧",32));
		tree.add(new Person(01,"呱呱",12));
		tree.add(new Person(04,"呜呜",25));
		System.out.println(tree);
	}

}

二.Map

     1.存储的数据都是key,value键值形式的

     2.key可以任意数据类型      无序的    唯一的   ----->set结合

     3.value可以任意数据类型    无序的    不唯一 的----->Collection结合

     4.一个key只能对应一个value（value可以为集合，集合中存储多个数据）

public class MapDemo01 {
	public static void main(String[] args) {
		Map<String,Integer> map=new HashMap();
		map.put("李敏镐",03);  
		map.put("胡歌",01);
		map.put("谢霆锋",04);  
		map.put("宋承宪",02);
		
		//V get(Object key)  
		
		System.out.println(map);
		System.out.println(map.get("胡歌"));
		
		/*
		 *   boolean containsKey(Object key) 
			          如果此映射包含指定键的映射关系，则返回 true。 
			 boolean containsValue(Object value) 
		 */
		System.out.println(map.containsKey("胡歌"));
		System.out.println(map.containsValue("胡歌"));
		
		//remove(key)
		System.out.println(map.remove("宋承宪"));
		
		System.out.println(map.put("胡歌", 100));;
		System.out.println(map);
	}
}

       5. HashSet    HashMap

           HashSet是由HashMap维护的,但是HashMap是键值对的形式,初始容量是16,加载因子是0.75
           底层是hash表的结构
           HashMap的key如果是引用数据类型的对象,做去重要重写hashCode和equals
           如果想要实现value去重,需要手动判断

import java.util.HashMap;
import java.util.Map;
public class HashMap02 {
	public static void main(String[] args) {
		HashMap<Person,Integer> map=new HashMap();
		map.put(new Person(01,"haha",100), 01);
		map.put(new Person(02,"hehe",200), 03);
		if(!map.containsValue(03)){
			map.put(new Person(01,"haha",100), 03);
		}
		
		System.out.println(map);
	}
}

       6.TreeSet是由TreeMap的key维护的,使用方式相同,但是是键值对的形式

import java.util.HashMap;
import java.util.TreeMap;
//TreeSet是由TreeMap的key维护的,使用方式相同,但是是键值对的形式
public class TreeMap03 {
	public static void main(String[] args) {
		TreeMap<Person,Integer> map=new TreeMap((o1,o2)->((Person)o1).getAge()-((Person)o2).getAge());
		map.put(new Person(01,"haha",100), 01);
		map.put(new Person(01,"haha",100), 02);
		map.put(new Person(02,"hehe",200), 03);
		System.out.println(map);
	}
}

三.反射

     1.反射是发生在程序运行期间的行为--java的一个动静态机制  反射

     2.创建对象的时候,拿到的都是当前类型Class对象的一个镜像|赋值体
     3.在类加载的时候,会在内存中存在当天前类型的一个Class对象,一个类的Class对象中存储这个类的所有信息(属性,方法,构造          器...)
     4.只要我们能够获取这个类型的Class对象,就可以对这个类做一切操作
     5. Class 类的实例表示正在运行的 Java 应用程序中的类和接口
     6.获取源头(Class对象):
       1）对象.getClass()
       2）类名.class 
       3)   Class.forName("类的权限命名:包名+类名")

public class ReflectDemo02 {
	public static void main(String[] args) throws ClassNotFoundException{
		//1.对象.getClass()
		Class cls1="哈哈".getClass();
		Class cls2="呵呵".getClass();
		System.out.println(cls1==cls2);
		
		//2.类名.class
		Class cls3=String.class;
		System.out.println(cls1==cls3);
		System.out.println(cls3);
		
		//3.Class.forName("类的权限命名:包名+类名")   推荐
		Class cls4=Class.forName("java.lang.String");
		System.out.println(cls3==cls4);
		
		//4.根据子类的Class对象获取父类的Class对象
		Class cls5=cls4.getSuperclass();
		System.out.println(cls5);
		
		//5.获取基本数据类型的Class对象
		Class base1=int.class;
		System.out.println(base1);
		Class cls6=Integer.class;
		System.out.println(base1==cls6);
		Class base2=Integer.TYPE;  //得到对应的基本数据类型的class对象
		System.out.println(base1==base2);
		
		//常用的方法
		//1.getName() 包名+类名
		System.out.println(cls5.getName());
		
		//2. Class<?>[] getInterfaces()  
		Class[] arr=cls4.getInterfaces();
		System.out.println(Arrays.toString(arr));
		
		//3.String getSimpleName()  
		System.out.println(cls4.getSimpleName());
		
		//4.boolean  isInterface()  isPrimitive() 
		System.out.println(Integer.class.isPrimitive());
		System.out.println(Integer.TYPE.isPrimitive());
		
	}
}

      7.通过反射创建对象

         1)通过反射获取到类中的构造器
         2)根据构造器创建对象
            构造器Constructor对象.newInstance(实参)方法
            直接通过class类的newIntance()方法创建对象,方法没有参数   调用空构造

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
public class ReflectDemo03 {
	public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, 
	IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		//1.先获取类的Class
		Class cls=Person.class;
		//2.通过Class类中的方法,获取到Person类中的构造器
		
		/*
		 *   Constructor<T> getConstructor(Class<?>... parameterTypes) 
			          返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。 
			 Constructor<?>[] getConstructors() 
			          返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。 
		 */
		Constructor con1=cls.getConstructor(int.class,String.class,int.class);
		Person p=(Person) con1.newInstance(01,"卢妹妹",18);
		System.out.println(p);
		
		Person p1=(Person)cls.newInstance();
		System.out.println(p1);
		
		/*
		 *   Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
			          返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。 
			 Constructor<?>[] getDeclaredConstructors() 
			          返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。 
		 */
		Constructor<Person>[] cons=cls.getDeclaredConstructors();
		System.out.println(Arrays.toString(cons));
		//私有的构造器
		//放开权限
		cons[1].setAccessible(true);  //权限方法
		Person p3=cons[1].newInstance(02,"卢双双");
		cons[1].setAccessible(false); 
		System.out.println(p3);
		
		
	}
}