java学习第四周

Object的功能

int hashCode():获取对象的hash码值--->支持散列表(支持key--value键值对)(理解为地址值,但不是真实地址值,每一个对象的hash码值都不同)
String toString:String toString():返回对象的字符串表示形式,结果应该是一个更容易让人读懂的信息表达式(建议所有的子类都覆盖这个方法)几乎Java所有类都会重写toString()方法
Boolean equals(Object obj)(指定其他对象与此对象是"相等")比较两个数据是否相等
clone(): protected Object clone() throws CloneNotSupportedException  创建对象并返回它的"副本"方法里面本身就会带有CloneNotSupportedException:克隆不支持的异常(当要对某个Object的类进行克隆如果这个类不能实现cloneable接口,那么就会出现这个异常)要进行创建对象的副本,前提这个类必须要实现clonable接口,否则无法克隆,jdk提供的接口,什么都没有(连方法都没有),这种接口称为"标记接口"
getClass():获取这个类的字节码文件对象  class com.qf.object_01.Student

==和equals区别
==:比较两个基本类型,数据值是否相等
==:连接是两个引用类型,比较的是地址值是否相等
而Object的equals方法,默认比较的是两个引用类型的地址值是否相等,建议子类需要重写这个equals(),重写之后比较的是
两个对象的成员信息是否相同!(Java中所有类都会重写!)    ,重写equals方法,必须同时重写hashCode()方法
重写equals:比较每一个对象的成员信息是否相同 如果一样,还要比较每一个成员信息 hashCode()哈希码值是否一样,如果都相同
系统认为这个两个人是一样的!

Scanner提供一个判断功能

  nextXXX():获取功能
    public int nextInt() :录入int类型
    public String nextLine() ;录入String类型
  判断功能:
       public boolean hasNextInt():判断录入的下一个数据是否为int类型,是,返回true,否则false
      public boolean hasNextLine():判断录入的下一个数据为一行内容
 
 
       键盘录入的时候
                   先录入int,在录入String ----nextLine() ,这块会出现被漏掉("回车符号")
                   解决方案:
                           1)在第一个录入int之后,重新创建一个新的键盘录入对象Scanner ,然后在使用nextLine()
                           2)在录入String---- String next()
 

String以及StringBuffer

String类: 这个类final修饰不能被继承
  字符串是不变; 它们的值在创建后不能被更改(字符串是一个常量,存储在常量池中)
 
  构造方法:
       public String():空字符串    类似于 String s = "" ;
       public String(String original):构造一个字符串对象,里面指定一个字符串常量值
       public String(byte[] bytes) :使用平台默认字符集(idea默认utf-8)解析解码--->字节数组--->字符串
       String(byte[] bytes, int offset, int length) :将一部分字节数组构造成字符串
       public String(char[] value):将字符数组---构造成String
       public String(char[] value,int offseet,int len):将一部分字符串数组构造成字符串

 
 面试题:
       数组中没有length(),字符串有没有length(),集合中没有有length()?
               数组  数组对象.length
               字符串   length()方法,
               集合没有,获取集合中 元素数 size()方法
 
 获取功能
  1)public char charAt(int index) :获取指定索引处的字符
 *      2)int length():获取字符串的长度
 *      3)public String concat(String str)拼接功能-- 将一个字符串拼接到指定字符串的后面(末尾追加)
 *      4)public String substring(int beginIndex):截取--->从指定位置开始截取,默认截取到末尾结束!
 *      public String substring(int beginIndex, int endIndex) 截取--->从指定位置开始截取到指定位置结束
 *                              包前不包后(包含第一个位置,不包含最后一个位置,只能取到endIndex-1处)
 *      5)public String[] split(String regex):拆分(分割) ,按照指定的分割符将字符串拆分成字符串数组
 *      6)public int indexOf(int ch) :返回此字符第一次在字符串中出现的索引值
 *       public int lastIndexOf(int ch):返回此字符最后一次在字符串中出现的索引值
 
   String类的转换功能
       1)char[] toCharArray() 将字符串转换成字符数组
       2)byte[] getBytes() 平台默认字符集编码(String--->byte[])   和
           byte[] getBytes(String charset):指定的字符集进行编码
       String(byte[] bytes) :(bytes[]--->String  ) 平台默认字符集解码
       String(byte[] bytes,String charset) :(bytes[]--->String  ) 指定字符集解码
 
       3)public String toLowerCase():将字符串转换成小写
          public String toUpperCase():将字符串转换成大写
 
       4)万能方法:  可以将任何数据类型---->String
       public static String valueOf(int i/float....Object)

      编码和解码必须一致,否则乱码!
        
 
  判断功能:
               boolean contains(String str):判断大串中是否包含指定子字符串
               boolean endsWith(String suffix):判断是否以指定结尾的字符串
               public boolean startsWith(String prefix):判断是否指定的字符串开头
               boolean equals(Object anObject)。:比较两个字符串内容是否相同
               boolean equalsIgnoreCase(String anotherString) :不区分大小写比较两个字符串是否相同
               public boolean isEmpty():判断字符串是否空 ,长度为0,true空串,和空对象? 一样吗?
                   不一样
 
 
             public String replace(char oldChar,char newChar)  :替换功能
             public String trim() :去除字符串两端空格 (一般io流中:  文件读写文件)
 
 
  *     按照字典顺序比较,它的结果是多少?   考察的就是compareTo的源码
 *     public int compareTo(String anotherString):两个字符串按照字典顺序比较!
 *
 *     两个字符串进行字典顺序比较,先算出长度,取出最小值,然后比较每一个字符,如果这俩个字符串的第一个字符都不相同
 *     使用前面的字符和后面的的字符进行相减(ASII码表的值相减)
 *     如果长度的最小值,在循环遍历两个字符串的每一个字符之前,都相同,直接是两个字符串长度相减!
 
  * concat(String str)  这两种哪一个高效?  +拼接符号更高效一些
 * String s = null ;
 * s.concat("hello") ;   左边不能为空对象,如果这样导致NullPointerException:空指针

Integer/Character

byte --- Byte

short --- Short

int --- Integer

long --- Long

float --- Float

double --- Double

char --- Character

boolean --- Boolean

String --- Integer --- int     Integer.parseInt(数字字符串)
String --- Long ---long  		Long.parseLong(String数据)
String --- Float --- float        	Float.parseFloat("小数字符串")

StringBuffer类(字符串缓冲区,线程安全类)/StringBuilder

构造方法:
StringBuffer :
	public StringBuffer()构造一个没有字符的字符串构建器，初始容量为16个字符。 
	StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。
	int length()获取字符串缓冲区长度
	int capacity():获取容量大小

功能:
追加
	public StringBuffer append()(任意java类型)将指定类型追加字符缓冲区的序列中,返回字符串本身
	StringBuffer insert(int offest,String str/可以任何java类型)在此前面插入指定数据,返回字符串本身

获取:
	public char charAt(int index)获取字符串缓冲区中指定位置的字符,返回指定的字符

删除:
	 StringBuffer delete(int start, int end)  :删除从指定位置开始到指定位置结束(end-1)的字符,返回字符串缓冲区本身
     StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回值字符串缓冲区本身

替换:
	public StringBuffer replace(int start,int end,String str)将字符串缓冲区中的从指定位置开始到指定位置结束(end-1)的字符序列使用指定的字符串进行替换
	
截取:
	public String substring(int beginIndex)
 	public String substring(int beginIndex,int endIndex) 
	
反转:(特有功能)
	public StringBuffer reverse() 将字符串缓冲区的字符序列进行反转
	

类型转换:
StringBuffer ---> String
	String s = "hello" ;
方式一:
	创建字符缓冲区:
	StringBuffer s = new StringBuffer();//空参  追加
	s.append();
方式二:
	StringBuffer s = new StringBuffer(String);//有参
	
	String ---> StringBuffer
	StringBuffer buffer = new StringBuffer("helloJavaEE") ;
方式一:
	转换成String
	String str = buffer.toString();
方式二:
	有参构造
	String str2 = new String(buffer) ;

String和StringBuffer/StrinBuilder的区别?
    String:是一个常量,一旦被赋值,其值不能被更改,不可变的字符序列!
	作为形式参数,形式参数的改变不影响实际参数(和基本类型作为形式参数传递的效果一致 ,特殊的引用类型)
	StringBuffer:支持可变的字符串序列,线程安全的类--->同步的--->执行效率低
	StringBuffer的大部分功能--->synchronzied:同步锁(悲观锁)(多线程)
	作为形式参数,形式参数的改变直接影响实际参数
	StringBuilder:和StringBuffer具备相互兼容的API,线程不安全的类---不同步的---->执行效率高
	单线程程序(只考虑效率)中,使用StringBuilder去替代StringBuffer
	多线程环境下(要考虑安全),使用StringBuffer
	

 String s1  = "hello" ;
        String s2 =  "world" ;
        String s3 = "helloworld" ;  //s3指向常量池里面的"helloworld"
        System.out.println(s3 == (s1+s2));  // false
        System.out.println(s3.equals(s1+s2));//true
        System.out.println(s3==("hello"+"world")) ;//true
        System.out.println(s3.equals("hello"+"world"));//true
        
//字符串常量相加:先拼接,任何看常量池中又没有数据,有返回地址
//字符串变量相加:先开地址
//s3 = (s1 + s2)

Date日期/Random(随机数生成器—>Math.randon()/System…)/Calendar类(日历)(重点)

 java.util.Date:特定的日期
      构造方法:
         public Date():系统时间的日期格式
      成员方法:
         public long getTime():获取指定Date对象的系统时间毫秒值
Date日期个--->String格式化
       public final String format(Date date)
   构造方法
   SimpleDateFormat(String pattern)        
   pattern模式:  
   	y:代表年               yyyy 代表整个年份 :2022
    M:代表月份             MM       11  07  06
    d:月份中的日           dd      03 11 01
    H:0-23(一天的小数数)    HH
    m:小时的分钟数          mm
    String日期文本---->Date 解析
  	public Date parse(String source)  throws ParseException :
如果String日期文本 和转换器SimpleDateFormat(String pattern) 里面的模式不匹配就会造成解析异常!
           String s = "2008-5-12"
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd ") ;//解析出问题了!

Random:伪随机数生成器
       public Random() 构造方法:创建新的随机数生成器
       public Random(long seed) 构造方法:创建新的随机数生成器(以指定的long 的类型计算随机数):每一次均分布局一样的 (不推荐)
      成员方法:
       public int nextInt():获取的int类型的取值范围
 	   public int nextInt(int n):[0,n)随机数

System类: 不能实例化
       三个成员变量 ---静态常量
           static PrintStream err“标准”错误输出流。
           static InputStream in“标准”输入流。   (InputStream:字节输入流 --读数据)
           static PrintStream out  “标准”输出流。(PrintStream字节打印流--->
           OutputStream字节输出流---写/打印)

成员方法
   	public static long currentTimeMillis():获取系统时间毫秒值(应用场景:计算程序的执行效率)
   	public static void exit(int status):参数为0,正常终止jvm
    public static void gc():手动开启垃圾回收器
     开启垃圾回收器,会调用Object类的finalize()垃圾回收方法
   	public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)  :复制数组
         参数1:原数组
         参数2:原数组中的某个位置
         参数3:目标数组
         参数4:目标数组中的某个位置
         参数5:从原数组的那个位置srcPos指定长度复制到目标数组中
 

支持可变的长度—“集合”(开发中使用最频繁的)

只能存储引用类型Collection<泛型>
集合的结构体系
集合的通用功能

Integer

jdk5 以后的新特性:自动拆装箱
	基本类型会自动装箱为引用类型:int-->Integer
	引用类型会拆箱为基本类型:Integer-->int
	public Integer(int value) :将int类型数据包装为Integer类型
	public Integer(String s)throws NumberFormatException :将字符串类型包装Integer类型,如果字符串非数字字符串,就会出现NumberFormatExceptio数字格式化异常

类型转换
       int---->String 静态方法Integer中  public static String toString(int i)
       String--->int  (使用居多)Integer中  public static int parseInt(String s)
                  前后端交互:前端提交的数据几乎String类型

Integer
控制台打印int类型的取值范围
    int--->Integer---->静态的常量
       public static final int MAX_VALUE
       public static final int MIN_VALUE

 	/* public static String toBinaryString(int i):将十进制--转换二进制的字符串形式
        public static String toHexString(int i)将十进制--转换十六进制的字符串形式
        public static String toOctalString(int i)将十进制--转换八进制的字符串形式*/

/ *   Integer 对象名 = 整数值; ---->执行底层Integer.valueOf(整数值)----> IntegerCache静态的成员内部类(内部缓存区)---->low(-128)/high(127)如果整数值在-128-127之间,直接从IntegerCache里面的cache[]里面取值如果超出范围内, new Integer(整数值); 重新创建Integer类对象,堆内存开辟空间
 *      public static Integer valueOf(int i) {  //整数值
 *         if (i >= IntegerCache.low && i <= IntegerCache.high)
 *             return IntegerCache.cache[i + (-IntegerCache.low)];
 *         return new Integer(i);
 *     }*/
public class IntegerTest {
    public static void main(String[] args) {
        Integer i1 = 127 ;
        Integer i2 = 127 ;
        System.out.println(i1==i2) ;//true
        System.out.println(i1.equals(i2)) ;//true

        Integer i3 = 127 ;// 在-128-127之间:IntegerCache内部缓存区取数据
        Integer i4 = new Integer(127) ; //堆内存开辟空间
        System.out.println(i3==i4) ; //false
        System.out.println(i3.equals(i4)) ;//true


        Integer i5 = 128 ;          //valueOf(128)--- return new Integer(128) ;
        Integer i6 = 128 ;          //return new Integer(128) ;
        System.out.println(i5==i6) ;//在-128-127之间:   128超了范围
                                    //false
        System.out.println(i5.equals(i6)) ; //true

        Integer i7 =  new Integer(128) ;
        Integer i8 =  new Integer(128) ;
        System.out.println(i7==i8) ;
        System.out.println(i7.equals(i8)) ;
    }
}

Character

构造方法
	Character(char value):包装一个char字符类型  char---->Character
成员方法
	public static boolean isDigit(char ch):判断是否为数字字符
	public static boolean isUpperCase(char ch):判断是否为大写字母字符
	public static boolean isLowerCase(char ch):判断是否为小写字母字符

面试题

 面试题:
       final,finalize,finally有什么区别?
           final:状态修饰符 表示最终的无法更改的
          修饰类,类不能被继承
          修饰符成员方法,方法不能被重写
          修饰变量,此时常量
       finalize是一个方法:Object类的方法---->主要垃圾回收器回收没有更多引用的对象,来释放内存空间
      finally:关键字:  捕获异常标准格式 :
      try{  //可能出现问题的代码
      }catch(异常类名 对象名){
             //处理异常
      }finally{
            //释放系统资源(Java底层语言都是c)
       	    //Io流(创建文件/流对象都需要关闭) /jdbc(连接对象,执行对象,查询对象都需要close)               }

Calender日历类/BigDecimal:小数精确计算

java.util.Calendar :日历类--->是一个抽象类,不能new
  	这个类里面的某些功能(静态功能)---一定完了这个类的子类的实例!
       创建日历实例--->public static Calendar getInstance()
 
   Calendar提供静态的字段(成员变量--->静态常量)
          public static final int DATE:月中的日期值
          public static final int MONTH:年中的月份值  (0-11),获取之后+1
          public static final int YEAR:年份值
 
  Calendar提供成员方法:
           public int get(int field):获取日历的字段值
                       参数就是需要通过Calendar访问的静态常量的那些字段
          public abstract void add(int field,int amount)    给日历字段设置偏移量,添加或者减去 amount值
          public final void set(int year,int month,int date) 设置日历字段

BigDecimal:作用针对小数进行精确计算
 构造方法
    BigDecimal(String value):参数 "小数字符串值"
    BigDecimal(int value):整数
    BigDecimal(double value):浮动类型
 
 
 成员方法:
    public BigDecimal add(BigDecimal augend):加
    public BigDecimal subtract(BigDecimal subtrahend)减
    public BigDecimal multiply(BigDecimal multiplicand)乘
    public BigDecimal divide(BigDecimal divisor):除
    public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
              参数1:除数值
              参数2:scale保留小数位数
              参数3:roundingMode舍入的模式  BigDecimal提供静态常量
 

Collection集合

Colleciton:没有jdk提供直接实现,通过具体的子接口List/Set的子实现类实现
  	创建集合的时候<E> :里面存储的引用类型的元素
    模拟数组,创建集合的时候就明确了集合中存储的数据类型,否则导致程序不安全!
 
  常用基本功能:
    添加
           boolean add(E e):添加元素 E--->Object任意Java元素
    删除
          删除集合中的元素boolean remove(Object o)
          暴力删除(将集合全部清空)void clear()
 
    判断
       boolean isEmpty():判断集合是否为空
       boolean contains(Object o):判断集合是否包含指定的元素
    遍历
       1)将集合转换对象数组
           Object[] toArray()  不推荐,还是变成数组!
 
        使用Collection存储自定义对象(学生对象--->针对学生类) 并进行遍历   (使用方式1---转换成数组)
       

List集合

 List集合的特点
 *      允许集合元素重复(实际应用,List集合如何去重?),而且有序集合(存储和取出一致)
 *
 *  List集合的特有功能:
 *              void add(int index, E element):在指定位置插入新的元素
 *              E get(int index):获取指定位置处的元素
 *              E set(int index,E element):在指定位置处替换(修改)指定的元素
 *             ListIterator<E> listIterator():List集合的专有遍历-->列表迭代器

JDK5新特性

Jdk5里面其他新特性:
      1)静态导入---->导入到方法的级别
          import static 包名.类名.方法名;
       前提使用静态导入,这个类的方法必须为静态
 
       在使用静态导入的时候,导入jdk提供的一些工具类里面静态方法的时候,我们定义的方法不能和它方法名冲突
       如果冲突了,静态导入是不识别,这个时候必须导入全限定名称 :包名.类名.方法名(xxx)
 
     2)可变参数,当一个方法形式参数不知道多少个,这个时候可以使用可变参数(类似一个数组)
          public  返回值类型 方法名(数据类型... 参数名)
          
//jdk提供@SuppressWarnings("all")  解决警告问题 (实际开发中,项目打包--安装-->部署--->上线)

迭代器Iterator

Iterator<E> iterator()
	Iterator接口提供了功能:Object next() :获取下一个可以遍历的元素
	boolean hasNext():判断如果迭代器里面有元素,则返回true,然后在获取!
 

使用Collection集合存储String类型,如果这个字符串是"world",那么添加一个新的字符串数据"javaEE"

 * 使用Collection集合存储String类型,如果这个字符串是"world",那么添加一个新的字符串数据"javaEE",
 *  然后遍历集合中的数据
 *
 *  分析:
 *          存储"hello","world","java"
 *          使用迭代器遍历集合
 *              获取元素---如果这个元素和"world"一致,给集合中添加"javaEE"
 *
 *
 *       按照上面的分析完成代码
 实现出现下面错误
 *              java.util.ConcurrentModificationException:并发修改异常
 *              并发:某个时间点
 *              并行:某个时间段
 *   出现并发修改异常的原因:
 *          当使用迭代器去遍历元素的时候,不能同时在使用集合操作元素;
 *   解决方案:
 *      1)使用迭代器遍历,迭代器添加,但是现在Collection的迭代器没有添加功能----->List集合的特有 列表迭代器ListIterator
 *      2)使用集合遍历,集合添加, Collection没有直接通过角标获取元素的功能---->List集合E get(int index)
          for(int x= 0 ;x < list集合对象.size();x++){
          String s = list集合对象.get(x) ;                                                           if("world").equals(s){
          list集合对象.add("javaee");
			 }
			}

public class CollectionTest2 {
    public static void main(String[] args) {
        //创建Collection
      //  Collection<String> c = new ArrayList<>() ;

        //使用List集合
        List<String> c = new ArrayList<>() ;
        ///添加数据
        c.add("hello") ;
        c.add("world") ;
        c.add("java") ;

        //获取迭代器
       // Iterator<String> it = c.iterator();
        //获取List列表迭代器
        //ListIterator<String> it = c.listIterator();  //List的迭代器遍历
        //遍历迭代器
       /* while(it.hasNext()){//迭代器的元素来自于集    合
            //获取
            String s = it.next() ;
            //加入判断
            if("world".equals(s)){//如果迭代器中的元素是world,使用集合给里面添加元素
                //给集合添加"javaEE"
                //c.add("javaEE") ;
                //列表迭代器里面就是add方法:插入元素  (在指定元素的后面插入)
                it.add("javaee");

            }
            System.out.println(s+"---"+s.length());
        }
        Iterator<String> it2 = c.iterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }*/


        //优化代码
        //解决方案2:集合遍历,集合添加List集合的普通for
        for(int x = 0 ; x < c.size() ; x++){
            //获取元素
            String s = c.get(x);
            if("world".equals(s)){
                c.add("javaEE") ;
            }
        }

        //遍历元素
        for(String s:c){
            System.out.println(s);
        }
    }
}

List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("javaEE");
 System.out.println("--------ListIterator迭代器-------");
        ListIterator<String> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            String s = listIterator.next();
            if ("hello".equals(s)){
                listIterator.add("Spring");
            }
        }
        for(String a:list){
            System.out.println(a);
        }

Vector集合

Vector集合:线程安全的类(底层结构:数组,查询快,增删慢)
  特有功能:
       public void addElement(E obj)将指定的元素添加Vector集合中(默认追加)
       public Enumeration<E> elements():获取枚举组件接口----->类似于Collection集合的Iterator iterator() Enumeration接口
 	  boolean hasMoreElements() 判断是否有更多的元素 ----->类似于Iterator里面的boolean hasNext()
       E  nextElement() :获取下一个元素              ----->类似于Iterator里面的E next()
 
       public E elementAt(int index):通过索引值获取元素   ---->类似List集合的E get(int index)
       int size():获取集合元素数
 

LinkedList集合

如果需求 大量 "写"的操作,采用LinkedList
大量"读"的操作,默认使用ArrayList,大量"读",考虑线程 使用Vector
线程不安全,不同步,执行效率高
      底层数据结构: 线程结构之链表,查询慢,增删快!
 
      特有功能:
           添加元素
           public void addFirst(E e) 将指定的元素添加到链表的开头
           public void addLast(E e) 将指定的元素添加到链表的末尾
           public E getFirst():获取第一个元素
           public E getLast():获取最后一个元素
           public E removeFirst():删除第一个并返回第一个元素
           public E removeLast():删除最后一个元素并返回

TreeSet集合的自然排序 实现Comparable接口

package com.stu.compartable;

import java.util.Objects;

/**
 * @author xiaolin
 * @version 2021.1
 * @date 2022/11/17 10:28
 */
public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
        Student student = (Student) o;
        return age == student.age && name.equals(student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    @Override
    public int compareTo(Student s) {
        int a = this.name.length()-s.name.length();
        int b= (a==0)?(this.name.compareTo(s.name)):a;
        int c =  (b==0)?(this.age-s.age):b;
        return c;
    }
}public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>();
        Student s1 = new Student("dianwei",35);
        Student s2 = new Student("dain",35);
        Student s3 = new Student("dian",35);
        Student s4 = new Student("zhang",36);
        Student s5 = new Student("zhangg",35);
        Student s6 = new Student("wa",45);
        Student s7 = new Student("zhangg",46);
        Student s8 = new Student("zhangg",20);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        ts.add(s8);
        for (Student s:ts){
            System.out.println(s.getName()+"--"+s.getAge());
        }
    }
}

public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>();
        Student s1 = new Student("dianwei",35);
        Student s2 = new Student("dain",35);
        Student s3 = new Student("dian",35);
        Student s4 = new Student("zhang",36);
        Student s5 = new Student("zhangg",35);
        Student s6 = new Student("wa",45);
        Student s7 = new Student("zhangg",46);
        Student s8 = new Student("zhangg",20);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        ts.add(s8);
        for (Student s:ts){
            System.out.println(s.getName()+"--"+s.getAge());
        }
    }
}

TreeSet集合的比较强排序–>Comparator接口匿名内部类

方式1:自定义一个类 实现Comparator接口---实现 public int compare(T t1,T t2){排序规则...}
	方式2:使用接口的匿名内部类
	TreeSet<自定义类型> ts = new TreeSet<>(new Comparator<自定义类型>(){
        public int compare(自定义类型 t1,自定义类型 t2){排序规则...}
        
	}) ;

public class CompartorTest {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int n1 = s1.getAge()-s2.getAge();
                int n2 = (n1==0)?(s1.getName().compareTo(s2.getName())):n1;
                return n2;
            }
        });
        Student s1 = new Student("dianwei",35);
        Student s2 = new Student("dain",35);
        Student s3 = new Student("dian",35);
        Student s4 = new Student("zhang",36);
        Student s5 = new Student("zhangg",35);
        Student s6 = new Student("wa",45);
        Student s7 = new Student("zhangg",46);
        Student s8 = new Student("zhangg",20);
         ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        ts.add(s8);
        for (Student s : ts) {
            System.out.println(s.getName()+"--"+s.getAge());
        }
    }
}

Map和Collection的区别 ?

面试题
        Collection<E>:单例集合,只能存储一种引用类型数据 遍历方式和Map不同;
         Collection集合的应用范围大:
                       ArrayList
                       Vector
                       LinkedList
         它里面的部分集合和Map有关联(HashSet--->依赖HashMap   / TreeSet---->依赖于TreeMap)
         Map<K,V>,双列集合---->可以存储键值对("夫妻对")
         遍历方式:通用方式 获取所有的键,通过键找值!
          应用范围:
               HashMap---->存储 和 获取 (默认使用)
               TreeMap---->存储---获取(按照排序规则排序)
               Map---->称为 "实体"
                       Map<Integer,Product>
 
   Map(针对键有效,键必须唯一!)的基本功能
       添加:
           V put(K key, V value):添加键值对元素,返回值什么意思?
        map针对键有效,键如果唯一的,返回是null;
        如果重复,将后面的键对应的值把前面的值覆盖了,返回第一次键对应的值
       删除:
           V remove(Object key):删除键,返回键对应的值
           void clear():暴力删除,将map清空掉
       判断:
           boolean containsKey(Object key):判断Map集合是否包含指定的键,包含返回true,否则false
           boolean containsValue(Object value):判断Map集合是否包含指定的值,包含则返回true,否则false
           boolean isEmpty() :判断集合是否为空

Map集合的遍历

遍历Map集合的方式
          1)获取所有的键的集合 Set<K> keySet()    (通用的遍历方式)    
             结合    V get(Object key):通过键找值
          2)Set<Map.Entry<K,V>> entrySet() :获取Map结合的键值对对象 
 
 	HashMap---->put方法---->依赖于hashCode()+equals()方法 能够保证键唯一!
    存储String,String类型重写了hashCode()+equals()方法,比较键的字符串内容是否相同!

java.util.Collections:针对集合操作工具类

常用的方法
       二分搜索法,在指定List集合中查询指定元素第一次出现索引值 (集合的元素有序)
 public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)
 public static <T> T max(Collection<? extends T> coll):针对Collection集合获取最大值(自然顺序比较获取最大值)
 public static <T> T min(Collection<? extends T> coll):针对Collection集合获取最小值(自然顺序比较获取最小值)
 public static void reverse(List<?> list):将List集合的元素反转
 public static void shuffle(List<?> list):针对List集合随机置换
  public static <T extends Comparable<? super T>> void sort(List<T> list):针对List集合按照自然顺序排序
  public static <T extends Comparable<? super T>> void sort(List<T> list,Comparator<T> com):
   针对List集合按照比较器进行排序

线程

 提供Thread类第一种创建线程的方式
 *      1)自定义一个类 继承的自Thread类
 *      2)重写Thread类的run方法---->完成一些的耗时的操作
 *      3)在main用户线程中,创建当前这个类对象
 *      4)开启线程---->不是run方法,run方法它只是一个普通方法(仅仅执行线程里面的内容:读文件/完成io的操作....)
 *      启动线程start()--->jvm是调用run线程的方法,结果是两个同时执行(具有随机性)
 *
 * 启动线程,想知道哪一个线程执行数据---Thread类提供一些基本功能:
 *      public final void setName(String name):设置线程的名称
 *      public final String getName():获取线程名称
 public static void yield():暂停当前正在执行的线程,执行其他线程
 public final void join() throws InterruptedException 等待该线程终止

线程优先级

 * public static final int MAX_PRIORITY 10  最大优先级
 * public static final int MIN_PRIORITY 1   最大优先级
 * public static final int NORM_PRIORITY 5  默认优先级
 * 优先级越大,线程抢占CPU执行权的几率越大!
 *
 * 给线程设置优先级
 *      public final void setPriority(int newPriority)
 * 获取线程的优先级
 *      public final int getPriority()