【java_week04】

一、选择排序

1.1选择排序的思想

使用数组中的第一个元素依次和后面的元素是比较，第一次比较完毕，最小值出现在最小索引处
依次这样比较，可以得到一个排好序的数组！

1.2选择排序过程以及规律

使用0角标对应的元素依次和后面的元素是比较，第一次比较完毕，最小值出现在最小索引处！
比较的次数：数组长度-1次

1.3选择排序核心代码实现

for(int i = 0;i<arr.length-1;i++){
    for(int x = i+1 ;x<arr.length;x++){
        if(arr[x]<arr[i]){
            int temp = arr[i];
               arr[i] = arr[x];
               arr[x] = temp;
      }
    }
}

二、常用类

2.1Object类的常用方法

2.1.1 getClass（）方法

获取正在运行的类（返回字节码文件对象）-----跟反射相关

2.1.2 在java中获取一个类的字节码文件对象的方式有几种？

有三种
第一种：public final Class getClass(): 获取正在运行的类;  (返回字节码文件对象) 
第二种：在java中任意类型的class属性   Class  s = 类名.class
第三种：Class 
跟反射相关-提供静态功能--->返回值是它自己本身
 public static Class  forName(String classPathName);
这个方法在使用过程中，可能出现类找不到异常，谁调用这个方法谁处理这个异常，----给上面抛
这个方法的参数需要传递当前类的“全限定名称”

2.1.3 toString()

public String toString()
返回的是一个字符串类型的数据   ------ 返回结果应该是简明扼要的，便于阅读的，建议子类覆盖此方法
直接输出对象名等价于----Object类的toString()
 任何类都继承Object类---toString方法源码
 *  public String toString() {
 *         return getClass().getName() + "@" + Integer.toHexString(hashCode());
 *
 *         //return this.getClass().getName() +"@" +Integer.Integer.toHexString(this.hashCode())
 *     }
 */

Integer.toHexString(整数类型):将整数类型---转成十六进制数据,并且以字符串形式体现

2.1.4 hashCode()

public int hashCode():返回对象的哈希码值,不同的对象,它的哈希码值不同
 *              (理解为 "地址值",它不是实际意义的地址值----通过哈希算法算出来的)
 */

2.1.5 ==和equals的区别（面试题）

==连接的是两个基本数据类型：比较的是两个数据值是否相等
==连接的两个是引用型数据类型，比较的是应用类型的地址值是否相等！

字符串常量相加:
 *                  先相加,然后看结果,是否在常量池中,如果有,直接返回值地址;否则开空间
 *      字符变量相加:
 *                  先在常量池开辟空间,然后在操作;
 *

2.1.6 equals()

equals:Object的equaels方法默认比较的是两个对象的地址值相同,子类重写了equals(),就比较两个对象的内容是否相同

 * 如果你要比较成员信息的内容是否相同,必须重写Object的equals方法以及hashCode,重写之后比较的是内容是否相同(成员信息)
 * equals重写之后,是比较里面的每一个成员信息是否一样,如果都一样;
 * 还有比较两个成员对应的hashCode是否一样,如果一样,是同一个人!

2.1.7 clone()

Object的克隆方法：创建并返回此对象的”副本“-----前提必须实现Cloneable这个接口，否则无法克隆!protected Object clone() throws CloneNotSupportedException
这个类必须实现Cloneable这个接口，才可以克隆
* 如果一个接口没有成员变量,连成员方法都没有,将这类接口称为"标记接口"
* Cloneable接口:某个类如果能够实现这个接口,那么这个类对象就可以克隆!

2.1.8 finalize()

 Object类的垃圾回收方法
 * protected void finalize()throws Throwable--跟gc垃圾回收器有关系
 * 当jvm开启垃圾回收器的时候,就会回收堆内存中没有更多引用的对象(new 出来的东西)
 *
 * 当前垃圾回收器开始运行,会调用Object类的finalize()方法,来回收对象,子类重写了,会调用子类的finalize方法
 *
System类--->public static void gc()运行垃圾回收器
        // 手动开启垃圾回收器 (java语言中自动回收)---jvm垃圾回收--是一个线程(垃圾回收线程)

2.2 Scanner

java.util.Scanner 文本扫描器（键盘录入数据的）
构造方法
public Scanner （InputStream source）:
    创建一个文本扫描器，里面参数是字节输入流，读取键盘录入的一些数据
成员方法
获取功能:除过不能录入char类型之外.都可以录入!
    int  nextInt():录入int类型
    String next() :录入字符串
    String nextLine():录入一行字符串
InputMismatchException:录入数据与提供数据类型不匹配
判断功能
    boolean hasxxx()：判断下一个录入的是为XXX类型
细节：如果先录入int，在录入String（使用String nextLine()）-----String的值可能会被漏掉
解决方案：
1)使用String next():录入单个字符串（推荐）
2）在使用nextLine()之前，重新创建一个新的Scanner对象；
//创建键盘录入对象
        //Scanner sc = new Scanner(System.in) ;
        //等价于
        //System类---提供静态变量:in--而且是一个常量

2.3 String类

代表字符串，是一个常量，创建之后，其值不能更改！
举例：
String s = "abc"; 开发中，定义字符串就是这个格式
字符串的底层就是一个字符数组组成 char data[] = {'a','b','c'}   String s = new String(data);
构造方法：
public String():创建字符串对象
public String(String original):将指定的字符串传进去，构造一个字符串对象
public String(char[] Value):将字符串数组----构造成String
public String(char[] value,int offset,int count):将一部分字符数组转换成String
public String(byte[] bytes)将字节数组---构造成String
public String(byte[] bytes, int offset,int length):将一部分字节数组---构造成String

如果存在类型转换问题:
 *              已知char[]--->String  public String(char[] value)
 *              已知byte[]--->String  public String(byte[] bytes)
 *
 *       如果仅仅表示定义一个String对象---推荐的格式
 *              String 变量名 = "字符串常量" ;

byte[] bytes = {97,98,99,100,101} ;
String s5 = new String(bytes) ;//转换过程,将每一个数据找ASII码表对应的字符值,构造成字符串
System.out.println("s5:"+s5) ;//abcde

2.3.1 面试题:s1和s2区别

String s1 = "hello";
String s2 = new String("hello");
第一个格式:
 *          创建一个对象,直接在常量池中创建;
 *     第二个格式:
 *          需要在堆内存开辟空间,而且指向常量池地址:内存创建了两个对象!
 *
 *    两个都是创建字符串实例,但是推荐第一种,从内存角度考虑,消耗内存资源不严重!

2.3.2字符串常量相加

看代码写结果
Strings1="hello";
Strings2="world";
Strings3="helloworld";
System.out.println((s1+s2)==s3);
System.out.println((s1+s2).equals(s3));
System.out.println("hello"+"world"==s3);
System.out.println("helloworld"==s3);
System.out.println(("hello"+"world").equals(s3));
false
true
true
true
true

字符串常量相加:
 *                  先相加,然后看结果,是否在常量池中,如果有,直接返回值地址;否则开空间
 *      字符变量相加:
 *                  先在常量池开辟空间,然后在操作;

2.3.3String类中常用的获取功能

1）public char charAt(int index) 获取指定索引值的对应的字符
2）public int length():字符串特有功能：获取字符串长度

//charAt(int index)+length()可以遍历字符串
        for(int x = 0 ; x < s.length(); x++){
            char ch = s.charAt(x) ;//获取指定索引值对应的字符
            System.out.print(ch+"\t");
        }
        System.out.println();

 3)public String concat(String str):拼接功能 将指定的字符串拼接到该字符串末尾,获取新的字符串
 4)public int indexOf(String str)返回指定字符串第一次出现索引值
 5）public int lastIndexOf(String str):返回指定子字符串最后一次出现的索引值
5)public String spilt(String regex):字符串拆分功能
6）public String substring (int beginIndex, int endIndex)
指定位置开始，截取到endIndex-1处结束，包前不包后
    public String substring(int beginIndex)
    指定位置开始，默认截取到末尾

2.3.4String 类中常见的转换功能

public byte[] getBytes():将字符串转换成字节数组（编码过程：将能看懂的东西----变成看不懂的）
一般不带参，使用idea默认的字符集（带参就按带参的，比如GBK是一个中文两个字节）
//idea设置的平台字符集：utf-8：一个中文三个字节
String(byte[] byte)；解码---->将看不懂的转为能看懂的字符串

2.3.5 将字符串转换成字符数组

public char[] toCharArray 将字符串转换成字符数组
public static String Valueof(常见的基本类型/long/double/boolean/Object)
String万能方法：将上面的常用类型---转换成String
public String toUpperCase():将指定字符串转换成大写
public String toLowerCase():将指定字符串转换成小写

2.3.6String 类的其他功能

 String类判断功能以及其他功能:
 *      public boolean constains(String str):判断大串中是否包指定的子字符串
 *      public boolean equals(Object anObject)):比较两个字符串内容是否相同
 *      public boolean equalsIgnoreCase(String anotherString)):忽略大小写比较
 *      public boolean startsWith(String prefix):字符串是否以指定的前缀开头
 *      public boolean endsWith(String str):字符串是否以指定的后缀结尾
 *
 * 其他功能:
 *      public String replace(char oldChar,char newChar)替换功能:使用指定的新的字符替换以前的字符
 *      public String trim():删除前后两端空格
 *
 *              应用场景:trim():  使用io(intput输入 Output输出)流进行 读写复制(文件内容在网络中传输)
 *   文件内容前后有一些空字符出现,获取到文件内容之后,先去trim()去除两端空格

2.4 StringBuffer

 :字符串缓冲区，线程安全，支持可变的字符序列
什么叫线程安全------>后面讲的多线程
线程安全---->意味着“同步”---->执行效率低-----“银行类的网站”
线程不安全---->意味着“不同步”---->执行效率高-----“论坛的网站”----不安全----锁机制---来解决线程安全问题（多线程）

2.4.1 StringBuffer和StringBuilder

这两个类都是字符串缓冲区，都支持可变的字符序列
前者：使用在多线程环境里面，能够保证线程安全---意味着同步----执行效率低
后者：是StringBuffer的简易替换，使用在单线程环境中，线程不安全---不同步--执行效率高！
单线程使用StringBuilder:效率高（速度块）
构造方法：
    public StringBuffer():无参构造方法，里面空的字符串序列，初始容量16个字符
    public StringBuffer(String str):有参构造方法，将字符串构造为StringBuffer类型，容量大小：当前里面的字符串长度+16
    前两个构造方法使用居多！
    public StringBuffer(int capacity)：创建一个字符串，指定容量大小
    1）获取字符串缓冲区长度---int length()
    2)获取字符串缓冲区的容量-----int capacity()

2.4.2 StringBuffer的添加删除的功能

添加：
    § public StringBuffer append(java任意类型数据)：可以将任意类型的元素添加（在末尾追加）到字符串缓冲区中，返回值是字符串缓冲区本身
    § public StringBuffer insert(int offset, 任意java数据类型)：在指定位置处的序列前面插入新的序列
    
    § public StringBuffer delete(int start,int end)从指定位置start处开始到end-1处的字符序列删除，返回值字符串缓冲区本身
    
    § public StringBuffer deleteCharAt(int index)在指定位置处删除指定的字符，返回字符缓冲区本身
    § 
    §  开发中使用居多:追加功能以及删除 deletCharAt(int  index)使用居多

2.4.3 String<---->StringBuffer相互转换 (重点)

String----->StringBuffer
//方式1)可以通过StringBuffer的有参构造方法
        //StringBuffer(String str)
        //创建一个字符串缓冲
        StringBuffer sb = new StringBuffer(s) ;
        System.out.println(sb) ;
//方式2:通过StringBuffer的无参构造方法+append(String str)
        StringBuffer sb2  = new StringBuffer() ;
        sb2.append(s) ;
        System.out.println(sb2);

StringBuffer------>String
方式1：
public String toString()返回字符串
StringBuffer sb = new StringBuffer();
String str = sb.toString();
//方式2:String类的构造方法
//public String(StringBuffer buffer)
  String str2 = new String(buffer)  ;
  System.out.println(str2) ;

2.4.4 StringBuffer的特有功能

§ public StringBuffer reverse()：字符串缓冲区反转功能，将字符串缓冲区中所有的字符序列反转！
 需求:
 *      键盘录入一个字符串,将字符串反转
 *
 *    方式1:不让你使用StringBuffer的特有功能,让你使用String
 *       1)将录入的字符串---->转换成字符数组
 *       2)定义一个String s = "" ;
 *       3)将字符数组倒着遍历
 *       for(int i = 字符数组.length-1;i>0 ;i --){
 *           s += 字符数组[i] ;
 *
 *       }
 *       4)返回结果变量s
 */
//方式2:使用StringBuffer的反转功能
    public static String reverse2(String s){
       /*StringBuffer sb = new StringBuffer() ;
       sb.append(s) ;
       return sb.reverse().toString() ;*/

2.4.5 StringBuffer其他功能

 public StringBuffer replace(int start,int end,String str)
 * 使用指定的字符串str从指定位置开始到end-1处进行替换,返回该字符串缓冲区本身
 * public String substring(int start):从指定位置开始截取,默认截取到末尾,返回被截取后的字符串
 * public String substring(int start,int end):从指定位置开始截取到指定位置end-1处,返回被截取后的字符串

2.5 Integer类

jdk提供了一个类Integer类,提供了一些功能:十进制转换成对应的进制的方法(静态方法)
四类八种的基本数据类型都会自动提升 对应的引用类型              jdk5以后新特性:自动拆装箱
 *
 *          拆箱:
 *                  这些包装类类型--->降为 基本类型
 *           装箱:
 *                  就是基本类型--->提升  对应的引用类型
 *
 *              基本类型                       引用类型的默认值null
 *                  byte                        Byte
 *                  short                       Short
 *                  int                         Integer(特殊)
 *                  long                        Long
 *
 *                  float                       Float
 *                  double                      Double
 *
 *                  char                        Character(特殊)
 *
 *                  boolean                     Boolean
 *
 *      这些四类八种中的基本数据类型可以String进行相互转换的---->中间桥梁 ---->对应的基本类型的包装类类型!
 *      String-->Integer--->int
 *          "100"  --->100

2.5.1 Integer类的构造方法

 public Integer(int value):创建一个Integer实例,里面包含的int类型的值
 *      public Integer(String s) throws NumberFormatException: 将数字字符串转换成Integer的实例
 *              可能会出现数字格式化异常(字符串如果不是数字字符串,就会出现这个异常)

2.5.2 Integer特点

将int类型赋值给Integer变量 这种格式,执行底层方式valueOf(int i)
 *
 *
 *   public static Integer valueOf(int i) {
 *          如果i的值在-128~127之间,直接从内部类--->IntegerCache缓存去中取数据
 *         if (i >= IntegerCache.low && i <= IntegerCache.high)
 *             return IntegerCache.cache[i + (-IntegerCache.low)]; //  cache属性:Integer cache[] 长度 =i+128
 *         return new Integer(i);   //如果上if不成立,重新开辟新的空间创建Integer实例
 *     }

2.6 Character类

构造方法：
    public Character（char value）:包含char类型的值
成员方法：
    判断功能
        public static boolean isDigit(char ch):判断当前字符是否为数字
        public static boolean isLowerCase(char ch):判断当前字符是否为小写
        public static boolean isUpperCase(char ch):判断当前字符是否为大写

2.7 int基本类型和引用String的相互转换

 String---int:                int  变量名 = Integer.parseInt(已知的数字字符串) 推荐
 * int---->String:            Integer类提供静态方法        String 变量名 = Integer.toString(int类型的值)
 */
//方式1)比较简单
        int i = 100 ;
        String s = "" ;
        s += i ; //拼接符号 s = s+i
        System.out.println(s) ;//"100"

//推荐一步执行:
        //Integer类提供了静态方法
        //public static int parseInt(String s)throws NumberFormatException:要转的字符串必须为数字字符串

        //万能方法:String--->long  --->Long引用提供静态方法 public static long pasreLong(String str)

三、其他类

3.1 System类

/**
 * java.lang.System:不能实例化:提供了静态字段(静态变量)
 *      public static final PrintStream out :标准 打印输出流
 *      public static final PrintStream err  标准错误输出流
 *      public static final InputStream in  标准输入流
 */
/**
 *  System类常用的成员方法:
 *
 *      public static long currentTimeMillis() 计算当前系统时间毫秒值  (很少单独用)
 *                      用来计算当前某个程序的时间复杂度(运行效率)
 *
 *      public static void gc() 收到开启垃圾回收器   ---会调用finalize(),回收没有更多引用的对象
 *      public static void exit(int status): 参数为0:终止jvm
 *      public static void arraycopy(
 *                                  Object src,  //原对象
 *                                  int srcPos,   //原对象中的某个位置
 *                              Object dest,      //目标对象
 *                              int destPos,       //目标对象的某个位置
 *                              int length)      //指定的长度
 */

3.2 Randrom类

/**
 * java.util.Random:伪随机数生成器  可以产生随机数 比Math.random()麻烦
 *      两个构造方法:
 *              public Random() :无参构造方法(推荐)
 *              public Random(long seed):有参构造,创建一个指定long类型的变量的随机数生成器
 *      两个成员方法:
 *              public int nextInt(): 产生伪随机数在,取值是int类型 的范围内
 *              public int nextInt(int n):产生0-n之间的随机数(推荐)
 */

3.3 Calendar日历（抽象类）

提供了获取年，年中的月
/**
 * java.util.Calendar:日历类(抽象类)
 *  提供了获取年,年中的月,月中的日期,小时,小时分钟数,分钟中的秒数都可以获取到
 *
 *  如果有一个类是抽象类,可以直接new子类,或者是它提供了一些静态方法---->
 *          完成了一些事情,创建子类对象,返回值是当前抽象类的本身
 *
 * 成员方法:
 *      public static Calendar getInstance() 创建日历对象
 *      public int get(int field):通过日历对象获取日历中的字段值
 *
 *                  参数:Calendar中提供的一些静态字段
 *                              public static final int YEAR:年份
 *                              public static final int DAY_OF_MONTH/public static final int DATE:月中的日期
 *                              public static final int MONTH:月份
 *
 *      public abstract void add(int field,int amount):给指定的日历字段值添加或者减去时间偏移量
 *
 */

3.4 BigDecimal

/**
 *BigDecimal这个类是对小数可以进行精确计算的!
 * 构造方法:
 *
 *      public BigDecimal(String val):将String类型数据构造成BigDecimal
 *          将double数据---使用"小数字符串"
 *
 *  成员方法:
 *          public BigDecimal add(BigDecimal augend):求和
 *          public BigDecimal subtract(BigDecimal subtrahend):相减
 *          public BigDecimal divide(BigDecimal divisor):小数除法
 *          public BigDecimal divide(BigDecimal divisor,int roundingMode):除法,第二个参数舍入模式
 *
 *                            BigDecimal提供的模式  public static final int ROUND_HALF_UP:四舍五入
 *                              ...
 *          public BigDecimal divide(BigDecimal divisor,
 *                          int scale,//保留几位小数
 *                          int roundingMode)     //舍入模式
 *          public BigDecimal multiply(BigDecimal multiplicand):乘法
 */

3.5 Pattern

public final class Pattern  extends Object  implements Serializable   正则表达式的编译表示。
○ Pattern p = Pattern.compile("a*b");
 Matcher m = p.matcher("aaaaab");
 boolean b = m.matches();
这个类定义了一个matches方法，以便在正则表达式只使用一次时方便。
○ 正则表达式跟前端js里面的一样，所以在前端里面在讲

3.6 Date(重点)

/**
 * java.util.Date:表单特定的日期时间,还允许格式化和解析日期字符串
 * 构造方法:
 *      public Date():创建当前日期对象:获取当前系统日期时间
 *      public Date(long date):里面传入long类型的时间毫秒值,获取的表示从标准基准时间（称为“时代”）即1970年1月1日00:00:00 GMT起的指定毫秒数
 *成员方法:
 *      public long getTime():将Date对象转换成long类型时间毫秒值
 *      public void setTime(long time):设置日期时间,参数时间毫秒值

3.6.1 Date和String日期文本相互转换

他们之间要进行转换需要使用类DateFormat
 * DateFormat是日期/时间格式化子类的抽象类，它以语言无关的方式格式化和分析日期或时间
 * 它具体的子类:SimpleDateFormat是一个具体的类,允许格式化（日期文本），解析（文本日期）
 *
 *构造方法:
 *      public SimpleDateFormat(String pattern):参数是日期模式         "yyyy-MM-dd"
 *      pattern的组成:
 *              y:表示年份中某个值----->yyyy 表示年 "1996/2023/..."
 *              M:表示年中的月份------>MM     表示月:七月-->"07" 十月 -->"10"
 *              d:表示月中的日期值----->dd   表示 "01","11","31"..
 * 成员方法
 *      将Date---->String:格式化  public final String format(Date date)
 *      将String日期---->Date:解析
 *
 *                              public Date parse(String source)throws ParseException
 */

四、集合

4.1 集合的概念：

集合、是一个容器，它可以存储不同数据类型的元素，当这些元素必须为引用数据类型，集合长度可变！

4.2 集合和数组区别

    1)长度区别
     *          数组:固定
     *          集合:可变
     *      2)存储数据类型的区别?
     *          数组:可以存储基本数据类型,也可以存储引用数据类型
     *                  Student[] students = new Student[5] ;//引用类型
     *                  int[] arr = new int[5] ; //基本数据类型
     *          集合:只能存储引用类型   集合<泛型>
     *      3)存储元素的区别?
     *           数组:数组存储的元素的数据类型必须一致
     *                      int[] arr = new int[5] ;
     *                      arr[0] = "hello" ; //不行
     *           集合:如果没有明确<泛型>,可以存储任意的引用类型(包含Object)

4.3 Collection

 Collection:单例集合顶层次的根接口,不能new,没有直接子实现类,是通过它子接口的子实现类来实例化!
     * 泛型: 集合里面创建的时候,如果不带泛型可能程序安全问题;带了<>,模拟创建数组的时候,明确了数据类型!
     * <E>:element
     * <T>:Type
     * <K>:Key键
     * <V>:Value值
     *
     * 基本功能:
     *      添加元素:
     *              boolean add(E e):添加元素
     *      删除:
     *              boolean remove(Object o):删除指定的元素
     *              void clear():暴力删除:清空集合
     *      判断:
     *              boolean contains(Object o):是否包含指定的元素
     *              boolean isEmpty():判断集合是否为空
     *
    Collection<String> c = new ArrayList<>() ;
            //=后面的集合的<> jdk7以后新特性；泛型推断  (加入泛型:保证数据的安全性),创建集合就明确了数据类型

4.3.1 Collection集合高级功能

     *      Object[] toArray():集合的传统方式遍历 将集合转换成对象数组(以后不会用的)
     *      Iterator<E> iterator():Collection专有迭代器(遍历集合) (过渡)
     /**
     *Iterator<E> iterator():Collection专有迭代器(遍历集合) (过渡)
     *
     * Iterator迭代器接口:
     *      boolean hasNext(): 判断迭代器里面是否下一个可以遍历的元素
     *      E next():获取迭代器的下一个元素 (和迭代器中的类型一致)
     *      
            //获取Collection的迭代器
                    //Iterator<E> iterator()
                    Iterator<String> it = c.iterator();
                    //E next() //E---类型需要和泛型的类型一致的
     *        开发中---集合遍历---->都用jdk5以后新特性:增强for循环 代替上面迭代器

4.3.2ConcurrentModificationException

需求:
 *      有一个Collection集合,存储一些不重复的String元素,如果现在里面有"world",需要给集合中
 * 添加一个新的"JavaEE"元素!
 *
 * 分析:
 *      1)创建Collection,模拟存储一些字符串,里面就包含"world"
 *      2)获取Collection集合迭代器,遍历元素,
 *      3)判断,如果这里面存在"world",然后添加"JavaEE"
 *
 *
 *  出现了异常"ConcurrentModificationException":并发修改异常
 *
 *  什么叫并发:在某个时间点上同时进行!
 *  在集合这块出现ConcurrentModificationException原因:
 *  当使用迭代器去遍历元素的时候,同时不能使用集合对象去操作(修改或添加...)元素,就会出现这个异常!
 *  因为,迭代器在遍历元素的时候,集合添加一个新的元素,迭代器不知道!
 *  解决方案:
 *
 *  Collection没有直接操作----->子接口List特有功能(ListIterator:列表迭代器/List集合普通for+size()+get(int index))
 *          1)集合遍历,集合添加------>List集合普通for+size()+get(int index)
 *          2)迭代器遍历,迭代器添加------->列表迭代器遍历元素，迭代器添加元素（ListIterator----void add(E e)将指定元素插入列表，
                                    不是在集合尾部添加，与Collection的add方法不一样！

4.3.3增强for循环

Jdk5新特性:<泛型>,增强for,可变参数,静态导入(导入到方法级别:方法必须静态)...
 *
 *
 * 增强for:是在集合/数组中存储的引用类型中使用居多,代替集合迭代器的,简化书写代码
 *  格式:
 *          for(集合中存储的数据类型 变量名 : 集合对象){
 *              使用这个变量名即可;
 *          }
 *
 *          注意:
 *                  要使用增强for遍历集合,集合对象不能null;
 *                  防止空指针异常,在使用增强for之前,对集合进行非空判断!

4.4 List集合

List集合常用三个子实现类特点：
    实际需求;单线程中，使用List完成一些事情，没有明确规定具体使用哪个实现类时，默认使用ArrayList集合！
    默认ArrayList
        底层数据结构是数组---->查询快，增删慢（数组，通过整数索引查询）
            元素查找：
                顺序查找、二分搜索（折半查找），哈希查找
                43,50,66,70,---->哈希查询,哈希表的长度10
                                                43 % 10 = 3
                
        线程角度：
            线程不安全的类，是一个不同步，执行效率高！
            底层扩容机制1.5倍
    Vector
        底层数据结构是数组---查询快，增删慢
        线程角度:
              线程安全的类,是同步的,执行效率低! 多线程环境下使用居多,单线程使用ArrayList代替Vector
    LinkedList
        底层数据是链表, 查询慢,增删快
                    线程角度:
                            线程不安全的类,不同步的,执行效率高!
    
    **
     * List集合特点:
     *      元素有序(存储和取出一致),而且元素可以重复!
     * Set集合:
     *      元素唯一的,无序(存储和取出不一致)
     *
     *List集合是Collection集合的子接口,它集合遍历方式:
     *      1)Collection的Object[] toArray()
     *      2)Collection的Iterator iterator() ;
     *      3)使用size()+ 存储的数据类型 get(int index)通过角标获取元素内容 :普通for循环格式
     *      4)ListIterator<E> listIterator()List集合的专有遍历方式 :列表迭代器
     *      5)增强for循环
    @SuppressWarnings("all") //压制所有警告  "jdk提供注解"
    List集合的专有遍历方式 :列表迭代器
    //列表迭代器提供了一些功能,进行逆序遍历(前提必须有上面的正向遍历)

4.4.1 Vector

1.Vector:底层数组，查询快，增删慢，线程安全的，执行效率低
2.Vector集合特有功能：
    遍历方式：
        Collection的Object[] toArray
        Collection的Iterator iterator()
        List接口提供的size()+get(int index)
        List接口提供的ListIterator  listiterator()
    特有遍历方式
          public Enumeration<E> elements()--->相当于集合的迭代器
              Enumeration接口:枚举组件
                   boolean hasMoreElements()---->相当于boolean hasNext()
                   E nextElement()          ---->相当于E next()
    public E elementAt(int index)--->相当于List的get(int index)+size方法相结合
     *
     *                 增强for
     *
     *          添加:
     *                  public void addElement(E obj)--->相当于List的add()
     *                  public E elementAt(int index)--->相当于List的get(int index)
    

4.4.2 LinkedList

LinkedList的特有方法：
         *      public void addFirst(E e) :在链表开头插入元素
         *      public void addLast(E e) :在链表末尾插入元素
         *      public E removeFirst(): 删除链表开头的第一个元素并返回该元素
         *      public E removeLast()从此列表中删除并返回最后一个元素。
         *      public E getFirst():返回链表头元素
         *      public E getLast():返回链表链尾元素
         
         *      需求:
         *              利用LinkedList模拟栈的结构特点,先进后出
         *
         *              自定义类--->里面使用到LinkedList的特有功能
         *                      方法add()--->linkedList的addFirst()
         *                      get()--->获取元素: LinkedList的removeFirst()删除并返回
         *                      自定义一个方法isEmpty()--->判断LinkedList是否为空

4.5 Set集合

4.5.1 Set接口特点

/**
 *      无序(存储和取出不一致),不能保证迭代次序,但是可以唯一!
 *    HashSet<E> : 存储和取出,保证元素唯一!
 *              ---底层是HashMap实例(哈希表)
 *    TreeSet<E> : 存储和取出,同时需要进行排序的取出!
 *              ---底层是依赖TreeMap实例(红黑树结构)
//必须实现接口Compareable,自然排序

4.5.2 TreeSet<E>有两种排序方式

自然排序:
 *                  public TreeSet():使用自然排序,当前里面存储的类型必须实现Comparable
 *          比较器排序