Java基础学习笔记2

Object类的概述:

         Object类概述:类层次结构的根类,所有类都直接或者间接的继承自该类
         构造方法:public Object();(空参构造)

Object类的hashCode()方法

         public int hashCode()
         a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
 b:不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。

Object类的getClass()方法

         public final Class getClass()
         a:返回此 Object 的运行时类。
         b:可以通过Class类中的一个方法，获取对象的真实类的全名称。    
              public String getName()

Object类的toString()方法

         public String toString()
         a:返回该对象的字符串表示。
           public StirngtoString() {
                     return name + "," + age;
              }
         b:它的值等于：
          getClass().getName()+ "@" + Integer.toHexString(hashCode())
c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。如果直接打印对象的引用，会默认调用toString方法

Object类的equals()方法

         a:指示其他某个对象是否与此对象“相等”。
         b:默认情况下比较的是对象的引用是否相同。
        c:由于比较对象的引用没有意义，一般建议重写该方法。

==号和equals方法的区别

         ==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性

Scanner的概述和方法介绍：

       Scanner的构造方法原理：Scanner(InputStream source)

       System类有一个静态的字段：public static finalInputStream in；标准的输入流

       一般方法：

              hansNextXxx()判断是否还有下一个输入项，其中Xxx可以是Int，Double等

              nextXxx()获取下一个输入项

Scanner获取数据出现的小问题以及解决方案：

       两常用方法：

              publicint nextInt（）；获取一个int类型的值

              publicString nextLine()；获取一个String类型的值，遇到\r\n就结束

       获取输入：

              1，输入多个int值使用nextInt（）方法，控制台回车获取多个输入

              2，输入多个String值使用nextLine（）方法，控制台回车获取多个输入

3，int和String都有则需要先用String接收，然后按照需求进行转换（或者创建两次对象，但是浪费空间）

String类的概述：

1，String类代表字符串，用final修饰（不能有子类），String类重写了toString方法返回的是该对象本身

       2，字符串字面值“abc”也可以看成是一个字符串对象

       3，字符串是常量，一旦被赋值就不能被改变

“”和null的区别：

“”是字符串常量，同时也是一个String类的对象，既然是对象当然可以调用String类中的方法

null是空常量，不能调用任何方法，否则会出现空指针异常

StringBuffer类的概述：

StringBuffer类的概述：final修饰，线程安全的可变字符序列，类似于String的字符串缓冲区，但不能修改（不能通过+号修改，但可以通过一系列的方法调用改变该序列的长度和内容）

StringBuffer是字符串缓冲区，当new的时候是在堆内存创建一个对象，底层是一个长度为16的字符数组，当调用添加的方法时，不会重新创建对象，在不断向原缓冲区添加字符

StringBuffer类重写了toString方法，显示的是对象中的属性值

StringBuffer和String的区别：String是一个不可变的字符序列（一旦被初始化就不能被改变），StringBuffer是一个可变的字符序列（初始化之后可以通过方法可以改变）

StringBuffer类的构造方法：

         StringBuffer的构造方法：
              publicStringBuffer():无参构造方法，初始容量16个字符
              publicStringBuffer(int capacity):指定容量的字符串缓冲区对象
              publicStringBuffer(String str):指定字符串内容字符串缓冲区对象
         StringBuffer的方法：
              public intcapacity()：返回当前容量。  理论值
              public int length():返回长度（实际字符数）。实际值

StringBuffer的添加功能：

public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身。
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身，如果没有指定位置的索引，就会出现索引位置异常

StringBuffer的删除功能：

public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身，如果缓冲区这个索引上没有元素，就会出现索引位置异常
public StringBuffer delete(int start,int end):内容，并返回本身，删除时，包含start索引但不包含end索引

StringBuffer的替换和反转功能：

         StringBuffer的替换功能：
public StringBuffer replace(int start,int end,String str):从start开始到end用str替换，不包含end索引
         StringBuffer的反转功能
         public StringBuffer reverse():字符串顺序反转

StringBuffer的截取功能及注意事项：

         public String substring(int start):从指定位置截取到末尾
public String substring(int start,int end):截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
         注意事项：返回值类型不再是StringBuffer本身，而是String字符

StringBuffer和String的相互转换：

         String -- StringBuffer
              a:通过构造方法：StringBuffer sb = newStringBuffer(“Hello”);
              b:通过append()方法:
                     StringBuffersb = new StringBuffer();
                     sb.append(“Hello”);
         StringBuffer -- String
              a:通过构造方法:
                     StringBuffersb = new StringBuffer();
                     Strings = new String(sb);
              b:通过toString()方法:
                     StringBuffersb = new StringBuffer(“Hello”);
                     sb.toString();
              c:通过subString(0,length);

StringBuilder类概述：

         StringBuilder和StringBuffer的构造方法以及其他一系列方法基本一致
         区别： StringBuffer是jdk1.0版本的,是线程安全的,效率低
                     StringBuilder是jdk1.5版本的,是线程不安全的,效率高
String和StringBuffer,StringBuilder的区别：String是一个不可变的字符序列； StringBuffer,StringBuilder是可变的字符序列

String和StringBuffer分别作为参数传递

         基本数据类型的值传递(当成参数传递)，不改变值本身（调用方法前后的值）
         引用数据类型的值传递(当成参数传递)，改变其值（调用方法前后的值）
         String类虽然是引用数据类型，但是他当做参数传递时和基本数据类型是一样的
         StringBuffer当成参数传递时和引用数据类型一样

数组高级冒泡排序:

         相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
       public
static int[] mao(int[]arrys){
                   for(inti = 0;i<arrys.length;i++){
                            for(intj=0;j<arrys.length-1-i;j++){
                                     if(arrys[j]>arrys[j+1]){
                                               inttemp =
arrys[j];
                                              
arrys[j] =
arrys[j+1];
                                              
arrys[j+1] =
temp;
                                     }
                            }
                   }
                   returnarrys;
            }

数组高级选择排序:

从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
       public
static int[] xuan(int[]arrys){
                   for(inti = 0;i<arrys.length;i++){
                            for(intj=i+1;j<arrys.length;j++){
                                     if(arrys[i]>arrys[j]){
                                               inttemp =
arrys[i];
                                              
arrys[i] =
arrys[j];
                                              
arrys[j] =
temp;
                                     }
                            }                 }
                   returnarrys;
   }

数组高级二分查找

         前提：数组元素有序, 如果数组无序，就不能使用二分查找；每次折半查找
              public
static int getIndex(int[]arr,intvalue){
                   intmin = 0;
                   intmax =
arr.length-1;
                   intmid = (min+max)/2;
                   while(arr[mid]!=value){
                            if(arr[mid]>value){
                                    
max = mid-1;
                            }elseif(arr[mid]<value){
                                    
min = mid+1;
                            }
                            mid = (min+max)/2;
                            if(min>max){
                                     return -1;
                            }
                   }
                   returnmid;
            }

Arrays类的概述和方法使用：

            Arrays类概述：针对数组进行操作的工具类；提供了排序，查找等功能。
         成员方法：
                     public static String toString(int[] a)  数组转字符串
                     publicstatic void sort(int[] a)         数组排序
                     publicstatic int binarySearch(int[] a,int key)二分

基本类型包装类的概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据，常用的操作之一：用于基本数据类型与字符串之间的转换。
         基本类型和包装类的对应
              byte                    Byte
              short                    Short
              int                        Integer
              long              Long
              float              Float
              double                 Double
              char                     Character
       boolean               Boolean

Integer类的概述和构造方法

Integer类概述：Integer 类在对象中包装了一个基本类型 int 的值；该类提供了多个方法，能在 int 类型和 String 类型之间互相转换；还提供了处理 int 类型时非常有用的其他一些常量和方法
         构造方法
              public Integer(intvalue)
              public Integer(String s)

String和int类型的相互转换：

         int -- String
              a:和""进行拼接
              b:public staticString valueOf(int i)
              c:int -- Integer-- String(Integer类的toString方法())
              d:public staticString toString(int i)(Integer类的静态方法)
         String -- int
              a:String --Integer -- int
              public static intparseInt(String s)
基本数据类型包装类有八种，其中七种都（除了Character，字符串到字符的转换通过toCharArray（）就可以把字符转换为字符数组）有parseXxx的方法，可以将这七种的字符串表现形式转换成基本数据类型

JDK5的新特性自动装箱和拆箱：

         自动装箱：把基本类型转换为包装类类型；Integer i = 100;
         自动拆箱：把包装类类型转换为基本类型；int x =i+200;
注意事项：在使用时，Integer  x = null;代码就会出现NullPointerException；建议先判断是否为null，然后再使用。
（#：-128到127是byte的取值范围，如果在这个取值范围内，自动装箱就不会创建对象，而是从常量池中获取，如果超过了byte取值范围就会再创建新对象）

正则表达式的概述和简单使用

正则表达式：用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的

正则常见对象：

         字符类
              [abc] a、b 或 c（简单类，[]表示单个字符，只能匹配一个字符）
              [^abc] 任何字符，除了 a、b 或 c（否定）
              [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
              [0-9] 0到9的字符都包括
         预定义字符类
              . 任何字符。
              \d 数字：[0-9]（在使用的格式“\\d”,因为java中默认”\”是转义字符）
              \w 单词字符：[a-zA-Z_0-9]
         Greedy 数量词
X? X，一次或一次也没有（匹配的是X体中的任意一个字符，X体除外的返回都是false）
              X* X，零次一直到多次
              X+ X，一次或多次（不包括零次）
              X{n} X，恰好 n 次
              X{n,} X，至少 n 次
              X{n,m} X，至少 n 次，但是不超过 m 次
         正则表达式的分割功能
              String类的功能：public String[] split(String regex)
注意：如果用”.”进行分割，需要转义(使用”\\.”)，因为真正表达式”.”是匹配任意字符
         正则表达式的分组功能
              叠词：快快乐乐  
              正则：String regex = “(.)\\1(.)\\2”;   
              解释：\\1代表第一组又出现一次，\\2代表第二组又出现一次
              实例1：高兴高兴  String regex = “(..)\\1”； 任意两个字符再出现一次
              实例2：
String
s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
                                     
String s1 =
s.replaceAll("\\.","");
                                     
String s2 =
s1.replaceAll("(.)\\1+",
"$1");  
System.out.println(s2);

Pattern和Matcher的概述；

         Pattern p = Pattern.compile("a*b");   //获取到正则表达式
         Matcher m =p.matcher("aaaaab");      //获取匹配器
         boolean b =m.matches();    //检测是否匹配，如果匹配就返回true
         实例：获取一个字符串中所有的手机号码
String mobile =
"我的手机号码：18512344321，朋友手机号码：15609877890";
                   Stringregex ="1[3578]\\d{9}";
                   Patternp = Pattern.compile(regex);
                   Matcherm =
p.matcher(mobile);
                   while(m.find()){//先找，find方法类似指针会自动移动到下一个
                            System.out.println(m.group());
                   }

Math类概述和方法使用

Math：包含执行基本数学运算的方法，如初等指数、对数、平方根和三角函数
         publicstatic int abs(int a)                 取绝对值
         publicstatic double ceil(double a)      向上取整
         publicstatic double floor(double a)  向下取整
         publicstatic int max(int a,int b)    两个值的最大值
         public static double pow(double a,double b)  次幂的值：ab
public static double random()生成0.0到1.0之间的随机小数，包含0.0，不包含1.0
         public static int round(float a)     四舍五入
public static double sqrt(double a) 开平方根

Random类的概述和方法使用

概述：此类用于产生随机数如果用相同的种子创建两个 Random 实例；行相同的方法调用序列，它们将生成并返回相同的数字序列。
         构造方法：
              public Random()             根据纳秒值来生成随机数据
              public Random(long seed)  根据seed种子生成的随机数
         成员方法：
              public intnextInt()
              public intnextInt(int n)生成0到n之间的随机数，包含0，不包含n

System类的概述和方法使用

         概述:System 类包含一些有用的类字段和方法。它不能被实例化。
         成员方法：
              public static voidgc()      运行垃圾回收器
            public static void exit(int status)     终止当前正在执行的java虚拟机，status如果是非0状态码表示异常终止，一般使用0
public static long currentTimeMillis()自1970.01.01至当前时间之间的时间差（以毫秒为单位）
pubiic static void arraycopy(Object src, int srcPos, Object dest, intdestPos, int length)源数组中复制一个数组，复制从指定位置开始，到目标数据的指定位置结束（src：源数组，srcPos：源数组中的起始位置，dest：目标数组，destPos：目标数组中的起始位置，length：要复制数据元素的数量）

BigInteger类的概述和方法使用

         概述:可以让超过Integer范围内的数据进行运算，不可变的任意精度的整数
         构造方法:public BigInteger(String val)字符串记录数据
         成员方法：
              public BigIntegeradd(BigInteger val)         加
              public BigIntegersubtract(BigInteger val)    减
              public BigIntegermultiply(BigInteger val)     乘
              public BigIntegerdivide(BigInteger val)       除
              public BigInteger[]divideAndRemainder(BigInteger val)
                     返回”/”和”%”结果的数组(一个是商的结果，一个是取余的结果)

BigDecimal类的概述和方法使用

概述：由于在运算的时候，float类型和double很容易丢失精度（因为用计算机二进制表示小数会损失精度）；所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal；不可变的、任意精度的有符号十进制数。
构造方法：public BigDecimal(String val)（一般都建议使用这种构造，或者直接使用BigDecimal.valueOf()方法）
         成员方法：
              public BigDecimaladd(BigDecimal augend)       加
              public BigDecimalsubtract(BigDecimal subtrahend)减
              public BigDecimalmultiply(BigDecimal multiplicand)乘
              public BigDecimaldivide(BigDecimal divisor)    除

Date类的概述和方法使用

         概述：类Date 表示特定的瞬间，精确到毫秒。
         构造方法
              public Date()                           代表当前时间
              public Date(long date)    如果传入参数为0代表的是1970年1月1日
         成员方法：
              public long getTime() 通过时间对象获取毫秒数（自1970.01.01至今）
              public void setTime(long time) 设置毫秒值，改变时间对象

SimpleDateFormat类实现日期和字符串的相互转换

DateFormat类的概述：DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat（DateFormat.getDateInstance()父类引用指向子类对象，返回一个子类对象SimpleDateFormat）
         SimpleDateFormat构造方法：
              publicSimpleDateFormat()
public SimpleDateFormat(String pattern)传入时间格式（yyyy年MM月dd日 HH:mm:ss）
         成员方法：
              public finalString format(Date date)  将日期对象转换为字符串
              public Dateparse(String source)      将时间字符串转换为字符串

Calendar类的概述和获取日期的方法

概述：Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。（不能直接new对象，获取对象：Caledar.getInstance(),父类引用指向子类对象）
         成员方法：
public static Calendar getInstance() 获取对象，父类引用指向子类对象
public int get(int field)   获取字段：Calendar.YEAR（年），Calendar.MONTH（月，月份是从0开始编号）
public void add(int field,int amount)  如果field给的是年就对年进行操作，amount对指定的字段进行向前减或向后加
public final void set(int year,int month,intdate) 修改指定字段
实例：判断年份是平年还是闰年
Scanner sc =new
Scanner(System.in);
                   System.out.println("请输入年份，判断该年份是平年还是闰年：");
                   Stringline =sc.nextLine();
                   intyear = Integer.parseInt(line);
                   Calendarc = Calendar.getInstance();
                   //设置为该年的3月1日（年是从0开始编号）
                   c.set(year, 2,1);
                   //将日向前减1
                   c.add(Calendar.DAY_OF_MONTH, -1);
                   //判断是如果是29天则是闰年否则非闰年
System.out.println(c.get(Calendar.DAY_OF_MONTH)==29?true:false);

对象数组的概述和使用：

概述：数组里的每个元素都类的对象，赋值时先定义对象，然后将对象直接赋给数组；数组和集合存储引用数据类型，存的都是地址值
使用：
              Student[] arr = new Student[2];              //存储学生对象
              arr[0] = new Student("张三", 23);
              arr[1] = new Student("李四", 24);

集合的由来及集合继承体系图

由来：数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少
         数组和集合的区别
              区别1 :
数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
              区别2:
                     数组长度是固定的,不能自动增长
                     集合的长度的是可变的,可以根据元素的增加而增长
         数组和集合什么时候用
              1,如果元素个数是固定的推荐用数组
              2,如果元素个数不是固定的推荐用集合
         集合继承体系图：

集合的遍历之集合转数组遍历

         遍历：其实就是依次获取集合中的每一个元素。
                     把集合转成数组，可以实现集合的遍历，toArray()

集合的遍历之迭代器遍历

         概述：集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)
         示例：
              Collection c=
new ArrayList();
                   c.add("a");
              c.add("b");
              c.add("c");
              c.add("d");
                   Iterator it =c.iterator();       
//获取迭代器的引用
                   while(it.hasNext()) {//判断集合中是否有元素，有就返回true
                            System.out.println(it.next());//集合中的迭代方法(遍历)
                   }

迭代器的原理

迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的

List集合的特有功能

         voidadd(int index,E element)   指定位置添加元素
  Eremove(int index)删除指定位置的元素，将被删除元素返回，删除时不会  自动装箱，会把传入的index当成索引值
         E get(intindex)                             获取指定位置的元素
        E set(int index,E element)            将指定位置的元素修改

ConcurrentModificationException异常处理

         List list =new ArrayList();
         list.add("a");
         list.add("b");
         list.add("world");
         list.add("d");
         list.add("e");
         Iterator it= list.iterator();
              while(it.hasNext()){
                     Stringstr = (String)it.next();
                     if(str.equals("world")){
                     list.add("javaee");                    
              //这里add会抛出ConcurrentModificationException并发修改异常
                            }
                     }

              在遍历的同时在增加元素，会有并发修改异常；

       解决方案：

              a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
              b:集合遍历元素，集合修改元素
              ListIterator lit = list.listIterator();            
              //如果想在遍历的过程中添加元素,可以用ListIterator中的add方法
                     while(lit.hasNext()) {
                            String str = (String)lit.next();
                            if(str.equals("world")) {
                                   lit.add("javaee"); 
                                   //list.add("javaee");
                            }
                     }

ListIterator

         boolean hasNext()                 是否有下一个
         boolean hasPrevious()           是否有前一个
         Object next()                          返回下一个元素
 Object previous()                   返回上一个元素

Vector的特有功能

         Vector类概述：可以实现可增长的对象数组，与数组一样可以用索引进行访问
         Vector类特有功能
              public voidaddElement(E obj)
              public EelementAt(int index)
              public Enumeration elements() 返回组件的枚举

       示例

              Vector v = newVector();   //创建集合对象,List的子类
                     v.addElement("a");
                     v.addElement("b");
                     v.addElement("c");
                     v.addElement("d");
                     //Vector迭代
                     Enumeration en = v.elements();     //获取枚举
                     while(en.hasMoreElements()) {      //判断集合中是否有元素
                     System.out.println(en.nextElement());//获取集合中的元素
                     }

数据结构之数组和链表

         数组：查询快修改也快（直接通过索引），增删慢（需要向后（向前）复制元素）
  链表：查询慢,修改也慢（需要遍历链表节点），增删快（通过链表节点直接断开（闭合））

List的三个子类的特点

         ArrayList:
                     底层数据结构是数组，查询快，增删慢。
                     线程不安全，效率高。
         Vector:
                     底层数据结构是数组，查询快，增删慢。
                     线程安全，效率低。
         Vector相对ArrayList查询慢(线程安全的)
         Vector相对LinkedList增删慢(数组结构)
         LinkedList:
                     底层数据结构是链表，查询慢，增删快。
                     线程不安全，效率高。
         Vector和ArrayList的区别
                     Vector是线程安全的,效率低
                     ArrayList是线程不安全的,效率高
         共同点:都是数组实现的
         ArrayList和LinkedList的区别
                     ArrayList底层是数组结果,查询和修改快
                     LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
         共同点:都是线程不安全的
         建议：查询多用ArrayList；增删多用LinkedList；都多ArrayList

ArrayList中的contains和remove方法：

ArrayList中的contains和remove方法底层都是用的equals实现，拿到当前对象和List集合中的对象用equal进行比较，如果想用contains以及remove方法，建议重写对象的equals()方法

LinkedList的特有功能

         概述：类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用
         特有功能：
              publicvoid addFirst(E e)及addLast(E e)添加元素从头或者尾部
              public EgetFirst()及getLast()获取头部或尾部元素
              public EremoveFirst()及public E removeLast() 移除头部或尾部
public E get(int index);获取指定位置元素（索引和[size/2]比较，如果小就从头找，否则从尾部找）

栈和队列数据结构

         栈：先进后出 ；队列：先进先出

泛型

由来：通过Object转型问题引入，Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
概述：它的本质是参数化类型（Parameterized Type）的应用，也就是说所操作的数据类型被指定为一个参数，在用到的时候在指定具体的类型。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。
         好处：提高安全性(将运行期的错误转换到编译期)；省去强转的麻烦
         泛型基本使用：<>中放的必须是引用数据类型
泛型使用注意事项：前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型) 

泛型类的概述及使用

         泛型类概述<T>：把泛型定义在类上
         定义格式：public class 类名<泛型类型1,…>
         注意事项：泛型类型必须是引用类型

泛型方法的概述和使用

         泛型方法概述：把泛型定义在方法上
         定义格式：public <泛型类型> 返回类型 方法名(泛型类型 变量名)

泛型接口的概述和使用

         泛型接口概述：把泛型定义在接口上
         定义格式：public interface 接口名<泛型类型>

泛型高级之通配符

泛型通配符<?>：任意类型，如果没有明确，那么就是Object以及任意的Java类了
         ? extends E：泛型固定上边界，向下限定，E及其子类
         ? super E：泛型固定下边界，向上限定，E及其父类

增强for的概述和使用

增强for概述：简化数组和Collection集合的遍历（不能修改list集合中的数据），底层依赖的是迭代器（Iterator）
         格式：
              for(元素数据类型 变量 : 数组或者Collection集合) {
                     使用变量即可，该变量就是元素
              }

三种迭代的能否删除

         普通for循环,可以删除,但是索引要进行减一（索引需要回退一次）
         迭代器,可以删除但是必须使用迭代器自身的remove方法,否则有并发修改异常
         增强for循环不能删除

静态导入的概述和使用

静态导入概述：静态导入可以使被导入类的静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。
         格式： import static 包名.类名.方法名;可以直接导入到方法的级别
注意事项：方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用。

可变参数的概述和使用

可变参数概述：定义方法的时候不知道该定义多少个参数（可变参数其实是一个数组）
         格式：修饰符 返回值类型 方法名(数据类型…  变量名){}
              public void print（int … arr）{}
注意事项：这里的变量其实是一个数组；如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

Arrays工具类的asList()方法的使用

Arrays工具类的asList()方法的使用,数组转集合虽然不能增减元素，但是可以用集合的思想操作数组，也就是说可以使用集合中的其他方法
         将数组转换成集合，数组必须是引用数据类型
Collection中toArray(T[] a)泛型版的集合转数组，当集合转换数组时，当数组的长度如果小于等于集合的size时，转换后的数组长度等于集合的size，如果数组的长度大于size，分配的数组长度就和指定的数组长度一致

Set集合概述及特点

Set集合，无索引，不能记住元素的添加顺序，不允许包含重复元素，如果添加重复元素，会添加失败，返回false，且不会添加进入

HashSet集合概述及特点

HashSet类：集合元素值可以为null；如果多个线程访问一个HashSet，需要通过代码保证其同步（非线程安全的）

注：如果把一个对象放入到HashSet中，重写了equals方法，则需要重写HashCode方法（即两个方法要保持同步）

遍历HashSet可以用增强for循环

HashSet的继承体系重写了toString方法

HashSet如何保证元素唯一性的原理

         HashSet原理:
我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数
当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象
                     如果没有哈希值相同的对象就直接存入集合
如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为false就存入, true则不存
         将自定义类的对象存入HashSet去重复
              类中必须重写hashCode()和equals()方法
hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)
equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储

LinkedHashSet的概述和使用

LinkedHashSet类：底层是链表实现的，是set集合中唯一一个能保证存储顺序的集合对象，HashSet的子类，根据hashCode方法计算位置，同时使用链表维护元素次序，内部元素是有序的（添加顺序）并且是唯一的（没有重复元素）

注：Set集合实现类HashSet、TreeSet、EnumSet都是线程不安全的，可以通过Collections工具类的synchronizedSortSet进行包装该Set集合，保证多个线程访问一个Set集合时的线程安全；Set集合遍历可以使用iterator迭代器进行迭代

TreeSet原理

特点：TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列，同样它也可以保证元素的唯一；TreeSet底层是二叉树（两个叉）：小的存储在左边（负数），大的存储在右边（正数），相等就不存（0）；在TreeSet集合如何存储元素取决于compareTo方法的返回值：
1：返回0，集合中只有一个元素

2：返回-1，集合会将存储的元素倒序

3：返回1，集合怎么存储就怎么取出

         使用方式
              a.自然顺序(Comparable)
                     1：TreeSet类的add()方法中会把存入的对象提升为Comparable类型
                     2：调用对象的compareTo()方法和集合中的对象比较
                     3：根据compareTo()方法返回的结果进行存储
              b.比较器顺序(Comparator)
                     1：创建TreeSet的时候可以制定 一个Comparator
2：如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
                     3：add()方法内部会自动调用Comparator接口中compare()方法排序
4：调用的对象是compare方法的第一个参数,集合中的对象是compare方法的第二个参数
              c.两种方式的区别
1：TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错ClassCastException)
                     2：TreeSet如果传入Comparator, 就优先按照Comparator

         1.List
              a.普通for循环, 使用get()逐个获取
              b.调用iterator()方法得到Iterator, 使用hasNext()和next()方法
              c.增强for循环, 只要可以使用Iterator的类都可以用
d.Vector集合可以使用Enumeration的hasMoreElements()和nextElement()方法
         2.Set
              a.调用iterator()方法得到Iterator, 使用hasNext()和next()方法
              b.增强for循环, 只要可以使用Iterator的类都可以用
 3.普通for循环,迭代器,增强for循环是否可以在遍历的过程中删除

Map集合概述和特点

Map集合：将键映射到值的对象；一个映射不能包含重复的键；每个键最多只能映射到一个值，Map和Set很像,Set集合底层就是使用了Map集合
         Map接口和Collection接口的不同
              a:Map是双列的,Collection是单列的
              b:Map的键唯一,Collection的子体系Set是唯一的
c:Map集合的数据结构值针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

Map集合的功能概述

         a:添加功能
              V put(K key,V value):添加元素。返回覆盖的值
                     如果键是第一次存储，就直接存储元素，返回null
                     如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
         b:删除功能
              void clear():移除所有的键值对元素
              V remove(Object key)：根据键删除键值对元素，并把值返回
         c:判断功能
              boolean containsKey(Object key)：判断集合是否包含指定的键
              boolean containsValue(Object value):判断集合是否包含传入的值
              boolean isEmpty()：判断集合是否为空
         d:获取功能
              Set<Map.Entry<K,V>> entrySet():
              V get(Object key):根据键获取值
              Set<K> keySet():获取集合中所有键的集合
              Collection<V> values():获取集合中所有值的集合
         e:长度功能
              int size()：返回集合中的键值对的个数

Map集合的遍历之键找值

         键找值思路：获取所有键的集合；遍历键的集合，获取到每一个键；根据键找值
         示例：
                     HashMap<String,Integer> hm = new HashMap<>();
                     hm.put("张三", 23);
                     hm.put("李四", 24);
                     hm.put("王五", 25);
                     hm.put("赵六", 26);
                    
                     /*Set<String> keySet = hm.keySet();//获取集合中所有的键
                     Iterator<String> it = keySet.iterator();   //获取迭代器
                     //判断单列集合中是否有元素
                     while(it.hasNext()){         
                            //获取集合中的每一个元素,其实就是双列集合中的键
                            String key = it.next();                            
                            Integer value = hm.get(key);                 //根据键获取值
                            System.out.println(key + "=" +value);   //打印键值对
                     }*/
                     //增强for循环迭代双列集合第一种方式
                     for(String key : hm.keySet()) {                     
                            System.out.println(key+ "=" + hm.get(key));
                     }

Map集合的遍历之键值对对象找键和值

键值对对象找键和值思路：获取所有键值对对象的集合；遍历键值对对象的集合，获取到每一个键值对对象；根据键值对对象找键和值，重写了toString方法
示例：
         HashMap<String,Integer> hm = new HashMap<>();
                     hm.put("张三", 23);
                     hm.put("李四", 24);
                     hm.put("王五", 25);
                     hm.put("赵六", 26);
                     /*  //获取所有的键值对象的集合
Set<Map.Entry<String, Integer>> entrySet = hm.entrySet(); 
Iterator<Entry<String, Integer>> it = entrySet.iterator();//获取迭代器
                     while(it.hasNext()) {
                            //获取键值对对象
                            Entry<String, Integer> en =it.next();           
                            //根据键值对对象获取键         
                            String key = en.getKey();                                                  
                            Integer value = en.getValue();                                                                //根据键值对对象获取值
                            System.out.println(key + "=" +value);
                     }*/
                     for(Entry<String,Integer> en :hm.entrySet()) {
System.out.println(en.getKey() + "=" + en.getValue());
                   }

LinkedHashMap的概述和使用

LinkedHashMap的特点：底层是链表实现的可以保证怎么存就怎么取，使用双向链表来维护

TreeMap的概述

TreeMap：底层是二叉树结构；允许使用null键和null值；线程不同步；可以给Map集合中的键进行排序

1*:让元素自身具备比较性，比如八种基本数据类型或则字符串;实现Compareble接口,覆盖compareTo方法，此方式是元素的自然顺序     

2*:当元素自身不具备比较性(比如存储学生对象时)或者具备的;比较性不是我们所需要的比较性时(比如想字符串的长度排序),此时就需要让集合自身具备自定义的比较性;可在集合初始化时，就让集合具备比较方式，即定义一个类，  实现Comparator接口，覆盖compare方法。

HashTable的特点

HashTable：底层是哈希表数据结构；不可以使用null键和null值；用作键的对象必须实现hashCode和equals方法来保证键的唯一性；线程同步，效率低

HashMap的特点及其原理       

HashMap：底层是哈希表数据结构；允许使用null键和null值；线程不同步，效率高；保证元素唯一性的:
原理：先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true(往HashSet里面存的自定义元素要复写hashCode和equals方法，
以保证元素的唯一性！)

HashMap和Hashtable的区别

        底层都是哈希算法，都是双列集合

Hashtable是JDK1.0版本出现的,是线程安全的,效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率高

Hashtable不能存储null键和null值,HashMap能存储null键和null值

Collections工具类的概述和常见方法讲解

         Collections类概述:针对集合操作 的工具类
         public static <T> void sort(List<T> list)  对list集合进行排序
public static <T> intbinarySearch(List<?> list,T key)二分查找法（list要有序，返回元素的索引）
public static <T> T max(Collection<?>coll) 获取最大值（底层会先排序，然后获取最大值）
         publicstatic void reverse(List<?> list) 反转（集合逆序）

public static void shuffle(List<?> list)随机置换（洗牌）