Movle

public Thread();      //分配一个新的线程对象
public Thread(String name);      //分配一个指定名字的新线程对象
public Thread(Runnable target);      //分配一个带有指定目标的新的线程对象
public Thread(Runnable target,String name);      //分配一个带有指定目标的新线程对象并指定名字

public String getName();		//获取当前线程的名称
public void start();		//导致此线程开始执行，Java虚拟机调用此线程的run方法
public void run();		//此线程要执行的任务在此定义
public static void sleep(long millis);		//使当前正在执行的线程以指定的毫秒数暂停
public static Thread currentThread();		//返回对当前正在执行的线程对象的引用

public static <T> requireNoNull(T obj);    //查看指定引用对象不是null

public static <T> requireNoNull(T obj){
	if(obj == null){
		throw new NullPointerException();
	}
	return obj;
}

public class ObjectsDemp {
    public static void main(String[] args) {
        demo01(null);
    }

    private static void demo01(Object obj) {

        //Objects.requireNonNull(obj);
        Objects.requireNonNull(obj,"传递对象的值是null");
    }
}

修饰符 返回值类型 方法名(参数列表) throws{
	throw new XXXException("产生原因");
	...
}

try{
	可能产生异常的代码
}catch(定义一个异常的变量，用来接收try中抛出的异常对象){
	异常的处理逻辑，异常对象之后，怎么处理异常对象
	一般在工作中，会把异常的信息记录到一个日志中
}
...
catch(异常类名 变量名){
	
}

String getMessage();  //返回此throwable的简短描述
String toString();    //返回此throwable的详细消息字符串
void printStackTrace();   //JVM打印异常对象，默认此方法，打印的异常信息是最全面的

public class XXXException extends Exception|RuntimeException{
	添加一个空参数的构造方法
	添加一个带异常信息的构造方法
}

try{
	可能产生异常的代码
}catch(定义一个异常的变量，用来接收try中抛出的异常对象){
	异常的处理逻辑，异常对象之后，怎么处理异常对象
	一般在工作中，会把异常的信息记录到一个日志中
}
...
catch(异常类名 变量名){
	
}finally{
	无论是否出现异常都会执行
}

public V put(K key,V value);       //	把指定的键与指定的值添加到Map集合中
public V remove(Object key);   //把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值
public V get(Object key);           //根据指定的键，在Map集合中获取对应的值
boolean containsKey(Object key);    //判断集合中是否包含指定的键
public Set<K> keySet();             //获取Map集合中所有的键，存储到Set集合中
public Set<Map.Entry<K,V>> entrySet();    //获取到Map集合中所有的键值对对象的集合(Set集合)

格式
	Set<Map.Entry<K,V>> entrySet()

Map集合中的方法：
	Set<K> keySet() 返回此映射中包含的键的Set视图
实现步骤：
	1.使用Map集合中的keySet()方法，把Map集合所有的key取出来，存储到一个Set集合中
	2.遍历Set集合，获取Map集合中的每一个key
	3.通过Map集合中的方法get(key)，通过key找到value

public class Map02KeySetDemo {

    public static void main(String[] args) {
        demo01();
    }

    /**
     * 使用keySet方法遍历Map
     */
    private static void demo01() {
        Map<String,Integer> map = new HashMap<>();
        map.put("林志玲",18);
        map.put("吴亦凡",38);
        map.put("林志颖",28);
        map.put("赵忠祥",48);
        map.put("成龙",57);

        Set<String> set = map.keySet();

        for(String k:set){
            Integer value = map.get(k);
            System.out.println(k+"="+value);
        }

    }
}

Map集合中的方法：
	Set <Map.Entry<K,V>> entrySet()  返回此映射中包含的映射关系的Set视图
	
实现步骤：
	1.使用Map集合中的方法entrySet()，把Map集合中多个Entry对象取出来，存储到一个Set集合中
	2.遍历Set集合，获取每一个Entry对象
	3.视图Entry对象中的方法getKey()和getValue()获取键和值

public class Map03EntrySetDemo {

    public static void main(String[] args) {
        demo01();
    }

    private static void demo01() {
        Map<String,Integer> map = new HashMap<>();
        map.put("林志玲",18);
        map.put("吴亦凡",38);
        map.put("林志颖",28);
        map.put("赵忠祥",48);
        map.put("成龙",57);

        Set<Map.Entry<String,Integer>> set = map.entrySet();

        System.out.println("========使用迭代器遍历=========");
        Iterator<Map.Entry<String,Integer>> it = set.iterator();

        while(it.hasNext()){
            Map.Entry<String,Integer> m = it.next();
            String K = m.getKey();
            Integer V = m.getValue();

            System.out.println(K+"="+V);
        }
        System.out.println("========增强for循环遍历=========");
        for (Map.Entry<String,Integer> m:set) {
            String Key = m.getKey();
            Integer Value = m.getValue();
            System.out.println(Key+"="+Value);
        }
    }

public class HashMap01Demo {
    public static void main(String[] args) {
        //demo01();
        demo02();
    }

    /**
     * HashMap存储自定义类型键值
     *      key:Person类型-Person类必须重写hashCode方法与equals方法，以保证key唯一
     *      value:String类型-可以重复
     */
    private static void demo02() {
        HashMap<Person,String> map = new HashMap<>();
        map.put(new Person("张三",19),"北京");
        map.put(new Person("李四",22),"南京");
        map.put(new Person("王五",99),"重庆");
        map.put(new Person("赵六",38),"上海");
        map.put(new Person("张三",19),"天津");

        Set<Map.Entry<Person, String>> entrys = map.entrySet();
        for (Map.Entry<Person,String> en:entrys) {
            Person person = en.getKey();
            String value = en.getValue();
            System.out.println(person+"-->"+value);
        }

    }

    /**
     * HashMap存储自定义类型键值
     *      key：String类型 -String类型重写HashCode和equals方法，可以保证唯一
     *      value：Person类型 - value可以重复(同名同年龄的人视为同一个)
     */
    private static void demo01() {
        HashMap<String,Person> map = new HashMap<>();

        map.put("北京",new Person("张三",19));
        map.put("南京",new Person("李四",17));
        map.put("重庆",new Person("王五",22));
        map.put("上海",new Person("赵六",30));
        map.put("天津",new Person("胡八",18));

        Set<String> set = map.keySet();
        for (String s:set) {
            Person value = map.get(s);
            System.out.println(s+"-->"+value);
        }
    }
}

public class Person {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public static <T> boolean addAll(Collection<T> c,T...elements);  //往集合中添加一些元素
public static void shuffle(List<?> list);					//打乱集合的顺序
public static <T> void sort(List<T> list);				//将集合中元素按照默认规则排序
public static <T> void sort(List<T> list,Comparator<? super T>);   //将集合中元素按照指定规则排序

public class CollectionsAPI {
    public static void main(String[] args) {
        //demo01();
        //demo02();
        //demo03();
        demo04();
    }

    /**
     * Collections工具类之sort排序另一种方法
     */
    private static void demo04() {
        ArrayList<Integer> Lisa = new ArrayList<>();
        Lisa.add(1);
        Lisa.add(4);
        Lisa.add(2);
        Lisa.add(3);
        Lisa.add(9);
        Lisa.add(8);
        System.out.println("排序前：lisa"+Lisa);

        Collections.sort(Lisa, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //生序
                //return o1-o2;
                //降序
                return o2-o1;
            }
        });
        System.out.println("排序后：lisa"+Lisa);

        ArrayList<Student> stu = new ArrayList<>();
        stu.add(new Student("迪丽热巴",18));
        stu.add(new Student("古力娜扎",20));
        stu.add(new Student("胡歌",17));
        stu.add(new Student("胡歌",18));
        System.out.println("排序前的stu:"+stu);

        Collections.sort(stu, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int result = o1.getAge()-o2.getAge();
                if(result==0){
                    result = o1.getName().charAt(0)-o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println("排序前后stu:"+stu);
    }

    /**
     * Collections工具类sort排序之自定义类型的排序
     * 自己(this)-参数 ：升序
     * 参数-自己(this)：降序
     */
    private static void demo03() {
        ArrayList<Person> person = new ArrayList<>();
        person.add(new Person("张三",18));
        person.add(new Person("李四",20));
        person.add(new Person("王武",15));
        System.out.println("排序前的集合：person"+person);

        Collections.sort(person);
        System.out.println("排序后的集合：person"+person);
    }

    /**
     * Collections工具类之排序
     */
    private static void demo02() {
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(4);
        list1.add(2);
        list1.add(3);
        list1.add(9);
        list1.add(8);
        System.out.println("排序前的集合:list1"+list1);

        Collections.sort(list1);
        System.out.println("排序后的集合:list1"+list1);
    }

    /**
     * Collections工具类的单次加入多个元素与打乱集合顺序
     */
    private static void demo01() {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("a");
        list1.add("b");
        list1.add("c");
        list1.add("d");
        list1.add("e");
        System.out.println("多次加入单个元素：list1"+list1);

        //添加多个元素
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"a","b","c","d","e");
        System.out.println("单次加入多个元素：list2"+list2);

        //打乱顺序
        Collections.shuffle(list1);
        System.out.println("打乱顺序后的集合：list1"+list1);

    }
}

public class Person implements Comparable<Person>{
    private String name;
    private int age;
    @Override
    public int compareTo(Person o) {
        /*年龄生序排列*/
        return this.getAge()-o.getAge();

        //return 0;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person() {
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public void setAge(int age) {
        this.age = age;
    }
}

public class Student {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Student() {
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

修饰符 返回值类型 方法名(数据类型...变量名){}

public static int sum(int...arr){
	int sum = 0;
	for(int i:arr){
		sum+=i;
	}
	return sum;
}

public static int sum(String a,Double b,int...arr){
	int sum = 0;
	for(int i:arr){
		sum+=i;
	}
	return sum;
}

public static void method(Object...obj){

}