Java基础4

1.public int hashCode():获取对象的hash码值--->支持散列表(支持key-value键值对)
    hashCode()哈希算法:理解为地址值,不是真实地址值,每一个对象的hash码值不一样
2.String toString(): 返回值对象的字符表示形式,结果应该是一个更容易让人读懂的信息表达式(建议所有子类都覆盖这个方法)

1.2.==和equals()方法区别?

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

1.3.Object的克隆方法

protected Object clone() throws CloneNotSupportedException  创建对象并返回它的"副本"方法里面本身就会带有CloneNotSupportedException:克隆不支持的异常(当要对某个Object的类进行克隆 如果这个类不能实现cloneable接口,那么就会出现这个异常)
    //Object提供了一个clone方法 来完成复制一个副本
        Student s4 = new Student("文章",35,"男") ;
        System.out.println(s4);
        Object obj = s4.clone();//调用者必须处理本身带有异常的方法
        System.out.println(obj) ;

二.Scanner类提供的的一个判断功能

2.1常用方法

java.util.Scanner:文本扫描器
1.构造方法:public Scanner(InputStream source) 创建键盘录入对象  
2.创建一个文本扫描器
    Scanner 对象名 = new Scanner(System.in) ;
    --->System类---变量名
    public static final InputStream in
3.nextXXX():获取功能
    public int nextInt() :录入int类型
    public String nextLine() ;录入String类型
4.判断功能:
    public boolean hasNextInt():判断录入的下一个数据是否为int类型,是,返回true,否则false
        对象名.hasNextInt()
    public boolean hasNextLine():判断录入的下一个数据为一行内容
5.键盘录入的时候
    先录入int,在录入String ----nextLine() ,这块会出现被漏掉("回车符号")
    解决方案:
        1)在第一个录入int之后,重新创建一个新的键盘录入对象Scanner ,然后在使用nextLine()
        2)在录入String---- String next()

三.String类

3.1String类:

    String类:这个类final修饰不能被继承
    字符串是不变,它们的值在创建后不能被更改(字符串是一个常量,存储在常量池中)

3.2转换

    1)char[] toCharArray() 将字符串转换成字符数组
            String s = "helloworld";
            char[] chs = s.toCharArray;//{'h','e','l','l','o','w','o','r','l','d'}
            //Arrays:数组工具类---toString(任意类型数组)--转换成String
            String resultStr = Arrays.toString(chs);
            System.out.println(resultStr);//[h, e, l, l, o, w, o, r, l, d]
    2)byte[] getBytes() 平台默认字符集编码(String--->byte[])和byte[] getBytes(String charset):指定的字符集进行编码
            String s2 = "我爱中国" ;
            byte[] bytes = s2.getBytes(); //平台字符集 utf-8 (一个中文对应三个字节)
            System.out.println(Arrays.toString(bytes));
            输出 [-26, -120, -111, -25, -120, -79, -28, -72, -83, -27, -101, -67]
      String(byte[] bytes) :(bytes[]--->String  ) 平台默认字符集解码
      String(byte[] bytes,String charset) :(bytes[]--->String  ) 指定字符集解码
            String s3 = new String(bytes) ;
            System.out.println(s3) ;
            输出  我爱中国
    3)public String toLowerCase():将字符串转换成小写
      public String toUpperCase():将字符串转换成大写
            String s = "helloworld"
            System.out.println(s.toUpperCase);//将字符串转换成大写
            String s1 = "JAVA"
            System.out.println(s1.toLowerCase);//将字符串转换成小写
    4)万能方法:  可以将任何数据类型---->String
      public static String valueOf(int i/float....Object)

3.3获取

   String s = "Java";
    1)public char charAt(int index) :获取指定索引处的字符
        for(int x= 0;x<s.length();x++){
            char ch = s.charAt(x);
            Syetem.out.print(ch="\t");
        }
    2)int length():获取字符串的长度
        Syetem.out.print(s.length());
    3)public String concat(String str)拼接功能-- 将一个字符串拼接到指定字符串的后面(末尾追加)
        String s1 = "123";
        String s2 = "456";
        String s3 = s2.concat(s2);
        Syetem.out.print(s4);
        输出 123456
    4)public String substring(int beginIndex):截取--->从指定位置开始截取,默认截取到末尾结束!
      public String substring(int beginIndex, int endIndex) 截取--->从指定位置开始截取到指定位置结束包前不包后(包含第一个位置,不包含最后一个位置,只能取到endIndex-1处)
        String s4 = "helloworld" ;
        System.out.println(s4.substring(5));
        System.out.println(s4.substring(5,8));
    5)public String[] split(String regex):拆分(分割) ,按照指定的分割符将字符串拆分成字符串数组
        String str = "JavaEE-Python-Golang-R-C-Php";
        String[] strs = str.split("-");
    6)public int indexOf(int ch) :返回此字符第一次在字符串中出现的索引值
      public int lastIndexOf(int ch):返回此字符最后一次在字符串中出现的索引值
        System.out.println(s.indexOf('a'));
        System.out.println(s.lastIndexOf('a'));

3.4字典比较

comperTo

3.5判断/替换/去除两端空格

    1)boolean contains(String str):判断大串中是否包含指定子字符串
        String s = "helloworldjavaee"
        System.out.println(s.contains("owo"));//true
        System.out.println(s.contains("awm"));//false
    2)boolean endsWith(String suffix):判断是否以指定结尾的字符串
      public boolean startsWith(String prefix):判断是否指定的字符串开头
        System.out.println(s.endsWhith("ee"));//true
        System.out.println(s.startsWith("he"));//true
        System.out.println(s.startsWith("we"));//false
    3)boolean equals(Object anObject)。:比较两个字符串内容是否相同
      boolean equalsIgnoreCase(String anotherString) :不区分大小写比较两个字符串是否相同
        String s1 = "HelloWorldJavaEE";
        System.out.println(s.equals(s1));false
        System.out.println(s.equalIgnorCase(s1));ture    
    4)public boolean isEmpty():判断字符串是否空 ,长度为0,true
    5)public String replace(char oldChar,char newChar)  :替换功能
         System.out.println(s.replace(l,*));
    6)public String trim() :去除字符串两端空格 (一般io流中:  文件读写文件)
        String str = " hello           " ;
        System.out.println(str+"----");
        String str2 = str.trim();
        System.out.println(str2+"----");//去除空格

3.6常用方法

    1)public String():空字符串    类似于 String s = "" ;
    2)public String(String original):构造一个字符串对象,里面指定一个字符串常量值
    3)public String(byte[] bytes) :使用平台默认字符集(idea默认utf-8)解析解码--->字节数组--->字符串
    4)String(byte[] bytes, int offset, int length) :将一部分字节数组构造成字符串
    5)public String(char[] value):将字符数组---构造成String
    6)public String(char[] value,int offseet,int len):将一部分字符串数组构造成字符串

四.StringBuffer(字符串缓冲区)

4.1StringBuffer

StringBuffer:线程安全的类,支持可变字符序列

4.2StringBufffer的构造方法

    public StringBuffer() 
    空参构造,初始容量16个字符
    public StringBuffer(int capacity)
    指定容量大小的字符串字符串缓冲区(很少用)
    public StringBuffer(String str)
    将指定的字符串内容构造到字符串缓冲区中,容量=当前str的长度+16

4.3StringBuffer 一些反转/截取/获取字符串长度

1.获取:
    public char charAt(int index)返回char在指定索引的值
    int length() : 返回长度（字符数）。 
    int capacity() : 获取容量大小
2.删除:
    StringBuffer delete(int start, int end) 
    删除此序列的子字符串中的字符。  
    StringBuffer deleteCharAt(int index) 
    删除 char在这个序列中的指定位置。 
3.追加:
    StringBuffer append(String str) 
    将指定的字符串附加到此字符序列。  
4.插入:
    StringBuffer insert(int offset, String str) 
    将字符串插入到此字符序列中。 
5.替换:
    StringBuffer replace(int start, int end, String str) 
    用指定的String中的字符替换此序列的子字符串中的 String 。
6.反转:
    StringBuffer reverse() 
    使用该字符序列被序列的相反代替 
    
    //分步走
        //1)创建一个字符串缓冲区
        StringBuffer sb = new StringBuffer() ;
        //2)将s追加到缓冲区中
        sb.append(s) ;
        //3)将字符串字符缓冲区中的字符序列反转
        StringBuffer sb2 = sb.reverse();
        //4)将sb2缓冲区---转换成String
        String str = sb2.toString();
        //5)使用反转之的最终的字符串结果和s进行比较 equals
        return str.equals(s) ;

4.4String和StringBuffer的相互转换

1.String--->StringBuffer
    方式1:
        StringBuffer的有参构造
        String s = "hello" ;
        StringBuffer sb = new StringBuffer(s) ;
    方式2:
        StringBuffer的无参构造+append(String str)
        StringBuffer sb2 = new StringBuffer() ;
        sb2.append(s) ;
    
2.StringBuffer--->String
    方式1:
        StringBuffer的成员方法 public String toString()
        StringBuffer buffer = new StringBuffer("abc") ;
        String s = buffer.toString() ;  
    方式2:
        String的构造方法 String(StringBuffer sb)
        StringBuffer buffer2 = new StringBuffer("abc") ;
        String s2 = new String(buffer2) ;

4.5StringBuffer和StringBuilder和String 有什么区别

1.String:
    String是一个常量,支持不可变的字符序列,一旦被赋值其值不能被更改!
    String作为形式参数,特殊的引用类型,形式参数的改变不影响实际参数(和基本类型一致的)
2.StringBuffer
    支持可变的字符序列,字符串缓冲区(容器,可以存储任意类型的数据--字符序列),最终容器--返回String
    线程安全的类(几乎所有成员方法有个关键字 synchronized:同步锁)--->多线程环境下使用居多
    除了String之外的引用类型,作为形式参数,形参的改变直接影响实际参数!
3.StringBuilder 
    和StringBuffer具有兼容的API;线程不安全的类---->不同步--->执行效率高
    单线程环境下使用StringBuilder去替代StringBuffer

五.Java.util.Date:精确到毫秒的日期

5.1构造方法

public Date():系统时间的日期格式

5.2成员方法

1.public Date():系统时间的日期格式
2.long getTime() 
    返回自1970年1月1日以来，由此 Date对象表示的00:00:00 GMT的毫秒数。 
3.DateFormat是静态类,其子实现类为SimpleDateFormat类
    SimpleDateFormat(String pattern) pattern:时间格式,如"yyyy年-MM月-dd日-HH-mm-ss"
    
4.String format(Date date):传入对象,得到格式化字符串

5.public Date parse(String source) throws ParseException从给定字符串的开始   解析文本以生成日期。该方法可能不会使用给定字符串的整个文本。里面模式不一样会造成异常,如yyyy-MM与yyyy年MM月

6.public static long currenTimeMillis() : 获取当前系统时间值

5.3String日期文本和java.util.Date类型相互转换

1.String--->Date  解析(使用居多)
    String s = "2022-11-16" ;
    1)创建解析器
    SimpleDateFomart sdf = new SimpleDateFormat("yyyy-MM-dd") ;
    2)Date date = sdf.parse(s) ;
    
2.Date---->String 格式化
    1)创建当前日期对象
    Date date2 = new Date() ;
    2)创建解析器对象
    SimpleDateFormat sdf2 = new  SimpleDateFormat("yyyy-MM-dd") ;
    //3)格式化
    String dateStr =sdf2.format(sdf2) ;

六.Integer类

6.1构造方法

1.public Integer(int value) :将int类型数据包装为Integer类型
2.public Integer(String s)throws NumberFormatException :将字符串类型包装Integer类型,如果字符串非数字字符串,就会出现NumberFormatExceptio数字格式化异常

6.2int和String之间的相互转换

1.int转String
    1.空字符串拼接
    2.int --> Integer ---> String
    3.使用Integer的静态方法toString(int i)
2.String转int
    1.String---> Integer ---> public int intValue()
    2.直接转换parseInt

6.3自动拆箱/装箱

装箱:基本类型----自动提升为引用类型

拆箱:引用类型---降为基本类型

6.4Integer s = 10 和 Integer s = new Integer()的区别

执行底层的Integer.valueOf()---IntegerCache静态成员内部类(内部缓存区)---Low(-128)/high(127),超过范围，new Integer();重新创建Integer类对象，开辟内存空间

6.5Character

包装一个char字符类型

1.成员方法
    1.static boolean isDigit(char ch) 
    确定指定的字符是否是数字。 
    2.static boolean isLowerCase(char ch) 
    确定指定的字符是否是小写字符。 
    3.static boolean isUpperCase(char ch) 
    确定指定的字符是否为大写字符。

6.6将int类型数据赋值给Integer类型变量,它的内部缓存区IntegerCache完成了什么事情?

/*
    Integer i = 整数值;
    执行Integer类的valueOf(整数值)
     IntegerCahce: 静态成员内部类
    if(整数值>= IntegerCahce.low && 整数值<=IntegerCache.high){ 
                //如果在-128-127之间,从Integer类型数组中取数据 Integer[]
            return  IntegerCache.cache[整数- (-Integer.low)]
    }
    
    //如果不再范围内,直接开堆内存空间 创建实例!
    return new Integer(整数值)

*/

Integer i1 = 127 ;
Integer i2 = 127 ;
System.out.println(i1==i2) ; //true
Integer i3 = 128 ;
Integer i4 = 128 ;
System.out.println(i3==i4) ; //false

七.其他常用类

7.1System类(不能实例化)

1.static PrintStream err"标准"错误输出流。

2.static InputStream in"标准"输入流。(InputStream:字节输入流--读数据)

3.static PrintStream out“标准"输出流。(PrintStreamt--->OutputStream字节输出流---写/打印)

4.Sysout.out 返回字节打印流,是字节输出流的一种

7.1.1成员方法

1.public static Long currentTimeMillis(): 获取系统时间毫秒值(应用场景:计算程序的执行效率)

2.public static void exit(int status): 参数为0,正常终止jvm

3.public static void gc(): 手动开启垃圾回收器

4.static void arraycopy(object src, int srcPos，0bject dest, int destPos, int Length) : 复制数组
参数1:原数组
参数2:原数组中的某个位置
参数3:目标数组
参数4:目标数组中的某个位置
参数5:从原数组的那个位置srcPos指定长度复制到目标数组中

7.2.final,finally和finalize的区别?

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

7.3Random(生成随机数的流)

7.3.1构造方法

Random() 
创建一个新的随机数生成器。

7.3.2成员方法

1. public int nextInt()返回下一个伪随机数，从这个随机数生成器的序列中均匀分布int值。
2. public int nextInt(int bound)返回伪随机的，生成随机数,[0,n)

7.4Calendar日历类

7.4.1日历类

日历类:是一个抽象类,不能new

7.4.2创建日历实例

public static Calendar getInstance()

7.4.3 Calendar提供静态的字段(成员变量--->静态常量)

public static final int DATE:月中的日期值
public static final int MONTH:年中的月份值  (0-11),获取之后+1
public static final int YEAR:年份值

7.4.4Calendar提供成员方法:

 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) 设置日历字段

7.5BigDecimal小数精确计算

7.5.1构造方法

BigDecimal(String value):参数 "小数字符串值"
BigDecimal(int value):整数
BigDecimal(double value):浮动类型

7.5.2成员方法

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提供静态常量

八.如何实现数组和 List之间的转换？

    数组转List:使用Array.asList(array);
    List转数组: 使用List自带的toArray()方法
public void arraysToList(){
        /**
        * List转Array
        */
        List<String> arrayList = new ArrayList<>();
        arrayList.add("a");

        //使用toArray之后，转换的是Object数组
        Object[] objects = arrayList.toArray();
        System.out.println(Arrays.toString(objects));

        /**
        * Array转List
        */
        String[] str = {"a", "b", "c"};
        List<String> list = Arrays.asList(str);
        System.out.println(list.toString());
    }

九.集合和数组的区别

1)长度区别
    数组长度固定的
    集合长度是可变的
2)存储数据类型的区别
    数组:既可以存储基本类型,也可以存储引用类型数据,但是这些数据的类型必须一致
    集合:只能存储引用类型数据,如果集合不带泛型,那么本身就可以存储任意用类型数据
3)存储元素的区别
    数组:存储必须一种类型的元素 (单一类型)
    集合:存储任意引|用类型的元素 (多种类型)

十.Collection集合

Collection:没有jdk提供直接实现,通过具体的子接口List/Set的子实现类实现
           创建集合的时候<E> :里面存储的引用类型的元素
           模拟数组,创建集合的时候就明确了集合中存储的数据类型,否则导致程序不安全!

10.1常用的基本功能

添加
    boolean add(E e):添加元素 E--->Object任意Java元素
删除
    删除集合中的元素boolean remove(Object o)
    暴力删除(将集合全部清空)void clear()
判断
    boolean isEmpty():判断集合是否为空
    boolean contains(Object o):判断集合是否包含指定的元素

10.2遍历方式

1.Object[] toArray() //将集合转换成对象数组,里面的类型是Object类型
    Collection<String> c = new ArrayList<>() ;
    c.add("hello") ;
    c.add("world") ;
    c.add("java") ;
    Object[] objects = c.toArray() ; // Object[] objects = {"hello","world","java"} ;
    //里面的每一个具体对象 Object obj = new String(xx) ;
    for(int x = 0 l x < objects.length;x++){
        //想去数据字符串内容,同时输出字符串长度 length()
        //向下转型
        String s = (String)objects[x] ;
        System.out.println(s+"---"+s.length()) ;
    }
2.迭代器 Collection 的 Iterator iterator()
    Collection<String> c = new ArrayList<>() ;
    c.add("hello") ;
    c.add("world") ;
    c.add("java") ;
    //获取Collection的迭代器
    Iterator<String> it = c.iterator() ;
    while(it.hasNext()){
        String s = it.next() ;
        System.out.println(s+"---"+s.length()) ;
    }
    //3)增强for循环
    for(String s:c){
        System.out.println(s+"----"+s.length()) ;
    }

十一.JDK5的新特性

1.静态导入---->导入到方法的级别
    import static 包名.类名.方法名;
2.可变参数,当一个方法形式参数不知道多少个,这个时候可以使用可变参数(类似一个数组)
    public  返回值类型 方法名(数据类型... 参数名)

十二.List集合

12.1List集合特点

允许集合元素重复(实际应用,List集合如何去重?),而且有序集合(存储和取出一致)

12.2List集合的特有功能

void add(int index, E element):在指定位置插入新的元素
E get(int index):获取指定位置处的元素
E set(int index,E element):在指定位置处替换(修改)指定的元素
ListIterator<E> listIterator():List集合的专有遍历-->列表迭代器

12.3List集合遍历方式

1.Collection集合的toArray()
2.Collection集合的迭代器Iterator iterator()
3.List集合的特有迭代器ListIterator listIterator()
4.List集合的E get(int index) 和int size()结合的普通for
5.增强for循环格式

public class ListTest {
    public static void main(String[] args) {
        ArrayList<String> c = new ArrayList<>();
        
        c.add("hello");
        c.add("world");
        c.add("java");
        
        //1.List集合继承Collection-->Object[] toArray
        Object[] objects = c.toArray();
        for (int i = 0; i < objects.length; i++) {
            String s = (String) objects[i];
            System.out.println(s+"----"+s.length());
        }
        System.out.println("-----------------------------------------");
        
        //2.Collection的迭代器Iterator iterator()
        Iterator<String> it = c.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s+"----"+s.length());
        }
        System.out.println("-----------------------------------------");
        
        //3.增强for作用:替代迭代器,简化代码书写
        //  格式  for(存储的数据类型 变量名: 集合对象或者数组对象 ){
        //              使用这个变量;
        //          }
        for (String s : c) {
            System.out.println(s+"-------"+s.length());
        }
        System.out.println("------------------------------------------");
        
        //4.ListIterator<E> listIterator():List集合的专有遍历-->列表迭代器
        ListIterator<String> lit = c.listIterator();
        while (lit.hasNext()){
            String s = lit.next();
            System.out.println(s+"-------"+s.length());
        }
        System.out.println("-------------------------------------------");
        
        //5.List集合的get(int index) +size() 的普通for循环
        for (int i = 0; i < c.size(); i++) {
            String s = c.get(i);
            if ("world".equals(s)){
                c.add("javaee");
            }
            System.out.println(s+"----"+s.length());
        }
        System.out.println("-----------------------------------------");
    }
}

12.4获取类字节码文件格式

三种方式
    1)Object类的getClass()--->使用任意Java对象调用 Student s = new Student() ;
        Class clazz1 = s.getClass()
        //class 包名.类名
    2)任意Java类型的class属性 定义了学生Student
        Class clazz2 = Student.class;
    3)Class类提供静态方法forName("全限定名称") ; 
    反射中用---->使用居多,参数是String字符串,可以在配置文件中进行配置!
        全限定名称:包名.类名

12.5List去重

12.5.1使用List集合存储重复String类型的数据,保证集合的元素唯一!(去重)

1.创建一个集合
2.添加重复的String
3.新建一个集合
4.遍历以前的集合
    一一获取以前集合中所有元素
    使用新集合判断里面如果不包含这个元素,不重复,添加到新集合中
5.遍历新集合

12.5.2去重自定义对象List<Student>,保证存储学生对象的唯一

去重思想:
    List存储自定义类型,
    而使用新建集合思想去重,contains()底层依赖于Obejct的equals
    而Object的equals方法默认比较 是== ,两个对象地址值是否一样
    存储自定义类型保证元素唯一,自定义类型重写equals方法()/hashCode(),成员信息是否一样,如果一样,还要比    较成员的哈希码值是否一样.都相同,就是同一个人

过程:
    1.创建一个集合
    2.添加重复的String
    3.新建一个集合
    4.遍历以前的集合
        一一获取以前集合中所有元素
        使用新集合判断里面如果不包含这个元素,不重复,添加到新集合中
    5.遍历新集合
    
    
选择排序去重关键代码
        for(int x = 0 ; x < list.size()-1 ;x++){
            for(int y = x+1; y<list.size() ; y++){
                //逻辑
                //使用0角标对应的元素依次和后面元素比较,如果后面元素和前面的元素重复,将后面的元素干掉,(集合中remove(元素))
                if(list.get(x).equals(list.get(y))){
                    //将后面的元素干掉
                    list.remove(y) ;
                    y-- ;
                }
            }
        }

十三.Vector和LinkedList的特有功能

13.1Vector

Vector集合:线程安全的类(底层结构:数组,查询快,增删慢)

13.1.1特有功能:

1.public void addElement(E obj)将指定的元素添加Vector集合中(默认追加)
2.int size():获取集合元素数

13.1.2遍历

1.public E elementAt(int index):通过索引值获取元素   ---->类似List集合的E get(int index)
//特有遍历方式1
        for(int x = 0 ; x < v.size() ;x++){
            String s = v.elementAt(x);
            System.out.println(s);
        }
2.public Enumeration<E> elements():获取枚举组件接口----->类似于Collection集合的Iterator iterator()
    Enumeration接口
         boolean hasMoreElements() 判断是否有更多的元素 ----->类似于Iterator里面的boolean hasNext()
         E  nextElement() :获取下一个元素             ----->类似于Iterator里面的E next()
//特有遍历方式2
      Enumeration<String> en = v.elements();
           while(en.hasMoreElements()){
               String s = en.nextElement();
               System.out.println(s);
           }

13.2LinkedList

LinkedList:线程不安全的类,不同步,执行效率高.
           底层数据结构: 线程结构之链表,查询慢,增删快!

13.2.1特有功能

添加元素:
    public void addFirst(E e) 将指定的元素添加到链表的开头
    public void addLast(E e) 将指定的元素添加到链表的末尾
    public E getFirst():获取第一个元素
    public E getLast():获取最后一个元素
    public E removeFirst():删除第一个并返回第一个元素
    public E removeLast():删除最后一个元素并返回

13.3List三个字实现类的特点

ArrayList:
    底层数据结构是数组,查询快,增删慢
    线程不安全,不同步----执行效率高
    扩容机制是1.5倍
Vector
    底层数据结构是数组,查询快,增删慢
    线程安全,同步--->执行效率低(多线程环境下使用)
LinkedList
    底层数据结构是链表,查询慢,增删快
    线程不安全,不同步--->执行效率高
    应用场景:添加操作---每次将数据添加集合的前面/删除末尾元素

十四.Set集合:唯一/无序(不能保证迭代顺序)

Set集合:元素唯一的默认情况使用HashSet进行实例(创建对象)

14.1HashSet

    HashSet的底层依赖于HashMap(哈希表结构),元素唯一,迭代顺序无法保证的!
    HashSet集合保证元素唯一---底层依赖HashMap的put方法---->依赖于hashCode()/equals(),而现在存储String类型,重写了equals和hashCode(),保证元素唯一!

14.2TreeSet

    TreeSet集合是Set集合的的实现类,它应该满足保证元素唯一
    底层基于TreeMap<K,V>,它是一个红黑树(red-black-tree)有自然排序/比较器排序
构造方法:
    public TreeSet():创建一个空的树,元素是按照自然排序顺序,里面的元素必须要实现Comparable接口 
    要实现自然排序,那么使用TreeSet的无参构造方法,而且存的类型一定要实现Comparable接口,重写compareTo(T t)方法,完成比较

14.2.1Tree集合自定义类型如何实现自然排序和比较器排序

自然排序
    Treeset<自定仪类型>，如果要实现自然排序，使用TreeSet的无参构造方法 public TreeSet<E>()自定义类型必须实现一个接口:Comparable<T>--->实现public int compareTo(T t){排序规则...)
    
比较器排序
    Treeset<E>(Comparator<T>com) :有参构造方法
    方式1:自定义一个类实现comparator接口---实现 public int compare(T t1,T t2){排序规则...})
    方式2:使用接口的匿名内部类
        Treeset<自定义类型>ts = new Treeset<>(new Comparator<自定义类型>(){
            public int compare(自定义类型t1,自定义类型t2){排序规则...}
        });

14.3描述String的compareTo(String Str)字典顺序比较的逻辑

string字符串里面的compareTo ( String str)逻辑
    "hello"
    "abc"
    "hell"
这个方法:将字符串---->字符数组---->获取两个字符串长度的最小值(临界点)int k = 0 ;
    while( k<长度最小值){
        不断两个字符数组每一个字符
        如果第一个字符值不同,直接方法结束:返回两个字符相减(ASCII码表的值)
        k++
        如果循环结束之前,如果者两个字符串的都相同,返回字符串长度相减
}

十五.Map集合

15.1Map和Collection的区别?

Collection<E>:单例集合,只能存储一种引用类型数据 遍历方式和Map不同;
Collection集合的应用范围大:
       ArrayList
       Vector
       LinkedList
它里面的部分集合和Map有关联(HashSet--->依赖HashMap/TreeSet---->依赖于TreeMap)
Map<K,V>,双列集合---->可以存储键值对("夫妻对")
       遍历方式:通用方式 获取所有的键,通过键找值!
       应用范围:
           HashMap---->存储 和 获取 (默认使用)
           TreeMap---->存储---获取(按照排序规则排序)
           Map---->称为 "实体"
           Map<Integer,Product>

15.2Map的基本功能

添加:
    v put(K key,V value):添加键值对元素，
        map针对键有效,键如果唯一的,返回是null;
        如果重复,将后面的键对应的值把前面的值覆盖了,返回第一次键对应的值
删除:
    v remove(0bject key):删除键，返回键对应的值
    void clear():暴力删除，将map清空掉
判断:
    boolean containsKey(object key):判断Map集合是否包含指定的键，包含返回true，否则false
    boolean containsValue(Object value):判断Map集合是否包含指定的值，包含则返回true，否则false
    boolean isEmpty() :判断集合是否为空

15.3Map集合遍历方式

//创建Map集合
HashMap<Student,String> map = new HashMap<>();

方式一:获取所有键的集合  Set<K> KeySet()
    结合 v get(Object key):通过键找值
    
    Set<String> keySet = map.keySet();
    for(String key:keySet){
        //通过键获取值
        String value = map.get(key);
        System.out.println(key+"--"+value);
    }
    
方式二:Set<Map.Entry<K,V>> entrySet():获取Map结合的键值对对象
    
    Set<Map.Entry<String,string>> entry = map.entrySet() ;
    //遍历所有映射项(一个键->一个值)
    for(Map.Entry<String,String> en:entry){
        //K getKey():通过键值对对象，获取键
        // K getKey():通过键值对获取值
        string key = en.getkey();
        string value = en.getValue();
        system.out.println(key+" --- "+value) ;
    }

15.4HashMap

HashMap<K,V> 存储键值对元素,保证K唯一,根据的类型有关系
  如果K是自定义类型,
  HashMap<Student,String> ,考虑保证学生对象唯一!
       Key:Student类型
       Value:String类型
 
       要针对键有效,需要键的类型,需要重写equals()和hashCode()
       equals():比较内容是否相同, hashCode():比较每一个成员信息的哈希码值是否一样

十六.Collections:针对集合的操作工具类

常用的方法:
   二分搜索法,在指定List集合中查询指定元素第一次出现索引值 (集合的元素有序)
   
    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集合按照比较器进行排序

十七.线程和进程的概念

线程依赖于进程存在

17.1进程

进程:能够调用系统资源的独立单位

多进程:计算机都是支持多进程,提高CPU的使用率

开启多个进程的时候,玩游戏的同时可以听音乐,他们并不是同时进行的,而是一点时间片在两个进程之间进行高效切换!

17.2线程

线程:能够执行的最小单元!
    360软件---->开启---->开启进程
    同时清理内存---同时查杀病毒
多线程:多线程在互相抢占CPU执行权,线程的执行具有随机性!
JVM:是一个多线程,至少两条线程
    main--->用户线程
    gc----->垃圾回收器 开启垃圾回收线程.

17.3Java创建多线程

两种方式:
    1.继承关系  Java提供的Thread类
    2.实现关系  Runnable接口(方式2:使用Java设计模式之静态代理---设计模式之结构型设计模式的一种
                代理类和被代理类都需要实现同一个接口)

17.4面试题:

17.4.1.线程的有几种状态?

线程的生命周期
就是线程从新建-->就绪-->执行-->死亡(终止)

17.4.2.Java能够直接创建多线程吗?

    创建线程---->需要创建进程---->需要使用系统资源创建进程
    Java是不能够直接操作系统资源的，底层语凯C是可以操作系统的.
    Jdk提供了Thread类，里面有个start()---->执行线程---底层非Java语言实现的

17.5实现多线程方式

方式一:
    提供Thread类第一种创建线程的方式
        1)自定义一个类继承的自Thread类
        2)重写Thread类的run方法---->完成一些的耗时的操作
        3)在main用户线程中，创建当前这个类对象
        4)开启线程---->不是run,它只是普通方法,
        启动线程start()--->jvm是调用run线程的方法,结果是两个同时执行(具有随机性)

17.6启动线程的功能

    public final void setName(String name):设置线程的名称
    public final String getName():获取线程名称
    public static void yield():暂停当前正在执行的线程,执行其他线程
    public final void join() throws InterruptedException 等待该线程终止
        线程1,线程2,线程3,线程2在线程1的后面执行,线程3在线程2的后面执行---使用join()方法
线程的优先级:
    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()