第四周总结

周总结

1.常用类之Object (重点)

int hashcode():哈希码值(理解为"地址值",并非实际地址值) 了解
String toString():重点
	String toString():返回对象的字符串表示形式,结果应该是一个更容易让人读懂的信息表达式(建议
	所有的子类都覆盖这个方法   几乎Java所有类都会重写toString()方法
boolean equals(Object obj):比较两个数据(引用类型) 是否相等
	Object的equals方法,默认比较的是两个引用类型的地址值是否相等,建议子类需要
	重写这个equals(),重写之后比较的是两个对象的成员信息是否相同!(Java中所有类
	都会重写!) ,重写equals方法,必须同时重写hashCode()方法;重写equals:比较每一个
	对象的成员信息是否相同 如果一样,还要比较每一个成员信息 hashCode()哈希码值
	是否一样,如果都相同,系统认为这个两个人是一样的!
clone():克隆
	protected Object clone() throws CloneNotSupportedException  创建对象并返回它
	的"副本"方法里面本身就会带有CloneNotSupportedException:克隆不支持的异常(当要对
    某个Object的类进行克隆如果这个类不能实现cloneable接口,那么就会出现这个异常)

2.Scanner类提供一个判断功能

构造方法:
 *      public Scanner(InputStream source) 创建键盘录入对象
 *
 *      创建一个文本扫描器
 *              Scanner 对象名 = new Scanner(System.in) ;
 *              --->System类---变量名
 *              public static final InputStream in
 * 成员方法:
 *
 * 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()

3.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属性  数组对象.length
 *              字符串有length(),
 *              集合没有,获取集合中 元素数 size()
 * 面试题:
 *	 String s = new String("hello") ;
 * 		和String s = "hello" ; 有什么区别?分别创建了几个对象?
 *
 * 	   区别
 * 	        前者:在堆内存中开辟空间,然后字符串值常量---指向常量池, 两个对象
 * 	        后者:推荐的方式,直接常量赋值,直接在常量池中找,有就返回地址,没有,开辟常量空间!	
* String类相关的获取功能
 *      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)
 *
 *      编码和解码必须一致,否则乱码!
String的判断/替换/去除两端空格 (了解)相关功能
 *      判断功能:
 *              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

## StringBuffer和StringBuilder的区别?

 * StringBuffer:线程安全的类,支持可变字符序列!
 * 线程-->依赖于进程,线程执行的最小单元!  (这周多线程讲)
 * 线程安全----->意味着 "同步"---->执行效率低
 *举例: 银行类的网站/医院平台
 * 线程不安全----> "不同步"---->执行效率高
 * 举例:
 *      论坛网站
 *
 * 构造方法:
 *      public StringBuffer()  --->空参构造,初始容量16个字符
 *      public StringBuffer(int capacity)--->指定容量大小的字符串字符串缓冲区(很少用)
 *      public StringBuffer(String str)--->将指定的字符串内容构造到字符串缓冲区中,容量=当前str的长度+16
 *
 *     int length()获取字符串缓冲区长度
 *     int capacity()  :获取容量大小
 * * StringBuffer的追加和插入
 *       public StringBuffer append(任意Java类型):将指定的类型追加字符串缓冲区的序列中,返回自己本身
 *       public StringBuffer insert(int index,String str/可以任意Java类型) 在指定位置处插入指定的数据,返回字符串缓冲区本身
 *
 *

## * StringBuufer的获取功能

 *          public char charAt(int index):获取字符串缓冲区中指定位置的字符,返回指定的字符
 * StringBuffer的删除
 *          StringBuffer delete(int start, int end)  :删除从指定位置开始到指定位置结束(end-1)的字符,返回字符串缓冲区本身
 *          StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回值字符串缓冲区本身
 *StringBuffer的替换功能:
 *          public StringBuffer replace(int start,int end,String str)
 *                      将字符串缓冲区中的从指定位置开始到指定位置结束(end-1)的字符序列使用指定的字符串进行替换
 *
 *StringBuffer的截取功能:
 *            public String substring(int beginIndex)
 *            public String substring(int beginIndex,int endIndex)
 * *  String---->StringBuffer
 *  StringBuffer---->String
 */
public class StringBufferDemo4 {
    public static void main(String[] args) {

        //String---->StringBuffer
        String s = "hello" ;
       /* String s = "hello" ;
        StringBuffer sb = s ;*/ //两个类型不匹配
        //方式1 :使用StringBuffer(String str)有参构造
        StringBuffer sb = new StringBuffer(s) ;
        System.out.println("sb:"+sb) ;

        System.out.println("-----------------------------------") ;
        //方式2:使用StringBuffer()空参构造,结合append(String str)追加
        StringBuffer sb2 = new StringBuffer() ;
        sb2.append(s) ;
        System.out.println("sb2:"+sb2);


        System.out.println("----------------------------------------------------");

        //StringBuffer---->String
        StringBuffer buffer = new StringBuffer("helloJavaEE") ;
        //方式1:StringBuffer--->public String toString()
        String str = buffer.toString();
        System.out.println(str) ;
        System.out.println("----------------------------------------------------") ;
        //方式2:String类----->构造方法public String(StringBuffer buffer)
        String str2 = new String(buffer) ;
        System.out.println(str2);


    }
}

## String和StringBuffer/StringBuilder的区别?

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

4.java.util.Date:精确到毫秒的日期 (重点)

String日期文本<--->java.util.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 ") ;//解析出问题了!
 *
ublic class DateDemo2 {
    public static void main(String[] args) throws ParseException {
        //将Date---->String 格式化
        //创建一个Date对象,当前系统日期对象
        Date date = new Date() ;
        //SimpleDateFormat(String pattern)   :转换器
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
        //public final String format(Date date)
        String dateStr = sdf.format(date);
        System.out.println(dateStr);
        System.out.println("---------------------------------------------------") ;
        //给定一个日期文本 String---->Date (重点)
        String str = "2020-12-31" ;
        //中间桥梁
//        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日") ;//模式不匹配
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd") ;
        //public Date parse(String source)  throws ParseException :
        Date date2 = sdf2.parse(str);
        System.out.println(date2);

    }
}

5.Integer/Character

基本类型四类八种---->八种引用类型 

Integer i = new Integer(100) ;
i += 100 ;

i?



jdk5以后的新特性:自动拆装箱  --->装箱:基本类型---自动提示引用类型
							 拆箱:引用类型----降为 基本类型
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("小数字符串")
 * Integer的构造方法:
 * public Integer(int value) :将int类型数据包装为Integer类型
 * public Integer(String s)throws NumberFormatException :将字符串类型包装Integer类型,如果字符串非数字字符串,
 * 就会出现NumberFormatExceptio数字格式化异常
 *
 * jdk5以后的新特性:自动拆装箱      /静态导入(导入到方法的级别,前提方法必须为静态)/增强for循环/可变参数...
 *      基本类型会自动装箱为 引用类型:    int-->Integer
 *      引用类型会拆箱为 基本类型  :     Integer-->int
 */
public class IntegerDemo2 {
    public static void main(String[] args) {
        //创建一个Integer类对象
        //public Integer(int value) :将int类型数据包装为Integer类型
        Integer i = new Integer(100) ;  //将int----Integer类型
        i += 200 ;                            //将Integer--->int--->在和200相加---->int--->Integer
        System.out.println(i) ;

        /*
        * 利用反编译工具类:将上面的字节码文件---反编译
        * 	Integer i = new Integer(100);//100 装箱 Integer
        *                                               //public int intValue():Integer--->int 拆箱
		    i = Integer.valueOf(i.intValue() + 200);  // --->(i.intValue()+200)--->300赋值给i
		    *                                       //将一个整数赋值给Integer--->底层执行的Integer.valueOf(300)
		    System.out.println(i);               //输出结果
        * */

        System.out.println("------------------------------------------------") ;
        //public Integer(String s)throws NumberFormatException :
        //String s = "hello" ; //字符串必须为数字字符串
        String s = "10" ;
        Integer ii = new Integer(s) ;
        System.out.println(ii);


        //Integer i = 100 ;
       // Integer i = new Integer(100) ;


    }
}

 * 类型转换
 *
 *      int---->String 静态方法public static String toString(int i)
 *      String--->int  (使用居多)  public static int parseInt(String s)
 *                  前后端交互:前端提交的数据几乎String类型
 */
public class IntegerDemo3 {
    public static void main(String[] args) {


        //int--->String
        int i = 100 ;
        String result = "" ;
        //方式1:字符串拼接符号+
        result += i;
        System.out.println(result) ;
        System.out.println("---------------------------------");
        //方式2:int--->Integer---->String
        //Integer(int i) ---->publict String toString()
        Integer ig = new Integer(i) ;
        String result2 = ig.toString();
        System.out.println(result2); //"100"
        System.out.println("---------------------------------");
        //方式3:Integer的静态方法public static String toString(int i)
        String result3 = Integer.toString(i);
        System.out.println(result3);

        System.out.println("--------------------------------------") ;
       // String---->int
        String s = "20" ; //数字字符串
       //方式1:String--->Integer --->public int intValue()
        Integer ig2 = new Integer(s) ;
        int value = ig2.intValue();
        System.out.println(value); //20
        System.out.println("-----------------------------------------") ;
        //方式2:直接转换public static int parseInt(String s) throws NumberFormatException
        int value2 = Integer.parseInt(s);
        System.out.println(value2); //20


        //parseXXX方法在任意的基本类型对应的类型都存在(万能方法)
        //String--Long-->long---->Long.parseLong(字符串)
        //String--Float-->float--->Float.parseFloat(小数字符串)

    }
}

6.System/Random/Math/BigDecimal小数精确计算

**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指定长度复制到目标数组中
**Random:伪随机数生成器**
 *      public Random() 构造方法:创建新的随机数生成器
 *      public Random(long seed) 构造方法:创建新的随机数生成器(以指定的long 的类型计算随机数):每一		次均分布局一样的 (不推荐)
 *      成员方法
 *          public int nextInt():获取的int类型的取值范围
 *          public int nextInt(int n):[0,n)随机数
 */
public class RandomDemo {
    public static void main(String[] args) {
        //使用Random类产生随机数
        Random random = new Random() ;
        //10个随机数
        for(int x = 0 ; x < 10 ; x++){
           // int n = random.nextInt();
            int n = random.nextInt(100);
            System.out.println(n);
        }
    }
}

 *  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提供静态常量
 *
 */
public class BigDecimalDemo {
    public static void main(String[] args) {

        //创建BigDecimal(String value):参数 "小数字符串值"
        BigDecimal bigDecimal = new BigDecimal("1.05") ;
        BigDecimal bigDecimal2 = new BigDecimal("0.5") ;
        /**
         * public BigDecimal add(BigDecimal augend):加
         *  public BigDecimal subtract(BigDecimal subtrahend)减
         *   public BigDecimal multiply(BigDecimal multiplicand)乘
         *  public BigDecimal divide(BigDecimal divisor):除
         */
        System.out.println(bigDecimal.add(bigDecimal2));
        System.out.println(bigDecimal.subtract(bigDecimal2));
        System.out.println(bigDecimal.multiply(bigDecimal2));
        System.out.println(bigDecimal.divide(bigDecimal2));
        /**
         * public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
         *              参数1:除数值
         *               参数2:scale保留小数位数
         *                参数3:roundingMode舍入的模式  BigDecimal提供静态常量
         */
        System.out.println(bigDecimal.divide(bigDecimal2,2,BigDecimal.ROUND_HALF_UP)); //支持四舍五入
    }
}

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

只能存储引用类型 Collection<泛型>				---> Map<K,V> 支持散列表

集合的结构体系
集合的通用功能

8.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):判断集合是否包含指定的元素
 *
 */
public class CollectionDemo {
    public static void main(String[] args) {
        //创建一个Collection,没有带泛型
       // Collection  c = new ArrayList() ;
        //创建的集合,带上<泛型>
        Collection<String> c = new ArrayList<>() ; //new 集合<默认和前面的泛型类型一致,可以不写> () ;  jdk7新特性 泛型推断
        System.out.println(c);
        // boolean add(E e):添加元素 E--->Object任意Java元素
       // boolean flag1 = c.add("hello") ;

       // boolean flag2 = c.add(100) ;
       // boolean flag3 = c.add('A') ;
        /**
         *   public boolean add(E e) {
         *        ///...中间的逻辑在数据扩容
         *         return true;
         *     }
         */
       // System.out.println(flag1+"---"+flag2+"---"+flag3);
        c.add("hello") ;
        c.add("world") ;
        c.add("javaee") ;
        //c.add(100) ;

        System.out.println("--------------------------------") ;
//        删除集合中的元素boolean remove(Object o)
//            暴力删除(将集合全部清空)void clear()
        //System.out.println(c.remove("javaee"));
//        c.clear();
        //boolean isEmpty():判断集合是否为空
        // boolean contains(Object o):判断集合是否包含指定的元素
       // System.out.println(c.isEmpty()) ;
        System.out.println(c.contains("高圆圆"));
        System.out.println(c.contains("world"));
        System.out.println(c);

    }
}

 * 遍历
 *      1)将集合转换对象数组
 *              Object[] toArray()  不推荐,还是变成数组!
 *
 *
 */
//jdk提供@SuppressWarnings("all")  解决警告问题 (实际开发中,项目打包--安装-->部署--->上线)
//@SuppressWarnings("all") //压制警告
public class CollectionDemo2 {
    public static void main(String[] args) {
        //创建一个集合--->存储String
        Collection<String>  c  = new ArrayList<>() ;
        //添加字符串数据
        c.add("hello") ;
        c.add("world") ;
        c.add("javaEE") ;
        c.add("Mysql") ;
        System.out.println(c);

        //转换成数组Object[] toArray()
        Object[] objects = c.toArray();
        for(int x = 0 ; x < objects.length ;x++){
            //objects[x]数组中---    相当于每一个元素 Object 对象名 = new String();//多态 向上转型
           // System.out.println(objects[x]);
            //遍历这些字符串并且同时它的长度
           // System.out.println(objects[x]+"---"+objects[x].length()); //Object类型没有length()
            //向下转型
            String s = (String) objects[x];
            System.out.println(s+"---"+s.length());


        }

    }
}

 * Collection的专有遍历方式:迭代器
 * Iterator<E> iterator()
 *          Iterator接口提供了功能:Object next() :获取下一个可以遍历的元素
 *          boolean hasNext():判断如果迭代器里面有元素,则返回true,然后在获取!
 *
 *          需求:使用Collection存储String类型,并去使用迭代器将元素一一遍历,打印控制台
 *
 *  1)使用Collection集合存储5个学生,使用迭代器的这种方式进行遍历!
 *  2)使用Collection集合存储String类型,如果这个字符串是"world",那么添加一个新的字符串数据"javaEE",
 *  然后遍历集合中的数据
 */
public class CollectionDemo {
    public static void main(String[] args)  {
        //创建一个集合对象
        Collection<String> c = new ArrayList<>() ;

        //存储String类型的元素
        c.add("hello") ;
        c.add("world") ;
        c.add("java") ;
        c.add("javaee") ;

        //Iterator<E> iterator() 获取迭代器
        Iterator<String> it = c.iterator();

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

        /*
        if(it.hasNext()){
            //第一次获取
            String next = it.next();
            System.out.println(next);
        }

        //第二次获取
        if(it.hasNext()){
            System.out.println(it.next());
        }

        //第三次获取
        if(it.hasNext()){
            System.out.println(it.next());
        }
        //第四次获取
        if(it.hasNext()){
            System.out.println(it.next());
        }
//        System.out.println(it.next());
        //java.util.NoSuchElementException 没有元素的异常
        //第五次获取
        if(it.hasNext()){
            System.out.println(it.next());
        }

         */
        //迭代器标准代码
        while(it.hasNext()){
            //有下一个元素
            //再获取
            String  s = it.next() ;
            System.out.println(s+"---"+s.length());
        }

    }
}

9.List和Set的区别

 * List集合的特点
 *      允许集合元素重复(实际应用,List集合如何去重?),而且有序集合(存储和取出一致)
 *
 *  List集合的特有功能:
 *              void add(int index, E element):在指定位置插入新的元素
 *              E get(int index):获取指定位置处的元素
 *              E set(int index,E element):在指定位置处替换(修改)指定的元素
 *             ListIterator<E> listIterator():List集合的专有遍历-->列表迭代器
 *
 */
public class ListDemo {
    public static void main(String[] args) {
        //创建List集合对象--存储String
        List<String> list = new ArrayList<>() ;

        list.add("hello") ;
        list.add("world") ;
        list.add("hello") ;
        list.add("hello") ;
        list.add("javaee") ;
        list.add("javaee") ;
        System.out.println(list) ;
        // void add(int index, E element):在指定位置前面插入新的元素
        list.add(2,"高圆圆") ;
        System.out.println(list);
        System.out.println("-------------------------------------------------") ;
        // E get(int index):获取指定位置处的元素
        System.out.println(list.get(4));
        System.out.println("-----------------------------------------------------");
        // E set(int index,E element):在指定位置处替换(修改)指定的元素
        System.out.println(list.set(1,"mysql"));
        System.out.println(list);

        System.out.println("---------------------------------------------------");
        // ListIterator<E> listIterator():List集合的专有遍历-->列表迭代器
        //ListIterator--->正向列表遍历 :boolean  hasNext()  + E next():获取下一个元素
        //                  反向遍历列表 booean hasPrevious()+E pervious:获取上一个元素 (必须有正向遍历列表)

        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()){
            //获取
            String s = lit.next() ;
            System.out.println(s+"---"+s.length());
        }
        System.out.println("------------------------------------------");
    /*    while(lit.hasPrevious()){
            //获取
            String s = lit.previous() ;
            System.out.println(s+"---"+s.length());
        }*/


        //将上面List集合中所有元素遍历
        //方式1:List集合继承Collection---->Object[] toArray()
        Object[] objects = list.toArray();
        for(int x = 0 ; x < objects.length; x++){
            String s = (String) objects[x];
            System.out.println(s+"---"+s.length());
        }
        System.out.println("---------------------方式2---------------------");
        // 方式2:Collection的迭代器Iterator iterator()
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next(); //it.next():使用一次 ,不能使用多次
            System.out.println(s+"---"+s.length());
        }
        System.out.println("---------------------方式3 /方式4---------------------");
        //列表迭代器ListIterator
        //方式4:List集合的get(int index) +size() 的普通for循环
        for(int x = 0 ; x < list.size(); x++){
            //通过角标获取元素
            String s = list.get(x);
            System.out.println(s+"---"+s.length());
        }

        System.out.println("---------------------方式5--------------------");
        /**
         * jdk5新特性 增强for循环---->目的 为了替代迭代器(集合,存储引用类型),简化代码书写程度
         * for(泛型里面存储的数据类型 变量名 : 集合或者数组名称){
         *     使用变量名
         * }
         *
         * 增强for的特点: 前台条件:集合或者数组对象不能为null,否则NullPointerException
         */
        for (String s : list) {
         /*   if("mysql".equals(s)){
                list.add("go") ; // 使用增强for遍历元素,集合添加元素,会出现并发修改异常ConcurrentModificationException
            }*/
            System.out.println(s+"---"+s.length());
        }

    }
}

9. Jdk5里面其他新特性:

•  1)静态导入---->导入到方法的级别
  

•     import static 包名.类名.方法名;
  

•  前提使用静态导入,这个类的方法必须为静态
  

•  在使用静态导入的时候,导入jdk提供的一些工具类里面静态方法的时候,我们定义的方法不能和它方法名冲突
  

•  如果冲突了,静态导入是不识别,这个时候必须导入全限定名称 :包名.类名.方法名(xxx)
  

• 2)可变参数,当一个方法形式参数不知道多少个,这个时候可以使用可变参数(类似一个数组)
  

•      public  返回值类型 方法名(数据类型... 参数名)
  

*/
import static java.lang.Math.abs;
import static java.lang.Math.max; //最大值
import static java.lang.Math.min; //最小值
import static java.lang.Math.pow; //pow(a,b) a的b次幂
public class JDK5StaticDemo {
public static void main(String[] args) {

    //java.lang.Math:针对数学运算的类
    //public static double/int abs(double/int a,double/int b):求绝对值
    //...都是静态成员方法
    System.out.println(Math.abs(-10));
    System.out.println(Math.abs(100));

    System.out.println(java.lang.Math.abs(-100));//使用到了静态导入,方法名和自定义的方法名冲突了
    System.out.println(max(10,15));
    System.out.println(min(5,3));
    System.out.println(pow(2,3));
    System.out.println("---------------------------------");
    int sum = add(10, 20, 30, 40, 50);
    System.out.println(sum) ;
}

//自定义的abs方法
public static void abs(int a){
    System.out.println(a);
}

//求多个数据和
public  static int add(int...a){//类似一个数组
    int sum = 0 ;
    //遍历
    for(int x = 0 ; x < a.length  ;x++){
        sum += a[x] ;
    }
    return sum ;

}

10.Vector集合的特有功能

package com.qf.vector_02;

import java.util.Enumeration;
import java.util.Vector;

/**
 * @author 高圆圆
 * @date 2022/11/17 11:08
 * 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():获取集合元素数
 */
public class VectorDemo {
    public static void main(String[] args) {

        //创建Vector集合
        Vector<String> v = new Vector<>() ;
        System.out.println(v) ;

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

11.LinkedList集合的特有功能

package com.qf.linkdlist_03;

import com.sun.xml.internal.ws.addressing.WsaActionUtil;

import java.util.LinkedList;

/**
 * @author 高圆圆
 * @date 2022/11/17 11:36
 * LinkedList:
 *      线程不安全,不同步,执行效率高
 *     底层数据结构: 线程结构之链表,查询慢,增删快!
 *
 *     特有功能:
 *          添加元素
 *              public void addFirst(E e) 将指定的元素添加到链表的开头
 *              public void addLast(E e) 将指定的元素添加到链表的末尾
 *              public E getFirst():获取第一个元素
 *              public E getLast():获取最后一个元素
 *              public E removeFirst():删除第一个并返回第一个元素
 *              public E removeLast():删除最后一个元素并返回
 *
 *
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        //创建一个链表
        LinkedList<String> lk = new LinkedList<>() ;
        //添加字符串
        lk.add("hello") ;
        lk.add("world") ;
        lk.add("java") ;
        System.out.println(lk) ;
        /*
         public void addFirst(E e) 将指定的元素添加到链表的开头
 *              public void addLast(E e) 将指定的元素添加到链表的末尾
 *              public E getFirst():获取第一个元素
 *              public E getLast():获取最后一个元素
 *              public E removeFirst():删除第一个并返回第一个元素
 *              public E removeLast():删除最后一个元素并返回
         */
        lk.addFirst("JavaEE"); ;
        lk.addLast("Android");
        System.out.println(lk);
        System.out.println(lk.getFirst());
        System.out.println(lk.getLast());
        System.out.println(lk.removeFirst());
        System.out.println(lk);
    }
}

12.使用LinkedList集合模拟栈结构特点:先进后出

package com.qf.linkdlist_03;

import java.util.LinkedList;

/**
 * @author 高圆圆
 * @date 2022/11/17 11:50
 * 自定义一个类MyStack,模拟栈--->里面使用LinkedList集合的功能
 *
 * interface 接口名<T>{}
 *
 *class 类名<T>{}
 * public <T> T 方法名(形式参数列表)  泛型定义在方法上
 */
public class MyStack<T> {//MyStack<String>
    //提供一个成员变量
    private LinkedList<T> lk ;
    //无参构造方法
    public MyStack(){
        //创建一个LinkedList集合对象
        lk = new LinkedList<>() ;

    }
    //定义一个功能,添加元素
    public void addElement(T t){
        //使用LinkedList集合的功能
        lk.addFirst(t) ;
        //System.out.println(lk);
    }
    //获取元素
    public T getElement(){
        return lk.removeFirst() ;//删除第一个并返回 --->相当于LinkedList的pop()弹栈
    }

    //提供一个判断
    public boolean myStackIsEmpty(){
        return lk.isEmpty() ;
    }

}

package com.qf.linkdlist_03;

/**
 * @author 高圆圆
 * @date 2022/11/17 11:49
 * 使用LinkedList来模拟栈结构特点:先进后出
 */

public class LinkedListTest {
    public static void main(String[] args) {
        //测试
        MyStack<String> my = new MyStack<>() ;//本质创建了LinkedList集合对象
        my.addElement("hello") ;
        my.addElement("world") ;
        my.addElement("javaee") ;
        my.addElement("android") ;

        //第一次获取
      /*  System.out.println(my.getElement());
        //第二次获取
        System.out.println(my.getElement());
        //第三次
        System.out.println(my.getElement());
        //第四次
        System.out.println(my.getElement());
        System.out.println(my.getElement());*/
        while (!my.myStackIsEmpty()){
            //如果不为,才获取元素
            System.out.println(my.getElement());
        }
    }
}

13.TreeSet集合的自然排序---->存储类型需要实现Comparable接口

package com.qf.treeset_05;

/**
 * @author 高圆圆
 * @date 2022/11/17 15:55
 */
//实现自然排序
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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //重写方法
    @Override
    public int compareTo(Student s) {
        //存储s1-s8  s1就是作为根节点
        //主要条件:
        // 按照学生的年龄从小到大排序
      /*  int num = this.age -s.age ;
        //次要条件(自己分析):如果年龄相同,还要比较姓名是否一样的
        int num2 = (num==0)?(this.name.compareTo(s.name)):num;
        return num2;*/


        //主要条件:按照学生的姓名长度比较: 从小到大比较
        int num = this.name.length() - s.name.length() ;
        //次要条件:如果num==0,姓名长度一样,比较姓名内容是否一样
        int num2 = (num==0)?(this.name.compareTo(s.name)):num;
        //次要条件2:如果姓名长度一样,姓名内容也一样,还要比较年龄是否一样
        int num3 = (num2==0)?(this.age-s.age):num2;
        return num3 ;


    }
}

package com.qf.treeset_05;

import java.util.TreeSet;

/**
 * @author 高圆圆
 * @date 2022/11/17 15:54
 * TreeSet<Stdudent>,使用TreeSet存储自定义类型
 * 存储的Student类型实现Comparable,完成自然排序!
 *                  排序条件(主要条件)
 *                          按照学生的年龄从小到大排序
 *
 *                         自己的分析次要条件:
 *
 *
 *  使用TreeSet<Student>,按照自然排序排序
 *              主要条件:
 *                      按需学生的姓名的长度从小到大比较
 *
 *               次要条件:长度相同,比较姓名内容是否相同
 *
 *
 * 键盘录入5个学生姓名,数学成绩,英语成绩,语文成绩 ,按照学生的总分从高到到低排序!
 *
 *
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建TreeSet集合
        TreeSet<Student> ts = new TreeSet<Student>() ;//无参构造方法,自然排序

        //创建一堆学生
        Student s1 = new Student("gaoyuanyuan",32) ;
        Student s2 = new Student("gaoyuayuan",32) ;
        Student s3 = new Student("liushishi",36) ;
        Student s4 = new Student("wangbaoqi",36) ;
        Student s5 = new Student("wenzhang",28) ;
        Student s6 = new Student("wenzhang",28) ;
        Student s7 = new Student("mabaoguo",65) ;
        Student s8 = new Student("mabaoguo",56) ;
        Student s9 = new Student("gaoyuanyuan",35) ;
        Student s10 = new Student("zhangwen",35) ;

        //添加
        //Student类没有实现自然排序接口
        //java.lang.ClassCastException: com.qf.treeset_05.Student cannot be cast to java.lang.Comparable
        ts.add(s1) ;
        ts.add(s2) ;
        ts.add(s3) ;
        ts.add(s4) ;
        ts.add(s5) ;
        ts.add(s6) ;
        ts.add(s7) ;
        ts.add(s8) ;
        ts.add(s9);
        ts.add(s10);

        //遍历
        for(Student s:ts){
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

14.TreeSet集合的比较强排序–>Comparator接口

方式1

package com.qf.treeset_06;


import java.util.Comparator;

/**
 * @author 高圆圆
 * @date 2022/11/17 17:12
 */
//自定义类实现Comparator,完成比较器排序
public class MyComparator  implements Comparator<Student> {

    @Override
    public int compare(Student s1, Student s2) {
        //按照学生的年龄从小到大排序(主要条件)
        //s1---->this
        //s2---->s
        int num = s1.getAge() - s2.getAge() ;
        //次要条件:年龄相同,比较姓名是否一致
        int num2 = (num==0)?(s1.getName().compareTo(s2.getName())):num ;
        return num2;
    }
}

package com.qf.treeset_06;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * @author 高圆圆
 * @date 2022/11/17 17:07
 *  存储的Student类型实现Comparable,完成比较器排序
 *                   排序条件(主要条件)
 *                           按照学生的年龄从小到大排序
 *   比较强排序:
 *          TreeSet有参构造方法
 *          public TreeSet(Comparator<? super E> comparator) 按照比较强排序
 */
public class TreeSetDemo {
    public static void main(String[] args) {

        //创建一个TreeSet集合
        //public TreeSet(Comparator<? super E> comparator) 按照比较强排序
        //比较器排序方式1:自定义一个类实现Comparator接口
        
        Comparator<Student> my = new MyComparator() ;  //接口多态
        TreeSet<Student> ts = new TreeSet<>(my) ;

    
        //创建学生对象
        Student s1 = new Student("wenzhang",25) ;
        Student s2 = new Student("wenzhang",25) ;
        Student s3 = new Student("gaoyuanyuan",25) ;
        Student s4 = new Student("luozhixiang",32) ;
        Student s5 = new Student("gaoyuanyuan",22) ;
        Student s6 = new Student("mayili",22) ;
        //添加
        ts.add(s1) ;
        ts.add(s2) ;
        ts.add(s3) ;
        ts.add(s4) ;
        ts.add(s5) ;
        ts.add(s6) ;
        for(Student s:ts){
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

方式2:Comparator接口匿名内部类

package com.qf.treeset_06;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * @author 高圆圆
 * @date 2022/11/17 17:07
 *  存储的Student类型实现Comparable,完成比较器排序
 *                   排序条件(主要条件)
 *                           按照学生的年龄从小到大排序
 *   比较强排序:
 *          TreeSet有参构造方法
 *          public TreeSet(Comparator<? super E> comparator) 按照比较强排序
 */
public class TreeSetDemo {
    public static void main(String[] args) {

        //创建一个TreeSet集合
     

     //方式2:public TreeSet(Comparator<? super E> comparator) 按照比较强排序,使用接口匿名内部类

        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //按照学生的年龄从小到大排序(主要条件)
                //s1---->this
                //s2---->s
                int num = s1.getAge() - s2.getAge() ;
                //次要条件:年龄相同,比较姓名是否一致
                int num2 = (num==0)?(s1.getName().compareTo(s2.getName())):num ;
                return num2;
            }
        }) ;
        //创建学生对象
        Student s1 = new Student("wenzhang",25) ;
        Student s2 = new Student("wenzhang",25) ;
        Student s3 = new Student("gaoyuanyuan",25) ;
        Student s4 = new Student("luozhixiang",32) ;
        Student s5 = new Student("gaoyuanyuan",22) ;
        Student s6 = new Student("mayili",22) ;
        //添加
        ts.add(s1) ;
        ts.add(s2) ;
        ts.add(s3) ;
        ts.add(s4) ;
        ts.add(s5) ;
        ts.add(s6) ;
        for(Student s:ts){
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

15. 引入多线程 (什么是线程,什么是进程)

线程依赖于进程存在!

进程:能够调用系统资源的独立单位!(打开计算机任务管理器,查看进程状态)
多进程:计算机都是支持多进程,提高CPU的使用率!
   开启多个进程的时候,玩游戏的同时可以听音乐,他们并不是同时进行的,而是一点时间片在两个进程之间进行高效切换!

线程:
       能够执行的最小单元!(一个线程可以看成进程的某个任务)

       360软件---->开启---->开启进程
            同时清理内存---同时查杀病毒
多线程的意义:
        多个线程在互相抢占CPU执行权!  线程的执行具有随机性!
        1v3打篮球,3个人抢占篮球几率大,不一定(线程执行的是一个随机的)

 JVM是多线程的吗?
    是一个多线程的,至少有两条线程
    main线程----用户线程
    gc----->垃圾回收器 开启垃圾回收线程(回收没有更多的对象!)

计算机---多进程(意义?)
JVM是多进程的吗?
 *      Java能够直接创建多线程吗?
 *
 *创建线程---->需要创建进程---->需要使用系统资源创建进程
 * Java是不能够直接操作系统资源的,底层语言C是可以操作系统的
 * Jdk提供了Thread类,里面有个start()---->执行线程---底层非Java语言实现的
 *
 *
 * 提供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 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()